OpenAI API: Decisões vs. Respostas

Use a API Decisions quando o trabalho for classificar, rotear, pontuar ou "gatear" algo e você quiser probabilidades de retorno: ela roda no GPT-6 Luna, retorna respostas tipadas em vez de texto, cobra a entrada a apenas US$0,10 por 1M de tokens sem cobrança de saída, leitura ou escrita de cache, e a OpenAI diz que é cerca de 10 vezes mais rápida que a API Responses. Use a API Responses quando precisar de texto gerado, JSON no seu próprio esquema, chamadas de ferramentas, streaming ou estado de conversação. A Decisions entrou em beta público em 06/10/2026.

Este post executa um trabalho (roteamento de um ticket de suporte) em ambos os endpoints, compara o que cada um retorna, calcula o custo uma vez e encerra com uma nota de migração e uma forma de testar ambos em um projeto Apidog. Para a anatomia do endpoint, comece com o pilar da API Decisions; para a linha de base, veja nosso guia da API Responses.

Matriz de recursos

Cada linha vem do guia de Decisions da OpenAI, da referência da API e da página de preços.

O mesmo trabalho de duas maneiras: rotear um ticket de suporte

O ticket diz “Fui cobrado duas vezes pelo meu pedido.” Os departamentos são faturamento, técnico, envio e outros. Aqui está a requisição Responses com Structured Outputs, que é como a maioria das equipes faz isso hoje:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "Route this support ticket to one department.\n\nTicket: I was charged twice for my order.",
    "text": {
      "format": {
        "type": "json_schema",
        "name": "ticket_route",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "department": {
              "type": "string",
              "enum": ["billing", "technical", "shipping", "other"]
            }
          },
          "required": ["department"],
          "additionalProperties": false
        }
      }
    }
  }'

E a requisição Decisions para o mesmo ticket:

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "I was charged twice for my order.",
    "questions": [
      {
        "type": "choice",
        "name": "department",
        "instructions": "Which department should handle this ticket?",
        "choices": [
          {"value": "billing", "description": "Charges, refunds, invoices"},
          {"value": "technical", "description": "Bugs, errors, login problems"},
          {"value": "shipping", "description": "Delivery, tracking, returns in transit"},
          {"value": "other", "description": "Anything else"}
        ]
      }
    ]
  }'

O corpo da requisição Responses contém a pergunta dentro do prompt e as respostas permitidas dentro de um esquema. O corpo da requisição Decisions contém o ticket bruto como input e a pergunta como uma choice com 2 a 255 valores únicos; não possui campos temperature, reasoning, stream ou text, pois nenhum existe nesse endpoint.

O que cada um retorna

Responses retorna texto gerado. Com um esquema estrito, esse texto é JSON válido, então, após a análise, você tem um rótulo:

{"department": "billing"}

Se você quiser um número de confiança, adicione um campo ao esquema e peça ao modelo para escrever um; o que volta é texto gerado que se parece com uma probabilidade, não uma medida.

Decisions retorna o rótulo mais a distribuição por trás dele. Os números abaixo são o exemplo do guia da OpenAI para esta entrada exata:

{
  "model": "gpt-6-luna",
  "answers": [
    {
      "type": "choice",
      "name": "department",
      "choice": "billing",
      "probabilities": [
        {"value": "billing", "probability": 0.95},
        {"value": "technical", "probability": 0.02},
        {"value": "shipping", "probability": 0.01},
        {"value": "other", "probability": 0.02}
      ],
      "confidence": 0.93
    }
  ]
}

Um objeto usage segue answers (mostrado na seção de custos). Sem parser, sem regex. O campo confidence é o que você usa como limiar, e a orientação da OpenAI é definir esse limiar a partir de seus próprios exemplos rotulados, porque não há figuras de precisão ou calibração publicadas. Uma recusa chega como {"type": "refusal", "name": "department"}; outras perguntas na mesma requisição ainda recebem respostas.

Custo: a aritmética de uma vez

Ambos os endpoints cobram a entrada Luna a US$0,10 por 1M de tokens em contexto curto (até 272K tokens de entrada). A diferença está na saída. Considere um ticket de 500 tokens em 1.000.000 de requisições:

• Decisions: 500 / 1.000.000 x US$0,10 = US$0,00005 por requisição, ou seja, US$50 pelo milhão, sem linhas de saída ou cache para adicionar.
• Responses: os mesmos US$50 de entrada, mais saída a US$0,50 por 1M. Um rótulo JSON de 40 tokens é 40 / 1.000.000 x US$0,50 = US$0,00002 por requisição, ou US$20 pelo milhão. Em seguida, adicione tokens de raciocínio, que Luna cobra como saída pelo mesmo US$0,50.

Então, a diferença visível apenas no rótulo é de US$50 contra US$70. A diferença maior é a linha de raciocínio, e a maneira honesta de afirmar é que Decisions não cobra nenhum token de saída; ambos os contadores marcam 0 no exemplo de referência da OpenAI:

"usage": {
  "input_tokens": 42,
  "input_tokens_details": {"cached_tokens": 0, "cache_write_tokens": 0},
  "output_tokens": 0,
  "output_tokens_details": {"reasoning_tokens": 0},
  "total_tokens": 42
}

Duas ressalvas. Responses tem alavancas que Decisions não tem: reasoning.effort vai até none no Luna, cache de prompt reduz a entrada repetida para US$0,01 por 1M, e a API Batch reduz as taxas padrão pela metade. Nenhuma delas está documentada para Decisions. E a entrada de contexto longo (acima de 272K tokens) dobra a taxa de entrada em ambos, então uma requisição Decisions longa custa US$0,20 por 1M de entrada (derivado do multiplicador da página de preços); o processamento regional adiciona 10%.

Velocidade

A OpenAI diz que a API Decisions é cerca de 10 vezes mais rápida que a API Responses. Nenhum número absoluto de latência é publicado, então trate a afirmação como uma direção em vez de um orçamento e meça seus próprios p50 e p95 antes de mover um caminho crítico. Um desenvolvedor no fórum da OpenAI relatou que decisões com entrada de imagem retornaram em cerca de 0,8 segundos em uma conexão lenta; isso é uma anedota, não um benchmark. A direção é plausível: Responses gera tokens, incluindo raciocínio, e você espera pelo último.

A regra de decisão

Escolha Decisions quando a saída for uma destas:

• Um sim/não com uma probabilidade (predicate): “Esta mensagem é spam?”
• Uma de N categorias não ordenadas (choice): departamento, intenção, qual modelo ou ferramenta chamar em seguida. Inclua um fallback como “outro”.
• Um nível ordenado (score): severidade, prioridade, urgência. A pontuação é uma média ponderada por probabilidade de índices de nível baseados em 0, então 1.1 significa entre o nível 1 e o nível 2, próximo de 1.
• Um gate: compare confidence ou probability com um limiar e envie itens de baixa confiança para uma fila humana.

Escolha Responses quando qualquer um destes for verdadeiro:

• Você precisa de texto que uma pessoa lerá: um resumo, uma resposta, uma explicação.
• Você precisa de um objeto em sua própria forma: campos extraídos, estruturas aninhadas, arrays de comprimento desconhecido. Isso é território de Structured Outputs, e o guia da OpenAI diz isso.
• O modelo deve solicitar uma chamada de ferramenta com argumentos: chamada de função.
• Você precisa de streaming, estado de conversação ou um modelo diferente de Luna.
• Uma decisão depende de outra e você quer ambas em uma única ida e volta. Decisions mantém várias perguntas independentes em uma entrada, mas decisões dependentes precisam de requisições separadas.

Muitos pipelines querem ambos: Decisions para classificar e "gatear", Responses para escrever a resposta.

Migrando um classificador de Responses para Decisions

Se você já roteia tickets com um esquema enum estrito, a mudança é pequena:

1. Mantenha o mesmo input, reduzido ao ticket bruto; a pergunta sai do prompt.
2. Coloque a pergunta em questions como uma choice, com seus valores enum como choices[].value e uma description de uma linha para cada. Os valores podem ser strings ou booleanos, e true e "true" são distintos.
3. Exclua o parser. Leia answers[0].choice e answers[0].confidence; as respostas chegam na ordem em que você perguntou e ecoam o name que você definiu. Em seguida, defina um limiar a partir de uma amostra rotulada.
4. Verifique o caminho de entrada. Decisions aceita apenas mensagens de usuário: sem funções de sistema ou assistente, sem chamadas de função, sem arquivos, sem file_id. Incorpore regras de prompt de sistema em instructions ou nas descrições das escolhas. Imagens entram como URLs de dados base64; a referência também lista URLs HTTP(S) públicos, então teste imagens hospedadas primeiro.
5. Divida as cadeias. “Classificar, então se for faturamento, decidir elegibilidade para reembolso” torna-se duas requisições.

Teste ambos em um projeto Apidog

A maneira mais clara de decidir é executar ambas as requisições contra os mesmos tickets rotulados e comparar. No Apidog, armazene a chave uma vez como uma variável de ambiente e referencie {{OPENAI_API_KEY}} no cabeçalho Authorization: Bearer de ambas as requisições salvas, para que nenhuma chave literal apareça em um corpo salvo.

Dê a ambas as requisições a mesma asserção: o departamento é igual a billing. Na requisição Decisions, isso é uma asserção JSONPath em $.answers[0].choice, com $.answers[0].confidence maior que 0.8 e $.usage.output_tokens igual a 0 ao lado. Na requisição Responses, o rótulo fica dentro do texto gerado, então um pequeno script pós-requisição o analisa em uma variável que a asserção verifica. Em seguida, compare o usage nas duas respostas: Decisions relata zero tokens de saída e raciocínio, Responses não.

Transforme o par em um cenário de teste orientado a dados sobre um CSV de texto de ticket e departamento esperado, e a execução mostrará quantos tickets cada endpoint roteia corretamente acima da sua linha de confiança. Simule o array answers para que o roteador possa ser construído primeiro, como em respostas simuladas condicionais, e execute o cenário em CI com o Apidog CLI para que uma mudança de redação ou alias de modelo falhe em um teste em vez de rotear tickets incorretamente. Veja testando aplicações LLM para mais padrões de asserção.

FAQ

A API Responses pode retornar probabilidades como a Decisions? Não como valores medidos. Um campo confidence em um esquema JSON lhe dá um número que o modelo escreveu, que é texto gerado. Decisions retorna probabilidades sobre as opções que você forneceu do próprio endpoint.

Posso usar um modelo diferente de GPT-6 Luna na Decisions? Não. O guia afirma que gpt-6-luna é o único modelo atualmente disponível. Veja nossa visão geral do GPT-6 Luna.

Como a Decisions é diferente do Jev da TypeSafe? Ambos retornam respostas tipadas com probabilidades e cobram apenas a entrada; eles diferem em preço, entradas e formatos de resposta. Veja API Decisions vs Jev.

A API Decisions é gratuita? Não. Ela cobra US$0,10 por 1M de tokens de entrada, sem um nível gratuito de Decisions documentado. Para rotas gratuitas para o próprio Luna, veja como usar o GPT-6 Luna gratuitamente.

Próximo passo

Pegue um classificador que você executa hoje via Responses, reconstrua-o como uma pergunta choice e execute ambos em 50 tickets rotulados no Apidog com a mesma asserção. Se o limiar de confiança se mantiver e o uso mostrar zero tokens de saída, você terá sua resposta. Baixe o Apidog, então siga como usar a API Decisions para a primeira chamada e o passo a passo completo de testes.