# Get Workflow run

> Retrieve a retained run with its triggering event, status, and action counts.

```json
{
  "path": "/workflows/{workflowId}/runs/{runId}",
  "method": "get",
  "schema": {
    "description": "Retrieve a retained run with its triggering event, status, and action counts.",
    "operationId": "getWorkflowRun",
    "parameters": [
      {
        "description": "ID of the Workflow.",
        "in": "path",
        "name": "workflowId",
        "required": true,
        "schema": {
          "type": "string"
        }
      },
      {
        "description": "ID of the Workflow run.",
        "in": "path",
        "name": "runId",
        "required": true,
        "schema": {
          "type": "string"
        }
      }
    ],
    "responses": {
      "200": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/WorkflowRunResponse",
              "examples": [
                {
                  "data": {
                    "actions": {
                      "cancelled": 0,
                      "completed": 0,
                      "failed": 0,
                      "reused": 0,
                      "skipped": 0,
                      "total": 2
                    },
                    "asset_execution_status": "running",
                    "asset_id": "ast_example",
                    "completed_at": null,
                    "created_at": "2026-10-02T10:00:00Z",
                    "event": "asset.ready",
                    "event_id": "evt_example",
                    "id": "wfr_example",
                    "revision": 1,
                    "root_run_id": "wfr_example",
                    "status": "running",
                    "updated_at": "2026-10-02T10:00:00Z",
                    "workflow_id": "wfl_example"
                  },
                  "status": "success"
                }
              ]
            }
          }
        },
        "description": "Get Workflow run"
      },
      "400": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorValidation"
            }
          }
        },
        "description": "Validation error"
      },
      "401": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorAuthentication"
            }
          }
        },
        "description": "Authentication error"
      },
      "403": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorForbidden"
            }
          }
        },
        "description": "Forbidden error"
      },
      "404": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorNotFound"
            }
          }
        },
        "description": "NotFound error"
      },
      "409": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorConflict"
            }
          }
        },
        "description": "Conflict error"
      },
      "429": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorTooManyRequests"
            }
          }
        },
        "description": "TooManyRequests error"
      },
      "503": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ResponseErrorServiceUnavailable"
            }
          }
        },
        "description": "ServiceUnavailable error"
      }
    },
    "security": [
      {
        "ProjectAccessToken": []
      }
    ],
    "summary": "Get Workflow run",
    "tags": [
      "Workflows"
    ],
    "x-codeSamples": [
      {
        "lang": "typescript",
        "source": "import Chunkify from '@chunkify/chunkify';\n\nconst client = new Chunkify({\n  projectAccessToken: 'My Project Access Token',\n});\n\nconst result = await client.workflows.runs.retrieve('wfr_example', {\n  workflowId: 'wfl_example',\n});\n\nconsole.log(result);"
      },
      {
        "lang": "python",
        "source": "from chunkify import Chunkify\n\nclient = Chunkify(\n    project_access_token=\"My Project Access Token\",\n)\n\nresult = client.workflows.runs.retrieve(\n    \"wfr_example\",\n    workflow_id=\"wfl_example\",\n)\n\nprint(result)"
      },
      {
        "lang": "php",
        "source": "\u003c?php\n\nuse Chunkify\\Client;\n\n$client = new Client(\n    projectAccessToken: 'My Project Access Token',\n);\n\n$result = $client-\u003eworkflows-\u003eruns-\u003eretrieve(\n    'wfr_example',\n    workflowID: 'wfl_example',\n);\n\nvar_dump($result);"
      },
      {
        "lang": "golang",
        "source": "package main\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\n\t\"github.com/chunkifydev/chunkify-go\"\n\t\"github.com/chunkifydev/chunkify-go/option\"\n)\n\nfunc main() {\n\tclient := chunkify.NewClient(\n\t\toption.WithProjectAccessToken(\"My Project Access Token\"),\n\t)\n\n\tresult, err := client.Workflows.Runs.Get(\n\t\tcontext.TODO(),\n\t\t\"wfr_example\",\n\t\tchunkify.WorkflowRunGetParams{\n\t\t\tWorkflowID: \"wfl_example\",\n\t\t},\n\t)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\tfmt.Printf(\"%+v\\n\", result)\n}\n"
      }
    ]
  }
}
```



```json #/components/schemas/WorkflowRunResponse
{
  "description": "Response containing one Workflow run.",
  "properties": {
    "data": {
      "$ref": "#/components/schemas/WorkflowRun",
      "description": "The requested Workflow run."
    },
    "status": {
      "const": "success",
      "description": "Status of the API request. Always success for this response.",
      "type": "string"
    }
  },
  "required": [
    "status",
    "data"
  ],
  "type": "object"
}
```



```json #/components/schemas/WorkflowRun
{
  "description": "One execution of Workflow rules for an Asset, started by an event or by updating to a newer revision.",
  "properties": {
    "actions": {
      "$ref": "#/components/schemas/WorkflowActionCounts",
      "description": "Counts of action outcomes in this run. Reused actions are included in completed."
    },
    "asset_execution_status": {
      "$ref": "#/components/schemas/WorkflowRunStatus",
      "description": "AssetExecutionStatus specifies the combined status of this revision for the Asset across retained runs.\nAny failed action or run makes it failed. Pending or active work, or an Asset still preparing for an unarchived Workflow, makes it running. Otherwise it is completed."
    },
    "asset_id": {
      "description": "ID of the Asset processed by this run.",
      "type": "string"
    },
    "completed_at": {
      "description": "When the run completed, failed, or was cancelled. Null while the run is pending or running.",
      "format": "date-time",
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "description": "When the run was created.",
      "format": "date-time",
      "type": "string"
    },
    "error": {
      "description": "Reason the run failed. Omitted when no failure message is available.",
      "type": "string"
    },
    "event": {
      "description": "Event specifies the Asset lifecycle event that triggered this run, or manual when the Asset was updated to a newer revision. Action details are available from the run's actions endpoint.",
      "type": "string"
    },
    "event_id": {
      "description": "EventId specifies the event that triggered this run. Null when the Asset was updated to a newer revision.",
      "type": [
        "string",
        "null"
      ]
    },
    "id": {
      "description": "Unique Workflow run ID.",
      "type": "string"
    },
    "revision": {
      "description": "Pinned Workflow revision used by this run.",
      "type": "integer"
    },
    "root_run_id": {
      "description": "ID of the first run in this event chain. Equals id when this run starts the chain.",
      "type": "string"
    },
    "status": {
      "$ref": "#/components/schemas/WorkflowRunStatus",
      "description": "Current status of this event run, based on its own actions."
    },
    "updated_at": {
      "description": "When the run was last updated.",
      "format": "date-time",
      "type": "string"
    },
    "workflow_id": {
      "description": "ID of the Workflow executed by this run.",
      "type": "string"
    }
  },
  "required": [
    "id",
    "asset_id",
    "workflow_id",
    "revision",
    "event_id",
    "event",
    "root_run_id",
    "status",
    "asset_execution_status",
    "actions",
    "created_at",
    "updated_at",
    "completed_at"
  ],
  "type": "object"
}
```



```json #/components/schemas/WorkflowActionCounts
{
  "description": "Counts of action outcomes in this run.",
  "properties": {
    "cancelled": {
      "description": "Number of actions cancelled before completion.",
      "minimum": 0,
      "type": "integer"
    },
    "completed": {
      "description": "Number of actions that completed successfully, including reused outputs.",
      "minimum": 0,
      "type": "integer"
    },
    "failed": {
      "description": "Number of actions that failed.",
      "minimum": 0,
      "type": "integer"
    },
    "reused": {
      "description": "Number of completed actions that reused an existing output. Included in completed.",
      "minimum": 0,
      "type": "integer"
    },
    "skipped": {
      "description": "Number of actions skipped without producing an output.",
      "minimum": 0,
      "type": "integer"
    },
    "total": {
      "description": "Total number of actions in the run, including unfinished actions.",
      "minimum": 0,
      "type": "integer"
    }
  },
  "required": [
    "total",
    "completed",
    "reused",
    "failed",
    "skipped",
    "cancelled"
  ],
  "type": "object"
}
```



```json #/components/schemas/WorkflowRunStatus
{
  "description": "Current run status. pending means its actions have not started; running means work remains. After all actions finish, failed takes precedence over cancelled. Otherwise the run is completed, including when actions were skipped.",
  "enum": [
    "pending",
    "running",
    "completed",
    "failed",
    "cancelled"
  ],
  "type": "string"
}
```



```json #/components/schemas/ResponseErrorValidation
{
  "properties": {
    "error": {
      "properties": {
        "code": {
          "const": 400,
          "description": "Code is the HTTP status code",
          "examples": [
            400
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "Invalid request parameters"
          ],
          "type": "string"
        },
        "type": {
          "const": "ValidationError",
          "description": "Type indicates the error category",
          "enum": [
            "ValidationError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ]
}
```



```json #/components/schemas/ResponseErrorAuthentication
{
  "description": "Error response",
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 401,
          "description": "Code is the HTTP status code",
          "examples": [
            401
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "Authentication error: invalid token or subscription inactive"
          ],
          "type": "string"
        },
        "type": {
          "const": "AuthenticationError",
          "description": "Type indicates the error category",
          "enum": [
            "AuthenticationError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ],
  "type": "object"
}
```



```json #/components/schemas/ResponseErrorForbidden
{
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 403,
          "description": "Code is the HTTP status code",
          "examples": [
            403
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "Unauthorized to perform this action"
          ],
          "type": "string"
        },
        "type": {
          "const": "ForbiddenError",
          "description": "Type indicates the error category",
          "enum": [
            "ForbiddenError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ]
}
```



```json #/components/schemas/ResponseErrorNotFound
{
  "description": "Error response",
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 404,
          "description": "Code is the HTTP status code",
          "examples": [
            404
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "Ressource not found"
          ],
          "type": "string"
        },
        "type": {
          "const": "NotFoundError",
          "description": "Type indicates the error category",
          "enum": [
            "NotFoundError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ],
  "type": "object"
}
```



```json #/components/schemas/ResponseErrorConflict
{
  "description": "Error response",
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 409,
          "description": "Code is the HTTP status code",
          "examples": [
            409
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "source_unavailable: the original video is no longer accessible"
          ],
          "type": "string"
        },
        "type": {
          "const": "ConflictError",
          "description": "Type indicates the error category",
          "enum": [
            "ConflictError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ],
  "type": "object"
}
```



```json #/components/schemas/ResponseErrorTooManyRequests
{
  "description": "Error response",
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 429,
          "description": "Code is the HTTP status code",
          "examples": [
            429
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "Rate limit exceeded"
          ],
          "type": "string"
        },
        "type": {
          "const": "TooManyRequestsError",
          "description": "Type indicates the error category",
          "enum": [
            "TooManyRequestsError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ],
  "type": "object"
}
```



```json #/components/schemas/ResponseErrorServiceUnavailable
{
  "properties": {
    "error": {
      "description": "Error response details",
      "properties": {
        "code": {
          "const": 503,
          "description": "Code is the HTTP status code",
          "examples": [
            503
          ],
          "type": "integer"
        },
        "message": {
          "description": "Message is a human-readable error description",
          "examples": [
            "The service is temporarily unavailable; retry the request"
          ],
          "type": "string"
        },
        "type": {
          "const": "ServiceUnavailableError",
          "description": "Type indicates the error category",
          "enum": [
            "ServiceUnavailableError"
          ],
          "type": "string"
        }
      },
      "required": [
        "type",
        "code",
        "message"
      ],
      "type": "object"
    },
    "status": {
      "const": "error",
      "description": "Status indicates the response status \"error\"",
      "type": "string"
    }
  },
  "required": [
    "status",
    "error"
  ]
}
```