Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Streaming: antwoorden in realtime ontvangen

Les 8 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Streaming: antwoorden in realtime ontvangen
  2. Waarom streamen?
  3. Getypte events, geen ongeordende stream
  4. Streaming en functieaanroepen
  5. Het asynchrone geval
  6. Fouten tijdens het streamen
  7. Belangrijkste punten

Streaming: antwoorden in realtime ontvangen

Met streaming ontvangt u het antwoord token voor token, in plaats van te wachten tot de volledige generatie is voltooid. Dit is niet slechts een cosmetische verbetering van de gebruikersinterface: het is het verschil tussen een chatbot die traag aanvoelt en een die vlot reageert, zelfs als de serverprestaties identiek zijn.

Waarom streamen?

Zonder streaming staren gebruikers soms tien tot dertig seconden naar een leeg scherm voordat het volledige antwoord in één keer verschijnt. Met streaming verschijnen de eerste woorden binnen een seconde en begint de lezing terwijl de generatie doorgaat. De totale duur is hetzelfde; de perceptie niet. Het inschakelen vereist slechts één parameter, stream=True, waarmee de retourwaarde van create() wordt omgezet in een event-iterator.

from openai import OpenAI
client = OpenAI()

# ZONDER streaming — wacht op alles
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Verschijnt in één keer na het wachten

# MET streaming — token voor token
stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()  # Nieuwe regel aan het einde

Getypte events, geen ongeordende stream

De stream bevat niet alleen tekst. U krijgt een melding wanneer het antwoord wordt gemaakt, wanneer elk uitvoeritem wordt toegevoegd, wanneer fragmenten binnenkomen en wanneer de voltooiing plaatsvindt; het laatste event bevat gebruiksstatistieken. U filtert op event.type om te weten wat u verwerkt. Deze structuur stelt u bijvoorbeeld in staat om direct een laadindicator weer te geven zodra response.created wordt geactiveerd en aan het einde tokens te tellen zonder een tweede API-aanroep.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!",
    stream=True
)

for event in stream:
    match event.type:
        case "response.created":
            print(f"[Response created] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[New output item]")
        case "response.output_text.delta":
            print(f"[Text] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Text complete]")
        case "response.completed":
            print(f"[Done] Tokens: {event.response.usage.total_tokens}")

# Output:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25

In een echte toepassing wilt u bijna altijd twee dingen tegelijk doen: de fragmenten weergeven en de volledige tekst reconstrueren, zodat u deze kunt archiveren of teruggeven aan de aanroeper. De regel is eenvoudig: verzamel tijdens het itereren, want zodra de stream is verbruikt, kan deze niet worden teruggespoeld.

def stream_and_collect(prompt: str) -> str:
    """Stream het antwoord terwijl u het verzamelt."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

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

    print()  # Nieuwe regel
    return full_text

result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")

Streaming en functieaanroepen

Functieaanroepen worden ook gestreamd, met hun eigen events: argumenten komen in fragmenten binnen via response.function_call_arguments.delta, en response.function_call_arguments.done geeft aan dat de JSON voltooid is. Dit heeft een belangrijke praktische consequentie: probeer de argumenten nooit te deserialiseren voordat het done-event plaatsvindt, anders heeft u slechts afgekapt JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What time is it in Tokyo?",
    tools=[{
        "type": "function",
        "name": "get_time",
        "description": "Get the time in a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }],
    stream=True
)

for event in stream:
    match event.type:
        case "response.output_text.delta":
            print(event.delta, end="")
        case "response.function_call_arguments.delta":
            print(f"[Args] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Function call complete]")

# Output:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Het asynchrone geval

Zodra uw toepassing meerdere gebruikers gelijktijdig bedient, schakelt u over op AsyncOpenAI: de synchrone client zou de event-loop blokkeren voor de volledige generatie, waardoor uw andere verzoeken moeten wachten. De syntaxis verschilt slechts met twee trefwoorden: await bij het aanmaken en async for bij het itereren.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynchroon streamen van het antwoord."""
    stream = await async_client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

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

asyncio.run(stream_async("Tell a short joke."))

Op het web is streaming nutteloos als het stopt bij uw server: u moet het uitbreiden naar de browser. FastAPI maakt dit mogelijk met StreamingResponse, gevoed door een generator die fragmenten doorgeeft zodra ze binnenkomen.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

@app.get("/chat")
async def chat(question: str):
    def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=question,
            stream=True
        )
        for event in stream:
            if event.type == "response.output_text.delta":
                yield event.delta

    return StreamingResponse(generate(), media_type="text/plain")

Fouten tijdens het streamen

Eén detail verdient uw aandacht: bij streaming kan er een fout optreden nadat fragmenten al zijn weergegeven. De gebruiker ziet dan een antwoord dat begint maar wordt afgebroken. Omhul daarom de iteratie zelf, niet alleen het aanmaken van de stream, zodat u de onderbreking netjes kunt signaleren in plaats van een zin in de lucht te laten hangen.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streamen met robuuste foutafhandeling."""
    try:
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True
        )

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

    except APIError as e:
        print(f"\nAPI error during streaming: {e.message}")
    except Exception as e:
        print(f"\nUnexpected error: {e}")

stream_with_errors("Explain streaming in 2 sentences.")

Belangrijkste punten

  • Schakel streaming in met stream=True voor een realtime-ervaring
  • Filter events op event.type om elk gegevenstype correct te verwerken
  • response.output_text.delta bevat tekstfragmenten
  • response.completed signaleert het einde en bevat gebruiksstatistieken
  • Gebruik AsyncOpenAI voor streaming in asynchrone toepassingen
  • Handel fouten altijd af, zelfs in de stream-modus