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

# Events of outbound calls

> Live status stream for one outbound call (server-sent events).


Subscribes to the call's status as a `text/event-stream`. The first event is always a `snapshot`, carrying the call's current `phase`/`outcome` plus its full `statusHistory` to date. Every subsequent event is a `phase` event describing one applied transition. Every event carries a `version` — use it to detect and discard a `phase` event that describes the same transition already included in the initial `snapshot`.

The stream stays open until the call reaches `phase=terminal` (one final event is still delivered) or the client disconnects. There is no guaranteed minimum interval between events; treat gaps as normal, not as evidence of a stall.


## OpenAPI

````yaml agent-platform/api-specs/outbound-calls.yaml get /api/v1/project/{projectSlug}/{env}/outbound-calls/{outboundCallId}/events 
openapi: 3.1.0
info:
  title: Outbound Dial API
  version: 1.0.0
  summary: >-
    Project-scoped API for placing, tracking, and terminating outbound phone/SIP
    calls through KoreVG.
  description: >
    Places an outbound call through a project's telephony channel connection,
    and lets you

    track it through to completion — either by polling, by listing/searching the
    call log, or

    by subscribing to a live server-sent-events stream.


    Outbound calls are asynchronous by nature. Initiating a call returns
    immediately with an

    `outboundCallId` and an initial `phase` of `accepted` — the call has been
    accepted for

    submission, not yet answered. Track its progress with `GET
    .../outbound-calls/{id}`, the

    live event stream at `GET .../outbound-calls/{id}/events`, or by
    listing/searching the call

    log.


    ### Call lifecycle


    A call moves through `phase` values in order: `accepted` → `dialing` →
    `ringing` →

    `in_progress` (answered) → `terminal` (call has ended, either way). Once a
    call reaches

    `terminal`, `outcome` explains how it ended (`completed`, `busy`,
    `rejected`, `no_answer`,

    `machine`, `failed`, `canceled`, or `expired`), and `failureReason` carries
    additional

    detail for a non-`completed` outcome. A call that connects (`in_progress`)
    creates a

    session — `sessionId` on the call record correlates to that session's own
    history/traces

    once available.


    ### Idempotency


    Every initiate request requires an `idempotencyKey`. Retrying the identical
    request body

    with the same key returns the **original** call (`200`) instead of placing a
    duplicate

    call (`201` on first submission). Reusing the same key with a **different**
    body is

    rejected with `409 IDEMPOTENCY_CONFLICT` — pick a new key for a genuinely
    different call.


    ### Authentication


    Authenticate with the `x-api-key` header, using a Platform API key

    (`abl_...`) scoped to the project you are calling. Write operations
    (initiate, terminate)

    require the `outbound_calls.initiate` scope; read operations (lookup, list,
    summary,

    search, event stream) require `outbound_calls.read`.


    ### Privacy


    `destination` is always returned masked on the wire (e.g. `+1*******67`) —
    the full

    number is never echoed back after initiation. `providerCallSid` (the
    underlying telephony

    provider's own call identifier) is likewise masked in call-log responses.
    List and search

    responses never carry an unmasked destination either; use `POST
    .../outbound-calls/search`

    with the real number to look a call up by destination — it is matched
    against a blind

    index server-side, so the raw number never appears in a URL or is logged in
    access logs.


    ### Isolation


    A call belonging to a different project is concealed as `404
    CHANNEL_NOT_FOUND` /

    `404 Not Found`, never `403` — the API does not disclose whether a resource
    exists outside

    your project's scope.
servers:
  - url: https://example.com
    description: Base URL of your platform.
    variables:
      host:
        default: runtime.example.com
security:
  - ApiKeyAuth: []
tags:
  - name: Outbound Calls
    description: Place and track outbound phone/SIP calls.
paths:
  /api/v1/project/{projectSlug}/{env}/outbound-calls/{outboundCallId}/events:
    get:
      tags:
        - Outbound Calls
      summary: Live status stream for one outbound call (server-sent events)
      description: |
        Live status stream for one outbound call (server-sent events).
      operationId: streamOutboundCallEvents
      parameters:
        - $ref: '#/components/parameters/ProjectSlug'
        - $ref: '#/components/parameters/Env'
        - $ref: '#/components/parameters/OutboundCallId'
      responses:
        '200':
          description: |
            An open `text/event-stream`. Each `data:` line is one JSON-encoded
            `OutboundStreamEvent`.
          content:
            text/event-stream:
              schema:
                $ref: '#/components/schemas/OutboundStreamEvent'
              example: >
                event: snapshot

                data:
                {"type":"snapshot","outboundCallId":"oc_01a0a4af5a417f5186af","phase":"ringing","outcome":null,"version":2,"statusHistory":[{"phase":"dialing","outcome":null,"providerEventAt":"2026-09-15T10:49:11.100Z","ingestedAt":"2026-09-15T10:49:11.204Z"},{"phase":"ringing","outcome":null,"providerEventAt":"2026-09-15T10:49:12.800Z","ingestedAt":"2026-09-15T10:49:12.910Z"}]}


                event: phase

                data:
                {"type":"phase","outboundCallId":"oc_01a0a4af5a417f5186af","phase":"in_progress","outcome":null,"version":3}
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  parameters:
    ProjectSlug:
      name: projectSlug
      in: path
      required: true
      description: The project's slug.
      schema:
        type: string
        minLength: 1
    Env:
      name: env
      in: path
      required: true
      description: >-
        Deployment environment segment the call runs under, e.g. `production`,
        `staging`, `dev`.
      schema:
        type: string
        minLength: 1
    OutboundCallId:
      name: outboundCallId
      in: path
      required: true
      description: Identifier returned when the call was initiated.
      schema:
        type: string
        minLength: 1
  schemas:
    OutboundStreamEvent:
      type: object
      required:
        - type
        - outboundCallId
        - phase
        - outcome
        - version
      properties:
        type:
          type: string
          enum:
            - snapshot
            - phase
          description: >-
            snapshot=the first event on the stream, current state + full
            history; phase=one applied transition.
        outboundCallId:
          type: string
        phase:
          $ref: '#/components/schemas/OutboundCallPhase'
        outcome:
          oneOf:
            - $ref: '#/components/schemas/OutboundCallOutcome'
            - type: 'null'
        version:
          type: integer
          description: >-
            Monotonically increasing per call. Use to dedupe a `phase` event
            already covered by the initial `snapshot`.
        statusHistory:
          type: array
          description: Present only on the `snapshot` event.
          items:
            $ref: '#/components/schemas/OutboundCallStatusHistoryEntry'
    OutboundCallPhase:
      type: string
      description: >
        Lifecycle phase, in order: accepted=submitted, not yet dialing;
        dialing=submitted to

        the carrier; ringing=destination is ringing; in_progress=answered, call
        is live;

        terminal=call has ended (see `outcome`).
      enum:
        - accepted
        - dialing
        - ringing
        - in_progress
        - terminal
    OutboundCallOutcome:
      type: string
      description: >
        How a terminal call ended. completed=ended normally after connecting;

        busy=destination was busy; rejected=destination actively
        declined/rejected the call;

        no_answer=rang without being picked up; machine=answering machine
        detected (only

        possible with `amdMode` other than `off`); failed=a hard failure
        prevented completion;

        canceled=terminated by a `.../terminate` call before it connected;
        expired=the call was

        abandoned before reaching a provider-reported outcome.
      enum:
        - completed
        - busy
        - rejected
        - no_answer
        - machine
        - failed
        - canceled
        - expired
    OutboundCallStatusHistoryEntry:
      type: object
      required:
        - phase
        - outcome
        - providerEventAt
        - ingestedAt
      properties:
        phase:
          $ref: '#/components/schemas/OutboundCallPhase'
        outcome:
          oneOf:
            - $ref: '#/components/schemas/OutboundCallOutcome'
            - type: 'null'
        providerEventAt:
          type:
            - string
            - 'null'
          format: date-time
          description: >-
            When the telephony provider says the transition happened. Null when
            the provider did not supply a timestamp.
        ingestedAt:
          type: string
          format: date-time
          description: When the platform recorded this transition.
    ErrorEnvelope:
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          const: false
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Stable machine-readable error code.
            message:
              type: string
              description: Human-readable detail.
            requestId:
              type: string
              description: Correlates this failure to platform-side logs.
  responses:
    Unauthorized:
      description: Missing or invalid `x-api-key`, or the key lacks the required scope.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
    NotFound:
      description: >
        `error.code=CHANNEL_NOT_FOUND` — either the `channelConnectionId`
        doesn't exist, or

        the `outboundCallId` doesn't exist or belongs to a different project
        (isolation is

        enforced by concealment, not a `403`).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorEnvelope'
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >
        Project-bound Platform API key (`abl_...`). The key must carry
        `outbound_calls.initiate`

        for write operations (initiate, terminate) or `outbound_calls.read` for
        read operations

        (lookup, list, summary, search, event stream).

````