OpenAI Responses API Tutorial: 14 körbara exempel för Python-utvecklare

Den Responses API-tutorial du faktiskt behöver: 14 körbara Python-exempel som täcker inbyggda verktyg, streaming, function calling, MCP och en 3-stegsmigrering från Chat Completions. Responses API lanserades den 11 mars 2025 som OpenAI:s samlade primitiv för agentbaserade appar, och från och med april 2026 är det den rekommenderade startpunkten för alla nya OpenAI-projekt. Vi har testat varje exempel nedan mot senaste openai>=1.50 Python SDK i april 2026 — varje kodblock kör direkt.

Viktiga slutsatser - Responses API (lanserat 11 mars 2025) förenar Chat Completions, Assistants och inbyggda verktyg i ett enda tillståndsfullt primitiv. - Det stöder web_search, file_search, code_interpreter, computer_use, image_generation och externa MCP-servrar direkt ur lådan. - Migrering från Chat Completions tar 3 steg: byt endpoint, döp om messages → input, uppdatera tool-scheman. - Använd previous_response_id (med store: true) för lättviktig state; Conversations API för robusta flertrådade sessioner.

Vad är OpenAI Responses API?

OpenAI Responses API är ett samlat primitiv lanserat i mars 2025 som kombinerar Chat Completions enkelhet med Assistants API:s verktygsanvändning. Det stöder text- och bildinput, inbyggda verktyg (webbsökning, filsökning, kodtolkare, datorstyrning, bildgenerering), function calling, strukturerade outputs, streaming och tillståndsbaserade konversationer via previous_response_id.

Varför lanserade OpenAI ett tredje API när Chat Completions redan fungerade? För att den agentbaserade loopen — modellen anropar ett verktyg, får ett resultat, bestämmer nästa steg — var klumpig att bygga ovanpå chat.completions. Man hamnade med att skicka tool-resultat fram och tillbaka i messages-arrayer, jonglera tråd-ID:n med Assistants API, eller rulla sin egen state-hantering. Responses API behandlar den loopen som ett förstklassigt koncept.

Startar du ett nytt OpenAI-projekt 2026 är Responses API standarden — Chat Completions är det äldre primitiv man migrerar bort från. De stora undantagen: realtidsljud (använd Realtime API) och rena embeddings (använd Embeddings API). För allt annat — chatbottar, agenter, RAG-pipelines, strukturerade dataextraktorer — är Responses det OpenAI:s docs och OpenAI:s tillkännagivande pekar på.

Orkestrerar du flera modeller eller vill ha ett högre abstraktionslager kombinerar du vanligtvis Responses API med OpenAI Agents SDK. Vi gick igenom avvägningarna i vår jämförelse av OpenAI Agents SDK — kortversionen: Responses är primitivet, Agents SDK är ramverket.

Hur skiljer sig Responses API från Chat Completions?

Responses API är en supermängd av Chat Completions: alla Chat Completions-funktioner fungerar i Responses, plus inbyggda verktyg, tillståndshantering och den agentbaserade loopen. OpenAI rekommenderar Responses för alla nya projekt. Chat Completions stöds fortfarande men är inte längre standardprimitivet för agenter.

Här är en jämförelse sida vid sida, hämtad från OpenAI platform-dokumentationen:

Alla Chat Completions-funktioner fungerar i Responses; omvändningen gäller inte. Beslutsregeln är kort: behöver du inbyggda verktyg, tillståndshantering, eller startar du från scratch — använd Responses. Har du en stabil Chat Completions-pipeline som inte rör verktyg och din gateway inte ännu stöder Responses är migreringen inte akut — bygg bara inte nya agenter på det gamla API:t.

Kom igång och ditt första Responses API-anrop

För att göra ditt första Responses API-anrop installerar du OpenAI Python SDK 1.50 eller senare, sätter din miljövariabel OPENAI_API_KEY och anropar client.responses.create() med ett model och input. Hello-world-exemplet tar under 60 sekunder.

Steg 1 — Installera SDK:t:

pip install --upgrade "openai>=1.50"

Steg 2 — Sätt din API-nyckel:

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

(På Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Commit aldrig detta till git — använd en .env-fil plus python-dotenv för lokal utveckling.)

Steg 3 — Hello-world-anrop:

from openai import OpenAI

client = OpenAI()

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

print(response.output_text)

Kör det och du får tillbaka en 5-ords hälsning. Hjälparen output_text sammanfogar varje textbit till en enda sträng — smidigt när du inte bryr dig om strukturerat output.

Steg 4 — Inspektera response-objektet:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # lista med output-objekt
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

response.output-arrayen är den du bör memorera. Den är en lista med typade objekt: text, verktygsanrop, verktygsresultat, resoneringssammanfattningar. Du itererar igenom den konstant när du börjar använda inbyggda verktyg.

Hur strömmar du svar med Responses API?

Streaming med Responses API använder Server-Sent Events. Skicka stream=True till client.responses.create() och iterera över den resulterande eventströmmen. Varje event har ett type-fält — response.output_text.delta för token-bitar och response.completed för det slutliga svaret. SDK 1.50+ exponerar en typad eventström.

Renderar du tokens till ett gränssnitt itererar du response.output_text.delta-events och ignorerar allt annat.

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[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

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

Några fallgropar vi stötte på vid testning: stream-kontexthanteraren sköter uppkopplingsstängning automatiskt, så stäng inte av den manuellt. Vill du ha async byter du OpenAI() mot AsyncOpenAI() och använder async with plus async for — samma eventnamn, samma struktur.

Inbyggda verktyg: webbsökning, filsökning, kodtolkare, datorstyrning, bildgenerering

Responses API levereras med fem inbyggda verktyg: web_search för liveinternet-sökning, file_search för vektordatabaslagring, code_interpreter för sandlåde-Python-körning, computer_use för webbläsare/skrivbordsautomation och image_generation för inbyggd bildskapande. Aktivera vilket som helst av dem genom att lägga till {"type": "<tool_name>"} i tools-arrayen.

Här är den matris vi har fäst bredvid vår editor:

När vi benchmarkade web_search i vår pipeline lade latensen till 1,5–3 sekunder på det första anropet men cacheades för upprepningar — planera för det i gränssnittet. OpenAI Cookbook-exemplet för webbsökning är den bästa referensen om du vill gå djupare.

Webbsökning

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)

# Inspektera web_search_call-objekt i response.output för råa sökträffar
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Filsökning

Filsökning är en tvåstegsprocess: skapa ett vektorlager, ladda upp dina filer, referera sedan lager-ID:t i din tools-array.

from openai import OpenAI

client = OpenAI()

# 1. Skapa ett vektorlager + ladda upp en fil
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. Använd det i ett Responses-anrop
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)

Kodtolkare

Behöver modellen köra Python på en CSV och rita ett diagram? code_interpreter gör det i en sandlådad 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)

Containern kvarstår mellan anrop inom samma session — användbart när du vill att modellen ska fortsätta iterera på en dataframe.

Datorstyrning

Fortfarande i förhandsvisning från och med april 2026. Modellen får en virtuell webbläsare/skrivbord och klickar runt för att slutföra uppgifter. Hoppa över det om du inte har ett specifikt webbläsarautomationsfall som Playwright/Selenium-världen inte redan kan lösa.

Bildgenerering

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

# Bilddata finns i image_generation_call-objekt
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Function calling med egna verktyg

Function calling i Responses API låter modellen anropa dina egna Python-funktioner. Definiera varje funktion som ett JSON-schema i tools-arrayen, kör anropet, kontrollera response.output efter function_call-objekt, exekvera funktionen och skicka tillbaka resultatet via function_call_output.

Responses API omvandlar function calling från en 4-stegsprocess till ett enda rundtripp när du låter den agentbaserade loopen hantera det. Här är ett komplett valutakonverteringsexempel:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Riktig implementation skulle anropa ett valuta-API. Stubbat för exemplet.
    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"],
    },
}]

# Tur 1: modellen bestämmer sig för att anropa vår funktion
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Hitta function_call-objektet, kör det, skicka tillbaka resultatet
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)

Det är hela loopen. Är du ny till mönstret går vår guide till function calling-grunderna igenom den konceptuella modellen, och vi underhåller en sammanfattning av function calling-bibliotek om du hellre inte vill skriva scheman för hand. Parametern tool_choice (satt till "auto", "required" eller ett specifikt verktygsnamn) är din spak för att tvinga eller förbjuda ett verktygsanrop när du behöver determinism.

Strukturerade outputs (JSON-schema och Pydantic)

Strukturerade outputs garanterar att modellen returnerar JSON som följer ditt schema. Skicka en parameter response_format={"type": "json_schema", "json_schema": {...}} eller, med Python SDK, skicka in en Pydantic-modell direkt via client.responses.parse(). Modellen begränsas vid avkodningstid, inte bara med promptning.

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)

Pydantic-vägen är den du vill ha 95% av tiden — typsäker, mindre boilerplate, och din IDE autofullbordar resultatet. Använd raw JSON-schema bara när du behöver delning av scheman mellan olika språk eller när schemat genereras dynamiskt. Vi går djupare in på avvägningarna i vår guide om strukturerade outputs och JSON-schema och vår introduktion till Pydantic för typsäkra scheman.

State-hantering: previousresponseid, Conversations API och store=true

Använd previous_response_id för lättviktig flerturns-kontext, Conversations API för robusta trådade sessioner, eller skicka fullständig meddelandehistorik för full kontroll på klientsidan. previous_response_id** kräver **store: true och kvarstår bara för cachade svar; falla tillbaka på fullständig historik om ID:t inte kan lösas upp.

Här är ett tvåtursexempel med previous_response_id:

from openai import OpenAI

client = OpenAI()

# Tur 1 — måste sätta store=True för att svaret ska kunna refereras
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Tur 2 — referera tur 1 med ID; modellen "minns" namnet
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..."

Glömmer du store: true löser sig previous_response_id till ingenting och modellen startar kallt varje tur. Vi har bränt en timme på att felsöka detta — API:t kastar inget fel, det amnesierar dig bara tyst. Standardretentionen är 30 dagar; behöver du längre, gå in i Conversations API som ger dig explicit kontroll över trådlivscykeln.

När bör du uppgradera till Conversations API? När du har flera användare i en app, när trådar lever längre än en enskild session, eller när du vill ha redigering/förgrening av meddelanden på serversidan. För en snabb chatbot räcker previous_response_id gott.

Hur migrerar du från Chat Completions till Responses API?

Migrering från Chat Completions till Responses API tar tre steg: byt /v1/chat/completions till /v1/responses, ersätt messages med input, och ersätt tools-scheman med det nya formatet. Function calling och multimodal input kräver lite annorlunda hantering. OpenAI levererar ett officiellt migreringspaket på GitHub.

Steg 1 — Byt endpoint:

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

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

Steg 2 — Döp om messages → input:

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

# Efter — input accepterar en sträng, en array av typade objekt, eller en chat-liknande array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Steg 3 — Uppdatera tool-scheman:

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

# Efter (Responses tool-format — plattare, ingen nästlad "function"-nyckel)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Det är det. Rulla trafik gradvis med en feature flag — håll din Chat Completions-kodstig aktiv bakom samma gränssnitt i en vecka eller två, logga båda svarsformaten sida vid sida, och vänd bara 100% när du har verifierat paritet. Migreringspaketets repo openai-cookbook har ett fylligare adaptermönster om du vill ha en referens.

Hur använder du MCP och externa MCP-servrar med Responses API?

Responses API stöder externa MCP (Model Context Protocol)-servrar som en verktygtyp. Lägg till en post som {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} i tools-arrayen. Modellen identifierar MCP-serverns verktygskatalog och anropar dem precis som inbyggda verktyg.

Har du aldrig rört MCP är det här 30-sekundersversionen: det är ett öppet protokoll som låter vilken tjänst som helst exponera sitt API som en verktygskatalog modellen kan anropa. Shopify, Stripe, GitHub och ett växande antal leverantörer kör publika MCP-endpoints. Vår djupdykning om Model Context Protocol (MCP) täcker protokollet i sig.

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",   # sätt till "always" i produktion
    }],
)
print(response.output_text)

Behandla MCP-servrar som vilket tredjeparts-API som helst. require_approval: "never" är okej för prototyper; i produktion vill du ha "always" (eller en tillåtelselista för verktyg) så att en komprometterad MCP-server inte tyst kan exfiltrera data. Granska serverns verktygskatalog innan du pekar din agent mot den.

Prissättning, rate limits och produktionsfallgropar

Responses API-prissättningen matchar Chat Completions på tokenkostnader (prompt + completion), med per-anropstillägg på inbyggda verktyg (web_search, file_search). Rate limits följer din befintliga OpenAI-nivå. Vanliga produktionsfallgropar inkluderar store: true standardretention, tillfälliga 429:or vid burstraffik och funktionssläp för Azure-varianten.

Prissättning förändras — verifiera alltid på OpenAI:s prissättningssida vid skrivtillfället.

För felhantering, omslut anrop i try/except openai.RateLimitError och try/except openai.APIStatusError, med exponentiell 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)

Vi stötte på en tillfällig 429 vid en burst av 20 parallella förfrågningar i vår stagingmiljö — tenacity med exponentiell backoff löste det rent. Felsträngen vi loggade var openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Läs den en gång och gå vidare; retry-dekoratören hanterar resten.

Azure-variant: Azure OpenAI exponerar Responses API men ligger efter Sam Altman-kontrollerade utrullningar med 4–8 veckor. Från och med april 2026 är MCP-stöd på Azure i förhandsvisning — kontrollera mot Microsoft Learns Azure OpenAI Responses API-dokumentation innan du driftsätter.

Gateway-kompatibilitet: proxar du OpenAI via LiteLLM proxy landade Responses API-stöd 2026. De flesta andra gateways håller på att komma ikapp. För produktionsutrullningar vill du ha AI-observabilitet och loggning kopplat innan du växlar trafik — Responses API-events är rikare än Chat Completions, och du vill ha varje verktygsanrop loggat.

När ska du INTE använda Responses API?

Hoppa över Responses API för låglatens realtidsljud (använd Realtime API), embeddings-generering (använd Embeddings API) och fine-tuning-arbetsflöden. Stanna kvar på Chat Completions om din gateway/proxy ännu inte stöder Responses (de flesta gör det via LiteLLM från 2026).

Några fler ärliga diskvalificerare:

• Realtidsröstbaserade agenter — Realtime API använder WebSockets och är byggt för tur-tagande under en sekund. Responses API-streaming är HTTP SSE; det känns trögare för röst.
• Rena embeddings-pipelines — client.embeddings.create() är billigare, snabbare och vad varje vektordatabas-integration förväntar sig.
• Fine-tuning — du tränar och driftsätter fine-tunes via fine-tuning API:t; du kan sedan anropa dem via Responses, men själva träningen är inte ett Responses-arbetsflöde.
• Batch API-jobb — bearbetar du en miljon promptar över natten till 50% rabatt vinner Batch API fortfarande på pris.
• Låst vid Chat Completions-semantik — om din eval-harness, observabilitet och prompt-bibliotek alla antar chat.completions.choices[0].message.content är migreringskostnaden verklig. Migrera inte bara för att det är nyare.

Är din stack nöjd med Chat Completions och du inte bygger agenter är migreringen inte gratis — ditt Q2-sprint kanske inte behöver den. Nyare betyder inte bättre-för-dig — Responses API är rätt primitiv för agenter, inte för varje OpenAI-arbetsflöde.

Vanliga frågor

Vad är OpenAI Responses API?

OpenAI Responses API är ett samlat primitiv lanserat i mars 2025 som kombinerar Chat Completions enkelhet med Assistants API:s verktygsanvändning. Det stöder text- och bildinput, fem inbyggda verktyg, function calling, strukturerade outputs, streaming och tillståndsbaserade konversationer via previous_response_id.

När lanserades OpenAI Responses API?

OpenAI tillkännagav Responses API den 11 mars 2025 i samband med ett bredare tillkännagivande om "new tools for building agents". API:t har varit allmänt tillgängligt sedan lansering, med Conversations API, MCP-stöd och verktyget image_generation tillagda i inkrementella uppdateringar under 2025 och tidigt 2026.

Är OpenAI Responses API tillståndsburen?

Ja — valfritt. Skicka previous_response_id plus store: true och modellen bär kontext mellan anrop utan att du behöver skicka hela historiken. För längre trådar ger Conversations API explicit hantering av trådlivscykeln. Du kan också förbli tillståndslös och skicka fullständig historik varje tur, precis som Chat Completions.

Vad är skillnaden mellan Responses API och Chat Completions?

Responses API är en supermängd av Chat Completions. Alla Chat Completions-funktioner fungerar i Responses, plus inbyggda verktyg (web_search, file_search osv.), tillståndshantering via previous_response_id och den agentbaserade loopen som ett förstklassigt koncept. OpenAI rekommenderar Responses för alla nya projekt från 2026.

Är Chat Completions API avvecklat?

Nej. Från och med april 2026 är Chat Completions inte avvecklat — det stöds fortfarande fullt ut. OpenAI rekommenderar Responses för nya projekt, och de flesta agent-tutorials förutsätter Responses. Chat Completions är nu det äldre primitivet: stabilt, men inte längre det där nya funktioner landar först.

Vilka OpenAI-modeller stöder Responses API?

GPT-5, gpt-5-mini, gpt-4.1 och o-serien av resoneringmodeller stöder alla Responses API. O-serien lägger till parametern reasoning_effort (low, medium, high) för arbetsbelastningar med utökat tänkande. Bildgenerering dirigeras via gpt-image-1 under huven när du aktiverar verktyget image_generation.

Hur migrerar jag från Chat Completions till Responses API?

Tre steg: byt client.chat.completions.create() till client.responses.create(), ersätt messages-arrayen med input (och flytta systemprompts till instructions), och platta till dina tool-scheman (ta bort den nästlade function-nyckeln). OpenAI:s migreringspaket på GitHub har fullständiga adapterexempel.

Stöder Responses API streaming?

Ja. Skicka stream=True till client.responses.create() (eller använd client.responses.stream() som en kontexthanterare) och iterera de typade Server-Sent Events. Token-stream-events du hanterar är response.output_text.delta för innehåll och response.completed för det slutliga svaret. Async-streaming fungerar via AsyncOpenAI.

Kan jag använda Responses API på Azure?

Ja. Azure OpenAI exponerar Responses API, men funktionsparitet ligger efter OpenAI:s direkta utrullningar med 4–8 veckor. Från och med april 2026 är MCP-stöd på Azure i förhandsvisning. Kontrollera Microsoft Learn för aktuella Azure-specifika egenheter innan du driftsätter till produktion.

Fungerar Responses API med MCP-servrar?

Ja — externa MCP-servrar (Model Context Protocol) är en förstklassig verktygstyp. Lägg till {"type": "mcp", "server_url": "...", "server_label": "..."} i din tools-array och modellen identifierar och anropar serverns verktygskatalog precis som ett inbyggt verktyg. Använd require_approval: "always" i produktion av säkerhetsskäl.

Sammanfattning

Du har nu hela bilden av Responses API: hur det skiljer sig från Chat Completions, hur du gör ditt första anrop, hur du kopplar upp inbyggda verktyg och hur du migrerar ett befintligt Chat Completions-projekt i tre steg. Några slutsatser att hålla fast vid:

• Bygg först, optimera sedan. Börja med hello-world-exemplet, lägg till ett inbyggt verktyg och lägg sedan på state med previous_response_id.
• Migrera gradvis. Använd en feature flag, logga båda svarsformaten, vänd 100% först efter verifierad paritet.
• Driftsätt MCP-integrationer. Det är frontlinjen 2026 — de flesta leverantörer tävlar om att exponera MCP-endpoints, och Responses API är det renaste sättet att konsumera dem.

På Techsy hjälper vi team att driftsätta produktionsklara OpenAI-integrationer — inklusive Responses API-utrullningar och Chat Completions-migrationer. Boka en kostnadsfri konsultation.

Av Techsys redaktionsteam — produktionsingenjörer som levererat OpenAI-integrationer sedan 2024. Senast uppdaterat: 25 april 2026.