Como Testar a API do ChatGPT com Apidog: Autenticação, Streaming, Ferramentas e CI

A API do ChatGPT é lançada rapidamente, quebra contratos com frequência e cobra por token mesmo quando seus testes estão errados. Respostas de streaming falham de forma diferente das não-streaming. A chamada de função adiciona uma camada de JSON-schema que nem sempre corresponde ao que o modelo retorna. Limites de taxa são atingidos silenciosamente em produção e não no seu console de desenvolvimento. Se você depurar tudo isso em um REPL Python ou um loop curl, você gasta dinheiro e tempo.

Este guia apresenta o fluxo de trabalho completo de teste da API do ChatGPT dentro do Apidog: autenticação, a primeira conclusão de chat, streaming SSE, chamada de função, tratamento de erros, verificações de limite de taxa e respostas simuladas para trabalho frontend paralelo. Ao final, você terá um projeto Apidog reutilizável que detecta desvios de contrato da OpenAI antes que cheguem à produção.

TL;DR

• Adicione a URL base do ChatGPT https://api.openai.com/v1 como um ambiente Apidog, armazene a chave da API como uma variável secreta e aplique autenticação Bearer no nível da pasta.
• Crie a requisição /chat/completions uma vez, salve-a e reutilize-a para cada modelo (GPT-5.5, GPT-5.5 Pro, GPT-4o, o3).
• O Apidog lida com streaming SSE nativamente, então você vê a saída token por token no painel de resposta sem ferramentas adicionais.
• A chamada de função é apenas um array tools no corpo da requisição; o Apidog valida o JSON tool_calls retornado em relação ao seu esquema.
• Simule o ChatGPT dentro do Apidog quando seu frontend estiver pronto, antes que seu orçamento de chave da OpenAI acabe.
• Salve a requisição funcionando como um cenário de teste com asserções no código de status, choices[0].message.content e usage.total_tokens. Execute-o na CI antes de cada alteração de prompt.

Por que testar a API do ChatGPT?

A superfície da API da OpenAI parece estável. Não é. Entre janeiro de 2024 e agora, a equipe lançou ou alterou:

• function_call para tool_calls (duas formas concorrentes ainda existem na prática)
• Modo estrito para esquemas de ferramentas
• Modelos de raciocínio (o1, o3) que eliminam os parâmetros temperature e top_p
• response_format: { type: "json_schema" } com versionamento
• Comportamento de streaming para chamadas de ferramentas (deltas chegam em pedaços, você precisa montá-los)
• Um novo endpoint /v1/responses que se sobrepõe a /v1/chat/completions

Se você conectar qualquer uma dessas funcionalidades diretamente em seu aplicativo e pular uma camada de teste, seu próximo PR de mudança de prompt lançará uma regressão que você não verá até que os usuários reclamem. Uma coleção de requisições no Apidog oferece um contrato que você controla. Você pode reproduzir a requisição exata, comparar a resposta e falhar ruidosamente quando a forma muda.

Passo 1: Adicionar OpenAI como um ambiente no Apidog

Abra o Apidog e crie um novo projeto. Dentro do projeto, abra Gerenciamento de Ambiente (dropdown no canto superior direito) e adicione um ambiente chamado OpenAI Prod:

Marque OPENAI_API_KEY como secreto para que seja mascarado em workspaces compartilhados e nunca seja escrito em coleções exportadas. O Apidog armazena segredos por usuário, então um colega de equipe que puxar o projeto verá o nome da variável, mas fornecerá sua própria chave.

Passo 2: Configurar autenticação Bearer no nível da pasta

Crie uma pasta chamada ChatGPT dentro do projeto. Abra as configurações da pasta, vá para Autenticação, escolha Bearer Token e cole {{OPENAI_API_KEY}}. Toda requisição dentro da pasta herda este cabeçalho. Você para de colar Authorization: Bearer sk-... em cada requisição, e a rotação de chaves é uma única edição.

Este é o pequeno detalhe que torna o Apidog mais rápido do que um fluxo de trabalho curl puro: a autenticação reside em um só lugar, os corpos das requisições permanecem limpos.

Passo 3: Criar a primeira requisição de conclusão de chat

Dentro da pasta ChatGPT, crie uma nova requisição:

• Método: POST
• URL: {{baseUrl}}/chat/completions
• Corpo (JSON):

{
  "model": "{{defaultModel}}",
  "messages": [
    { "role": "system", "content": "You are a senior backend engineer. Answer in under 100 words." },
    { "role": "user", "content": "What's the difference between idempotent and safe HTTP methods?" }
  ],
  "temperature": 0.2
}

Clique em Enviar. Você deve receber um 200 com um campo choices[0].message.content contendo a resposta e um bloco usage com a contagem de tokens. Salve a requisição como chat-completion-basic.

Se você receber 401, sua chave não foi carregada. Verifique se o dropdown de ambiente no canto superior direito está configurado para OpenAI Prod. Se você receber 429, você atingiu um limite de taxa, o que o próximo passo abordará.

Passo 4: Testar respostas de streaming (SSE)

O streaming é onde a maioria das integrações do ChatGPT falha. A resposta é text/event-stream, não JSON, e cada chunk é uma linha data: {...} com um delta parcial. O Apidog entende SSE nativamente.

Duplique chat-completion-basic, renomeie para chat-completion-stream e adicione "stream": true ao corpo:

{
  "model": "{{defaultModel}}",
  "stream": true,
  "messages": [
    { "role": "user", "content": "Stream the first 100 prime numbers, comma-separated." }
  ]
}

Clique em Enviar. O painel de resposta muda para a visualização de streaming e renderiza cada chunk data: à medida que chega. Você vê os frames SSE reais, não apenas o texto montado. Essa é a visualização que você precisa ao depurar um delta malformado ou um terminador [DONE] ausente.

O que observar:

• O frame final é a string literal data: [DONE]. Se seu cliente não lidar com isso, ele lançará um erro de análise JSON.
• usage não está nas respostas de streaming, a menos que você passe "stream_options": { "include_usage": true }. Adicione-o se seu pipeline de cobrança depender da contagem de tokens por chamada.
• Os deltas de chamada de ferramenta chegam em pedaços: index, depois id, depois function.name, depois function.arguments acumulados caractere por caractere. Teste isso explicitamente.

Passo 5: Testar chamada de função e uso de ferramentas

A chamada de função é o lugar mais comum onde as mudanças de prompt quebram silenciosamente o código downstream. O modelo retorna um array tool_calls; sua tarefa é validar que os argumentos são analisados como o JSON Schema que você registrou.

Crie uma requisição chat-completion-tools com este corpo:

{
  "model": "{{defaultModel}}",
  "messages": [
    { "role": "user", "content": "What is the weather in Singapore right now?" }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": {
            "city": { "type": "string" },
            "unit": { "type": "string", "enum": ["c", "f"] }
          },
          "required": ["city"]
        },
        "strict": true
      }
    }
  ],
  "tool_choice": "auto"
}

Uma resposta correta tem choices[0].message.tool_calls[0].function.name === "get_weather" e function.arguments é uma string JSON que pode ser analisada para { "city": "Singapore", "unit": "c" } (ou similar).

Na aba Testes da requisição, adicione:

pm.test("Tool was called", () => {
  const body = pm.response.json();
  const call = body.choices[0].message.tool_calls?.[0];
  pm.expect(call?.function?.name).to.eql("get_weather");
});

pm.test("Arguments parse as valid JSON", () => {
  const body = pm.response.json();
  const args = JSON.parse(body.choices[0].message.tool_calls[0].function.arguments);
  pm.expect(args.city).to.be.a("string");
});

Execute. Os testes verdes são agora seu contrato. Quando a OpenAI muda a forma, o teste fica vermelho antes que seu tráfego de produção o faça.

Passo 6: Lidar explicitamente com erros e limites de taxa

As integrações de produção do ChatGPT falham de cinco maneiras previsíveis. Crie uma requisição para cada uma e afirme o comportamento esperado:

Adicione asserções na aba Testes para que uma regressão apareça como um teste vermelho, e não como uma tempestade de retries silenciosos. O cabeçalho Retry-After é o que a maioria do código de produção erra. Ele está em segundos, às vezes um valor fracionário, e você deve lê-lo em vez de codificar um backoff.

Passo 7: Simular o ChatGPT para desenvolvimento frontend paralelo

Sua chave da OpenAI tem um limite mensal. Sua equipe de frontend não. Quando a UI precisa renderizar tokens transmitidos, sugestões de acompanhamento e cartões de chamada de ferramenta antes que o prompt do backend seja finalizado, entregue a eles um mock do Apidog.

Na pasta ChatGPT, clique com o botão direito na requisição chat-completion-basic, escolha Smart Mock e ative. O Apidog retorna uma resposta sintética que corresponde ao esquema da OpenAI: id, object, created, model, choices, usage. A URL do mock se parece com https://mock.apidog.com/m1/<projectId>/chat/completions e aceita o mesmo corpo.

Para mocks de streaming, defina um script na aba Advanced Mock que escreve chunks data: { ... }\n\n em um intervalo de 50ms. O frontend obtém um stream SSE realista sem qualquer tráfego da OpenAI.

Quando o prompt real for implementado, mude a URL base do frontend de volta para https://api.openai.com/v1. Nada mais muda.

Passo 8: Salvar o conjunto como um cenário de teste CI

Os Cenários de Teste do Apidog permitem encadear requisições com asserções e executá-las sem interface gráfica. Crie um cenário que:

1. Chama chat-completion-basic, afirma status === 200 e usage.total_tokens > 0.
2. Chama chat-completion-stream, afirma que o SSE terminou com [DONE].
3. Chama chat-completion-tools, afirma que o esquema da chamada de ferramenta é validado.
4. Chama cada cenário de erro do Passo 6, afirma o código de status correto.

Exporte o cenário e execute-o na CI via apidog-cli run scenario.json --env OpenAI Prod. Conecte-o ao pipeline de PR para o arquivo que contém seus prompts. Cada mudança de prompt agora é executada contra a API real da OpenAI como uma verificação pré-merge. Custo: alguns centavos por execução da CI. Valor: você para de lançar regressões de prompt.

FAQ

• Isso funciona com Azure OpenAI? Sim. Troque baseUrl pela URL do seu recurso Azure, adicione o parâmetro de consulta api-version e mude a autenticação de Bearer para o cabeçalho api-key. Os corpos das requisições são idênticos.
• Posso usar isso para os modelos de raciocínio o1 e o3? Sim, mas esses modelos rejeitam temperature, top_p, presence_penalty e frequency_penalty. Crie uma pasta separada Reasoning com um template de corpo simplificado.
• Como faço o versionamento de prompts dentro do Apidog? O Apidog possui suporte a branches. Crie um branch por experimento de prompt, execute o cenário de teste contra a API real, compare o uso de tokens e a qualidade da resposta, e então faça o merge. É o mesmo fluxo de trabalho do código, aplicado aos prompts.
• E o novo endpoint /v1/responses? Configure uma pasta separada para ele. A autenticação e a URL base são idênticas; apenas a forma do corpo difere. Mantenha ambas as pastas para que você possa fazer testes A/B com os mesmos prompts.
• O Apidog cobra por chamada de API? Não. O cliente Apidog é gratuito para uso individual e para a maioria dos usos em equipe. A OpenAI cobra por token; o Apidog não se intercala entre você e a OpenAI.

Conclusão

A API do ChatGPT continuará mudando. O streaming falhará de novas maneiras, os esquemas de ferramentas ficarão mais rigorosos e os modelos de raciocínio continuarão descartando parâmetros que você considerava estáveis. A defesa é uma coleção de requisições que você controla, um servidor mock no qual seu frontend pode se apoiar e um cenário de teste que sua CI executa antes de cada PR de prompt.

Baixe o Apidog e importe suas chamadas existentes da OpenAI. Coleções do Postman e comandos curl são convertidos em um clique. Crie as oito requisições acima uma vez, e cada atualização futura do ChatGPT se tornará uma execução de teste controlada em vez de um incidente de produção.