> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edges.run/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Run Outputs

> Retrieve processed outputs for an async or scheduled run once it has terminated, including stopped and failed runs.

<Info>
  This endpoint is **not available** for runs executed in `live` mode. It only works for runs executed in `async` or `schedule` mode. For live mode runs, results are returned directly in the API response.
</Info>

## When outputs are available

You can retrieve outputs once the run has **terminated** — not only when `status` is `SUCCEEDED`.

That includes terminal statuses that are not a full success, such as `STOPPED`, `FAILED`, and `PARTIAL_SUCCEEDED`. Use [`GET /runs/{run_uid}`](/v1/api/runs/get) to read `status` and `output_count`. If `output_count` is greater than `0`, those processed rows are available here.

If the terminated run produced no outputs, the response is an empty list.

<Tip>
  Stopping or canceling an async run does not discard work already done. Fetch this endpoint to collect the outputs produced before termination.
</Tip>

<Note>
  A **`409`** (`STATUS_409`) is returned only while the run is still **active or pending**. The message is that outputs cannot be retrieved for a run that is not terminated. Do not match on the previous wording (`Cannot get outputs for a run that is not succeeded`).
</Note>

<Info>
  Integrations that treated every non-`SUCCEEDED` run as a `409` will now receive a `200` with the outputs produced before termination.
</Info>

## Pagination

This endpoint uses **cursor-based pagination** by default. Follow the `X-Pagination-Next` response header to retrieve subsequent pages.

* `limit` controls the page size (default: **100**, max: **500**).
* The `X-Pagination-Next` header contains the **full URL** for the next page, including `limit` and `cursor`.
* When the `X-Pagination-Next` header is **absent**, there are no more pages.

```bash theme={null}
# First request
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200" \
  -H "Accept: application/json" \
  -H "X-API-Key: <YOUR_API_KEY>"

# Follow X-Pagination-Next header for subsequent pages
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200&cursor=<cursor_value>" \
  -H "Accept: application/json" \
  -H "X-API-Key: <YOUR_API_KEY>"
```

<Warning>
  The `offset` parameter is **deprecated**. If provided, the system falls back to offset-based pagination and cursor pagination is not used. Prefer following the `X-Pagination-Next` URL for all new integrations.
</Warning>

## Rate Limits

### Run's Routes Limits

<Info>
  All `/runs/*` routes share a single limit — `status`, `outputs`, `inputs` and the rest draw on the same per-minute budget, so polling several of them counts against one allowance.
</Info>

| Plan Tier | Max Requests/Second | Max Requests/Minute | Rationale |
| - | - | - | - |
| Trial | \< 1 | 30 | Supports 2 concurrent runs @ 10s polling interval |
| Bronze | 1 | 60 | Supports 2 concurrent runs with more aggressive polling |
| Silver / Gold | 2.5 | 150 | Supports 5 concurrent runs @ 10s polling interval |
| Platinum / Diamond | 5 | 300 | Supports 10 concurrent runs @ 10s polling interval |
| Titanium | 10 | 600 | Supports 15 concurrent runs @ 10s polling interval |

Rate limits for polling run results via `/v1/runs/{run_uid}/outputs`. These limits support realistic polling patterns if you prefer polling over callbacks.

<Tip>These limits are aligned with concurrent execution limits. For example, with a Silver/Gold plan (5 concurrent runs), you can poll all active runs every 10 seconds with comfortable headroom.</Tip>

#### Capacity Examples

| Plan Tier | Polling Capacity | Use Case |
| - | - | - |
| Trial | Poll 2 runs every 10s | Basic polling during development |
| Bronze | Poll 2 runs every 10s with headroom | Small-scale polling |
| Silver / Gold | Poll 5 runs every 10s, or 1 run every 4s | Team polling operations |
| Platinum / Diamond | Poll 10 runs every 10s | Multi-workspace polling |
| Titanium | Poll 15 runs every 10s | Enterprise-scale polling |

<Note>
  **Implementation Details:**

  * Rate limit type: Per-workspace, per-minute
  * Error response: Standard 429 with `X-RateLimit-Type: /v1/runs/outputs`
  * Headers include `X-RateLimit-Remaining` for visibility
</Note>


## OpenAPI

````yaml v1/api/actions.json get /runs/{run_uid}/outputs
openapi: 3.1.0
info:
  title: ED Automation External API
  description: This is the External API documentation for ED Automation
  version: dev
servers:
  - url: https://api.edges.run/v1
security:
  - XApiKeyAuth: []
paths:
  /runs/{run_uid}/outputs:
    get:
      tags:
        - public / runs
      summary: Get outputs by Run UUID
      operationId: getRunOutputs
      parameters:
        - schema:
            type: integer
            minimum: 1
            maximum: 500
            default: 100
          in: query
          name: limit
          required: false
          description: Number of outputs to return
        - schema:
            type:
              - integer
              - 'null'
            minimum: 0
            default: null
            deprecated: true
          in: query
          name: offset
          required: false
          description: (deprecated) Number of outputs to skip for pagination
        - schema:
            type: string
            title: Pagination Cursor
          in: query
          name: cursor
          required: false
          description: >-
            (optional) Cursor value obtained from the `X-Pagination-Next`
            response header of a previous request, used to continue pagination.
            If not provided, the first page will be returned.
        - schema:
            type: string
            format: uuid
          in: path
          name: run_uid
          required: true
          description: Run UUID
      responses:
        '200':
          description: Returns the run outputs
          headers:
            X-Pagination-Next:
              schema:
                title: Next Page URL
                type: string
              description: >-
                URL to retrieve the next page of results. If present, indicates
                that there are more results to fetch. This URL includes the
                necessary query parameters (like cursor) to get the next set of
                outputs.
          content:
            application/json:
              schema:
                description: Returns the run outputs
                type: array
                items:
                  type: object
                  description: Run Output
                  additionalProperties: true
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/def-0'
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/def-0'
        '409':
          description: Conflict
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/def-0'
        '422':
          description: Unprocessable Entity
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/def-0'
        '500':
          description: Internal Server Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/def-0'
components:
  schemas:
    def-0:
      title: APIError
      description: >-
        Represents an error returned by the API. This schema defines the
        standard structure of error messages to ensure consistent error handling
        across the application.
      type: object
      properties:
        error_label:
          type:
            - string
            - 'null'
        error_scope:
          type:
            - string
            - 'null'
          enum:
            - input
            - integ
            - param
            - config
        error_ref:
          type:
            - string
            - 'null'
          examples:
            - ERR-12345
        message:
          type: string
        status_code:
          type:
            - integer
            - 'null'
        params:
          type:
            - object
            - 'null'
          additionalProperties:
            anyOf:
              - type: string
              - type: number
              - type: boolean
              - type: 'null'
              - type: array
                items:
                  type: string
        data:
          type:
            - object
            - 'null'
          additionalProperties: true
          description: Additional data about the error
      additionalProperties: false
  securitySchemes:
    XApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-Key

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.