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

# Get Blueprint run status

> Poll a Blueprint run until it reaches a terminal state.

Returns a customer-safe status projection: lifecycle status, a coarse progress
step, timestamps, and a structured terminal error when failed. Never returns
inputs, outputs, file URLs, or run content.

```bash theme={null}
curl -s "$RUBIE_API_URL/api/v1/blueprint-runs/run_.../status" \
  -H "Authorization: Bearer $RUBIE_API_KEY"
```

`runId` accepts either the opaque `run_...` id or the UUID `run_key` from the
trigger response.

## Status values

| Status      | Meaning                     | Suggested client action       |
| ----------- | --------------------------- | ----------------------------- |
| `queued`    | Accepted, not yet executing | Keep polling                  |
| `running`   | In progress                 | Keep polling                  |
| `completed` | Succeeded                   | Stop; mark success in your UI |
| `failed`    | Did not complete            | Stop; offer retry / escalate  |
| `cancelled` | Stopped early               | Stop                          |

Poll every 2–5 seconds. `progress_step` is a coarser lifecycle hint that may
gain Blueprint-defined milestones later — treat it as an open string set.

## Terminal errors

When `status` is `failed`, `error` is present:

| `error.code`       | Meaning                  |
| ------------------ | ------------------------ |
| `execution_failed` | The run did not complete |

Today every failure uses `execution_failed`. More specific Blueprint-defined
codes will be added later without changing this shape — branch on codes you
know and fall back to a generic retry path otherwise.

See [Triggering Blueprint runs](/guides/blueprint-runs) and
[Get Blueprint run results](/api-reference/blueprint-runs/get-blueprint-run-results).


## OpenAPI

````yaml GET /blueprint-runs/{runId}/status
openapi: 3.0.3
info:
  title: Rubie API
  version: 1.0.0
  description: >
    Collect end-user credentials through a Rubie-hosted form, then run Rubie

    Blueprints against them asynchronously.


    This API is deliberately thin. Rubie does not model your domain: what a

    Blueprint accepts as input, what it does with a connected system, and what
    it

    produces are all defined by that Blueprint's configuration. The endpoints

    below are the transport around it.


    All endpoints require bearer authentication. Responses use opaque prefixed
    IDs

    (`cred_`, `sess_`, `ecs_`, `strat_`, `run_`, `bp_`), snake_case fields, and
    a

    single top-level error envelope — never a `success` wrapper.
servers:
  - url: https://app.rubiehq.com/api/v1
    description: Production
security:
  - BearerAuth: []
tags:
  - name: Credential Sessions
    description: Start and poll Rubie-hosted credential collection flows.
  - name: Embedded Credential Sessions
    description: Embed a Blueprint picker and credential capture flow in your product.
  - name: Credentials
    description: Revoke vaulted credentials.
  - name: Blueprints
    description: Trigger a Rubie Blueprint run.
  - name: Blueprint Runs
    description: Poll run status and retrieve completed outputs.
paths:
  /blueprint-runs/{runId}/status:
    get:
      tags:
        - Blueprint Runs
      summary: Get blueprint run status
      description: >
        Returns lifecycle status, a coarse progress step, timestamps, and a
        structured terminal error. Never returns input/output URLs or any run
        content, so it is safe to poll from systems handling sensitive data.
      operationId: getBlueprintRunStatus
      parameters:
        - name: runId
          in: path
          required: true
          schema:
            type: string
          description: >-
            Opaque `run_...` id from the trigger response (UUID run_key also
            accepted).
          example: run_MQ
      responses:
        '200':
          description: Status projection
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BlueprintRunStatusResponse'
              examples:
                running:
                  summary: In progress
                  value:
                    id: run_MQ
                    run_key: 550e8400-e29b-41d4-a716-446655440000
                    status: running
                    progress_step: running
                    created_at: '2026-07-31T17:10:00.000Z'
                    started_at: '2026-07-31T17:10:05.000Z'
                    ended_at: null
                    error: null
                    blueprint_id: bp_MQ
                completed:
                  summary: Succeeded
                  value:
                    id: run_MQ
                    run_key: 550e8400-e29b-41d4-a716-446655440000
                    status: completed
                    progress_step: completed
                    created_at: '2026-07-31T17:10:00.000Z'
                    started_at: '2026-07-31T17:10:05.000Z'
                    ended_at: '2026-07-31T17:12:00.000Z'
                    error: null
                    blueprint_id: bp_MQ
                failed:
                  summary: Failed
                  value:
                    id: run_MQ
                    run_key: 550e8400-e29b-41d4-a716-446655440000
                    status: failed
                    progress_step: failed
                    created_at: '2026-07-31T17:10:00.000Z'
                    started_at: '2026-07-31T17:10:05.000Z'
                    ended_at: '2026-07-31T17:11:00.000Z'
                    error:
                      code: execution_failed
                      message: >-
                        The run failed. Retry the request, or contact support if
                        the issue persists.
                    blueprint_id: bp_MQ
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  schemas:
    BlueprintRunStatusResponse:
      type: object
      required:
        - id
        - run_key
        - status
        - progress_step
        - created_at
        - blueprint_id
      properties:
        id:
          type: string
          example: run_MQ
        run_key:
          type: string
          format: uuid
        status:
          $ref: '#/components/schemas/BlueprintRunStatus'
        progress_step:
          type: string
          description: >
            Coarse lifecycle step. Today it closely tracks `status`; finer
            Blueprint-defined milestones will be added later, so treat this as
            an open string set rather than a fixed enum.
          enum:
            - queued
            - authenticating
            - running
            - awaiting_review
            - completed
            - failed
            - cancelled
            - unknown
        created_at:
          type: string
          format: date-time
        started_at:
          type: string
          format: date-time
          nullable: true
        ended_at:
          type: string
          format: date-time
          nullable: true
        error:
          allOf:
            - $ref: '#/components/schemas/BlueprintRunError'
          nullable: true
        blueprint_id:
          type: string
          example: bp_MQ
    BlueprintRunStatus:
      type: string
      enum:
        - queued
        - running
        - completed
        - failed
        - cancelled
    BlueprintRunError:
      type: object
      required:
        - code
        - message
      description: >
        Present only when `status` is `failed`. Today the API returns a single
        generic code; richer Blueprint-defined codes will be added later without
        changing this shape, so treat `code` as an open string set.
      properties:
        code:
          type: string
          enum:
            - execution_failed
        message:
          type: string
    ErrorResponse:
      type: object
      required:
        - error
      properties:
        error:
          $ref: '#/components/schemas/Error'
    Error:
      type: object
      required:
        - type
        - message
      properties:
        type:
          type: string
          enum:
            - authentication_error
            - authorization_error
            - not_found
            - validation_error
            - conflict
            - rate_limit_exceeded
            - internal_error
        message:
          type: string
        details:
          type: array
          items:
            $ref: '#/components/schemas/ErrorDetail'
    ErrorDetail:
      type: object
      required:
        - message
      properties:
        message:
          type: string
        code:
          type: string
          nullable: true
        field:
          type: string
          nullable: true
  responses:
    Unauthorized:
      description: Missing or invalid API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    Forbidden:
      description: API key is not authorized for this resource
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    NotFound:
      description: Resource not found in this account
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIKey
      description: Your Rubie API key as a bearer token.

````