# List Workflow runs

> List retained runs for this Workflow, newest first. Each run corresponds to one matching Asset event.

```json
{
  "path": "/workflows/{workflowId}/runs",
  "method": "get",
  "schema": {
    "description": "List retained runs for this Workflow, newest first. Each run corresponds to one matching Asset event.",
    "operationId": "getWorkflowRunList",
    "parameters": [
      {
        "description": "ID of the Workflow.",
        "in": "path",
        "name": "workflowId",
        "required": true,
        "schema": {
          "type": "string"
        }
      },
      {
        "description": "Limit specifies the maximum number of results to return.\nAccepts 1 to 100. Defaults to 100.",
        "in": "query",
        "name": "limit",
        "required": false,
        "schema": {
          "default": 100,
          "maximum": 100,
          "minimum": 1,
          "type": "integer"
        }
      },
      {
        "description": "Offset specifies the number of matching results to skip.\nMust be at least 0. Defaults to 0.",
        "in": "query",
        "name": "offset",
        "required": false,
        "schema": {
          "default": 0,
          "minimum": 0,
          "type": "integer"
        }
      },
      {
        "description": "LatestPerAsset specifies whether to return only the latest matching run for each Asset. Defaults to false. Pagination and total count apply to Assets when true.",
        "in": "query",
        "name": "latest_per_asset",
        "required": false,
        "schema": {
          "default": false,
          "type": "boolean"
        }
      },
      {
        "description": "AssetId specifies the Asset whose results to return. Omit it to include all Assets.",
        "in": "query",
        "name": "asset_id",
        "required": false,
        "schema": {
          "type": "string"
        }
      },
      {
        "description": "Status specifies the run status to filter by. Omit it to include all statuses.",
        "in": "query",
        "name": "status",
        "required": false,
        "schema": {
          "enum": [
            "pending",
            "running",
            "completed",
            "failed",
            "cancelled"
          ],
          "type": "string"
        }
      },
      {
        "description": "Created at or after this Unix timestamp in seconds.",
        "in": "query",
        "name": "created.gte",
        "required": false,
        "schema": {
          "type": "integer"
        }
      },
      {
        "description": "Created at or before this Unix timestamp in seconds.",
        "in": "query",
        "name": "created.lte",
        "required": false,
        "schema": {
          "type": "integer"
        }
      },
      {
        "description": "EventId specifies the triggering event ID to filter by. Omit it to include all events.",
        "in": "query",
        "name": "event_id",
        "required": false,
        "schema": {
          "type": "string"
        }
      }
    ],
    "responses": {
      "200": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/WorkflowRunListResponse",
              "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"
                    }
                  ],
                  "limit": 100,
                  "offset": 0,
                  "status": "success",
                  "total": 1
                }
              ]
            }
          }
        },
        "description": "List Workflow runs"
      },
      "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": "List Workflow runs",
    "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.list('wfl_example', {\n  latest_per_asset: true,\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.list(\n    \"wfl_example\",\n    latest_per_asset=True,\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-\u003elist(\n    'wfl_example',\n    latestPerAsset: true,\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.List(\n\t\tcontext.TODO(),\n\t\t\"wfl_example\",\n\t\tchunkify.WorkflowRunListParams{\n\t\t\tLatestPerAsset: chunkify.Bool(true),\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/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"
  ]
}
```



```json #/components/schemas/WorkflowRunListResponse
{
  "description": "A page of Workflow runs.",
  "properties": {
    "data": {
      "description": "Workflow runs in this page.",
      "items": {
        "$ref": "#/components/schemas/WorkflowRun"
      },
      "type": "array"
    },
    "limit": {
      "description": "Maximum number of results requested per page.",
      "type": "integer"
    },
    "offset": {
      "description": "Number of matching results skipped.",
      "type": "integer"
    },
    "status": {
      "const": "success",
      "description": "Status of the API request. Always success for this response.",
      "type": "string"
    },
    "total": {
      "description": "Total number of results matching the filters before pagination.",
      "type": "integer"
    }
  },
  "required": [
    "status",
    "data",
    "total",
    "offset",
    "limit"
  ],
  "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"
}
```