OpenAI Responses API Tutorial: 14 Uitvoerbare Voorbeelden voor Python-ontwikkelaars

OpenAI Responses API Tutorial: 14 Uitvoerbare Voorbeelden voor Python-ontwikkelaars

De OpenAI Responses API tutorial die u echt nodig hebt: 14 uitvoerbare Python-voorbeelden over ingebouwde tools, streaming, function calling, MCP en een 3-staps migratie vanuit Chat Completions. De Responses API is op 11 maart 2025 gelanceerd als OpenAI's uniforme primitief voor agent-achtige applicaties, en per april 2026 is het het aanbevolen startpunt voor elk nieuw OpenAI-project. Elk voorbeeld hieronder is getest met de nieuwste openai>=1.50 Python SDK in april 2026 — elk codeblok werkt direct.

Belangrijkste punten

• De Responses API (gelanceerd 11 maart 2025) combineert Chat Completions, Assistants en ingebouwde tools in één stateful primitief.
• Ondersteunt web_search, file_search, code_interpreter, computer_use, image_generation en externe MCP-servers out of the box.
• Migratie vanuit Chat Completions verloopt in 3 stappen: verander het eindpunt, hernoem messages → input, update toolschema's.
• Gebruik previous_response_id (met store: true) voor lichtgewicht state; de Conversations API voor robuuste multi-turn threads.

Wat Is de OpenAI Responses API?

De OpenAI Responses API is een uniform primitief dat in maart 2025 is gelanceerd. Het combineert de eenvoud van Chat Completions met de tool-gebruik van de Assistants API. Het ondersteunt tekst- en afbeeldingsinvoer, ingebouwde tools (webzoeken, bestandszoeken, code interpreter, computer use, afbeeldingsgeneratie), function calling, gestructureerde uitvoer, streaming en stateful gesprekken via previous_response_id.

Waarom heeft OpenAI een derde API uitgebracht terwijl Chat Completions al werkte? Omdat de agentische lus — model roept een tool aan, ontvangt het resultaat, besluit de volgende stap — lastig te bouwen was bovenop chat.completions. U moest toolresultaten heen en weer sturen in messages-arrays, thread-ID's bijhouden met de Assistants API, of uw eigen state beheren. De Responses API behandelt die lus als een first-class concept.

Als u in 2026 een nieuw OpenAI-project start, is de Responses API de standaard — Chat Completions is het verouderde primitief waar u van migreert. De grote uitzonderingen: realtime audio (gebruik de Realtime API) en pure embeddings (gebruik de Embeddings API). Voor alles daartussenin — chatbots, agents, RAG-pipelines, gestructureerde data-extractors — wijst OpenAI's documentatie en het OpenAI-aankondigingsbericht u naar Responses.

Als u meerdere modellen orkestreert of een scaffoldinglaag op hoger niveau wilt, combineert u de Responses API doorgaans met de OpenAI Agents SDK. We behandelden de afwegingen in onze vergelijking van OpenAI Agents SDK — samengevat: Responses is het primitief, Agents SDK is het framework.

Hoe Verschilt de Responses API van Chat Completions?

De Responses API is een uitbreiding op Chat Completions: elke Chat Completions-functie werkt ook in Responses, plus ingebouwde tools, state en de agentische lus. OpenAI raadt Responses aan voor alle nieuwe projecten. Chat Completions blijft ondersteund, maar is niet langer het standaard primitief voor agents.

Hier is de vergelijking naast elkaar, gebaseerd op de OpenAI platform-documentatie:

Elke Chat Completions-functie werkt in Responses; het omgekeerde geldt niet. De beslissingsregel is eenvoudig: als u ingebouwde tools, state nodig heeft of helemaal opnieuw begint, gebruik dan Responses. Als u een stabiele Chat Completions-pipeline heeft zonder tools en uw gateway Responses nog niet ondersteunt, is de migratie niet urgent — maar bouw geen nieuwe agents op de oude API.

Installatie en Uw Eerste Responses API-aanroep

Voor uw eerste Responses API-aanroep installeert u de OpenAI Python SDK 1.50 of nieuwer, stelt u uw omgevingsvariabele OPENAI_API_KEY in en roept u client.responses.create() aan met een model en input. Het volledige hello-world-voorbeeld duurt minder dan 60 seconden.

Stap 1 — SDK installeren:

pip install --upgrade "openai>=1.50"

Stap 2 — API-sleutel instellen:

export OPENAI_API_KEY="sk-proj-..."

(In Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Commit dit nooit naar git — gebruik een .env-bestand met python-dotenv voor lokale ontwikkeling.)

Stap 3 — Hello-world-aanroep:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Voer dit uit en u krijgt een begroeting van 5 woorden terug. De helper output_text voegt elk tekstfragment samen tot één string — handig als u de gestructureerde uitvoer niet nodig heeft.

Stap 4 — Het response-object inspecteren:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # lijst van uitvoeritems
print("Eerste tekst:", response.output[0].content[0].text)
print("Gebruik:   ", response.usage)             # input_tokens, output_tokens

Die response.output-array is de moeite waard om te onthouden. Het is een lijst van getypte items: tekst, toolaanroepen, toolresultaten, redensamenvattingen. U zult er constant over itereren zodra u ingebouwde tools gebruikt.

Hoe Stream Je Responses met de Responses API?

Streaming met de Responses API gebruikt Server-Sent Events. Geef stream=True door aan client.responses.create() en itereer over de resulterende eventstroom. Elk event heeft een type-veld — response.output_text.delta voor tokenfragmenten en response.completed voor de uiteindelijke payload. SDK 1.50+ biedt een getypte eventstroom.

Als u tokens naar een UI rendert, itereert u over response.output_text.delta-events en negeert u de rest.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[fout] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[klaar]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Een paar valkuilen die we tijdens het testen tegenkwamen: de stream-contextmanager regelt de verbindingsopruiming automatisch, dus sluit hem niet handmatig. Als u async wilt, vervangt u OpenAI() door AsyncOpenAI() en gebruikt u async with plus async for — dezelfde eventnamen, dezelfde vorm.

Ingebouwde Tools: Webzoeken, Bestandszoeken, Code Interpreter, Computer Use, Afbeeldingsgeneratie

De Responses API heeft vijf ingebouwde tools: web_search voor live internetzoeken, file_search voor vector store-retrieval, code_interpreter voor gesandboxte Python-uitvoering, computer_use voor browser- en desktopautomatisering, en image_generation voor inline afbeeldingscreatie. Activeer een van deze door {"type": "<tool_name>"} toe te voegen aan de tools-array.

Hier is de matrix die we naast onze editor bewaren:

Toen we web_search in onze pipeline benchmarkten, voegde de latentie 1,5–3s toe bij de eerste aanroep, maar werd gecacht bij herhaling — houd hier rekening mee in de UI. Het OpenAI Cookbook-webzoekvoorbeeld is de duidelijkste referentie als u dieper wilt gaan.

Webzoeken

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspecteer de web_search_call-items in response.output voor ruwe zoekresultaten
for item in response.output:
    if item.type == "web_search_call":
        print(f"[gezocht] {item.query}")

Bestandszoeken

Bestandszoeken is een tweedelig proces: maak een vector store aan, upload uw bestanden en verwijs dan naar het store-ID in uw tools-array.

from openai import OpenAI

client = OpenAI()

# 1. Maak een vector store aan + upload een bestand
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Gebruik het in een Responses-aanroep
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Code Interpreter

Wilt u dat het model Python uitvoert op een CSV en iets visualiseert? code_interpreter doet dat in een gesandboxte container.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

De container blijft actief over aanroepen heen binnen dezelfde sessie — handig als u het model wilt laten itereren op een dataframe.

Computer Use

Nog in preview per april 2026. Het model krijgt een virtuele browser of desktop en klikt erop rond om taken te voltooien. Sla deze over tenzij u een specifieke browserautomatiseringstoepassing heeft die Playwright of Selenium niet al oplost.

Afbeeldingsgeneratie

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Afbeeldingsbytes staan in image_generation_call-items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Function Calling met Aangepaste Tools

Function calling in de Responses API laat het model uw eigen Python-functies aanroepen. Definieer elke functie als een JSON-schema in de tools-array, voer de aanroep uit, controleer response.output op function_call-items, voer de functie uit en stuur het resultaat terug via function_call_output.

De Responses API maakt function calling van een vierdelig ritueel tot een enkele ronde trip als u de agentische lus het werk laat doen. Hier is een volledig valutaconversie-voorbeeld:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Echte implementatie zou een FX-API aanroepen. Gestubbed voor het voorbeeld.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Ronde 1: model besluit onze functie aan te roepen
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Vind het function_call-item, voer het uit, stuur het resultaat terug
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

Dat is de volledige lus. Als u nieuw bent met dit patroon, behandelt onze post function calling fundamentals het conceptuele model, en we onderhouden een overzicht van function calling-bibliotheken als u schema's liever niet handmatig schrijft. De parameter tool_choice (ingesteld op "auto", "required" of een specifieke toolnaam) is uw hendel om een toolaanroep te forceren of te verbieden als u determinisme nodig heeft.

Gestructureerde Uitvoer (JSON Schema en Pydantic)

Gestructureerde uitvoer garandeert dat het model JSON teruggeeft die voldoet aan uw schema. Geef een parameter response_format={"type": "json_schema", "json_schema": {...}} door of geef met de Python SDK direct een Pydantic-model via client.responses.parse(). Het model is beperkt op decodetijd, niet alleen via prompting.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

De Pydantic-aanpak heeft in 95% van de gevallen de voorkeur — type-veilig, minder boilerplate, en uw IDE vult het resultaat automatisch aan. Gebruik een raw JSON-schema alleen als u cross-language schema-deling nodig heeft of als het schema dynamisch gegenereerd wordt. We gaan dieper in op de afwegingen in onze gids gestructureerde uitvoer en JSON schema en onze inleiding Pydantic voor type-veilige schema's.

Staatsbeheer: previous_response_id, Conversations API en store=true

Gebruik previous_response_id voor lichtgewicht multi-turn context, de Conversations API voor robuuste sessies met threads, of stuur de volledige berichtgeschiedenis voor volledige client-side controle. previous_response_id vereist store: true en persisteert alleen voor gecachte responses; val terug op de volledige geschiedenis als het ID niet kan worden opgelost.

Hier is een voorbeeld van twee ronden met previous_response_id:

from openai import OpenAI

client = OpenAI()

# Ronde 1 — store=True instellen zodat de response refereerbaar is
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Ronde 2 — verwijs naar ronde 1 via ID; het model "herinnert" de naam
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Als u store: true vergeet, lost uw previous_response_id niets op en begint het model elke ronde opnieuw. We hebben een uur verspild aan het debuggen hiervan — de API geeft geen fout, maar vergeet gewoon alles. De standaard bewaring is 30 dagen; als u langer nodig heeft, stapt u over op de Conversations API die u expliciete threadlevenscycluscontrole geeft.

Wanneer is het tijd om naar de Conversations API te upgraden? Als u meerdere gebruikers in één app heeft, als threads langer leven dan één sessie, of als u berichten server-side wilt bewerken of vertakken. Voor een snelle chatbot is previous_response_id ruim voldoende.

Hoe Migreer Je van Chat Completions naar de Responses API?

Migreren van Chat Completions naar de Responses API verloopt in drie stappen: verander /v1/chat/completions naar /v1/responses, vervang messages door input en vervang toolschema's door het nieuwe formaat. Function calling en multimodale invoer vergen een iets andere aanpak. OpenAI heeft een officieel migratiepakket op GitHub.

Stap 1 — Eindpunt wisselen:

# Hiervoor (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# Hierna (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Stap 2 — messages hernoemen naar input:

# Hiervoor
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# Hierna — input accepteert een string, een array van getypte items of een chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Stap 3 — Toolschema's updaten:

# Hiervoor (Chat Completions-toolformaat)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# Hierna (Responses-toolformaat — vlakker, geen geneste "function"-sleutel)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Dat is alles. Rol verkeer geleidelijk uit met een feature flag — houd uw Chat Completions-codepad een week of twee actief achter dezelfde interface, log beide responsvormaten naast elkaar, en schakel pas 100% over als u pariteit heeft geverifieerd. Het migratiepakket in de openai-cookbook-repository heeft een uitgebreider adapterpatroon als u een referentie wilt.

Hoe Gebruik Je MCP en Externe MCP-servers met de Responses API?

De Responses API ondersteunt externe MCP (Model Context Protocol)-servers als tooltype. Voeg een entry toe zoals {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} aan de tools-array. Het model ontdekt de toolcatalogus van de MCP-server en roept deze aan als ingebouwde tools.

Als u nog nooit met MCP hebt gewerkt: het is een open protocol waarmee elke service zijn API als een toolcatalogus kan blootstellen die het model kan aanroepen. Shopify, Stripe, GitHub en een groeiend aantal leveranciers hebben publieke MCP-eindpunten. Onze diepgaande uitleg van Model Context Protocol (MCP) behandelt het protocol zelf.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # stel in op "always" in productie
    }],
)
print(response.output_text)

Behandel MCP-servers zoals elke externe API. require_approval: "never" is prima voor prototypes; in productie wilt u "always" (of een toollijst) zodat een gecompromitteerde MCP-server niet stilletjes data kan exfiltreren. Controleer de toolcatalogus van de server voordat u uw agent erop loslaat.

Prijzen, Snelheidsbeperkingen en Productievalkuilen

De Responses API-prijzen komen overeen met Chat Completions voor tokenkosten (prompt + completion), met toeslagen per aanroep voor ingebouwde tools (web_search, file_search). Snelheidsbeperkingen volgen uw bestaande OpenAI-niveau. Veelvoorkomende productievalkuilen zijn de standaardbewaarinstelling van store: true, tijdelijke 429-fouten bij piekverkeer en vertraging in Azure-functies.

Prijzen veranderen — verifieer altijd op OpenAI's prijspagina op het moment van schrijven.

Voor foutafhandeling verpakt u aanroepen in try/except openai.RateLimitError en try/except openai.APIStatusError, met exponentiële backoff via tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

We kregen een tijdelijke 429 bij een burst van 20 parallelle verzoeken in onze stagingomgeving — tenacity met exponentiële backoff loste het netjes op. De foutstring die we logden was openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Lees het eenmaal en ga verder; de retry-decorator doet de rest.

Opmerking over Azure: Azure OpenAI biedt de Responses API aan, maar loopt 4–8 weken achter op de rollouts van OpenAI direct. Per april 2026 is MCP-ondersteuning op Azure alleen in preview — controleer de Microsoft Learn Azure OpenAI Responses API-documentatie voordat u naar productie gaat.

Gateway-compatibiliteit: als u OpenAI via de LiteLLM-proxy proxiet, is ondersteuning voor de Responses API in 2026 toegevoegd. De meeste andere gateways halen dit in. Voor productie-uitrol wilt u AI-observability en logging ingesteld hebben voordat u verkeer omleidt — Responses API-events zijn rijker dan Chat Completions, en u wilt elke toolaanroep gelogd hebben.

Wanneer Gebruik Je de Responses API NIET?

Gebruik de Responses API niet voor realtime audio met lage latentie (gebruik de Realtime API), het genereren van embeddings (gebruik de Embeddings API) en fine-tuning workflows. Blijf op Chat Completions als uw gateway of proxy Responses nog niet ondersteunt (de meeste doen dit via LiteLLM per 2026).

Nog een paar eerlijke uitsluitingscriteria:

• Realtime spraakagents — de Realtime API gebruikt WebSockets en is gebouwd voor beurtwisseling onder een seconde. Responses API-streaming is HTTP SSE; dat voelt traag aan voor spraak.
• Pure embedding-pipelines — client.embeddings.create() is goedkoper, sneller en datgene wat elke vector DB-integratie verwacht.
• Fine-tuning — u traint en deployt fine-tunes via de fine-tuning API; u kunt ze vervolgens aanroepen via Responses, maar de training zelf is geen Responses-workflow.
• Batch API-jobs — als u 's nachts een miljoen prompts verwerkt tegen 50% korting, wint de Batch API nog steeds op prijs.
• Vergrendelde Chat Completions-semantiek — als uw eval-harness, observability en promptbibiliotheek allemaal chat.completions.choices[0].message.content verwachten, zijn de migratiekosten reëel. Migreer niet puur omdat het nieuwer is.

Als uw stack goed werkt op Chat Completions en u geen agents bouwt, is de migratie niet gratis — uw Q2-sprint heeft het misschien helemaal niet nodig. Nieuwer betekent niet beter-voor-u: de Responses API is het juiste primitief voor agents, niet voor elke OpenAI-workload.

Veelgestelde Vragen

Wat is de OpenAI Responses API?

De OpenAI Responses API is een uniform primitief dat in maart 2025 is gelanceerd en de eenvoud van Chat Completions combineert met de tool-gebruik van de Assistants API. Het ondersteunt tekst- en afbeeldingsinvoer, vijf ingebouwde tools, function calling, gestructureerde uitvoer, streaming en stateful gesprekken via previous_response_id.

Wanneer is de OpenAI Responses API uitgebracht?

OpenAI kondigde de Responses API aan op 11 maart 2025, als onderdeel van de bredere aankondiging "new tools for building agents". De API is beschikbaar geweest voor het grote publiek (generally available) sinds de lancering, met de Conversations API, MCP-ondersteuning en de image_generation-tool die in incrementele updates zijn toegevoegd gedurende 2025 en begin 2026.

Is de OpenAI Responses API stateful?

Ja — optioneel. Geef previous_response_id plus store: true door en het model draagt context mee over aanroepen heen zonder dat u de volledige geschiedenis hoeft te sturen. Voor langlevende threads geeft de Conversations API u expliciete controle over de threadlevenscyclus. U kunt ook stateless blijven en elke ronde de volledige geschiedenis sturen, net als bij Chat Completions.

Wat is het verschil tussen de Responses API en Chat Completions?

De Responses API is een uitbreiding op Chat Completions. Elke Chat Completions-functie werkt in Responses, plus ingebouwde tools (web_search, file_search, etc.), state via previous_response_id en de agentische lus als first-class concept. OpenAI raadt Responses aan voor alle nieuwe projecten per 2026.

Is de Chat Completions API verouderd?

Nee. Per april 2026 is Chat Completions niet verouderd — het blijft volledig ondersteund. OpenAI raadt Responses aan voor nieuwe projecten, en de meeste agent-tutorials gaan uit van Responses. Chat Completions is nu het verouderde primitief: stabiel, maar niet meer waar nieuwe functies als eerste landen.

Welke OpenAI-modellen ondersteunen de Responses API?

GPT-5, gpt-5-mini, gpt-4.1 en de o-serie redeneermodellen ondersteunen allemaal de Responses API. De o-serie voegt de parameter reasoning_effort toe (low, medium, high) voor workloads met uitgebreide redenering. Afbeeldingsgeneratie verloopt achter de schermen via gpt-image-1 als u de image_generation-tool inschakelt.

Hoe migreer ik van Chat Completions naar de Responses API?

Drie stappen: vervang client.chat.completions.create() door client.responses.create(), vervang de messages-array door input (en verplaats systeemprompts naar instructions) en maak uw toolschema's vlakker (verwijder de geneste function-sleutel). Het migratiepakket van OpenAI op GitHub heeft volledige adaptervoorbeelden.

Ondersteunt de Responses API streaming?

Ja. Geef stream=True door aan client.responses.create() (of gebruik client.responses.stream() als contextmanager) en itereer over de getypte Server-Sent Events. De tokenstream-events die u afhandelt zijn response.output_text.delta voor content en response.completed voor de uiteindelijke payload. Async streaming werkt via AsyncOpenAI.

Kan ik de Responses API op Azure gebruiken?

Ja. Azure OpenAI biedt de Responses API aan, maar functiepariteit loopt 4–8 weken achter op de directe rollouts van OpenAI. Per april 2026 is MCP-ondersteuning op Azure in preview. Controleer Microsoft Learn voor de huidige Azure-specifieke eigenaardigheden voordat u naar productie gaat.

Werkt de Responses API met MCP-servers?

Ja — externe MCP (Model Context Protocol)-servers zijn een first-class tooltype. Voeg {"type": "mcp", "server_url": "...", "server_label": "..."} toe aan uw tools-array en het model ontdekt en roept de toolcatalogus van de server aan zoals ingebouwde tools. Gebruik require_approval: "always" in productie voor veiligheid.

Afsluiting

U heeft nu het volledige beeld van de Responses API: hoe het verschilt van Chat Completions, hoe u uw eerste aanroep doet, hoe u ingebouwde tools aansluit en hoe u een bestaand Chat Completions-project in drie stappen migreert. Een paar aandachtspunten:

• Bouw eerst, optimaliseer daarna. Begin met het hello-world-voorbeeld, voeg een ingebouwde tool toe en laag vervolgens state op via previous_response_id.
• Migreer geleidelijk. Gebruik een feature flag, log beide responsvormaten en schakel pas 100% over na pariteitsverificatie.
• Implementeer MCP-integraties. Dit is de grens van 2026 — de meeste leveranciers zetten nu een sprint in om MCP-eindpunten te bieden, en de Responses API is de schoonste manier om ze te consumeren.

Bij Techsy helpen we teams om productiekwaliteitsmatige OpenAI-integraties te implementeren — inclusief Responses API-uitrolprojecten en Chat Completions-migraties. Vraag een gratis adviesgesprek aan.

Door het Techsy redactieteam — productieingenieurs die OpenAI-integraties bouwen sinds 2024. Laatst bijgewerkt: 25 april 2026.