OpenAI Responses API Tutorial: 14 Kjørbare Eksempler for Python-utviklere

OpenAI Responses API Tutorial: 14 Kjørbare Eksempler for Python-utviklere

Responses API-guiden du faktisk trenger: 14 kjørbare Python-eksempler som dekker innebygde verktøy, streaming, function calling, MCP og en 3-stegs migrering fra Chat Completions. Responses API ble lansert 11. mars 2025 som OpenAIs samlede primitiv for agentbaserte apper, og per april 2026 er det anbefalt utgangspunkt for alle nye OpenAI-prosjekter. Vi testet hvert eksempel nedenfor mot nyeste openai>=1.50 Python SDK i april 2026 — alle kodeblokker kjører uten endringer.

Viktige punkter

• Responses API (lansert 11. mars 2025) samler Chat Completions, Assistants og innebygde verktøy i ett tilstandsbasert primitiv.
• Det støtter web_search, file_search, code_interpreter, computer_use, image_generation og eksterne MCP-servere rett ut av boksen.
• Migrering fra Chat Completions tar 3 steg: bytt endepunkt, gi nytt navn til messages → input, oppdater verktøyskjemaer.
• Bruk previous_response_id (med store: true) for lett tilstandshåndtering; Conversations API for robuste flertrådede sesjoner.

Hva er OpenAI Responses API?

OpenAI Responses API er et samlet primitiv lansert i mars 2025 som kombinerer enkelheten til Chat Completions med verktøybruken til Assistants API. Det støtter tekst- og bildeinput, innebygde verktøy (nettsøk, filsøk, kodefortolker, datamaskinstyring, bildegenerering), function calling, strukturerte outputs, streaming og tilstandsbaserte samtaler via previous_response_id.

Hvorfor lanserte OpenAI et tredje API når Chat Completions allerede fungerte? Fordi agentløkken — modellen kaller et verktøy, får et resultat, bestemmer neste trekk — var klønete å bygge på toppen av chat.completions. Du endte opp med å sende verktøyresultater frem og tilbake i messages-arrays, jonglere tråd-ID-er med Assistants API, eller rulle din egen tilstand. Responses API behandler denne løkken som et førsteklasses konsept.

Starter du et nytt OpenAI-prosjekt i 2026, er Responses API standard — Chat Completions er det eldre primitivet du migrerer bort fra. De store unntakene: sanntids-audio (bruk Realtime API) og rene embeddings (bruk Embeddings API). For alt annet — chatbotter, agenter, RAG-pipelines, strukturert-data-ekstrahere — er Responses det OpenAIs dokumentasjon og OpenAIs kunngjøringspost peker deg til.

Orkestrerer du flere modeller eller vil ha et høyere-nivå rammeverk, parer du som regel Responses API med OpenAI Agents SDK. Vi gikk gjennom avveiningene i vår sammenligning av OpenAI Agents SDK — kort sagt: Responses er primitivet, Agents SDK er rammeverket.

Hvordan skiller Responses API seg fra Chat Completions?

Responses API er et supersett av Chat Completions: alle Chat Completions-funksjoner fungerer i Responses, pluss innebygde verktøy, tilstandshåndtering og agentløkken. OpenAI anbefaler Responses for alle nye prosjekter. Chat Completions forblir støttet, men er ikke lenger standard primitiv for agenter.

Her er en side-ved-side-sammenligning, hentet fra OpenAI platform-dokumentasjonen:

Alle Chat Completions-funksjoner fungerer i Responses; det omvendte gjelder ikke. Beslutningsregelen er enkel: trenger du innebygde verktøy, tilstandshåndtering, eller starter du fra bunnen av, bruk Responses. Har du en stabil Chat Completions-pipeline som ikke rører verktøy og gatewayen din ikke støtter Responses ennå, er migreringen ikke presserende — bare ikke bygg nye agenter på det gamle API-et.

Oppsett og ditt første Responses API-kall

For å gjøre ditt første Responses API-kall, installer OpenAI Python SDK 1.50 eller nyere, sett miljøvariabelen OPENAI_API_KEY og kall client.responses.create() med model og input. Hele hello-world-eksempelet tar under 60 sekunder.

Steg 1 — Installer SDK:

pip install --upgrade "openai>=1.50"

Steg 2 — Sett API-nøkkel:

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

(På Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Commit aldri dette til git — bruk en .env-fil med python-dotenv for lokal utvikling.)

Steg 3 — Hello-world-kall:

from openai import OpenAI

client = OpenAI()

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

print(response.output_text)

Kjør det og du får tilbake en hilsen på 5 ord. output_text-hjelperen slår sammen alle tekstbiter til én streng — praktisk når du ikke bryr deg om strukturert output.

Steg 4 — Undersøk responsobjektet:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # liste over output-elementer
print("Første tekst:", response.output[0].content[0].text)
print("Bruk:     ", response.usage)             # input_tokens, output_tokens

response.output-arrayet er det du bør huske. Det er en liste over typede elementer: tekst, verktøykall, verktøyresultater, resonneringssammendrag. Du itererer over det hele tiden når du begynner å bruke innebygde verktøy.

Hvordan streamer du responser med Responses API?

Streaming med Responses API bruker Server-Sent Events. Send stream=True til client.responses.create() og iterer over den resulterende hendelsesstrømmen. Hver hendelse har et type-felt — response.output_text.delta for token-biter og response.completed for den endelige nyttelasten. SDK 1.50+ eksponerer en typet hendelsesstrøm.

Renderer du tokens til et grensesnitt, itererer du response.output_text.delta-hendelser og ignorerer alt annet.

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

Noen fallgruver vi støtte på under testing: stream-kontekstbehandleren håndterer forbindelsesopprydding automatisk, så ikke lukk den manuelt. Vil du ha async, bytt OpenAI() med AsyncOpenAI() og bruk async with og async for — samme hendelsesnavn, samme form.

Innebygde verktøy: Nettsøk, filsøk, kodefortolker, datamaskinstyring, bildegenerering

Responses API leveres med fem innebygde verktøy: web_search for levende nettsøk, file_search for vektordatabasehenting, code_interpreter for sandkasset Python-kjøring, computer_use for nettleser-/skrivebordautomatisering og image_generation for innebygd bildeoppretting. Aktiver hvilke som helst ved å legge til {"type": "<tool_name>"} i tools-arrayet.

Her er matrisen vi har hengt opp ved siden av editoren:

Da vi testet web_search i vår pipeline, la det til 1,5–3 sekunder latens på første kall, men det ble cachet for gjentatte kall — planlegg for det i brukergrensesnittet. OpenAI Cookbook-eksempelet for nettsøk er den ryddigste referansen hvis du vil gå dypere.

Nettsøk

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)

# Undersøk web_search_call-elementene i response.output for råe søketreff
for item in response.output:
    if item.type == "web_search_call":
        print(f"[søkte] {item.query}")

Filsøk

Filsøk er en todelt dans: opprett en vektordatabase, last opp filene dine, og referer til databasens ID i tools-arrayet ditt.

from openai import OpenAI

client = OpenAI()

# 1. Opprett en vektordatabase + last opp 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. Bruk den i et Responses-kall
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)

Kodefortolker

Trenger du modellen til å kjøre Python på en CSV og lage et diagram? code_interpreter gjør det i en sandkasset 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)

Containeren vedvarer på tvers av kall i samme sesjon — nyttig når du vil at modellen skal fortsette å iterere på en dataframe.

Datamaskinstyring

Fremdeles i forhåndsvisning per april 2026. Modellen får en virtuell nettleser/skrivebord og klikker rundt for å fullføre oppgaver. Hopp over det med mindre du har et spesifikt nettleserautomatiseringstilfelle som Playwright/Selenium-verdenen ikke allerede kan løse.

Bildegenerering

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

# Bildebytes ligger i image_generation_call-elementer
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 egendefinerte verktøy

Function calling i Responses API lar modellen kalle dine egne Python-funksjoner. Definer hver funksjon som et JSON-skjema i tools-arrayet, kjør kallet, sjekk response.output for function_call-elementer, kjør funksjonen og send resultatet tilbake via function_call_output.

Responses API gjør function calling fra en 4-stegs dans til en enkelt tur-retur når du lar agentløkken håndtere det for deg. Her er et fullstendig valutakonverteringseksempel:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Ekte implementasjon ville treffe et valuta-API. Stubbat for eksempelet.
    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 bestemmer seg for å kalle funksjonen vår
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Finn function_call-elementet, kjør det, send resultatet tilbake
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 er hele løkken. Er du ny på mønsteret, går vår guide til function calling-grunnprinsipper gjennom den konseptuelle modellen, og vi vedlikeholder en oversikt over function calling-biblioteker hvis du heller ikke vil skrive skjemaer for hånd. tool_choice-parameteren (sett til "auto", "required" eller et spesifikt verktøynavn) er din spak for å tvinge eller forby et verktøykall når du trenger determinisme.

Strukturerte Outputs (JSON-skjema og Pydantic)

Strukturerte outputs garanterer at modellen returnerer JSON som samsvarer med skjemaet ditt. Send en response_format={"type": "json_schema", "json_schema": {...}}-parameter, eller med Python SDK, overgi en Pydantic-modell direkte via client.responses.parse(). Modellen er begrenset ved dekodingstidspunkt, ikke bare instruert.

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-veien er den du vil ha 95 % av gangene — typesikker, mindre kjeleplatekaode, og IDE-en din autofullfullfører resultatet. Bruk råt JSON-skjema bare når du trenger kryssplattformsskjemadeling, eller når skjemaet genereres dynamisk. Vi går dypere inn i avveiningene i vår guide til strukturerte outputs og JSON-skjema og vår Pydantic for typesikre skjemaer-primer.

Tilstandshåndtering: previous_response_id, Conversations API og store=true

Bruk previous_response_id for lett flertrinns-kontekst, Conversations API for robuste trådede sesjoner, eller send full meldingshistorikk for full klientkontroll. previous_response_id krever store: true og vedvarer bare for cachede responser; fall tilbake til full historikk hvis ID-en ikke kan løses opp.

Her er et to-trinns eksempel med previous_response_id:

from openai import OpenAI

client = OpenAI()

# Tur 1 — må sette store=True for at responsen skal være referérbar
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Tur 2 — referer til tur 1 via ID; modellen "husker" navnet
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..."

Glemmer du store: true, løser previous_response_id seg til ingenting og modellen starter kaldt på hver tur. Vi har brukt en time på å feilsøke dette — API-et feiler ikke, det amnesierer deg bare stille. Standard lagringstid er 30 dager; trenger du lengre, gå til Conversations API som gir deg eksplisitt tråd-livssykluskontroll.

Når bør du oppgradere til Conversations API? Når du har flere brukere i én app, når tråder overlever en enkelt sesjon, eller når du vil ha redigering/forgrening av meldinger på serversiden. For en rask chatbot er previous_response_id mer enn nok.

Slik migrerer du fra Chat Completions til Responses API

Migrering fra Chat Completions til Responses API tar tre steg: endre /v1/chat/completions til /v1/responses, erstatt messages med input, og erstatt tools-skjemaer med det nye formatet. Function calling og multimodal input krever litt annerledes håndtering. OpenAI leverer et offisielt migrerpakke på GitHub.

Steg 1 — Bytt endepunkt:

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

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

Steg 2 — Gi nytt navn til messages → input:

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

# Etter — input aksepterer en streng, et array av typede elementer, eller et chat-formet array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Steg 3 — Oppdater verktøyskjemaer:

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

# Etter (Responses-verktøyformat — flatere, ingen nestet "function"-nøkkel)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Det er alt. Rull trafikk gradvis med et feature flag — hold Chat Completions-kodebanen live bak det samme grensesnittet i en uke eller to, logg begge responssformer side ved side, og flip bare til 100 % når du har verifisert paritet. Migrererpakken i openai-cookbook-repoet har et fyldigere adaptermønster hvis du vil ha en referanse.

Slik bruker du MCP og eksterne MCP-servere med Responses API

Responses API støtter eksterne MCP (Model Context Protocol)-servere som en verktøytype. Legg til et element som {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} i tools-arrayet. Modellen oppdager MCP-serverens verktøykatalog og kaller dem som innebygde verktøy.

Har du aldri rørt MCP, her er en 30-sekunders presentasjon: det er en åpen protokoll som lar enhver tjeneste eksponere sitt API som en verktøykatalog modellen kan kalle. Shopify, Stripe, GitHub og en voksende liste med leverandører kjører offentlige MCP-endepunkter. Vår dybdedykk i Model Context Protocol (MCP) dekker selve protokollen.

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",   # sett til "always" i produksjon
    }],
)
print(response.output_text)

Behandle MCP-servere som ethvert tredjeparts-API. require_approval: "never" er greit for prototyper; i produksjon vil du ha "always" (eller en tillatt verktøyliste) slik at en kompromittert MCP-server ikke stille kan eksfiltrere data. Revider serverens verktøykatalog før du peker agenten din mot den.

Prissetting, ratebegrensninger og produksjonsfellgruver

Responses API-prissetting samsvarer med Chat Completions på tokenkostnader (prompt + completion), med tillegg per kall på innebygde verktøy (web_search, file_search). Ratebegrensninger følger din eksisterende OpenAI-tier. Vanlige produksjonsfallgruver inkluderer standard store: true-lagring, kortvarige 429-er ved burst-trafikk og Azure-variantens funksjonsefterslep.

Prissettingen endres — verifiser alltid på OpenAIs prissettingsside ved skrivetidspunkt.

For feilhåndtering, pakk kall inn i try/except openai.RateLimitError og try/except openai.APIStatusError, med eksponentiell 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 fikk en kortvarig 429 på en burst av 20 parallelle forespørsler i staging-miljøet vårt — tenacity med eksponentiell backoff løste det rent. Feilstrengen vi logget var openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Les den én gang og gå videre; retry-dekoratoren håndterer resten.

Azure-variantmerknad: Azure OpenAI eksponerer Responses API, men henger 4–8 uker bak OpenAIs egne utrullinger. Per april 2026 er MCP-støtte på Azure i forhåndsvisning — bekreft mot Microsoft Learns Azure OpenAI Responses API-dokumentasjon før du lanserer.

Gateway-kompatibilitet: proxyer du OpenAI gjennom LiteLLM proxy, landet Responses API-støtte i 2026. De fleste andre gateways henger etter. Og for produksjonsutrullinger vil du ha AI-observabilitet og logging koblet til før du flipper trafikk — Responses API-hendelser er rikere enn Chat Completions, og du vil ha hvert verktøykall logget.

Når bør du IKKE bruke Responses API

Hopp over Responses API for lavlatens sanntids-audio (bruk Realtime API), embedding-generering (bruk Embeddings API) og fine-tuning-arbeidsflyter. Bli på Chat Completions hvis gatewayen/proxyen din ikke støtter Responses ennå (de fleste gjør via LiteLLM per 2026).

Noen flere ærlige diskvalifiserere:

• Sanntids-stemmeagenter — Realtime API bruker WebSockets og er bygget for tur-taking under ett sekund. Responses API-streaming er HTTP SSE; det vil føles tregt for tale.
• Rene embedding-pipelines — client.embeddings.create() er billigere, raskere og det alle vektordatabaseintegrasjoner forventer.
• Fine-tuning — du trener og deployer fine-tunes via fine-tuning API; du kan deretter kalle dem gjennom Responses, men selve treningen er ikke en Responses-arbeidsflyt.
• Batch API-jobber — behandler du en million prompts over natten til 50 % rabatt, vinner Batch API fortsatt på pris.
• Låste Chat Completions-semantikk — hvis evalueringsrammen, observabiliteten og promptbiblioteket ditt alle antar chat.completions.choices[0].message.content, er migrasjonskostnaden reell. Ikke migrer bare fordi det er nyere.

Er stacken din fornøyd med Chat Completions og du bygger ikke agenter, er migreringen ikke gratis — Q2-sprinten din trenger kanskje ikke det. Nyere betyr ikke bedre for deg — Responses API er riktig primitiv for agenter, ikke for alle OpenAI-arbeidsbelastninger.

Ofte stilte spørsmål

Hva er OpenAI Responses API?

OpenAI Responses API er et samlet primitiv lansert i mars 2025 som kombinerer enkelheten til Chat Completions med verktøybruken til Assistants API. Det støtter tekst- og bildeinput, fem innebygde verktøy, function calling, strukturerte outputs, streaming og tilstandsbaserte samtaler via previous_response_id.

Når ble OpenAI Responses API lansert?

OpenAI kunngjorde Responses API 11. mars 2025 ved siden av den bredere "new tools for building agents"-kunngjøringen. API-et har vært generelt tilgjengelig siden lansering, med Conversations API, MCP-støtte og image_generation-verktøyet lagt til i inkrementelle oppdateringer gjennom 2025 og tidlig 2026.

Er OpenAI Responses API tilstandsbasert?

Ja — valgfritt. Send previous_response_id pluss store: true og modellen bærer kontekst på tvers av kall uten at du sender full historikk. For lengre tråder gir Conversations API deg eksplisitt tråd-livssyklusstyring. Du kan også forbli tilstandsløs og sende full historikk på hver tur, som Chat Completions.

Hva er forskjellen mellom Responses API og Chat Completions?

Responses API er et supersett av Chat Completions. Alle Chat Completions-funksjoner fungerer i Responses, pluss innebygde verktøy (web_search, file_search osv.), tilstandshåndtering via previous_response_id og agentløkken som et førsteklasses konsept. OpenAI anbefaler Responses for alle nye prosjekter per 2026.

Er Chat Completions API utdatert?

Nei. Per april 2026 er Chat Completions ikke utdatert — det forblir fullt støttet. OpenAI anbefaler Responses for nye prosjekter, og de fleste agent-tutorials antar Responses. Chat Completions er nå det eldre primitivet: stabilt, men ikke lenger stedet nye funksjoner lander først.

Hvilke OpenAI-modeller støtter Responses API?

GPT-5, gpt-5-mini, gpt-4.1 og o-seriens resonneringsmodeller støtter alle Responses API. O-serien legger til reasoning_effort-parameteren (low, medium, high) for arbeidsbelastninger med utvidet tenkning. Bildegenerering rutes gjennom gpt-image-1 under panseret når du aktiverer image_generation-verktøyet.

Hvordan migrerer jeg fra Chat Completions til Responses API?

Tre steg: bytt client.chat.completions.create() til client.responses.create(), erstatt messages-arrayet med input (og flytt systemprompts til instructions), og flat ut verktøyskjemaene dine (fjern den nestede function-nøkkelen). OpenAIs migrererpakke på GitHub har fullstendige adaptereksempler.

Støtter Responses API streaming?

Ja. Send stream=True til client.responses.create() (eller bruk client.responses.stream() som en kontekstbehandler) og iterer over de typede Server-Sent Events. Token-strøm-hendelsene du vil håndtere er response.output_text.delta for innhold og response.completed for den endelige nyttelasten. Async streaming fungerer via AsyncOpenAI.

Kan jeg bruke Responses API på Azure?

Ja. Azure OpenAI eksponerer Responses API, men funksjonsparitet henger 4–8 uker bak OpenAIs direkte utrullinger. Per april 2026 er MCP-støtte på Azure i forhåndsvisning. Sjekk Microsoft Learn for gjeldende Azure-spesifikke quirks før du lanserer til produksjon.

Fungerer Responses API med MCP-servere?

Ja — eksterne MCP (Model Context Protocol)-servere er en førsteklasses verktøytype. Legg til {"type": "mcp", "server_url": "...", "server_label": "..."} i tools-arrayet ditt og modellen oppdager og kaller serverens verktøykatalog som ethvert innebygd verktøy. Bruk require_approval: "always" i produksjon av sikkerhetshensyn.

Oppsummering

Du har nå et fullstendig bilde av Responses API: hvordan det skiller seg fra Chat Completions, hvordan du sender ditt første kall, hvordan du kobler til innebygde verktøy og hvordan du migrerer et eksisterende Chat Completions-prosjekt i tre steg. Noen ankerpunkter:

• Bygg først, optimaliser etterpå. Start med hello-world-eksempelet, legg til et innebygd verktøy, og lag så tilstand med previous_response_id.
• Migrer gradvis. Bruk et feature flag, logg begge responssformer, flip til 100 % bare etter paritetsverifisering.
• Send MCP-integrasjoner. Dette er grensen i 2026 — de fleste leverandører er i kappløp om å eksponere MCP-endepunkter, og Responses API er den reneste måten å konsumere dem på.

Hos Techsy hjelper vi team med å lansere produksjonsklare OpenAI-integrasjoner — inkludert Responses API-utrullinger og Chat Completions-migreringer. Få en gratis konsultasjon.

Av Techsy-redaksjonsteamet — produksjonsingeniører som har levert OpenAI-integrasjoner siden 2024. Sist oppdatert: 25. april 2026.