Comment Tester l'API ChatGPT avec Apidog : Authentification, Streaming, Outils et Intégration Continue

L'API ChatGPT évolue rapidement, enfreint souvent les contrats et vous facture par jeton même lorsque vos tests sont erronés. Les réponses en streaming échouent différemment des réponses non-streaming. L'appel de fonction ajoute une couche JSON-schema qui ne correspond pas toujours à ce que le modèle renvoie. Les limites de débit sont atteintes silencieusement en production et non dans votre console de développement. Si vous déboguez tout cela dans un REPL Python ou une boucle curl, vous perdez de l'argent et du temps.

Ce guide vous accompagne tout au long du flux de travail de test de l'API ChatGPT à l'intérieur d'Apidog : authentification, première complétion de chat, streaming SSE, appel de fonction, gestion des erreurs, vérification des limites de débit et réponses simulées pour un travail frontend parallèle. À la fin, vous disposerez d'un projet Apidog réutilisable qui détecte les dérives de contrat OpenAI avant qu'elles n'atteignent la production.

En bref

• Ajoutez l'URL de base de ChatGPT https://api.openai.com/v1 comme environnement Apidog, stockez la clé API comme variable secrète et appliquez l'authentification Bearer au niveau du dossier.
• Construisez la requête /chat/completions une fois, enregistrez-la et réutilisez-la pour chaque modèle (GPT-5.5, GPT-5.5 Pro, GPT-4o, o3).
• Apidog gère nativement le streaming SSE, vous voyez donc la sortie jeton par jeton dans le panneau de réponse sans outil supplémentaire.
• L'appel de fonction n'est qu'un tableau tools dans le corps de la requête ; Apidog valide le JSON tool_calls retourné par rapport à votre schéma.
• Simulez ChatGPT dans Apidog lorsque votre frontend est prêt avant que votre budget de clé OpenAI ne soit épuisé.
• Enregistrez la requête fonctionnelle comme scénario de test avec des assertions sur le code d'état, choices[0].message.content et usage.total_tokens. Exécutez-le en CI avant chaque modification de prompt.

Pourquoi tester l'API ChatGPT ?

La surface de l'API d'OpenAI semble stable. Ce n'est pas le cas. Entre janvier 2024 et aujourd'hui, l'équipe a livré ou modifié :

• function_call en tool_calls (deux formes concurrentes existent toujours dans la nature)
• Mode strict pour les schémas d'outils
• Modèles de raisonnement (o1, o3) qui suppriment les paramètres temperature et top_p
• response_format: { type: "json_schema" } avec versioning
• Comportement de streaming pour les appels d'outils (les deltas arrivent par morceaux, vous devez les assembler)
• Un nouveau point de terminaison /v1/responses qui chevauche /v1/chat/completions

Si vous intégrez directement l'un de ces éléments dans votre application et ignorez une couche de test, votre prochaine PR de modification de prompt provoquera une régression que vous ne verrez pas tant que les utilisateurs ne se plaindront pas. Une collection de requêtes dans Apidog vous offre un contrat que vous contrôlez. Vous pouvez rejouer la requête exacte, comparer la réponse et échouer bruyamment lorsque la forme change.

Étape 1 : Ajouter OpenAI comme environnement dans Apidog

Ouvrez Apidog et créez un nouveau projet. Dans le projet, ouvrez la gestion des environnements (menu déroulant en haut à droite) et ajoutez un environnement appelé OpenAI Prod :

Marquez OPENAI_API_KEY comme secret afin qu'il soit masqué dans les espaces de travail partagés et ne soit jamais écrit dans les collections exportées. Apidog stocke les secrets par utilisateur, de sorte qu'un coéquipier qui récupère le projet verra le nom de la variable mais fournira sa propre clé.

Étape 2 : Définir l'authentification Bearer au niveau du dossier

Créez un dossier appelé ChatGPT dans le projet. Ouvrez les paramètres du dossier, allez dans Auth, choisissez Bearer Token et collez {{OPENAI_API_KEY}}. Chaque requête à l'intérieur du dossier hérite de cet en-tête. Vous n'avez plus à coller Authorization: Bearer sk-... dans chaque requête, et la rotation des clés est une seule modification.

C'est le petit détail qui rend Apidog plus rapide qu'un workflow curl brut : l'authentification est centralisée, les corps de requête restent propres.

Étape 3 : Construire la première requête de complétion de chat

Dans le dossier ChatGPT, créez une nouvelle requête :

• Méthode : POST
• URL : {{baseUrl}}/chat/completions
• Corps (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
}

Appuyez sur Envoyer. Vous devriez recevoir un 200 avec un champ choices[0].message.content contenant la réponse et un bloc usage avec les comptes de jetons. Enregistrez la requête sous le nom chat-completion-basic.

Si vous obtenez 401, votre clé n'a pas été chargée. Vérifiez que le menu déroulant d'environnement en haut à droite est défini sur OpenAI Prod. Si vous obtenez 429, vous avez atteint une limite de débit, ce que l'étape suivante couvre.

Étape 4 : Tester les réponses en streaming (SSE)

Le streaming est l'endroit où la plupart des intégrations ChatGPT échouent. La réponse est text/event-stream, pas du JSON, et chaque fragment est une ligne data: {...} avec un delta partiel. Apidog gère nativement le SSE.

Dupliquez chat-completion-basic, renommez-le en chat-completion-stream, et ajoutez "stream": true au corps :

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

Appuyez sur Envoyer. Le panneau de réponse passe en mode streaming et affiche chaque fragment data: au fur et à mesure de son arrivée. Vous voyez les trames SSE réelles, pas seulement le texte assemblé. C'est la vue dont vous avez besoin pour déboguer un delta malformé ou un terminateur [DONE] manquant.

Ce qu'il faut surveiller :

• La trame finale est la chaîne de caractères littérale data: [DONE]. Si votre client ne gère pas cela, il lancera une erreur d'analyse JSON.
• L'utilisation (usage) n'est pas présente dans les réponses en streaming, sauf si vous passez "stream_options": { "include_usage": true }. Ajoutez-le si votre pipeline de facturation dépend du nombre de jetons par appel.
• Les deltas d'appels d'outils arrivent par morceaux : index, puis id, puis function.name, puis function.arguments accumulés caractère par caractère. Testez cela explicitement.

Étape 5 : Tester l'appel de fonction et l'utilisation d'outils

L'appel de fonction est l'endroit le plus courant où les modifications de prompt cassent silencieusement le code en aval. Le modèle renvoie un tableau tool_calls ; votre travail consiste à valider que les arguments s'analysent comme le schéma JSON que vous avez enregistré.

Créez une requête chat-completion-tools avec ce corps :

{
  "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"
}

Une réponse correcte a choices[0].message.tool_calls[0].function.name === "get_weather" et function.arguments est une chaîne JSON qui s'analyse en { "city": "Singapore", "unit": "c" } (ou similaire).

Dans l'onglet Tests de la requête, ajoutez :

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");
});

Exécutez-le. Les tests réussis sont désormais votre contrat. Lorsque OpenAI change la forme, le test devient rouge avant que votre trafic de production ne le fasse.

Étape 6 : Gérer explicitement les erreurs et les limites de débit

Les intégrations ChatGPT en production échouent de cinq manières prévisibles. Créez une requête pour chacun et affirmez le comportement attendu :

Ajoutez des assertions dans l'onglet Tests afin qu'une régression apparaisse comme un test rouge, et non comme une tempête de réessais silencieuse. L'en-tête Retry-After est celui que la plupart des codes de production gèrent mal. Il est en secondes, parfois une valeur fractionnaire, et vous devriez le lire au lieu de coder en dur un délai d'attente exponentiel.

Étape 7 : Simuler ChatGPT pour un développement frontend parallèle

Votre clé OpenAI a un plafond mensuel. Votre équipe frontend n'en a pas. Lorsque l'interface utilisateur doit afficher des jetons en streaming, des suggestions de suivi et des cartes d'appel d'outils avant que le prompt backend ne soit finalisé, donnez-leur une simulation Apidog.

Dans le dossier ChatGPT, faites un clic droit sur la requête chat-completion-basic, choisissez Smart Mock, et activez. Apidog renvoie une réponse synthétique qui correspond au schéma OpenAI : id, object, created, model, choices, usage. L'URL de simulation ressemble à https://mock.apidog.com/m1/<projectId>/chat/completions et accepte le même corps.

Pour les simulations en streaming, définissez un script dans l'onglet Advanced Mock qui écrit des fragments data: { ... }\n\n à un intervalle de 50 ms. Le frontend obtient un flux SSE réaliste sans aucun trafic OpenAI.

Lorsque le vrai prompt est prêt, rebasculez l'URL de base du frontend sur https://api.openai.com/v1. Rien d'autre ne change.

Étape 8 : Enregistrer la suite comme scénario de test CI

Les scénarios de test d'Apidog vous permettent d'enchaîner des requêtes avec des assertions et de les exécuter sans interface utilisateur. Créez un scénario qui :

1. Appelle chat-completion-basic, affirme que status === 200 et usage.total_tokens > 0.
2. Appelle chat-completion-stream, affirme que le SSE s'est terminé par [DONE].
3. Appelle chat-completion-tools, affirme que le schéma d'appel d'outil est valide.
4. Appelle chaque scénario d'erreur de l'étape 6, affirme le code d'état correct.

Exportez le scénario et exécutez-le en CI via apidog-cli run scenario.json --env OpenAI Prod. Intégrez-le dans le pipeline de PR pour le fichier qui contient vos prompts. Chaque modification de prompt s'exécute désormais contre l'API OpenAI en direct comme vérification préalable à la fusion. Coût : quelques centimes par exécution en CI. Valeur : vous cessez d'expédier des régressions de prompt.

FAQ

Cela fonctionne-t-il avec Azure OpenAI ? Oui. Remplacez baseUrl par l'URL de votre ressource Azure, ajoutez le paramètre de requête api-version et modifiez l'authentification de Bearer à l'en-tête api-key. Les corps de requête sont identiques.

Puis-je l'utiliser pour les modèles de raisonnement o1 et o3 ? Oui, mais ces modèles rejettent temperature, top_p, presence_penalty et frequency_penalty. Créez un dossier séparé Reasoning avec un modèle de corps simplifié.

Comment versionner les prompts dans Apidog ? Apidog prend en charge les branches. Créez une branche par expérience de prompt, exécutez le scénario de test sur l'API en direct, comparez l'utilisation des jetons et la qualité de la réponse, puis fusionnez. C'est le même flux de travail que le code, appliqué aux prompts.

Qu'en est-il du nouveau point de terminaison /v1/responses ? Configurez un dossier séparé pour celui-ci. L'authentification et l'URL de base sont identiques ; seule la forme du corps diffère. Conservez les deux dossiers afin de pouvoir les A/B tester avec les mêmes prompts.

Apidog facture-t-il par appel API ? Non. Le client Apidog est gratuit pour un usage individuel et la plupart des usages en équipe. OpenAI facture par jeton ; Apidog ne s'insère pas entre vous et OpenAI.

En résumé

L'API ChatGPT continuera d'évoluer. Le streaming se rompra de nouvelles manières, les schémas d'outils deviendront plus stricts, et les modèles de raisonnement continueront à supprimer des paramètres que vous pensiez stables. La défense est une collection de requêtes que vous contrôlez, un serveur de simulation sur lequel votre frontend peut s'appuyer, et un scénario de test que votre CI exécute avant chaque PR de prompt.

Téléchargez Apidog et importez vos appels OpenAI existants. Les collections Postman et les commandes curl se convertissent en un clic. Construisez les huit requêtes ci-dessus une fois, et chaque future mise à jour de ChatGPT deviendra une exécution de test contrôlée au lieu d'un incident de production.