Tutorial OpenAI Responses API: 14 Esempi Python Eseguibili per Sviluppatori

Il tutorial sulla OpenAI Responses API di cui hai davvero bisogno: 14 esempi Python eseguibili che coprono strumenti integrati, streaming, function calling, MCP e una migrazione in 3 passi da Chat Completions. La Responses API è stata lanciata l'11 marzo 2025 come primitiva unificata di OpenAI per applicazioni con architettura agentica, e ad aprile 2026 è il punto di partenza consigliato per ogni nuovo progetto OpenAI. Abbiamo testato tutti gli esempi qui sotto con l'ultimo Python SDK openai>=1.50 ad aprile 2026 — ogni blocco di codice gira così com'è.

Punti chiave - La Responses API (lanciata l'11 marzo 2025) unifica Chat Completions, Assistants e strumenti integrati in un'unica primitiva con stato. - Supporta web_search, file_search, code_interpreter, computer_use, image_generation e server MCP remoti out of the box. - La migrazione da Chat Completions richiede 3 passi: cambia l'endpoint, rinomina messages → input, aggiorna gli schemi degli strumenti. - Usa previous_response_id (con store: true) per uno stato leggero; la Conversations API per thread multi-turno robusti.

Cos'è la OpenAI Responses API?

La OpenAI Responses API è una primitiva unificata lanciata a marzo 2025 che combina la semplicità di Chat Completions con le capacità di tool-use dell'Assistants API. Supporta input testo + immagine, strumenti integrati (ricerca web, ricerca file, code interpreter, computer use, generazione immagini), function calling, output strutturati, streaming e conversazioni con stato tramite previous_response_id.

Perché OpenAI ha rilasciato una terza API quando Chat Completions funzionava già? Perché il loop agentico — il modello chiama uno strumento, ottiene un risultato, decide la mossa successiva — era scomodo da costruire su chat.completions. Finivi per passare risultati di strumenti avanti e indietro in array messages, gestire thread ID con l'Assistants API, o costruire il tuo stato da zero. La Responses API tratta quel loop come un concetto di prima classe.

Se stai iniziando un nuovo progetto OpenAI nel 2026, la Responses API è l'impostazione predefinita — Chat Completions è la primitiva legacy da cui migrare via. Le grandi eccezioni: audio in tempo reale (usa la Realtime API) ed embedding puri (usa la Embeddings API). Per tutto il resto — chatbot, agenti, pipeline RAG, estrattori di dati strutturati — Responses è quello a cui puntano la documentazione OpenAI e il post di annuncio OpenAI.

Se stai orchestrando più modelli o vuoi uno strato di scaffolding di livello più alto, di solito accoppi la Responses API con l'OpenAI Agents SDK. Abbiamo trattato i compromessi nel nostro confronto OpenAI Agents SDK — in breve: Responses è la primitiva, Agents SDK è il framework.

In Che Modo la Responses API Differisce da Chat Completions?

La Responses API è un superset di Chat Completions: ogni funzionalità di Chat Completions funziona anche in Responses, più strumenti integrati, stato e il loop agentico. OpenAI raccomanda Responses per tutti i nuovi progetti. Chat Completions rimane supportata ma non è più la primitiva predefinita per gli agenti.

Ecco il confronto fianco a fianco, estratto dalla documentazione della piattaforma OpenAI:

Ogni funzionalità di Chat Completions funziona in Responses; il contrario non vale. La regola di decisione è semplice: se hai bisogno di strumenti integrati, stato, o stai partendo da zero, usa Responses. Se hai una pipeline Chat Completions stabile che non tocca strumenti e il tuo gateway non supporta ancora Responses, la migrazione non è urgente — non costruire però nuovi agenti sulla vecchia API.

Setup e la Tua Prima Chiamata alla Responses API

Per effettuare la tua prima chiamata alla Responses API, installa l'OpenAI Python SDK 1.50 o superiore, imposta la variabile d'ambiente OPENAI_API_KEY, e chiama client.responses.create() con un model e un input. L'esempio hello-world completo richiede meno di 60 secondi.

Passo 1 — Installa l'SDK:

pip install --upgrade "openai>=1.50"

Passo 2 — Imposta la tua API key:

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

(Su Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Non committare mai questo su git — usa un file .env con python-dotenv per lo sviluppo locale.)

Passo 3 — Chiamata hello-world:

from openai import OpenAI

client = OpenAI()

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

print(response.output_text)

Eseguilo e riceverai un saluto di 5 parole. Il helper output_text concatena ogni frammento di testo in un'unica stringa — comodo quando non ti interessa l'output strutturato.

Passo 4 — Ispeziona l'oggetto risposta:

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

Quell'array response.output è la cosa da memorizzare. È una lista di elementi tipizzati: testo, chiamate a strumenti, risultati di strumenti, riepiloghi di ragionamento. Lo itererai continuamente una volta che inizi a usare gli strumenti integrati.

Come Fare Streaming delle Risposte con la Responses API?

Lo streaming con la Responses API usa i Server-Sent Events. Passa stream=True a client.responses.create() e itera sul flusso di eventi risultante. Ogni evento ha un campo type — response.output_text.delta per i frammenti di token e response.completed per il payload finale. SDK 1.50+ espone un flusso di eventi tipizzato.

Se stai rendendo i token in una UI, itererai gli eventi response.output_text.delta e ignorerai tutto il resto.

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

Alcune insidie che abbiamo incontrato nei test: il context manager dello stream gestisce automaticamente la pulizia della connessione, quindi non chiuderlo manualmente. Se vuoi l'async, sostituisci OpenAI() con AsyncOpenAI() e usa async with più async for — stessi nomi degli eventi, stessa struttura.

Strumenti Integrati: Web Search, File Search, Code Interpreter, Computer Use, Generazione Immagini

La Responses API include cinque strumenti integrati: web_search per la ricerca live su internet, file_search per il recupero da vector store, code_interpreter per l'esecuzione Python in sandbox, computer_use per l'automazione di browser/desktop, e image_generation per la creazione di immagini inline. Abilitane uno qualsiasi aggiungendo {"type": "<nome_strumento>"} all'array tools.

Ecco la matrice che teniamo fissa vicino all'editor:

Quando abbiamo testato web_search nella nostra pipeline, la latenza ha aggiunto 1,5–3s alla prima chiamata ma era in cache per le successive — tienilo a mente nella UI. Il web search example nell'OpenAI Cookbook è il riferimento più pulito se vuoi approfondire.

Web Search

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)

# Ispeziona gli elementi web_search_call in response.output per i risultati grezzi
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

File Search

La ricerca file è un processo in due fasi: crea un vector store, carica i tuoi file, poi fai riferimento all'ID dello store nell'array tools.

from openai import OpenAI

client = OpenAI()

# 1. Crea un vector store + carica un file
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. Usalo in una chiamata Responses
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

Hai bisogno che il modello esegua Python su un CSV e produca un grafico? code_interpreter lo fa in un container sandbox.

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)

Il container persiste tra le chiamate nella stessa sessione — utile quando vuoi che il modello continui a iterare su un dataframe.

Computer Use

Ancora in preview ad aprile 2026. Il modello ottiene un browser/desktop virtuale e naviga cliccando per completare attività. Saltalo a meno che non tu abbia un caso d'uso specifico di automazione browser che il mondo Playwright/Selenium non riesce già a risolvere.

Image Generation

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

# I byte dell'immagine si trovano negli elementi image_generation_call
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Function Calling con Strumenti Custom

Il function calling nella Responses API permette al modello di invocare le tue funzioni Python. Definisci ogni funzione come JSON schema nell'array tools, esegui la chiamata, controlla response.output per gli elementi function_call, esegui la funzione e passa il risultato indietro tramite function_call_output.

La Responses API trasforma il function calling da un processo in 4 fasi in un singolo round-trip quando lasci che il loop agentico lo gestisca per te. Ecco un esempio completo di conversione valuta:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # L'implementazione reale chiamerebbe un'API FX. Qui è solo un esempio.
    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"],
    },
}]

# Turno 1: il modello decide di chiamare la nostra funzione
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Trova l'elemento function_call, eseguilo, invia il risultato indietro
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)

Questo è il loop completo. Se sei nuovo al pattern, il nostro post sui fondamenti del function calling illustra il modello concettuale, e manteniamo una raccolta di librerie per il function calling se preferisci non scrivere gli schemi a mano. Il parametro tool_choice (impostato su "auto", "required", o il nome di uno strumento specifico) è la leva per forzare o vietare una chiamata a strumento quando hai bisogno di determinismo.

Output Strutturati (JSON Schema e Pydantic)

Gli output strutturati garantiscono che il modello restituisca JSON conforme al tuo schema. Passa un parametro response_format={"type": "json_schema", "json_schema": {...}} oppure, con l'SDK Python, passagli direttamente un modello Pydantic tramite client.responses.parse(). Il modello è vincolato al momento della decodifica, non solo attraverso il prompt.

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)

Il percorso Pydantic è quello che vuoi nel 95% dei casi — type-safe, meno boilerplate, e il tuo IDE completa automaticamente il risultato. Usa JSON schema grezzo solo quando hai bisogno di condivisione dello schema tra linguaggi o quando lo schema è generato dinamicamente. Approfondiamo i compromessi nella nostra guida agli output strutturati e JSON schema e nel nostro primer su Pydantic per schemi type-safe.

Gestione dello Stato: previousresponseid, Conversations API e store=true

Usa previous_response_id per un contesto multi-turno leggero, la Conversations API per sessioni con thread robusti, oppure invia la cronologia completa dei messaggi per il pieno controllo lato client. previous_response_id** richiede **store: true e persiste solo per le risposte in cache; ricadi sulla cronologia completa se l'ID non è risolvibile.

Ecco un esempio a due turni con previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turno 1 — devi impostare store=True perché la risposta sia referenziabile
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turno 2 — fai riferimento al turno 1 tramite ID; il modello "ricorda" il nome
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..."

Se dimentichi store: true, il tuo previous_response_id non si risolve in nulla e il modello riparte da zero a ogni turno. Ci abbiamo perso un'ora a fare debug — l'API non dà errore, semplicemente fa perdere silenziosamente la memoria. La retention predefinita è 30 giorni; se ne hai bisogno di più, passa alla Conversations API che ti dà un controllo esplicito sul ciclo di vita del thread.

Quando dovresti passare alla Conversations API? Quando hai più utenti in una sola app, quando i thread sopravvivono a una singola sessione, o quando vuoi la modifica/ramificazione dei messaggi lato server. Per un chatbot rapido, previous_response_id è più che sufficiente.

Come Migrare da Chat Completions alla Responses API

Migrare da Chat Completions alla Responses API richiede tre passi: cambia /v1/chat/completions in /v1/responses, sostituisci messages con input, e sostituisci gli schemi tools con il nuovo formato. Il function calling e gli input multimodali richiedono una gestione leggermente diversa. OpenAI mette a disposizione un migration pack ufficiale su GitHub.

Passo 1 — Cambio endpoint:

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

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

Passo 2 — Rinomina messages → input:

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

# Dopo — input accetta una stringa, un array di elementi tipizzati, o un array chat-shaped
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Passo 3 — Aggiorna gli schemi degli strumenti:

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

# Dopo (formato strumenti Responses — più piatto, senza la chiave "function" annidata)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Fatto. Sposta il traffico gradualmente con un feature flag — tieni il tuo codice Chat Completions attivo dietro la stessa interfaccia per una o due settimane, registra entrambe le strutture di risposta fianco a fianco, e passa al 100% solo dopo aver verificato la parità. Il migration pack nel repository openai-cookbook ha un pattern adapter più completo se vuoi un riferimento.

Come Usare MCP e Server MCP Remoti con la Responses API

La Responses API supporta server MCP (Model Context Protocol) remoti come tipo di strumento. Aggiungi un elemento come {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} all'array tools. Il modello scopre il catalogo di strumenti del server MCP e li chiama come strumenti integrati.

Se non hai mai toccato MCP, ecco il pitch in 30 secondi: è un protocollo aperto che permette a qualsiasi servizio di esporre la propria API come catalogo di strumenti che il modello può chiamare. Shopify, Stripe, GitHub e un numero crescente di vendor gestiscono endpoint MCP pubblici. Il nostro approfondimento su Model Context Protocol (MCP) copre il protocollo in sé.

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",   # impostare su "always" in produzione
    }],
)
print(response.output_text)

Tratta i server MCP come qualsiasi API di terze parti. require_approval: "never" va bene per i prototipi; in produzione vuoi "always" (o una allowlist di strumenti) perché un server MCP compromesso non possa esfiltrare dati silenziosamente. Verifica il catalogo degli strumenti del server prima di puntarci il tuo agente.

Prezzi, Rate Limit e Insidie in Produzione

I prezzi della Responses API corrispondono a Chat Completions sui costi dei token (prompt + completion), con supplementi per chiamata sugli strumenti integrati (web_search, file_search). I rate limit seguono il tuo tier OpenAI esistente. Le insidie comuni in produzione includono i default di retention con store: true, 429 transitori su traffico a burst, e il ritardo di feature parity sulla variante Azure.

I prezzi cambiano — verifica sempre sulla pagina dei prezzi OpenAI.

Per la gestione degli errori, wrappa le chiamate in try/except openai.RateLimitError e try/except openai.APIStatusError, con exponential backoff tramite 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)

Abbiamo avuto un 429 transitorio su un burst di 20 richieste parallele nel nostro ambiente di staging — tenacity con exponential backoff lo ha risolto in modo pulito. La stringa di errore che abbiamo registrato era openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Leggila una volta e vai avanti; il decorator di retry gestisce il resto.

Nota sulla variante Azure: Azure OpenAI espone la Responses API ma accumula ritardi rispetto ai rollout di Sam Altman di 4–8 settimane. Ad aprile 2026, il supporto MCP su Azure è in preview — conferma sulla documentazione Azure OpenAI Responses API di Microsoft Learn prima di andare in produzione.

Compatibilità dei gateway: se fai proxy di OpenAI tramite LiteLLM proxy, il supporto alla Responses API è arrivato nel 2026. La maggior parte degli altri gateway si sta adeguando. E per i rollout in produzione vorrai avere AI observability e logging configurato prima di spostare il traffico — gli eventi della Responses API sono più ricchi di quelli di Chat Completions, e vorrai ogni chiamata a strumento registrata.

Quando NON Usare la Responses API

Salta la Responses API per audio realtime a bassa latenza (usa la Realtime API), generazione di embedding (usa la Embeddings API), e workflow di fine-tuning. Rimani su Chat Completions se il tuo gateway/proxy non supporta ancora Responses (la maggior parte lo fa tramite LiteLLM dal 2026).

Alcune altre ragioni concrete per non usarla:

• Agenti vocali realtime — la Realtime API usa WebSocket ed è costruita per il turn-taking sub-secondo. Lo streaming della Responses API è HTTP SSE; sembrerà lento per la voce.
• Pipeline di embedding pure — client.embeddings.create() è più economico, più veloce, e quello che si aspetta ogni integrazione con vector DB.
• Fine-tuning — alleni e distribuisci i fine-tune tramite la fine-tuning API; puoi poi chiamarli attraverso Responses, ma l'addestramento in sé non è un workflow Responses.
• Job Batch API — se stai elaborando un milione di prompt di notte al 50% di sconto, la Batch API vince ancora sul prezzo.
• Semantica Chat Completions bloccata — se il tuo harness di valutazione, l'observability e la prompt library assumono tutti chat.completions.choices[0].message.content, il costo di migrazione è reale. Non migrare solo perché è più nuovo.

Se il tuo stack funziona bene su Chat Completions e non stai costruendo agenti, la migrazione non è gratuita — il tuo sprint del Q2 potrebbe non averne bisogno. Più nuovo non significa migliore-per-te — la Responses API è la primitiva giusta per gli agenti, non per ogni workload OpenAI.

Domande Frequenti

Cos'è la OpenAI Responses API?

La OpenAI Responses API è una primitiva unificata lanciata a marzo 2025 che combina la semplicità di Chat Completions con le capacità di tool-use dell'Assistants API. Supporta input testo e immagine, cinque strumenti integrati, function calling, output strutturati, streaming e conversazioni con stato tramite previous_response_id.

Quando è stata rilasciata la OpenAI Responses API?

OpenAI ha annunciato la Responses API l'11 marzo 2025 insieme al più ampio annuncio "nuovi strumenti per costruire agenti". L'API è generalmente disponibile dal lancio, con la Conversations API, il supporto MCP e lo strumento image_generation aggiunti in aggiornamenti incrementali durante il 2025 e l'inizio del 2026.

La OpenAI Responses API ha stato?

Sì — opzionalmente. Passa previous_response_id più store: true e il modello porta il contesto tra le chiamate senza che tu debba inviare la cronologia completa. Per thread di lunga durata, la Conversations API ti dà una gestione esplicita del ciclo di vita del thread. Puoi anche rimanere stateless e inviare la cronologia completa a ogni turno, come con Chat Completions.

Qual è la differenza tra Responses API e Chat Completions?

La Responses API è un superset di Chat Completions. Ogni funzionalità di Chat Completions funziona in Responses, più strumenti integrati (web_search, file_search, ecc.), stato tramite previous_response_id, e il loop agentico come concetto di prima classe. OpenAI raccomanda Responses per tutti i nuovi progetti dal 2026.

La Chat Completions API è deprecata?

No. Ad aprile 2026, Chat Completions non è deprecata — rimane pienamente supportata. OpenAI raccomanda Responses per i nuovi progetti, e la maggior parte dei tutorial in stile agentico assume Responses. Chat Completions è ora la primitiva legacy: stabile, ma non più dove atterrano prima le nuove funzionalità.

Quali modelli OpenAI supportano la Responses API?

GPT-5, gpt-5-mini, gpt-4.1 e i modelli di ragionamento della serie o supportano tutti la Responses API. La serie o aggiunge il parametro reasoning_effort (low, medium, high) per workload di extended-thinking. La generazione di immagini viene instradata attraverso gpt-image-1 sotto il cofano quando abiliti lo strumento image_generation.

Come migro da Chat Completions alla Responses API?

Tre passi: cambia client.chat.completions.create() in client.responses.create(), sostituisci l'array messages con input (e sposta i system prompt in instructions), e appiattisci gli schemi dei tuoi strumenti (elimina la chiave function annidata). Il migration pack di OpenAI su GitHub ha esempi di adapter completi.

La Responses API supporta lo streaming?

Sì. Passa stream=True a client.responses.create() (o usa client.responses.stream() come context manager) e itera i Server-Sent Events tipizzati. Gli eventi del flusso di token che gestirai sono response.output_text.delta per il contenuto e response.completed per il payload finale. Lo streaming async funziona tramite AsyncOpenAI.

Posso usare la Responses API su Azure?

Sì. Azure OpenAI espone la Responses API, ma la parità delle funzionalità è in ritardo rispetto ai rollout diretti di OpenAI di 4–8 settimane. Ad aprile 2026, il supporto MCP su Azure è in preview. Controlla Microsoft Learn per le problematiche specifiche di Azure prima di andare in produzione.

La Responses API funziona con i server MCP?

Sì — i server MCP (Model Context Protocol) remoti sono un tipo di strumento di prima classe. Aggiungi {"type": "mcp", "server_url": "...", "server_label": "..."} al tuo array tools e il modello scopre e chiama il catalogo degli strumenti del server come qualsiasi strumento integrato. Usa require_approval: "always" in produzione per la sicurezza.

Conclusione

Hai ora una visione completa della Responses API: come differisce da Chat Completions, come mandare in produzione la prima chiamata, come configurare gli strumenti integrati, e come migrare un progetto Chat Completions esistente in tre passi. Alcuni punti su cui fare leva:

• Prima costruisci, poi ottimizza. Inizia con l'esempio hello-world, aggiungi uno strumento integrato, poi stratifica lo stato con previous_response_id.
• Migra gradualmente. Usa un feature flag, registra entrambe le strutture di risposta, passa al 100% solo dopo la verifica della parità.
• Sfrutta le integrazioni MCP. Questa è la frontiera del 2026 — la maggior parte dei vendor sta correndo a esporre endpoint MCP, e la Responses API è il modo più pulito per consumarli.

In Techsy aiutiamo i team a portare in produzione integrazioni OpenAI di livello production-grade — inclusi rollout della Responses API e migrazioni da Chat Completions. Richiedi una consulenza gratuita.

A cura del team editoriale di Techsy — ingegneri in produzione che realizzano integrazioni OpenAI dal 2024. Ultimo aggiornamento: 25 aprile 2026.