Streaming

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
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:

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)

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);
    }
}

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)

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);
    }
}

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
  }'

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.

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")

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`);

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}")

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}`);

cURL streams raw SSE events. See Read raw SSE for parsing terminal events. For routing metadata with the OpenAI SDK, see OpenAI Compatibility.

Stream asynchronously

Stream with the async client:

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())

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())

TypeScript’s SDK is inherently async. See the 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 for the data: [DONE] format used by the other endpoint. See Error Handling for error recovery patterns.

Get Started

Guides

Response API

Frameworks

Integrations

Specifications

Platform

Changelog

Prerequisites

Stream text

Handle event types

Lifecycle events

Content events

Reasoning events

Tool call events

Error event

Access completed response

Stream asynchronously

Read raw SSE

​Prerequisites

​Stream text

​Handle event types

​Lifecycle events

​Content events

​Reasoning events

​Tool call events

​Error event

​Access completed response

​Stream asynchronously

​Read raw SSE

Prerequisites

Stream text

Handle event types

Lifecycle events

Content events

Reasoning events

Tool call events

Error event

Access completed response

Stream asynchronously

Read raw SSE