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

# Stream run activity

> Opens a server-sent event stream of a run's activity: first every event recorded so far
(or those after `after_id`, to resume after a reconnect), then new events as the daemon
reports them. While at least one person is watching, CliqHub asks the run's daemon to
stream its events live. A comment line is sent every 30 seconds to keep the connection open.

Requires a realm member (or higher) with the `runs.view` permission on the realm that owns the run given by `run_id` (query string).



## OpenAPI

````yaml /openapi/hub-by-tag/hub-runs.yaml get /v1/runs/stream
openapi: 3.0.3
info:
  title: 'CliqHub API: Runs'
  version: 1.0.0
  description: >-
    Runs of a team on a daemon. People start runs (Start a run), follow them
    (Get a run, Stream

    run activity, Search run logs, Get run telemetry), and control them (Cancel
    a run, Resume a

    run, Supply run inputs). CliqHub hands each control to the run's daemon,
    which must be

    online: when it is not, the call fails with a `run/daemon_offline` or
    `run/daemon_stranded`

    conflict (cancel instead marks the run cancelled on CliqHub).


    Daemons report what happens during a run through the other endpoints here,
    with their realm

    token: Record a new run, Update run status, Complete a run, and three
    separate channels for

    run activity (the live timeline), run telemetry (token usage and traces) and
    run logs (text).
servers:
  - url: https://{host}
    variables:
      host:
        default: cliqhub.io
        description: CliqHub host
security: []
tags:
  - name: Runs
    description: >-
      Runs of a team on a daemon. People start runs (Start a run), follow them
      (Get a run, Stream

      run activity, Search run logs, Get run telemetry), and control them
      (Cancel a run, Resume a

      run, Supply run inputs). CliqHub hands each control to the run's daemon,
      which must be

      online: when it is not, the call fails with a `run/daemon_offline` or
      `run/daemon_stranded`

      conflict (cancel instead marks the run cancelled on CliqHub).


      Daemons report what happens during a run through the other endpoints here,
      with their realm

      token: Record a new run, Update run status, Complete a run, and three
      separate channels for

      run activity (the live timeline), run telemetry (token usage and traces)
      and run logs (text).
paths:
  /v1/runs/stream:
    get:
      tags:
        - Runs
      summary: Stream run activity
      description: >-
        Opens a server-sent event stream of a run's activity: first every event
        recorded so far

        (or those after `after_id`, to resume after a reconnect), then new
        events as the daemon

        reports them. While at least one person is watching, CliqHub asks the
        run's daemon to

        stream its events live. A comment line is sent every 30 seconds to keep
        the connection open.


        Requires a realm member (or higher) with the `runs.view` permission on
        the realm that owns the run given by `run_id` (query string).
      operationId: GET_v1_runs_stream
      parameters:
        - in: query
          name: run_id
          required: true
          description: The run to follow.
          schema:
            type: string
        - in: query
          name: after_id
          required: false
          description: Id of the last event you received; only later events are replayed.
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: >-
            A `text/event-stream`. Each message has `id` (the event id), `event`
            (the event type) and `data`.
          content:
            text/event-stream:
              schema:
                type: string
                description: >
                  Each message: `id: <event id>`, `event: <event type>`
                  (`run.started`, `phase.started`,

                  `phase.completed`, `phase.input_required`, `run.completed`, …)
                  and

                  `data: { id, event_type, phase, agent, payload, timestamp }`.
                  The stream does not end

                  by itself when the run finishes; close it once you see a
                  `run.*` end event.
              example: >
                id: 5e1f0a2b-3c4d-4e5f-8a6b-7c8d9e0f1a2b

                event: phase.started

                data:
                {"id":"5e1f0a2b-3c4d-4e5f-8a6b-7c8d9e0f1a2b","event_type":"phase.started","phase":"review","agent":"claude-code","payload":null,"timestamp":1759834210000}


                : keepalive
        '400':
          description: '`missing_run_id`: The `run_id` query parameter was not sent.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                missing_run_id:
                  summary: missing_run_id
                  value:
                    ok: false
                    error: run_id is required
                    code: missing_run_id
        '401':
          description: >-
            `unauthorized`: No `Authorization` header, or the token is
            malformed, expired or revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                unauthorized:
                  summary: unauthorized
                  value:
                    ok: false
                    error:
                      code: unauthorized
                      message: Authentication required
        '403':
          description: >-
            `forbidden`: You can see the record but your role in its realm is
            too low or lacks the required permission.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                forbidden:
                  summary: forbidden
                  value:
                    ok: false
                    error:
                      code: forbidden
                      message: You do not have access to do this
        '404':
          description: >-
            `not_found`: The run does not exist or is in a realm you cannot see
            (404 rather than 403, so its existence is not revealed).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                not_found:
                  summary: not_found
                  value:
                    ok: false
                    error:
                      code: not_found
                      message: Not found
        '500':
          description: >-
            `internal_error`: An unexpected server fault. Retry later; if it
            persists, report it with the time of the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                internal_error:
                  summary: internal_error
                  value:
                    ok: false
                    error: Internal server error
                    code: internal_error
      security:
        - BearerAuth: []
components:
  schemas:
    HubErr:
      type: object
      required:
        - ok
        - error
      description: >-
        Every failure. Route-policy denials (401/403/404, and 400 when neither
        realm_id nor org_id was sent) answer `error` as `{ code, message }`;
        errors raised by the endpoint answer `error` as the message with the
        code beside it in `code`. Every error has a code. See
        [Errors](/hub-api/errors).
      properties:
        ok:
          type: boolean
          description: Always false on error
        error:
          description: The message, or `{ code, message }` for an access denial.
          oneOf:
            - type: string
            - type: object
              required:
                - code
                - message
              properties:
                code:
                  type: string
                message:
                  type: string
        code:
          type: string
          description: Stable error code of an endpoint error.
        details:
          type: object
          additionalProperties: true
          description: Structured detail, when there is some.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: cliq_tok_* | cliq_dt_*
      description: >-
        User PAT (`cliq_tok_…`, including session-scoped) or realm token
        (`cliq_dt_…`).

````

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