Tutorial da API Responses da OpenAI: 14 exemplos executáveis para programadores Python

Tutorial da API Responses da OpenAI: 14 exemplos executáveis para programadores Python

O tutorial da API Responses da OpenAI de que realmente precisa: 14 exemplos em Python prontos a executar, que cobrem ferramentas integradas, streaming, chamada de funções, MCP e uma migração em 3 passos desde as Chat Completions. A API Responses foi lançada a 11 de março de 2025 como o primitivo unificado da OpenAI para aplicações de estilo agêntico e, em abril de 2026, é o ponto de partida recomendado para qualquer novo projeto na OpenAI. Testámos todos os exemplos abaixo com a versão mais recente do SDK Python openai>=1.50 em abril de 2026 — cada bloco de código executa tal como está.

Principais conclusões

• A API Responses (lançada a 11 de março de 2025) unifica as Chat Completions, a API Assistants e as ferramentas integradas num único primitivo com estado.
• Suporta nativamente web_search, file_search, code_interpreter, computer_use, image_generation e servidores MCP remotos.
• A migração desde as Chat Completions requer 3 passos: alterar o endpoint, renomear messages para input e atualizar os esquemas das ferramentas.
• Utilize previous_response_id (com store: true) para um estado leve; a API Conversations para threads multi-turno fiáveis.

O que é a API Responses da OpenAI?

A API Responses da OpenAI é um primitivo unificado lançado em março de 2025 que combina a simplicidade das Chat Completions com a capacidade de utilização de ferramentas da API Assistants. Suporta entradas de texto e imagem, ferramentas integradas (pesquisa na web, pesquisa de ficheiros, interpretador de código, uso do computador, geração de imagens), chamada de funções, saídas estruturadas, streaming e conversas com estado através de previous_response_id.

Então, por que razão lançou a OpenAI uma terceira API quando as Chat Completions já funcionavam? Porque o ciclo agêntico — o modelo chama uma ferramenta, obtém um resultado, decide o próximo passo — era difícil de construir sobre chat.completions. Acabava por ter de transportar os resultados das ferramentas para trás e para a frente em arrays de messages, gerir IDs de threads com a API Assistants ou criar o seu próprio sistema de estado. A API Responses trata esse ciclo como um conceito de primeira classe.

Se está a iniciar um novo projeto na OpenAI em 2026, a API Responses é a opção padrão; as Chat Completions são o primitivo legado do qual deve migrar. As grandes exceções: áudio em tempo real (utilize a API Realtime) e embeddings puros (utilize a API Embeddings). Para todo o resto — chatbots, agentes, pipelines RAG, extratores de dados estruturados —, a API Responses é para onde apontam a documentação da OpenAI e a publicação de anúncio da OpenAI.

Se estiver a orquestrar múltiplos modelos ou quiser uma camada de estruturação de nível superior, normalmente irá combinar a API Responses com o SDK Agents da OpenAI. Abordámos as compensações no nosso comparativo do SDK Agents da OpenAI; em resumo: a API Responses é o primitivo, o SDK Agents é a framework.

Como difere a API Responses das Chat Completions?

A API Responses é um superconjunto das Chat Completions: todas as funcionalidades das Chat Completions funcionam na API Responses, acrescidas de ferramentas integradas, gestão de estado e o ciclo agêntico. A OpenAI recomenda a API Responses para todos os novos projetos. As Chat Completions continuam suportadas, mas deixaram de ser o primitivo padrão para agentes.

Eis uma comparação lado a lado, baseada na documentação da plataforma OpenAI:

Todas as funcionalidades das Chat Completions funcionam na API Responses; o inverso não é verdade. A regra de decisão é curta: se precisar de ferramentas integradas, gestão de estado ou estiver a começar de zero, utilize a API Responses. Se tiver um pipeline estável de Chat Completions que não utiliza ferramentas e o seu gateway ainda não suporta a API Responses, a migração não é urgente, apenas não construa novos agentes sobre a API antiga.

Configuração e a sua primeira chamada à API Responses

Para fazer a sua primeira chamada à API Responses, instale o SDK Python da OpenAI versão 1.50 ou superior, defina a variável de ambiente OPENAI_API_KEY e chame client.responses.create() com um model e input. O exemplo completo de "hello world" demora menos de 60 segundos.

Passo 1 — Instalar o SDK:

pip install --upgrade "openai>=1.50"

Passo 2 — Definir a sua chave de API:

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

(No PowerShell do Windows: $env:OPENAI_API_KEY = "sk-proj-...". Nunca faça commit disto para o git; utilize um ficheiro .env com python-dotenv para desenvolvimento local.)

Passo 3 — Chamada "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)

Execute isso e receberá uma saudação de 5 palavras. O auxiliar output_text concatena todos os fragmentos de texto numa única cadeia, útil quando não lhe interessa a saída estruturada.

Passo 4 — Inspecionar o objeto de resposta:

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

Esse array response.output é o que deve memorizar. É uma lista de itens tipados: texto, chamadas de ferramentas, resultados de ferramentas, resumos de raciocínio. Irá iterá-lo constantemente assim que começar a utilizar ferramentas integradas.

Como fazer streaming de respostas com a API Responses?

O streaming com a API Responses utiliza Server-Sent Events. Passe stream=True para client.responses.create() e itere sobre o fluxo de eventos resultante. Cada evento tem um campo type, response.output_text.delta para fragmentos de tokens e response.completed para a carga útil final. O SDK 1.50+ expõe um fluxo de eventos tipado.

Se estiver a renderizar tokens numa interface de utilizador, irá iterar os eventos response.output_text.delta e ignorar tudo o 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}")

Algumas armadilhas que encontrámos durante os testes: o gestor de contexto do fluxo trata automaticamente da limpeza da ligação, por isso não o feche manualmente. Se quiser assíncrono, substitua OpenAI() por AsyncOpenAI() e utilize async with juntamente com async for; os nomes dos eventos e a estrutura mantêm-se iguais.

Ferramentas Integradas: Pesquisa Web, Pesquisa de Ficheiros, Interpretador de Código, Uso do Computador, Geração de Imagens

A API Responses inclui cinco ferramentas integradas: web_search para pesquisa na Internet em direto, file_search para recuperação em vetores store, code_interpreter para execução de Python em sandbox, computer_use para automação de navegador/desktop e image_generation para criação inline de imagens. Ative qualquer uma delas adicionando {"type": "<nome_da_ferramenta>"} ao array tools.

Eis a matriz que mantemos sempre à mão junto ao nosso editor:

Quando testámos o web_search no nosso pipeline, a latência adicionou 1,5–3s na primeira chamada, mas ficou em cache para repetições; tenha isso em conta na interface. O exemplo de pesquisa web do Cookbook da OpenAI é a referência mais limpa se quiser aprofundar.

Pesquisa Web

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)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Pesquisa de Ficheiros

A pesquisa de ficheiros é uma dança em dois passos: crie um vector store, carregue os seus ficheiros e, em seguida, referencie o ID do store no seu array tools.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a 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. Use it in a Responses call
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)

Interpretador de Código

Precisa que o modelo execute Python num CSV e crie um gráfico? O code_interpreter faz isso num contentor em 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)

O contentor persiste entre chamadas na mesma sessão, útil quando pretende que o modelo continue a iterar sobre um dataframe.

Uso do Computador

Ainda em prévia em abril de 2026. O modelo recebe um navegador/desktop virtual e clica para concluir tarefas. Ignore-a, a menos que tenha um caso de uso específico de automação de navegador que o mundo Playwright/Selenium já não consiga resolver.

Geração de Imagens

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

# Image bytes live 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)

Chamada de Funções com Ferramentas Personalizadas

A chamada de funções na API Responses permite que o modelo invoque as suas próprias funções Python. Defina cada função como um esquema JSON no array tools, execute a chamada, verifique response.output por itens function_call, execute a função e devolva o resultado através de function_call_output.

A API Responses transforma a chamada de funções, de uma dança de 4 passos, numa única ida e volta quando deixa o ciclo agêntico tratar disso por si. Eis um exemplo completo de conversão de moeda:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    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"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
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)

Este é o ciclo completo. Se é novo neste padrão, o nosso artigo sobre fundamentos da chamada de funções explica o modelo conceptual, e mantemos uma compilação de bibliotecas de chamada de funções se preferir não criar esquemas manualmente. O parâmetro tool_choice (definido como "auto", "required" ou um nome de ferramenta específico) é a sua alavanca para forçar ou proibir uma chamada de ferramenta quando precisa de determinismo.

Saídas Estruturadas (Esquema JSON e Pydantic)

As saídas estruturadas garantem que o modelo devolve JSON em conformidade com o seu esquema. Passe um parâmetro response_format={"type": "json_schema", "json_schema": {...}} ou, com o SDK Python, forneça-lhe diretamente um modelo Pydantic através de client.responses.parse(). O modelo é restringido no momento da descodificação, não apenas através do 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)

O caminho Pydantic é o que deseja 95% das vezes: seguro em termos de tipos, menos código repetitivo e o seu IDE completa automaticamente o resultado. Utilize o esquema JSON bruto apenas quando precisar de partilha de esquemas entre linguagens ou quando o esquema é gerado dinamicamente. Analisamos as compensações no nosso guia sobre saídas estruturadas e esquema JSON e na nossa introdução ao Pydantic para esquemas seguros.

Gestão de Estado: previous_response_id, API Conversations e store=true

Utilize previous_response_id para contexto multi-turno leve, a API Conversations para sessões threadadas fiáveis ou envie o histórico completo de mensagens para controlo total do lado do cliente. previous_response_id requer store: true e apenas persiste para respostas em cache; recorra ao histórico completo se o ID não for resolvível.

Eis um exemplo de dois turnos utilizando previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
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 se esquecer de store: true, o seu previous_response_id não resolve nada e o modelo começa de zero em cada turno. Já perdemos uma hora a depurar isto; a API não gera erro, apenas o esquece silenciosamente. A retenção padrão é de 30 dias; se precisar de mais tempo, utilize a API Conversations, que lhe dá controlo explícito do ciclo de vida do thread.

Quando deve atualizar para a API Conversations? Quando tem vários utilizadores numa aplicação, quando os threads sobrevivem a uma única sessão ou quando pretende edição/ramificação de mensagens do lado do servidor. Para um chatbot rápido, previous_response_id é mais do que suficiente.

Como migrar das Chat Completions para a API Responses

A migração das Chat Completions para a API Responses leva três passos: alterar /v1/chat/completions para /v1/responses, substituir messages por input e substituir os esquemas de tools pelo novo formato. A chamada de funções e as entradas multimodais necessitam de um tratamento ligeiramente diferente. A OpenAI disponibiliza um pacote oficial de migração no GitHub.

Passo 1 — Troca de endpoint:

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

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

Passo 2 — Renomear messages → input:

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

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Passo 3 — Atualizar esquemas de ferramentas:

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

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

É tudo. Distribua o tráfego gradualmente com uma feature flag, mantenha o seu caminho de código das Chat Completions ativo por trás da mesma interface durante uma ou duas semanas, registe ambas as formas de resposta lado a lado e só ative 100% após verificar a paridade. O pacote de migração no repositório openai-cookbook tem um padrão de adaptador mais completo se quiser uma referência.

Como utilizar MCP e servidores MCP remotos com a API Responses

A API Responses suporta servidores remotos MCP (Model Context Protocol) como um tipo de ferramenta. Adicione uma entrada como {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} ao array tools. O modelo descobre o catálogo de ferramentas do servidor MCP e chama-as como ferramentas integradas.

Se nunca trabalhou com MCP, eis o resumo de 30 segundos: é um protocolo aberto que permite a qualquer serviço expor a sua API como um catálogo de ferramentas que o modelo pode chamar. Shopify, Stripe, GitHub e uma lista crescente de fornecedores executam endpoints MCP públicos. O nosso artigo detalhado sobre o Model Context Protocol (MCP) cobre o protocolo em si.

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",   # set to "always" in production
    }],
)
print(response.output_text)

Trate os servidores MCP como qualquer API de terceiros. require_approval: "never" é aceitável para protótipos; em produção, desejará "always" (ou uma lista de permissão de ferramentas) para que um servidor MCP comprometido não possa exfiltrar dados silenciosamente. Audite o catálogo de ferramentas do servidor antes de apontar o seu agente para ele.

Preços, limites de taxa e armadilhas de produção

Os preços da API Responses igualam os das Chat Completions nos custos por token (prompt + conclusão), com sobretaxas por chamada nas ferramentas integradas (web_search, file_search). Os limites de taxa seguem o seu nível existente na OpenAI. As armadilhas comuns de produção incluem os padrões de retenção de store: true, erros 429 transitórios em tráfego de pico e atraso de funcionalidades na variante Azure.

Os preços mudam; verifique sempre na página de preços da OpenAI no momento da escrita.

Para tratamento de erros, envolva as chamadas em try/except openai.RateLimitError e try/except openai.APIStatusError, com retry exponencial 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)

Encontrámos um erro 429 transitório numa explosão de 20 pedidos paralelos no nosso ambiente de staging; o tenacity com retry exponencial resolveu-o limparmente. A cadeia de erro que registámos foi openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Leia uma vez e siga em frente; o decorador de retry trata do resto.

Nota sobre a variante Azure: A Azure OpenAI expõe a API Responses, mas fica atrasada 4–8 semanas em relação aos lançamentos controlados pela Sam Altman. Em abril de 2026, o suporte MCP na Azure está apenas em prévia; confirme através da documentação da API Responses da Azure OpenAI no Microsoft Learn antes de lançar.

Compatibilidade com gateway: se fizer proxy da OpenAI através do proxy LiteLLM, o suporte à API Responses chegou em 2026. A maioria dos outros gateways está a acompanhar. E para lançamentos em produção, quererá ter a observabilidade e registo de IA configurada antes de direcionar o tráfego; os eventos da API Responses são mais ricos do que os das Chat Completions e desejará que todas as chamadas de ferramentas fiquem registadas.

Quando NÃO utilizar a API Responses

Ignore a API Responses para áudio em tempo real de baixa latência (utilize a API Realtime), geração de embeddings (utilize a API Embeddings) e fluxos de trabalho de fine-tuning. Mantenha-se nas Chat Completions se o seu gateway/proxy ainda não suportar a API Responses (a maioria suporta via LiteLLM em 2026).

Mais alguns desqualificadores honestos:

• Agentes de voz em tempo real: a API Realtime utiliza WebSockets e foi construída para troca de turnos em subsegundos. O streaming da API Responses é HTTP SSE; parecerá lento para voz.
• Pipelines de embeddings puros: client.embeddings.create() é mais barato, mais rápido e é o que cada integração de base de dados vetorial espera.
• Fine-tuning: treina e implementa fine-tunes através da API de fine-tuning; pode depois chamá-los através da API Responses, mas o treino em si não é um fluxo de trabalho da API Responses.
• Tarefas da Batch API: se estiver a processar um milhão de prompts durante a noite com 50% de desconto, a Batch API ainda ganha em preço.
• Semântica bloqueada nas Chat Completions: se o seu uso de avaliação, observabilidade e biblioteca de prompts assumirem chat.completions.choices[0].message.content, o custo da migração é real. Não migre apenas porque é mais novo.

Se a sua stack está satisfeita com as Chat Completions e não está a construir agentes, a migração não é gratuita; o seu sprint do Q2 pode não precisar disto. Mais novo não significa melhor para si; a API Responses é o primitivo certo para agentes, não para todas as cargas de trabalho da OpenAI.

Perguntas Frequentes

O que é a API Responses da OpenAI?

A API Responses da OpenAI é um primitivo unificado lançado em março de 2025 que combina a simplicidade das Chat Completions com a utilização de ferramentas da API Assistants. Suporta entradas de texto e imagem, cinco ferramentas integradas, chamada de funções, saídas estruturadas, streaming e conversas com estado através de previous_response_id.

Quando foi lançada a API Responses da OpenAI?

A OpenAI anunciou a API Responses a 11 de março de 2025, juntamente com o seu anúncio mais amplo de "novas ferramentas para construir agentes". A API tem estado geralmente disponível desde o lançamento, tendo a API Conversations, o suporte MCP e a ferramenta image_generation sido adicionadas em atualizações incrementais ao longo de 2025 e início de 2026.

A API Responses da OpenAI tem estado?

Sim, opcionalmente. Passe previous_response_id juntamente com store: true e o modelo mantém o contexto entre chamadas sem que tenha de enviar o histórico completo. Para threads de vida mais longa, a API Conversations oferece-lhe gestão explícita do ciclo de vida do thread. Também pode manter-se sem estado e enviar o histórico completo em cada turno, como nas Chat Completions.

Qual é a diferença entre a API Responses e as Chat Completions?

A API Responses é um superconjunto das Chat Completions. Todas as funcionalidades das Chat Completions funcionam na API Responses, acrescidas de ferramentas integradas (web_search, file_search, etc.), gestão de estado via previous_response_id e o ciclo agêntico como conceito de primeira classe. A OpenAI recomenda a API Responses para todos os novos projetos a partir de 2026.

A API Chat Completions está descontinuada?

Não. Em abril de 2026, as Chat Completions não estão descontinuadas; continuam totalmente suportadas. A OpenAI recomenda a API Responses para novos projetos, e a maioria dos tutoriais de estilo agêntico assume a API Responses. As Chat Completions são agora o primitivo legado: estável, mas já não é onde as novas funcionalidades chegam primeiro.

Quais modelos da OpenAI suportam a API Responses?

GPT-5, gpt-5-mini, gpt-4.1 e os modelos de raciocínio da série o suportam todos a API Responses. A série o adiciona o parâmetro reasoning_effort (low, medium, high) para cargas de trabalho de pensamento prolongado. A geração de imagens passa por gpt-image-1 nos bastidores quando ativa a ferramenta image_generation.

Como migrar das Chat Completions para a API Responses?

Três passos: mude client.chat.completions.create() para client.responses.create(), substitua o array messages por input (e mova os prompts de sistema para instructions) e achate os seus esquemas de ferramentas (elimine a chave function aninhada). O pacote de migração da OpenAI no GitHub tem exemplos completos de adaptadores.

A API Responses suporta streaming?

Sim. Passe stream=True para client.responses.create() (ou utilize client.responses.stream() como gestor de contexto) e itere os Server-Sent Events tipados. Os eventos de fluxo de tokens que irá tratar são response.output_text.delta para conteúdo e response.completed para a carga útil final. O streaming assíncrono funciona via AsyncOpenAI.

Posso utilizar a API Responses na Azure?

Sim. A Azure OpenAI expõe a API Responses, mas a paridade de funcionalidades fica atrasada 4–8 semanas em relação aos lançamentos diretos da OpenAI. Em abril de 2026, o suporte MCP na Azure está em prévia. Consulte o Microsoft Learn para as peculiaridades específicas da Azure atuais antes de lançar para produção.

A API Responses funciona com servidores MCP?

Sim, os servidores MCP remotos (Model Context Protocol) são um tipo de ferramenta de primeira classe. Adicione {"type": "mcp", "server_url": "...", "server_label": "..."} ao seu array tools e o modelo descobrirá e chamará o catálogo de ferramentas do servidor como qualquer ferramenta integrada. Utilize require_approval: "always" em produção por segurança.

Conclusão

Tem agora o panorama completo da API Responses: como difere das Chat Completions, como efetuar a sua primeira chamada, como configurar ferramentas integradas e como migrar um projeto existente de Chat Completions em três passos. Algumas conclusões para reter:

• Construa primeiro, otimize depois. Comece com o exemplo hello world, adicione uma ferramenta integrada e, em seguida, adicione estado com previous_response_id.
• Migre gradualmente. Utilize uma feature flag, registe ambas as formas de resposta e só ative 100% após verificação de paridade.
• Implemente integrações MCP. Esta é a fronteira de 2026; a maioria dos fornecedores está a correr para expor endpoints MCP, e a API Responses é a forma mais limpa de os consumir.

Na Techsy, ajudamos equipas a implementar integrações OpenAI de grau de produção, incluindo lançamentos da API Responses e migrações de Chat Completions. Obtenha uma consulta gratuita.

Pela equipa editorial da Techsy, engenheiros de produção que implementam integrações OpenAI desde 2024. Última atualização: 25 de abril de 2026.