A API Responses é nossa nova primitiva de API, uma evolução de Chat Completions que traz mais simplicidade e primitivas agênticas poderosas para suas integrações.
Chat Completions continua com suporte, mas recomendamos Responses para todos os novos projetos.
Sobre a API Responses
A API Responses é uma interface unificada para criar aplicativos poderosos que atuam como agentes. Ela inclui:
Interações fluidas com múltiplos turnos que permitem passar respostas anteriores para obter resultados de raciocínio mais precisos.
Suporte multimodal nativo para texto e imagens.
Benefícios de Responses
A API Responses oferece vários benefícios em relação a Chat Completions:
Melhor desempenho: Usar modelos de raciocínio, como GPT-5, com Responses resulta em maior inteligência do modelo em comparação com Chat Completions. Nossas avaliações internas mostram uma melhoria de 3% no SWE-bench com o mesmo prompt e a mesma configuração.
Agêntica por padrão: A API Responses funciona como um ciclo agêntico, permitindo que o modelo chame várias ferramentas, como web_search, image_generation, file_search, code_interpreter e servidores MCP remotos, além de suas próprias funções personalizadas, em uma única requisição à API.
Custos menores: Reduz os custos graças ao melhor aproveitamento do cache (melhoria de 40% a 80% em comparação com Chat Completions em testes internos).
Contexto com estado: Use store: true para manter o estado entre turnos, preservando o contexto de raciocínio e das ferramentas de um turno para outro.
Entradas flexíveis: Passe uma string em input ou uma lista de mensagens; use instructions para fornecer orientações no nível do sistema.
Raciocínio criptografado: Opte por não manter o estado e continue aproveitando o raciocínio avançado.
Preparada para o futuro: Pronta para os próximos modelos.
Capacidades
API chat completions
API Responses
Geração de texto
Áudio
Em breve
Visão
Saídas estruturadas
Chamada de função
Pesquisa na Web
Pesquisa de arquivos
Uso do computador
Code Interpreter
MCP
Geração de imagens
Resumos de raciocínio
Exemplos
Veja como a API Responses se compara à API chat completions em cenários específicos.
Mensagens vs. itens
As duas APIs facilitam a geração de saídas com nossos modelos. A entrada e o resultado de uma chamada a Chat Completions são arrays de mensagens, enquanto
a API Responses usa itens. Um item é uma união de vários tipos que representam as possíveis
ações do modelo. Um message é um tipo de item, assim como function_call ou function_call_output. Ao contrário de uma mensagem de Chat Completions, em que
várias responsabilidades se concentram em um único objeto, os itens são distintos entre si e representam melhor a unidade básica de contexto do modelo.
Além disso, Chat Completions pode retornar várias gerações paralelas em choices, usando o parâmetro n. Em Responses, removemos esse parâmetro, permitindo apenas uma geração.
API chat completions
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15from openai import OpenAIclient = OpenAI()completion = client.chat.completions.create(model="gpt-6-astra",messages=[ {"role": "user","content": "Write a one-sentence bedtime story about a unicorn.", } ],)print(completion.choices[0].message.content)
1
2
3
4
5
6
7
8
9
10
11
12
13require "openai"client = OpenAI::Client.newcompletion = client.chat.completions.create( model: "gpt-6-astra", messages: [ { role: :user, content: "Write a one-sentence bedtime story about a unicorn." } ])puts(completion.choices.fetch(0).message.content)
API Responses
Python
1
2
3
4
5
6
7
8
9
10from openai import OpenAIclient = OpenAI()response = client.responses.create(model="gpt-6-astra",input="Write a one-sentence bedtime story about a unicorn.",)print(response.output_text)
1
2
3
4
5
6
7
8require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Write a one-sentence bedtime story about a unicorn.")puts(response.output_text)
Ao receber uma resposta da API Responses, os campos são ligeiramente diferentes.
Em vez de um message, você recebe um objeto response tipado com seu próprio id.
As respostas de Responses são armazenadas por padrão. As de Chat Completions são armazenadas por padrão para novas contas.
Para desativar o armazenamento em qualquer uma das APIs, defina store: false.
Os objetos retornados por essas APIs são ligeiramente diferentes. Em Chat Completions, você recebe um array de
choices, cada um contendo um message. Em Responses, você recebe um array de itens chamado output.
API chat completions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19{"id": "chatcmpl-C9EDpkjH60VPPIB86j2zIhiR8kWiC","object": "chat.completion","created": 1756315657,"model": "gpt-5.5","choices": [ {"index": 0,"message": {"role": "assistant","content": "Under a blanket of starlight, a sleepy unicorn tiptoed through moonlit meadows, gathering dreams like dew to tuck beneath its silver mane until morning.","refusal": null,"annotations": [] },"finish_reason": "stop" } ],...}
API Responses
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29{"id": "resp_68af4030592c81938ec0a5fbab4a3e9f05438e46b5f69a3b","object": "response","created_at": 1756315696,"model": "gpt-5.5","output": [ {"id": "rs_68af4030baa48193b0b43b4c2a176a1a05438e46b5f69a3b","type": "reasoning","content": [],"summary": [] }, {"id": "msg_68af40337e58819392e935fb404414d005438e46b5f69a3b","type": "message","status": "completed","content": [ {"type": "output_text","annotations": [],"logprobs": [],"text": "Under a quilt of moonlight, a drowsy unicorn wandered through quiet meadows, brushing blossoms with her glowing horn so they sighed soft lullabies that carried every dreamer gently to sleep." } ],"role": "assistant" } ],...}
Outras diferenças
As respostas de Responses são armazenadas por padrão. As de Chat Completions são armazenadas por padrão para novas contas. Para desativar o armazenamento em qualquer uma das APIs, defina store: false.
Os modelos de raciocínio oferecem uma experiência mais completa na API Responses, com melhor uso de ferramentas. A partir do GPT-5.4, Chat Completions não oferece suporte a chamadas de ferramentas com valores de reasoning_effort diferentes de none.
A estrutura da API para saídas estruturadas é diferente. Em Responses, use text.format em vez de response_format. Saiba mais no guia de saídas estruturadas.
A estrutura da API para chamadas de função é diferente, tanto na configuração da função na requisição quanto nas chamadas de função retornadas na resposta. Veja todas as diferenças no guia de chamada de função.
O SDK de Responses tem o recurso auxiliar output_text, que não existe no SDK de Chat Completions.
Em Chat Completions, o estado da conversa precisa ser gerenciado manualmente. A API Responses é compatível com a API Conversations para conversas persistentes e também permite passar um previous_response_id para encadear respostas com facilidade.
Migração de Chat Completions
Considere a migração como três mudanças relacionadas: enviar requisições para /v1/responses, ler a saída de um array output tipado e escolher como seu aplicativo manterá o estado entre turnos.
1. Atualize os endpoints de geração
Comece atualizando seus endpoints de geração de post /v1/chat/completions para post /v1/responses.
Se você não usa funções nem entradas multimodais, as entradas de mensagens simples são compatíveis entre as duas APIs:
Chat Completions usa messages tanto na entrada quanto na saída. Responses usa os arrays input e output, compostos por Itens tipados. message é um tipo de Item, assim como reasoning, function_call e function_call_output.
Conceito em Chat Completions
Equivalente em Responses
messages[]
input, como uma string ou um array de Itens de entrada
Orientações do sistema ou do desenvolvedor
instructions no nível superior, ou Itens de mensagem compatíveis quando você precisa preservar um histórico de conversa existente
Mensagem do usuário
Um Item de mensagem de entrada com role: "user"
Mensagem do assistente
Um Item de mensagem de saída em response.output; envie-o novamente em input se você gerencia o estado manualmente
Chamada de ferramenta ou função
Um Item de saída do tipo function_call
Resultado de ferramenta ou função
Um Item de entrada do tipo function_call_output vinculado à chamada por call_id
Múltiplas gerações com n
Não disponível em Responses; faça requisições separadas se precisar de múltiplas saídas candidatas
Quando precisar apenas do texto final, use o recurso auxiliar output_text do SDK. Quando seu fluxo usar raciocínio, ferramentas ou saída multimodal, percorra response.output e trate cada Item de acordo com seu type.
3. Atualize as conversas com múltiplos turnos
Se seu aplicativo tem conversas com múltiplos turnos, atualize a lógica de contexto. Responses oferece três opções comuns de gerenciamento de estado:
Use previous_response_id quando quiser que a OpenAI gerencie o contexto das respostas anteriores. Reenvie o conteúdo fixo de instructions em cada requisição, pois previous_response_id não mantém o conteúdo de instructions definido no nível superior da resposta anterior.
Envie novamente os Itens de output anteriores na próxima requisição quando precisar gerenciar ou reduzir o contexto por conta própria.
Use a API Conversations quando precisar de um objeto de conversa persistente.
Chat Completions
Em Chat Completions, você armazena o histórico da conversa e envia o array
messages acumulado em cada requisição.
Conversa com múltiplos turnos
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16let messages = [ { role: "system", content: "You are a helpful assistant." }, { role: "user", content: "What is the capital of France?" },];constres1=await client.chat.completions.create({ model: "gpt-6-astra", messages,});messages = messages.concat([res1.choices[0].message]);messages.push({ role: "user", content: "And its population?" });constres2=await client.chat.completions.create({ model: "gpt-6-astra", messages,});
1
2
3
4
5
6
7
8
9
10messages = [ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "What is the capital of France?"},]res1 = client.chat.completions.create(model="gpt-6-astra", messages=messages)messages += [res1.choices[0].message]messages += [{"role": "user", "content": "And its population?"}]res2 = client.chat.completions.create(model="gpt-6-astra", messages=messages)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.chat.completions.ChatCompletionCreateParams;var params = ChatCompletionCreateParams.builder() .model("gpt-6-astra") .addSystemMessage("You are a helpful assistant.") .addUserMessage("What is the capital of France?") .build();var first = client.chat().completions().create(params);var second = client .chat() .completions() .create( params.toBuilder() .addAssistantMessage(first.choices().get(0).message().content().orElseThrow()) .addUserMessage("And its population?") .build());second.choices().stream() .flatMap(choice -> choice.message().content().stream()) .forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18using OpenAI.Chat;string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;string model = "gpt-6-astra";ChatClient client = new(model, key);List<ChatMessage> messages =[ new SystemChatMessage("You are a helpful assistant."), new UserChatMessage("What is the capital of France?"),];ChatCompletion first = await client.CompleteChatAsync(messages);messages.Add(new AssistantChatMessage(first));messages.Add(new UserChatMessage("And its population?"));ChatCompletion second = await client.CompleteChatAsync(messages);Console.WriteLine(second.Content[0].Text);
Com Responses, você pode passar manualmente as saídas de uma resposta para a
entrada de outra.
Conversa com múltiplos turnos
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import { toResponseInputItems } from"openai/lib/responses/ResponseInputItems";let context = [{ role: "user", content: "What is the capital of France?" }];constres1=await client.responses.create({ model: "gpt-6-astra", input: context,});// Append the first response’s output to contextcontext = context.concat(toResponseInputItems(res1.output));// Add the next user messagecontext.push({ role: "user", content: "And its population?" });constres2=await client.responses.create({ model: "gpt-6-astra", input: context,});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16context = [{"role": "user", "content": "What is the capital of France?"}]res1 = client.responses.create( model="gpt-6-astra", input=context,)# Append the first response's output to contextcontext += res1.output# Add the next user messagecontext += [{"role": "user", "content": "And its population?"}]res2 = client.responses.create( model="gpt-6-astra", input=context,)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);ResponseResult first = await client.CreateResponseAsync( "gpt-6-astra", "What is the capital of France?");ResponseResult second = await client.CreateResponseAsync( "gpt-6-astra", "And its population?", previousResponseId: first.Id);Console.WriteLine(second.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18require "openai"client = OpenAI::Client.newfirst = client.responses.create( model: "gpt-6-astra", input: "What is the capital of France?", store: true)second = client.responses.create( model: "gpt-6-astra", previous_response_id: first.id, input: "And its population?", store: true)puts(second.output_text)
Mesmo ao usar previous_response_id, todos os tokens de entrada anteriores das respostas na cadeia são cobrados como tokens de entrada na API.
4. Decida quando manter o estado
As respostas de Responses são armazenadas por padrão. As de Chat Completions são armazenadas por padrão para contas novas. Para desativar o armazenamento em qualquer uma das APIs, defina store: false.
Algumas organizações, como as que têm requisitos de zero retenção de dados (ZDR), não podem usar a API Responses com manutenção de estado devido a políticas de conformidade ou de retenção de dados. Para atender a esses casos, a OpenAI oferece itens de raciocínio criptografados, permitindo que seu fluxo de trabalho não mantenha estado e ainda se beneficie dos itens de raciocínio.
Para desativar a manutenção de estado e ainda aproveitar o raciocínio:
Preserve e reenvie todos os itens de raciocínio retornados. Cada item inclui encrypted_content por padrão quando você cria uma resposta.
A API então retornará uma versão criptografada dos tokens de raciocínio, que você poderá reenviar em requisições futuras como faria com itens de raciocínio comuns.
Para organizações com ZDR, a OpenAI aplica store: false automaticamente. Quando uma requisição inclui encrypted_content, esse conteúdo é descriptografado na memória, usado para gerar a próxima resposta e depois descartado com segurança. Todos os novos tokens de raciocínio são imediatamente criptografados e retornados a você, garantindo que nenhum estado intermediário seja persistido.
5. Atualize as definições e saídas das funções
Há duas diferenças pequenas, mas relevantes, na forma como as funções são definidas em Chat Completions e Responses.
Em Chat Completions, as definições de funções usam marcação externa. Em Responses, usam marcação interna.
Em Chat Completions, as funções não usam o modo estrito por padrão. Em Responses, omitir strict faz com que a API tente usar o modo estrito; se não for possível tornar o esquema compatível, Responses recorre à chamada de função não estrita, por melhor esforço, e retorna a ferramenta com a configuração efetiva strict: false. Para manter explicitamente o comportamento não estrito em Responses, defina strict: false.
O exemplo de função da API Responses à direita é funcionalmente equivalente ao exemplo de Chat Completions à esquerda.
Siga as práticas recomendadas para chamada de função
Em Responses, as chamadas de ferramentas e suas saídas são dois tipos distintos de Itens, correlacionados por um call_id. Consulte
a documentação de chamada de função para saber mais sobre como as chamadas de função funcionam em Responses.
6. Atualize as definições de saídas estruturadas
Na API Responses, as definições de saídas estruturadas passaram de response_format para text.format:
O streaming de Chat Completions retorna blocos incrementais com um campo delta. O streaming de Responses usa eventos tipados enviados pelo servidor. Atualize os consumidores de streaming para selecionar o tratamento com base no type de cada evento e processar os eventos necessários para sua interface ou camada de orquestração.
Se seu aplicativo tem casos de uso que se beneficiariam das ferramentas nativas da OpenAI, você pode atualizar suas chamadas de ferramentas para usar as ferramentas prontas para uso da OpenAI.
Chat Completions
Com Chat Completions, você não pode usar ferramentas hospedadas pela OpenAI de forma nativa e precisa
escrever sua própria integração de ferramentas.
Este exemplo usa GPT-5.6 porque GPT-6 Astra exige a API Responses
para chamadas de ferramentas.
Ferramenta de pesquisa na Web
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24asyncfunctionweb_search(query) {constres=awaitfetch(`https://api.example.com/search?q=${query}`);constdata=await res.json();return data.results;}constcompletion=await client.chat.completions.create({ model: "gpt-5.6", messages: [ { role: "system", content: "You are a helpful assistant." }, { role: "user", content: "Who is the current president of France?" }, ], functions: [ { name: "web_search", description: "Search the web for information", parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"], }, }, ],});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import requestsdef web_search(query): r = requests.get(f"https://api.example.com/search?q={query}") return r.json().get("results", [])completion = client.chat.completions.create( model="gpt-5.6", messages=[ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "Who is the current president of France?"}, ], functions=[ { "name": "web_search", "description": "Search the web for information", "parameters": { "type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"], }, } ],)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34package mainimport ( "context" "fmt" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/shared")func main() { client := openai.NewClient() completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{ Model: "gpt-5.6", Messages: []openai.ChatCompletionMessageParamUnion{ openai.SystemMessage("You are a helpful assistant."), openai.UserMessage("Who is the current president of France?"), }, Functions: []openai.ChatCompletionNewParamsFunction{{ Name: "web_search", Description: openai.String("Search the web for information"), Parameters: map[string]any{ "type": "object", "properties": map[string]any{"query": map[string]any{"type": "string"}}, "required": []string{"query"}, }, }}, ReasoningEffort: shared.ReasoningEffortNone, }) if err != nil { panic(err) } fmt.Println(completion.Choices[0].Message)}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.JsonValue;import com.openai.models.FunctionParameters;import com.openai.models.ReasoningEffort;import com.openai.models.chat.completions.ChatCompletionCreateParams;import java.util.List;import java.util.Map;ChatCompletionCreateParams params = ChatCompletionCreateParams.builder() .model("gpt-5.6") .reasoningEffort(ReasoningEffort.NONE) .addSystemMessage("You are a helpful assistant.") .addUserMessage("Who is the current president of France?") .addFunction( ChatCompletionCreateParams.Function.builder() .name("web_search") .description("Search the web for information") .parameters( FunctionParameters.builder() .putAdditionalProperty("type", JsonValue.from("object")) .putAdditionalProperty( "properties", JsonValue.from(Map.of("query", Map.of("type", "string")))) .putAdditionalProperty("required", JsonValue.from(List.of("query"))) .build()) .build()) .build();client.chat().completions().create(params).choices().stream() .map(choice -> choice.message()) .forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31require "openai"client = OpenAI::Client.newcompletion = client.chat.completions.create( model: "gpt-5.6", reasoning_effort: :none, messages: [ { role: :system, content: "You are a helpful assistant." }, { role: :user, content: "Who is the current president of France?" } ], functions: [ { name: "web_search", description: "Search the web for information", parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] } } ])puts(completion.choices.fetch(0).message)
Com Responses, você pode especificar as ferramentas que deseja que o modelo use.
Ferramenta de pesquisa na Web
JavaScript
1
2
3
4
5
6
7constanswer=await client.responses.create({ model: "gpt-6-astra", input: "Who is the current president of France?", tools: [{ type: "web_search" }],});console.log(answer.output_text);
1
2
3
4
5
6
7answer = client.responses.create( model="gpt-6-astra", input="Who is the current president of France?", tools=[{"type": "web_search"}],)print(answer.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.WebSearchTool;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input("Who is the current president of France?") .addTool(WebSearchTool.builder().type(WebSearchTool.Type.WEB_SEARCH).build()) .build();client.responses().create(params).output().stream() .flatMap(item -> item.message().stream()) .flatMap(message -> message.content().stream()) .flatMap(content -> content.outputText().stream()) .forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new() { Model = "gpt-6-astra" };options.Tools.Add(ResponseTool.CreateWebSearchTool());options.InputItems.Add( ResponseItem.CreateUserMessageItem("Who is the current president of France?"));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Who is the current president of France?", tools: [{ type: :web_search }])puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "gpt-6-astra", "input": "Who is the current president of France?", "tools": [{"type": "web_search"}] }'
9. Verifique os erros comuns de migração
Fique atento a estes problemas ao migrar código de Chat Completions para Responses:
Ler choices[0].message.content em vez de response.output_text ou response.output.
Tratar cada entrada de output como uma mensagem. Raciocínio, chamadas de ferramentas e chamadas de função são tipos distintos de Itens.
Descartar Itens de raciocínio, de chamada de função ou de saída de chamada de função ao transferir manualmente o contexto para a próxima resposta.
Enviar o resultado de uma função sem o call_id correspondente.
Usar response_format em uma requisição de Responses em vez de text.format.
Reutilizar os processadores de blocos de streaming de Chat Completions sem tratar os eventos tipados de Responses.
Supor que previous_response_id elimina a cobrança pelo contexto anterior. Os tokens de entrada anteriores na cadeia de respostas continuam sendo cobrados como tokens de entrada.
Lista de verificação para adoção gradual
Chat Completions continua tendo suporte, então você pode migrar um fluxo de usuário por vez.
Comece com um fluxo simples de geração de texto.
Atualize o endpoint, o corpo da requisição e o tratamento da saída.
Decida se o fluxo usa previous_response_id, reenvio manual de Itens ou a API Conversations.
Se o fluxo não mantém estado ou usa ZDR, adicione store: false e inclua itens de raciocínio criptografados quando o contexto de raciocínio precisar ser mantido entre os turnos.
Migre as definições de função e verifique se as saídas das chamadas de função incluem o call_id correto.
Mova os esquemas de saídas estruturadas de response_format para text.format.
Atualize os consumidores de streaming para tratar os eventos tipados de Responses.
Substitua a orquestração personalizada por ferramentas hospedadas pela OpenAI quando elas forem adequadas ao fluxo de trabalho.
Compare o comportamento, a latência, o uso de tokens e os erros antes de direcionar mais tráfego para Responses.
Recomendamos migrar todos os fluxos para a API Responses ao longo do tempo para aproveitar os recursos e as melhorias mais recentes da OpenAI.
API Assistants
Com base no feedback dos desenvolvedores durante a versão beta da API Assistants, incorporamos melhorias importantes à API Responses para torná-la mais flexível, rápida e fácil de usar. A API Responses representa o caminho para o futuro da criação de agentes na OpenAI.
A API Assistants foi oficialmente desativada em 26 de agosto de 2026 e não está mais disponível. Siga o guia de migração para atualizar sua integração para a API Responses.
