
Ce guide de la GPT-6.2 API vous mène d’une clé API à une requête fonctionnelle pour gpt-6.2-sol ou gpt-6.2-astra en cURL et avec le SDK OpenAI pour Python, sur les endpoints Responses et Chat Completions. Chaque corps de requête suit le schéma publié par PoYo et les notes de migration GPT-6.2 d’OpenAI à la date du 18 novembre 2026. Vous pouvez d’abord tester vos prompts sur la page du modèle GPT-6.2 Sol ou la page du modèle GPT-6.2 Astra.
Vous découvrez ces modèles ? La présentation de la GPT-6.2 API couvre leurs limites et leur positionnement.
Avant de commencer
Créez une clé dans le tableau de bord PoYo et conservez-la côté serveur :
export POYO_API_KEY="your-poyo-key"
| Format | Endpoint | À utiliser quand |
|---|---|---|
| Responses | POST https://api.poyo.ai/v1/responses | Nouveau code, outils de fonction, entrée image, effort de raisonnement |
| Chat Completions | POST https://api.poyo.ai/v1/chat/completions | Code Chat Completions existant, messages texte uniquement, sans outils |
Chaque requête envoie Authorization: Bearer $POYO_API_KEY. Les exemples utilisent gpt-6.2-sol ; remplacez-le par gpt-6.2-astra pour Astra. Les formes de requête sont identiques.
Trois règles du guide GPT-6.2 d’OpenAI s’appliquent à tous les exemples ci-dessous :
- N’envoyez ni
temperaturenitop_p. OpenAI demande de les omettre, ainsi quelogprobsettop_logprobssur Chat Completions ettop_logprobssur Responses. Les schémas de PoYo listent toujourstemperatureettop_ppour les anciens modèles. - Ne réglez pas l’effort de raisonnement sur
none; l’API le refuse. - Placez les instructions stables dans un message
developerau début deinput. GPT-6.2 ajoute lesinstructionsde premier niveau aprèsinput, ce qui les sort du préfixe pouvant être mis en cache.
Première requête à la GPT-6.2 API avec cURL
curl https://api.poyo.ai/v1/responses \
-H "Authorization: Bearer $POYO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-sol",
"input": [
{"role": "developer", "content": "You are a code reviewer. Be specific and cite line numbers."},
{"role": "user", "content": "Review this function for race conditions: ..."}
],
"reasoning": {"effort": "medium"},
"max_output_tokens": 8000,
"store": false
}'
model et input sont obligatoires. input est une simple chaîne ou un tableau d’éléments avec role (developer, system, user, assistant) et content. Autres champs documentés utilisés dans ce guide : reasoning, max_output_tokens, stream, store, tools, tool_choice, previous_response_id et metadata.
La réponse est un objet Responses renvoyé directement. Le texte se trouve dans les blocs output[].content[] de type: "output_text" ; le statut de l’appel est dans status ; et les décomptes sont dans usage.input_tokens, usage.output_tokens et usage.total_tokens.
Python avec le SDK OpenAI
Pointez le SDK vers PoYo :
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.poyo.ai/v1", api_key=os.environ["POYO_API_KEY"])
resp = client.responses.create(
model="gpt-6.2-sol",
input=[
{"role": "developer", "content": "You are a senior backend engineer."},
{"role": "user", "content": "Write a migration plan from Celery 4 to Celery 5."},
],
reasoning={"effort": "medium"},
max_output_tokens=8000,
)
print(resp.output_text)
print(resp.status, resp.usage)
resp.output_text est l’assistant du SDK qui concatène tous les blocs output_text. Journalisez resp.usage à chaque appel ; la section sur le coût ci-dessous s’en sert.
Chat Completions pour le code existant
Si votre code utilise déjà chat.completions.create, changez le modèle et supprimez les champs d’échantillonnage :
resp = client.chat.completions.create(
model="gpt-6.2-sol",
messages=[
{"role": "system", "content": "You are a senior backend engineer."},
{"role": "user", "content": "Explain the CAP theorem with one example per trade-off."},
],
max_tokens=4000,
)
print(resp.choices[0].message.content, resp.choices[0].finish_reason)
La même requête en cURL :
curl https://api.poyo.ai/v1/chat/completions \
-H "Authorization: Bearer $POYO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-sol",
"messages": [{"role": "user", "content": "Explain vector databases in one sentence."}],
"max_tokens": 1000
}'
Le schéma Chat Completions de PoYo documente model, messages (content de type chaîne ; rôles system, user, assistant), max_tokens, stream, stop, n et les champs de pénalité. Il ne documente pas tools, et OpenAI indique que l’appel d’outils de GPT-6.2 nécessite Responses : les agents ont donc leur place sur /v1/responses.
Régler l’effort de raisonnement via la GPT-6.2 API
OpenAI nomme le champ reasoning.effort dans Responses et reasoning_effort dans Chat Completions. La référence Responses de PoYo documente reasoning (exemple {"effort": "medium"}) ; sa référence Chat Completions ne liste pas encore reasoning_effort, ce guide règle donc l’effort uniquement sur Responses.
| Situation | Réglage | Source |
|---|---|---|
| Nouvelle intégration | medium | OpenAI : « Commencez par medium pour une nouvelle intégration. » |
Auparavant none ou minimal | low | Note de migration GPT-6.2 d’OpenAI |
| Tâches longues ou complexes | Un niveau plus élevé | OpenAI : un effort plus élevé « peut l’aider à aller jusqu’au bout des vérifications finales » |
none | Refusé | Pages de modèle d’OpenAI |
Le guide du raisonnement d’OpenAI cite low, medium, high, xhigh et max parmi les valeurs possibles, mais précise qu’elles dépendent du modèle. Les pages de modèle de GPT-6.2 ne listent pas les valeurs acceptées : envoyez donc une requête de test avant de coder en dur un niveau supérieur à medium. Les tokens de raisonnement sont facturés comme de la sortie et comptent dans max_output_tokens ; OpenAI les indique dans usage.output_tokens_details.reasoning_tokens.
Streaming des réponses de la GPT-6.2 API
Avec "stream": true, PoYo renvoie text/event-stream. Chaque ligne data: est un JSON dont le type nomme l’événement ; le texte arrive sous forme de response.output_text.delta, et response.completed contient l’objet final avec usage. PoYo n’envoie pas de lignes event: séparées, et le flux se termine par data: [DONE].
stream = client.responses.create(
model="gpt-6.2-sol",
input="Write a 100-word product introduction for a log search tool.",
reasoning={"effort": "low"},
max_output_tokens=2000,
stream=True,
store=False,
)
usage = None
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
elif event.type == "response.completed":
usage = event.response.usage
elif event.type == "response.failed":
raise RuntimeError(event.response)
print("\n", usage)
Sur Chat Completions, stream=True renvoie des événements chat.completion.chunk ; le texte est dans choices[0].delta.content et le dernier chunk contient usage.
Entrée image
GPT-6.2 accepte des images avec du texte. Sur PoYo, envoyez-les à Responses sous forme de blocs input_image avec une URL publique ou une Data URI complète (data:image/png;base64,...). La documentation de PoYo recommande de placer le texte avant les images :
{
"model": "gpt-6.2-sol",
"input": [
{
"role": "user",
"content": [
{"type": "input_text", "text": "List every service in this architecture diagram that writes to the database."},
{"type": "input_image", "image_url": "https://example.com/diagram.png"}
]
}
],
"max_output_tokens": 3000
}
Lire l’usage et calculer le coût d’une requête
Prix PoYo par 1M tokens : Sol $1.60 en entrée, $8 en sortie, $0.08 en lecture de cache, $2 en écriture de cache ; Astra $6.40, $32, $0.32, $8 (1 crédit = $0.005).
Le guide de mise en cache d’OpenAI indique les lectures de cache facturées dans usage.input_tokens_details.cached_tokens et les écritures dans usage.input_tokens_details.cache_write_tokens. Le schéma de PoYo inclut input_tokens_details et output_tokens_details sans en lister les clés : lisez-les donc de façon défensive :
PRICES = { # PoYo USD per 1M tokens: input, output, cache read, cache write
"gpt-6.2-sol": (1.60, 8.00, 0.08, 2.00),
"gpt-6.2-astra": (6.40, 32.00, 0.32, 8.00),
}
def estimate_cost_usd(model: str, usage) -> float:
p_in, p_out, p_read, p_write = PRICES[model]
details = getattr(usage, "input_tokens_details", None)
cached = getattr(details, "cached_tokens", 0) or 0
written = getattr(details, "cache_write_tokens", 0) or 0
fresh = usage.input_tokens - cached - written
return (fresh * p_in + cached * p_read + written * p_write
+ usage.output_tokens * p_out) / 1_000_000
Considérez ce résultat comme une estimation et rapprochez-le de votre journal d’usage PoYo. Tous les prix ici sont des tarifs en contexte court. OpenAI facture davantage au-delà de 272K tokens en entrée : vérifiez donc la page du modèle pour toute requête de cette taille. Des exemples chiffrés figurent dans Prix de la GPT-6.2 API.
Erreurs à gérer
| HTTP | Cause | Que faire |
|---|---|---|
| 400 | Champ invalide (validation_error, détails listés) | Corrigez le corps ; un effort none ou un champ non documenté peut aboutir ici |
| 401 | Clé API absente ou invalide | Vérifiez l’en-tête Authorization |
| 402 | Crédits insuffisants | Rechargez avant de réessayer |
| 404 | Modèle inconnu (model_not_found) | Vérifiez l’identifiant : gpt-6.2-sol, gpt-6.2-astra |
| 429 | Limite de débit atteinte | Attendez puis réessayez |
| 500 / 502 / 503 | Erreur serveur ou en amont | Réessayez avec un backoff exponentiel |
La documentation de PoYo indique que les endpoints LLM ne sont actuellement soumis à aucune limite de débit, mais gérez quand même 429. Avec le SDK OpenAI, interceptez openai.APIStatusError et branchez sur status_code. Ne réessayez que les 5xx et 429 ; une erreur 400 échouera à nouveau tant que le corps n’aura pas changé. Les corps complets sont dans les codes d’erreur PoYo.
Checklist avant la mise en production
- Gardez
POYO_API_KEYcôté serveur ; ne l’embarquez jamais dans du code navigateur ou mobile. - Supprimez
temperatureettop_pde tous les chemins de requête GPT-6.2, y compris des fonctions utilitaires partagées. - Définissez toujours
max_output_tokens(oumax_tokens), en laissant de la place aux tokens de raisonnement sous ce plafond. - Journalisez
status/finish_reasonet le blocusagecomplet à côté de votre propre identifiant de requête, afin de repérer les réponses tronquées et les pics de coût. - Placez le contexte long et stable dans le premier message
developeret la question variable en dernier, ce qui donne une chance à la mise en cache du prompt de s’appliquer. - Fixez l’identifiant de modèle dans la configuration, pour pouvoir basculer entre
gpt-6.2-soletgpt-6.2-astrasans redéploiement.
Pour les outils, le streaming des appels d’outils et la mise en cache dans les longues sessions d’agent, poursuivez avec GPT-6.2 API pour les agents de code.
Questions fréquentes
Comment appeler la GPT-6.2 API en Python ?
Utilisez le SDK OpenAI avec base_url="https://api.poyo.ai/v1", votre clé PoYo et model="gpt-6.2-sol" ou "gpt-6.2-astra" dans client.responses.create.
La GPT-6.2 API prend-elle en charge le streaming ?
Oui, sur les deux endpoints. Définissez stream: true ; Responses envoie des événements typés comme response.output_text.delta et Chat Completions envoie des événements chat.completion.chunk. Les deux se terminent par data: [DONE].
Comment régler l’effort de raisonnement de la GPT-6.2 API ?
Envoyez "reasoning": {"effort": "medium"} sur /v1/responses. OpenAI recommande de commencer par medium et refuse none.
Pourquoi ma requête à la GPT-6.2 API échoue-t-elle avec temperature ?
OpenAI demande d’omettre temperature et top_p pour GPT-6.2. Supprimez-les et contrôlez la longueur de la sortie avec max_output_tokens ou max_tokens.
Comment envoyer une image à la GPT-6.2 API ?
Utilisez /v1/responses avec un bloc input_image (URL ou Data URI) après un bloc input_text. Le schéma Chat Completions de PoYo ne documente que du contenu de type chaîne.