DEV Community

Cover image for Comment utiliser l'API GPT-6.2 Astra ?
Antoine Laurent
Antoine Laurent

Posted on Originally published at apidog.com

Comment utiliser l'API GPT-6.2 Astra ?

Comment utiliser l'API GPT-6.2 Astra : première requête, effort de raisonnement, outils et coûts

Réponse rapide : pour utiliser l'API GPT-6.2 Astra, envoyez une requête vers le endpoint Responses d'OpenAI (POST /v1/responses) avec "model": "gpt-6.2-astra", un niveau d'effort de raisonnement tel que "high", et votre entrée. Le coût est de 8 $ par million de tokens d'entrée et de 40 $ par million de tokens de sortie. Le modèle accepte jusqu'à 922K tokens en entrée et renvoie jusqu'à 128K tokens en sortie. Ne réglez pas l'effort sur none : l'API le rejette.

Essayez Apidog dès aujourd'hui

OpenAI a publié GPT-6.2 Astra et son petit frère moins cher GPT-6.2 Sol le 17 novembre 2026. Si vous avez déjà appelé GPT-6 Astra, la majeure partie de votre code reste valable. Ce guide parcourt l'API GPT-6.2 Astra, de votre première requête aux appels d'outils, en passant par le réglage de l'effort, les pièges tarifaires et un test répétable que votre agent de codage peut exécuter pour vous.

Ce qu'il vous faut avant votre premier appel à l'API GPT-6.2 Astra

Il vous faut quatre choses, et vous en avez probablement déjà trois :

  1. Une clé API OpenAI obtenue depuis le tableau de bord de la plateforme, exportée sous forme de OPENAI_API_KEY.
  2. Un palier d'utilisation payant. La page des modèles d'OpenAI liste des limites de débit Astra à partir du palier Build (5 000 requêtes et 1M tokens par minute).
  3. L'identifiant du modèle gpt-6.2-astra. Le modèle moins cher est gpt-6.2-sol.
  4. Un endpoint pris en charge : Responses, Chat Completions ou Batch. Realtime, Assistants et le fine-tuning ne prennent en charge aucun des deux modèles.

Ces spécifications proviennent de la page du modèle GPT-6.2 Astra d'OpenAI, vérifiée le 18 novembre 2026.

Spécification GPT-6.2 Astra
Identifiant du modèle gpt-6.2-astra
Fenêtre de contexte 1 050 000 tokens
Entrée max. 922 000 tokens
Sortie max. 128 000 tokens
Date limite des connaissances 18 mai 2026
Endpoints Responses, Chat Completions, Batch
Fonctionnalités Streaming, function calling, sorties structurées, entrée d'image, mise en cache de prompt

Comment effectuer votre première requête vers l'API GPT-6.2 Astra

L'API Responses est le endpoint pour lequel OpenAI développe ses nouvelles fonctionnalités, alors commencez par là. Voici les étapes :

  1. Exportez votre clé : export OPENAI_API_KEY=sk-...
  2. Envoyez une requête avec l'identifiant du modèle et un niveau d'effort.
  3. Lisez output_text pour la réponse et usage pour le décompte des tokens.

Avec curl :

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-astra",
    "reasoning": { "effort": "high" },
    "input": "Review this migration plan and list the three biggest risks."
  }'
Enter fullscreen mode Exit fullscreen mode

Avec le SDK Python officiel (pip install --upgrade openai) :

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY

response = client.responses.create(
    model="gpt-6.2-astra",
    reasoning={"effort": "high"},
    input="Review this migration plan and list the three biggest risks.",
)

print(response.output_text)
print(response.usage)
Enter fullscreen mode Exit fullscreen mode

Avec Node.js (npm install openai) :

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6.2-astra",
  reasoning: { effort: "high" },
  input: "Review this migration plan and list the three biggest risks.",
});

console.log(response.output_text);
Enter fullscreen mode Exit fullscreen mode

Vérifiez le bloc usage à chaque appel initial. Astra dépense des tokens de raisonnement avant d'écrire le moindre mot, et ceux-ci sont facturés comme sortie. Une réponse courte peut donc coûter plus cher que prévu.

Diagramme d'une requête API GPT-6.2 Astra : un POST vers /v1/responses transportant le modèle, l'effort de raisonnement, les outils et l'entrée, renvoyant le texte de sortie, les appels d'outils et un bloc usage avec les tokens d'entrée, de sortie et de raisonnement

Choisir un effort de raisonnement pour GPT-6.2 Astra

L'effort de raisonnement est le levier le plus puissant sur la qualité comme sur le coût. Le guide sur le raisonnement d'OpenAI liste les valeurs none, minimal, low, medium, high, xhigh et max, et précise que chaque modèle n'en prend en charge qu'un sous-ensemble. Pour GPT-6.2 Astra et Sol, la seule règle confirmée est que none est rejeté : chaque appel effectue donc un certain raisonnement.

Effort Utilisation recommandée
low / medium Modifications simples, extraction, réponses courtes
high Revue de code, planification, la plupart des prompts difficiles. Un défaut raisonnable pour commencer les tests
xhigh Longues exécutions d'agents et travail asynchrone, uniquement si vos évaluations montrent un gain net
max Vos problèmes les plus difficiles, quand une meilleure réponse justifie plusieurs fois le coût en tokens

OpenAI ne précise pas l'effort par défaut d'Astra : définissez-le donc explicitement à chaque requête. Cela garantit des factures et des résultats de test reproductibles.

À quel point l'effort change-t-il la facture ? Simon Willison a exécuté le même prompt d'image sur chaque modèle à trois niveaux d'effort le jour du lancement et a publié les coûts. Astra a coûté 11,55 cents à high, 17,70 cents à xhigh et 88,71 cents à max. Passer de high à max a multiplié le coût par près de huit.

Diagramme à barres du coût par exécution en cents US pour gpt-6.2-astra, gpt-6.2-sol, gpt-6-astra et gpt-6.1-sol aux efforts high, xhigh et max : Astra 6.2 monte de 11,55 à high à 88,71 à max, Sol 6.2 de 2,41 à 13,69

Notez que GPT-6.2 Astra était moins cher que GPT-6 Astra à high et xhigh, mais plus coûteux à max. Le prix par token a baissé de 20 %, mais l'effort max raisonne plus longtemps. Mesurez le coût par tâche terminée, et non le coût par million de tokens.

Utiliser les outils et les sorties structurées avec l'API GPT-6.2 Astra

Astra prend en charge le function calling, les sorties structurées et une longue liste d'outils hébergés dans l'API Responses : recherche web, recherche de fichiers, génération d'images, interpréteur de code, shell hébergé, application de patchs, skills, utilisation d'ordinateur, MCP et recherche d'outils.

Un outil de fonction se présente de la même manière que pour GPT-6 Astra :

response = client.responses.create(
    model="gpt-6.2-astra",
    reasoning={"effort": "high"},
    tools=[{
        "type": "function",
        "name": "get_order_status",
        "description": "Look up an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    }],
    input="Where is order A-1042?",
)

for item in response.output:
    if item.type == "function_call":
        print(item.name, item.arguments)
Enter fullscreen mode Exit fullscreen mode

Exécutez la fonction vous-même, puis renvoyez le résultat sous forme d'élément function_call_output avec le call_id correspondant. Astra rédige ensuite la réponse finale à partir de celui-ci.

Pour une sortie lisible par machine, transmettez un schéma JSON dans text.format avec "type": "json_schema" et "strict": true. Le modèle renvoie alors un JSON conforme à votre schéma, que vous pouvez analyser sans deviner.

Deux bonnes pratiques s'imposent avec un modèle aussi puissant. D'abord, donnez à chaque outil une description précise et un schéma strict ; le jour du lancement, des testeurs ont signalé qu'Astra pouvait s'égarer sur des tâches longues et ouvertes. Ensuite, définissez max_output_tokens dans vos boucles d'agent afin qu'une étape déréglée ne dévore pas votre budget. Pour en savoir plus sur ce endpoint, consultez notre guide de l'API OpenAI Responses.

Tarification et limites de débit de l'API GPT-6.2 Astra

Astra est facturé au million de tokens, avec un supplément pour les prompts très longs. Ces tarifs proviennent de la page du modèle :

Élément GPT-6.2 Astra GPT-6 Astra (pour référence)
Entrée 8,00 $ 10,00 $
Entrée en cache 0,40 $ 1,00 $
Écritures en cache (rétention de 30 min) 10,00 $ n/d
Sortie 40,00 $ 50,00 $

Le piège, c'est la règle du contexte long. Dès qu'une requête dépasse 272K tokens d'entrée, les tarifs d'entrée et de cache doublent et la sortie coûte 1,5 fois plus cher pour toute la requête. Un prompt de 300K tokens est facturé 16 $ en entrée et 60 $ en sortie, et pas seulement les tokens au-delà du seuil. Si vous fournissez à Astra des dépôts entiers, découpez ou mettez en cache sous 272K quand c'est possible.

Les jobs Batch conviennent aux évaluations et aux remplissages différés qui peuvent attendre ; selon VentureBeat, Batch s'exécute à moitié prix.

Limites de débit standard par palier :

Palier Requêtes/min Tokens/min
Build 5 000 1 000 000
Launch 10 000 4 000 000
Grow 15 000 40 000 000

Gérez les réponses 429 avec un backoff exponentiel. Une longue exécution d'agent à xhigh peut épuiser rapidement un budget de tokens du palier Build.

Migrer de GPT-6 Astra vers GPT-6.2 Astra

Pour la plupart du code, une seule modification suffit : la chaîne du modèle. Avant de basculer en production, vérifiez ces points :

  • Identifiant du modèle : gpt-6-astra devient gpt-6.2-astra.
  • Effort none : si un chemin de code l'envoie, il échoue désormais. Passez à la valeur la plus basse acceptée par vos évaluations.
  • Mise en cache de prompt : l'entrée en cache est passée de 1,00 $ à 0,40 $ ; les prompts système stables et les listes d'outils méritent donc désormais d'être mis en cache.
  • Prompts longs : revérifiez toute requête proche de 272K tokens par rapport à la règle du contexte long ci-dessus.
  • Sécurité : OpenAI indique que les deux modèles GPT-6.2 atteignent son seuil « Critical » en cybersécurité et sont livrés avec des garde-fous plus stricts. Les prompts d'outils de sécurité peuvent se heurter à des refus qui n'existaient pas avant.

Les premières critiques sont mitigées : testez donc avant de basculer. Ethan Mollick a jugé Astra « très inégale & étrange », et Dan Shipper a déclaré qu'elle s'arrêtait souvent trop tôt sur des builds de bout en bout, selon le tour d'horizon de VentureBeat. D'autres ont salué sa revue de code et son utilisation d'ordinateur. Vos propres prompts restent le seul benchmark qui compte. Le guide de l'API GPT-6 Astra détaille ce qui reste valable de la génération précédente, et si l'essentiel de votre trafic est routinier, le guide de l'API GPT-6.1 Sol présente la forme des requêtes du palier moins cher.

Laissez votre agent de codage tester GPT-6.2 Astra avec Apidog CLI

Coller des prompts dans un terminal vous dit comment Astra a performé aujourd'hui. Cela ne vous dira pas quand une mise à jour cassera votre schéma le mois prochain. Laissez plutôt votre agent de codage construire le test et l'exécuter avec Apidog CLI ; vous n'avez qu'un seul prompt à écrire.

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted
Enter fullscreen mode Exit fullscreen mode

Donnez ensuite à Claude Code, Codex ou Cursor un seul prompt :

In Apidog project <projectId>, create a test case for POST https://api.openai.com/v1/responses
with model "gpt-6.2-astra", reasoning effort "high" and a get_order_status function tool.
Assert status 200, that the output contains a function_call named get_order_status,
that its arguments parse as JSON with an order_id, and that usage.output_tokens is under 4000.
Read the API key from the OPENAI_API_KEY variable in environment <envId>, then run it.
Enter fullscreen mode Exit fullscreen mode

L'agent lit le schéma du payload, vérifie son fichier, crée le cas de test et l'exécute :

apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json
Enter fullscreen mode Exit fullscreen mode

Conservez la clé dans l'environnement Apidog, et non dans le prompt, afin qu'elle ne figure jamais dans le contexte de votre agent. Ajoutez --upload-report pour examiner l'exécution dans l'application Apidog, ou -n 5 pour la répéter et mesurer la stabilité des appels d'outils d'Astra. Intégrez -r junit dans un pipeline et le test se relance à chaque déploiement ; le guide d'Apidog CLI en CI/CD présente la configuration, et Apidog CLI dans Claude Code couvre le côté agent. Le plan gratuit d'Apidog couvre les équipes de jusqu'à 4 utilisateurs.

FAQ

Quel est l'identifiant du modèle pour l'API GPT-6.2 Astra ? gpt-6.2-astra. Le modèle frère moins cher est gpt-6.2-sol. Les deux fonctionnent sur les endpoints Responses, Chat Completions et Batch.

Combien coûte l'API GPT-6.2 Astra ? 8 $ par million de tokens d'entrée, 0,40 $ par million de tokens d'entrée en cache et 40 $ par million de tokens de sortie. Les requêtes dépassant 272K tokens d'entrée paient le double en entrée et 1,5 fois en sortie pour toute la requête.

Pourquoi ma requête GPT-6.2 Astra échoue-t-elle avec l'effort de raisonnement none ? Les deux modèles GPT-6.2 rejettent "effort": "none". Réglez high, ou le niveau le plus bas que vos tests montrent efficace pour votre tâche.

Quelle est la fenêtre de contexte de GPT-6.2 Astra ? 1 050 000 tokens au total, avec jusqu'à 922 000 tokens d'entrée et 128 000 tokens de sortie.

Puis-je utiliser GPT-6.2 Astra avec l'API Chat Completions ? Oui. Elle est prise en charge, mais les outils hébergés tels que la recherche web, l'utilisation d'ordinateur et l'application de patchs sont listés pour l'API Responses : privilégiez donc Responses pour le travail d'agent.

GPT-6.2 Astra est-il disponible gratuitement ? Pas via l'API : chaque appel est facturé. Dans ChatGPT Work et Codex, il est inclus aux plans Plus, Pro, Enterprise et Edu, selon l'annonce de lancement d'OpenAI.

Top comments (0)