Streaming responses over SSE

Set "stream": true to receive the response incrementally as Server-Sent Events (SSE). Pass -N (or --no-buffer) to curl so it prints chunks as they arrive.

Read a stream with Python

Install openai and set IMPOSSIBL_API_KEY as in the quickstart.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.impossibl.com/v1",
    api_key=os.environ["IMPOSSIBL_API_KEY"],
)

stream = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Count to three."}],
    stream=True,
    stream_options={"include_usage": True},
)
for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)
    if chunk.usage:
        print("\nTokens:", chunk.usage.total_tokens)

The usage chunk can have an empty choices array. Check it before indexing.

A stream can fail after HTTP 200. Handle SDK exceptions and incomplete output; a connection closing is not proof of success. See streaming errors.

Chat Completions

cURL and Chat Completions events

Each event is a line data: <json> carrying a chat.completion.chunk:

curl -N https://api.impossibl.com/v1/chat/completions \
  -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
  -H 'content-type: application/json' \
  -d '{
    "model": "openai/gpt-4o-mini",
    "stream": true,
    "stream_options": { "include_usage": true },
    "messages": [{"role":"user","content":"Count to 3"}]
  }'

Stream (abridged)

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"1"},"finish_reason":null}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":9,"completion_tokens":5,"total_tokens":14}}

data: [DONE]

First chunk → delta.role: "assistant", finish_reason: null
Content chunks → delta.content holds the next token(s)
Final chunk → empty delta, finish_reason set (stop, length, …)
Usage chunk → only when stream_options.include_usage is true; it has an empty choices array and a usage object
Terminator → data: [DONE]

To reassemble the text, concatenate choices[0].delta.content only when choices is nonempty and the delta contains text. Because the gateway emits the exact OpenAI shape, client.chat.completions.create(..., stream=True) in any OpenAI SDK works unchanged.

Responses API

Show request format

The Responses API streams semantic events instead of generic chunks. Each event has both an event: line and a data: line, and a monotonically increasing sequence_number.

curl -N https://api.impossibl.com/v1/responses \
  -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"model":"anthropic/claude-haiku-4-5","stream":true,"input":"Count to 3"}'

For a text-only response, events arrive in this order:

Event	Meaning
`response.created`	response started (status `in_progress`)
`response.in_progress`	progress heartbeat
`response.output_item.added`	the assistant message item begins
`response.content_part.added`	an `output_text` part begins
`response.output_text.delta`	a text delta (`delta` field) — repeats
`response.output_text.done`	the text part finished
`response.content_part.done`	the content part finished
`response.output_item.done`	the message item finished
`response.completed`	final — carries the full `response` object + `usage`

Aggregate the delta fields from response.output_text.delta events to build the text; read final token usage from response.completed.When the model reasons, a reasoning item comes first, at output_index 0, and the message item follows at the next index. Its summary events appear only when the request sets reasoning.summary; each reasoning block is one summary part (summary_index):

Event	Meaning
`response.output_item.added`	the `reasoning` item begins (empty `summary`)
`response.reasoning_summary_part.added`	a `summary_text` part begins
`response.reasoning_summary_text.delta`	a summary delta (`delta` field) — repeats
`response.reasoning_summary_text.done`	the summary part’s full `text`
`response.reasoning_summary_part.done`	the summary part finished
`response.output_item.done`	the reasoning item finished, with its full `summary`

See reasoning for the item’s shape.

Messages (Anthropic)

Show request format

POST /v1/messages streams Anthropic’s semantic events, so the official anthropic SDK’s client.messages.stream(...) works unchanged. Like the Responses API, each event has an event: line and a data: line. (A bare claude-... model id routes to Anthropic; any provider/model id also works here — see SDKs & integrations.)

curl -N https://api.impossibl.com/v1/messages \
  -H "x-api-key: $IMPOSSIBL_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"model":"claude-haiku-4-5","max_tokens":64,"stream":true,"messages":[{"role":"user","content":"Count to 3"}]}'

For a text-only response, events arrive in this order:

Event	Meaning
`message_start`	the assistant `message` begins (empty `content`, zeroed usage)
`content_block_start`	a `text` content block begins (`index` 0)
`ping`	keep-alive heartbeat
`content_block_delta`	a `text_delta` (`delta.text`) — repeats
`content_block_stop`	the content block finished
`message_delta`	carries the final `stop_reason` and cumulative `usage`
`message_stop`	final — the stream is complete

Concatenate delta.text from content_block_delta events to build the output; read the final token usage (and stop_reason) from message_delta. Note the usage on message_start is zeroed — real token counts are only known at the end.

Get started

Build

Modalities

Manage

Streaming responses over SSE

Read a stream with Python

Chat Completions

Responses API

Messages (Anthropic)

​Read a stream with Python

​Chat Completions

​Responses API

​Messages (Anthropic)

Read a stream with Python

Chat Completions

Responses API

Messages (Anthropic)