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

# Streaming

> Stream Response API events as they're generated

Each streaming event carries a `type` field like `response.output_text.delta` or `response.completed`. The stream ends with a terminal event (`response.completed`, `response.incomplete`, or `response.failed`) instead of a `data: [DONE]` sentinel.

## Prerequisites

* An [Auriko API key](https://auriko.ai/signup?redirectTo=%2Fdashboard%3Ftab%3Dapi-keys)
* Python 3.10+ with the OpenAI SDK (`pip install openai`) or the Auriko SDK (`pip install auriko`)
  * OR Node.js 18+ with the OpenAI SDK (`npm install openai`) or `@auriko/sdk` (`npm install @auriko/sdk`)

## Stream text

Stream a response and print each text token:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  stream = client.responses.create(
      model="gpt-4o",
      input="Count from 1 to 10",
      stream=True
  )

  for event in stream:
      if event.type == "response.output_text.delta":
          print(event.delta, end="", flush=True)
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const stream = await client.responses.create({
      model: "gpt-4o",
      input: "Count from 1 to 10",
      stream: true,
  });

  for await (const event of stream) {
      if (event.type === "response.output_text.delta") {
          process.stdout.write(event.delta);
      }
  }
  ```

  ```python Python Auriko theme={null}
  import os
  from auriko import Client

  client = Client(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  stream = client.responses.create(
      model="gpt-4o",
      input="Count from 1 to 10",
      stream=True
  )

  for event in stream:
      if event.type == "response.output_text.delta":
          print(event.delta, end="", flush=True)
  ```

  ```typescript TypeScript Auriko theme={null}
  import { Client } from "@auriko/sdk";

  const client = new Client({
      apiKey: process.env.AURIKO_API_KEY,
      baseUrl: "https://api.auriko.ai/v1",
  });

  const stream = await client.responses.create({
      model: "gpt-4o",
      input: "Count from 1 to 10",
      stream: true,
  });

  for await (const event of stream) {
      if (event.type === "response.output_text.delta") {
          process.stdout.write(event.delta);
      }
  }
  ```

  ```bash cURL theme={null}
  curl --no-buffer https://api.auriko.ai/v1/responses \
    -H "Authorization: Bearer $AURIKO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-4o",
      "input": "Count from 1 to 10",
      "stream": true
    }'
  ```
</CodeGroup>

## Handle event types

A basic text response emits events in this order:

`response.created` → `response.in_progress` → `response.output_item.added` → `response.content_part.added` → `response.output_text.delta` (repeated) → `response.output_text.done` → `response.content_part.done` → `response.output_item.done` → `response.completed`

### Lifecycle events

| Event                  | Description                                          |
| ---------------------- | ---------------------------------------------------- |
| `response.created`     | Response object created, status is `in_progress`     |
| `response.in_progress` | Processing has started                               |
| `response.completed`   | Response finished, includes final `response` object  |
| `response.incomplete`  | Response stopped early (token limit, content filter) |
| `response.failed`      | Response failed, includes error details              |

### Content events

| Event                         | Description                                                 |
| ----------------------------- | ----------------------------------------------------------- |
| `response.output_item.added`  | New output item started (text, function call, or reasoning) |
| `response.output_item.done`   | Output item finished                                        |
| `response.content_part.added` | New content part within an output item                      |
| `response.content_part.done`  | Content part finished                                       |
| `response.output_text.delta`  | Text chunk, access via `event.delta`                        |
| `response.output_text.done`   | Text output complete, access full text via `event.text`     |

### Reasoning events

| Event                                   | Description                     |
| --------------------------------------- | ------------------------------- |
| `response.reasoning_summary_part.added` | Reasoning summary part started  |
| `response.reasoning_summary_part.done`  | Reasoning summary part finished |
| `response.reasoning_summary_text.delta` | Reasoning summary text chunk    |
| `response.reasoning_summary_text.done`  | Reasoning summary text complete |

### Tool call events

| Event                                    | Description                      |
| ---------------------------------------- | -------------------------------- |
| `response.function_call_arguments.delta` | Function call arguments chunk    |
| `response.function_call_arguments.done`  | Function call arguments complete |

### Error event

| Event   | Description        |
| ------- | ------------------ |
| `error` | Stream-level error |

Terminal events (`response.completed`, `response.incomplete`, `response.failed`) carry the final `response` object with `usage` and `routing_metadata`.

## Access completed response

You can read `response_headers` before iterating. After iteration, the stream exposes the terminal event's full response object.

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  stream = client.responses.create(
      model="gpt-4o",
      input="What is 2 + 2?",
      stream=True
  )

  completed = None
  for event in stream:
      if event.type == "response.output_text.delta":
          print(event.delta, end="", flush=True)
      elif event.type == "response.completed":
          completed = event.response

  print(f"\nModel: {completed.model}")
  print(f"Usage: {completed.usage.input_tokens} in, {completed.usage.output_tokens} out")
  ```

  ```typescript TypeScript OpenAI theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
      apiKey: process.env.AURIKO_API_KEY,
      baseURL: "https://api.auriko.ai/v1",
  });

  const stream = await client.responses.create({
      model: "gpt-4o",
      input: "What is 2 + 2?",
      stream: true,
  });

  let completed: any = null;
  for await (const event of stream) {
      if (event.type === "response.output_text.delta") {
          process.stdout.write(event.delta);
      } else if (event.type === "response.completed") {
          completed = event.response;
      }
  }

  console.log(`\nModel: ${completed?.model}`);
  console.log(`Usage: ${completed?.usage?.input_tokens} in, ${completed?.usage?.output_tokens} out`);
  ```

  ```python Python Auriko theme={null}
  import os
  from auriko import Client

  client = Client(
      api_key=os.environ["AURIKO_API_KEY"],
      base_url="https://api.auriko.ai/v1"
  )

  stream = client.responses.create(
      model="gpt-4o",
      input="What is 2 + 2?",
      stream=True
  )

  for event in stream:
      if event.type == "response.output_text.delta":
          print(event.delta, end="", flush=True)

  final = stream.completed_response
  print(f"\nModel: {final.model}")
  print(f"Tokens: {final.usage.total_tokens}")
  print(f"Provider: {final.routing_metadata.provider}")
  ```

  ```typescript TypeScript Auriko theme={null}
  import { Client } from "@auriko/sdk";

  const client = new Client({
      apiKey: process.env.AURIKO_API_KEY,
      baseUrl: "https://api.auriko.ai/v1",
  });

  const stream = await client.responses.create({
      model: "gpt-4o",
      input: "What is 2 + 2?",
      stream: true,
  });

  for await (const event of stream) {
      if (event.type === "response.output_text.delta") {
          process.stdout.write(event.delta);
      }
  }

  const final = stream.completedResponse;
  console.log(`\nModel: ${final?.model}`);
  console.log(`Tokens: ${final?.usage?.total_tokens}`);
  console.log(`Provider: ${final?.routing_metadata?.provider}`);
  ```
</CodeGroup>

cURL streams raw SSE events. See [Read raw SSE](#read-raw-sse) for parsing terminal events.

For routing metadata with the OpenAI SDK, see [OpenAI Compatibility](/openai-compatibility#access-routing-metadata).

## Stream asynchronously

Stream with the async client:

<CodeGroup>
  ```python Python OpenAI theme={null}
  import os
  import asyncio
  from openai import AsyncOpenAI

  async def stream_response():
      client = AsyncOpenAI(
          api_key=os.environ["AURIKO_API_KEY"],
          base_url="https://api.auriko.ai/v1"
      )

      stream = await client.responses.create(
          model="gpt-4o",
          input="Write a haiku about code",
          stream=True
      )

      async for event in stream:
          if event.type == "response.output_text.delta":
              print(event.delta, end="", flush=True)

  asyncio.run(stream_response())
  ```

  ```python Python Auriko theme={null}
  import os
  import asyncio
  from auriko import AsyncClient

  async def stream_response():
      client = AsyncClient(
          api_key=os.environ["AURIKO_API_KEY"],
          base_url="https://api.auriko.ai/v1"
      )

      stream = await client.responses.create(
          model="gpt-4o",
          input="Write a haiku about code",
          stream=True
      )

      async for event in stream:
          if event.type == "response.output_text.delta":
              print(event.delta, end="", flush=True)

  asyncio.run(stream_response())
  ```
</CodeGroup>

TypeScript's SDK is inherently async. See the [Stream text](#stream-text) example above.

## Read raw SSE

The raw wire format uses `event:` and `data:` lines. A basic text response looks like this:

```
event: response.created
data: {"type":"response.created","response":{"id":"resp_abc123","object":"response","status":"in_progress",...}}

event: response.in_progress
data: {"type":"response.in_progress","response":{"id":"resp_abc123","object":"response","status":"in_progress",...}}

event: response.output_item.added
data: {"type":"response.output_item.added","output_index":0,"item":{"type":"message","role":"assistant","content":[]}}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":"The"}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":" capital"}

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_abc123","object":"response","status":"completed","output":[...],"usage":{...},"routing_metadata":{...}}}
```

See [Chat Completions streaming](/guides/streaming) for the `data: [DONE]` format used by the other endpoint. See [Error Handling](/guides/error-handling) for error recovery patterns.