DEV Community

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

Posted on • Originally published at apidog.com

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

A API do ChatGPT muda rápido, pode alterar contratos e cobra por token mesmo quando um teste falha. Streaming se comporta diferente de respostas não streaming, tool_calls adiciona validação por JSON Schema, e limites de taxa podem aparecer só em produção. Se você depura tudo com REPL Python ou curl, gasta tempo e orçamento.

Experimente o Apidog hoje

Este guia mostra como testar a API do ChatGPT no Apidog: autenticação, primeira chamada para /chat/completions, streaming SSE, chamada de função, erros, limites de taxa, mocks para frontend e execução em CI. O objetivo é terminar com um projeto reutilizável que detecta mudanças de contrato antes de chegarem à produção.

TL;DR

  • Configure https://api.openai.com/v1 como baseUrl no ambiente do Apidog.
  • Armazene OPENAI_API_KEY como variável secreta.
  • Aplique autenticação Bearer no nível da pasta.
  • Crie uma requisição POST /chat/completions e reutilize para modelos como GPT-5.5, GPT-5.5 Pro, GPT-4o e o3.
  • Teste streaming SSE diretamente no painel de resposta do Apidog.
  • Valide tool_calls com testes automatizados.
  • Crie mocks para o frontend consumir sem gastar tokens.
  • Rode os cenários na CI antes de aprovar mudanças de prompt.

Por que testar a API do ChatGPT?

A superfície da API da OpenAI parece estável, mas muda com frequência. Nos últimos ciclos, a API adicionou ou alterou recursos como:

  • function_call para tool_calls
  • modo estrito para schemas de ferramentas
  • modelos de raciocínio como o1 e o3, que rejeitam parâmetros como temperature e top_p
  • response_format: { "type": "json_schema" }
  • streaming de chamadas de ferramentas com deltas parciais
  • endpoint /v1/responses, que se sobrepõe ao /v1/chat/completions

Se você conecta essas mudanças diretamente ao app sem uma camada de teste, uma alteração de prompt pode quebrar parsing, schema ou cobrança sem aviso. Uma coleção no Apidog funciona como contrato executável: você reproduz a mesma requisição, valida a resposta e falha o teste quando a forma muda.

Passo 1: Criar um ambiente OpenAI no Apidog

Crie um novo projeto no Apidog. Depois, abra o gerenciamento de ambientes e adicione um ambiente chamado OpenAI Prod.

Variável Valor
baseUrl https://api.openai.com/v1
OPENAI_API_KEY sk-proj-...
defaultModel gpt-5.5

Marque OPENAI_API_KEY como Secret. Assim, a chave fica mascarada em workspaces compartilhados e não aparece em exportações. Outros membros da equipe veem o nome da variável, mas precisam usar suas próprias chaves.

Passo 2: Configurar autenticação Bearer na pasta

Crie uma pasta chamada ChatGPT.

Nas configurações da pasta:

  1. Abra Authentication.
  2. Selecione Bearer Token.
  3. Use este valor: 
{{OPENAI_API_KEY}}
Enter fullscreen mode Exit fullscreen mode

Todas as requisições dentro da pasta herdam o cabeçalho:

Authorization: Bearer {{OPENAI_API_KEY}}
Enter fullscreen mode Exit fullscreen mode

Isso evita duplicar autenticação em cada requisição e simplifica rotação de chave.

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

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

  • Método: POST
  • URL: {{baseUrl}}/chat/completions
  • Body: 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
}
Enter fullscreen mode Exit fullscreen mode

Clique em Send.

Você deve receber 200 com uma resposta parecida com:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "total_tokens": 123
  }
}
Enter fullscreen mode Exit fullscreen mode

Salve a requisição como:

chat-completion-basic
Enter fullscreen mode Exit fullscreen mode

Se receber 401, verifique se o ambiente OpenAI Prod está selecionado e se OPENAI_API_KEY foi preenchida. Se receber 429, você atingiu limite de taxa.

Passo 4: Testar streaming SSE

Streaming é uma das partes mais frágeis da integração. A resposta usa text/event-stream, não JSON puro. Cada chunk chega como uma linha data: {...} com um delta parcial.

Duplique chat-completion-basic, renomeie para:

chat-completion-stream
Enter fullscreen mode Exit fullscreen mode

Atualize o body:

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

Clique em Send.

No painel de resposta, o Apidog mostra os frames SSE conforme chegam. Use essa visualização para validar:

  • se cada chunk começa com data:
  • se os deltas chegam na ordem esperada
  • se o stream termina com data: [DONE]
  • se seu cliente não tenta fazer JSON.parse() no [DONE]

Se você precisa de contagem de tokens em streaming, adicione:

{
  "stream_options": {
    "include_usage": true
  }
}
Enter fullscreen mode Exit fullscreen mode

Exemplo completo:

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

Também teste streaming com ferramentas. Deltas de tool_calls podem chegar em partes: index, id, function.name e function.arguments acumulados caractere por caractere.

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

Crie uma requisição chamada:

chat-completion-tools
Enter fullscreen mode Exit fullscreen mode

Use este body:

{
  "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"
}
Enter fullscreen mode Exit fullscreen mode

Uma resposta válida deve conter:

choices[0].message.tool_calls[0].function.name
Enter fullscreen mode Exit fullscreen mode

com valor:

get_weather
Enter fullscreen mode Exit fullscreen mode

E function.arguments deve ser uma string JSON parseável, por exemplo:

{
  "city": "Singapore",
  "unit": "c"
}
Enter fullscreen mode Exit fullscreen mode

Na aba Tests, 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");
});
Enter fullscreen mode Exit fullscreen mode

Agora a chamada de ferramenta virou um contrato testável. Se o modelo parar de chamar a ferramenta ou retornar argumentos inválidos, o teste falha.

Passo 6: Testar erros e limites de taxa

Crie requisições específicas para cenários de falha. Não trate erro apenas em produção.

Cenário Como acionar Esperado
Chave inválida Use OPENAI_API_KEY = sk-bad em ambiente Sandbox 401 com error.code = "invalid_api_key"
Limite de taxa Execute a requisição repetidamente no runner de coleção 429 com cabeçalho Retry-After
Limite de tokens excedido Envie prompt maior que o contexto do modelo 400 com error.code = "context_length_exceeded"
Modelo inválido Use "model": "gpt-99" 404
Violação de schema Use ferramenta com strict: true e entrada malformada O modelo rejeita a ferramenta ou retorna texto simples

Exemplo de teste para 401:

pm.test("Invalid API key returns 401", () => {
  pm.expect(pm.response.code).to.eql(401);

  const body = pm.response.json();
  pm.expect(body.error.code).to.eql("invalid_api_key");
});
Enter fullscreen mode Exit fullscreen mode

Exemplo para 429:

pm.test("Rate limit returns Retry-After", () => {
  pm.expect(pm.response.code).to.eql(429);
  pm.expect(pm.response.headers.has("Retry-After")).to.eql(true);
});
Enter fullscreen mode Exit fullscreen mode

No código de produção, leia Retry-After em vez de usar um backoff fixo. O valor pode ser em segundos e pode ser fracionário.

Passo 7: Criar mocks para desenvolvimento frontend

Sua equipe de frontend pode precisar renderizar:

  • tokens em streaming
  • estados de carregamento
  • sugestões de continuação
  • cartões baseados em tool_calls
  • erros 401, 429 e 400

Não gaste tokens reais para isso.

Na pasta ChatGPT:

  1. Clique com o botão direito em chat-completion-basic.
  2. Escolha Smart Mock.
  3. Ative o mock.

O Apidog gera uma URL parecida com:

https://mock.apidog.com/m1/<projectId>/chat/completions
Enter fullscreen mode Exit fullscreen mode

Ela aceita o mesmo body da API real e retorna uma resposta no formato esperado, com campos como:

{
  "id": "chatcmpl_mock",
  "object": "chat.completion",
  "created": 1710000000,
  "model": "gpt-5.5",
  "choices": [],
  "usage": {
    "total_tokens": 0
  }
}
Enter fullscreen mode Exit fullscreen mode

Para mocks de streaming, configure um script em Advanced Mock que escreva chunks SSE:

data: {"choices":[{"delta":{"content":"Hello"}}]}

data: {"choices":[{"delta":{"content":" world"}}]}

data: [DONE]
Enter fullscreen mode Exit fullscreen mode

Assim, o frontend testa um stream realista sem chamar a OpenAI.

Quando o backend estiver pronto, volte a URL base para:

https://api.openai.com/v1
Enter fullscreen mode Exit fullscreen mode

O contrato do body permanece igual.

Passo 8: Salvar tudo como cenário de teste para CI

Crie um cenário de teste no Apidog com esta sequência:

  1. Executar chat-completion-basic

    • validar status === 200
    • validar usage.total_tokens > 0

  2. Executar chat-completion-stream

    • validar que o SSE termina com [DONE]

  3. Executar chat-completion-tools

    • validar tool_calls[0].function.name
    • validar que function.arguments é JSON parseável

  4. Executar cenários de erro

    • validar 401
    • validar 429
    • validar 400
    • validar 404

Exemplo de asserção para tokens:

pm.test("Total tokens is greater than zero", () => {
  const body = pm.response.json();

  pm.expect(body.usage.total_tokens).to.be.greaterThan(0);
});
Enter fullscreen mode Exit fullscreen mode

Depois, exporte o cenário e rode na CI:

apidog-cli run scenario.json --env "OpenAI Prod"
Enter fullscreen mode Exit fullscreen mode

Conecte isso ao pipeline de PR que altera prompts. Cada mudança passa por uma chamada real controlada antes do merge.

FAQ

Isso funciona com Azure OpenAI?

Sim. Troque baseUrl pela URL do seu recurso Azure, adicione api-version como query param e mude a autenticação de Bearer para o cabeçalho api-key. Os bodies permanecem semelhantes.

Posso usar isso com os modelos de raciocínio o1 e o3?

Sim, mas esses modelos rejeitam parâmetros como:

  • temperature
  • top_p
  • presence_penalty
  • frequency_penalty

Crie uma pasta separada chamada Reasoning com um body simplificado.

Como versionar prompts no Apidog?

Use branches. Crie um branch por experimento de prompt, rode o cenário contra a API real, compare uso de tokens e qualidade da resposta, e só então faça merge.

E o endpoint /v1/responses?

Crie uma pasta separada para ele. A autenticação e a URL base são as mesmas; o formato do body muda. Mantenha /chat/completions e /responses lado a lado para testes A/B.

O Apidog cobra por chamada de API?

Não. A OpenAI cobra por token. O Apidog não se intercala entre você e a OpenAI.

Conclusão

A API do ChatGPT continuará mudando. Streaming, schemas de ferramentas, modelos de raciocínio e endpoints novos podem quebrar integrações que não têm testes de contrato.

A solução prática é manter:

  • uma coleção de requisições versionada
  • testes para respostas, erros e streaming
  • mocks para desenvolvimento frontend
  • execução em CI antes de mudanças de prompt

Baixe o Apidog e importe suas chamadas existentes da OpenAI. Coleções do Postman e comandos curl podem ser convertidos. Depois, crie as requisições acima uma vez e transforme futuras mudanças da API em execuções de teste, não em incidentes de produção.

Top comments (0)