DEV Community

Cover image for Comment utiliser GPT-6.1 Sol APl
Antoine Laurent
Antoine Laurent

Posted on Originally published at apidog.com

Comment utiliser GPT-6.1 Sol APl

Pour appeler l’API GPT-6.1 Sol, envoyez une requête POST vers https://api.openai.com/v1/responses avec "model": "gpt-6.1-sol" et votre clé API comme jeton Bearer. Le tarif reste de 2 $ par million de jetons d’entrée et 10 $ par million de jetons de sortie, comme GPT-6 Sol. Le changement tarifaire principal concerne l’entrée mise en cache, qui passe de 0,20 $ à 0,10 $. La migration depuis gpt-6-sol consiste surtout à changer l’ID du modèle, mais GPT-6.1 Sol n’accepte plus none ni minimal pour reasoning.effort : mappez ces valeurs vers low et réévaluez vos flux.

Essayez Apidog dès aujourd’hui

OpenAI a lancé GPT-6.1 Sol lors du DevDay du 29 septembre 2026. Consultez le récapitulatif du DevDay 2026 pour les autres annonces et qu’est-ce que GPT-6.1 Sol pour les benchmarks. Ce guide montre comment envoyer une première requête, choisir l’effort de raisonnement, migrer votre code, contrôler les coûts et comparer les deux modèles avant de déplacer le trafic de production.

GPT-6 Sol vs GPT-6.1 Sol : changements d’API

La majorité des spécifications ne change pas. Voici les différences à traiter, d’après la page du modèle GPT-6.1 Sol, la page du modèle GPT-6 Sol et le guide de migration GPT-6.

Élément gpt-6-sol gpt-6.1-sol Action
Entrée / sortie par 1M de jetons, Standard 2 $ / 10 $ 2 $ / 10 $ Aucune
Entrée mise en cache par 1M 0,20 $ 0,10 $ Recalculez les coûts de cache
Écritures de cache par 1M 2,50 $ 2,50 $ Aucune
Fenêtre de contexte / entrée max / sortie max 1 050 000 / 922 000 / 128 000 Identique Aucune
Date limite des connaissances 20 avril 2026 30 avril 2026 Réexécutez les évaluations sensibles à la récence
reasoning.effort none, low, medium, high, xhigh, max low, medium, high, xhigh, max Remplacez none et minimal par low
Appel de fonction avec Chat Completions Seulement avec reasoning_effort: "none" Non pris en charge Déplacez les outils vers Responses
Endpoints Chat Completions, Responses, Batch Identiques Aucune
Limites de débit Niveau 1 : 500 RPM / 500K TPM ; niveau 5 : 15 000 RPM / 40M TPM Identiques Aucune

La page GPT-6 Sol redirige désormais vers GPT-6.1 Sol comme nouveau modèle Sol.

Envoyer votre première requête GPT-6.1 Sol

Exportez votre clé API :

export OPENAI_API_KEY="votre_cle"
Enter fullscreen mode Exit fullscreen mode

Envoyez ensuite une requête à l’API Responses :

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.1-sol",
    "reasoning": {"effort": "medium"},
    "input": "List three ways a webhook retry policy can create duplicate orders. One line each."
  }'
Enter fullscreen mode Exit fullscreen mode

Avec le SDK Python, utilisez la même variable d’environnement :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    reasoning={"effort": "medium"},
    input="List three ways a webhook retry policy can create duplicate orders. One line each.",
)

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

Contrôlez ces champs dans la réponse :

  • status doit être completed. Si le budget de sortie est insuffisant, l’état peut être incomplete avec incomplete_details.reason: "max_output_tokens", parfois sans texte exploitable. Le guide de raisonnement recommande de réserver au moins 25 000 jetons pour le raisonnement et la sortie pendant les tests.
  • output est un tableau. Recherchez l’élément type: "message" et son contenu output_text. Ne dépendez pas d’un index fixe.
  • usage.output_tokens inclut les jetons de raisonnement, facturés au tarif de sortie. Utilisez usage.output_tokens_details.reasoning_tokens pour les isoler.
  • usage.input_tokens_details expose notamment cached_tokens et cache_write_tokens, indispensables pour suivre les économies de cache.

Utilisez l’API Responses dès que votre flux appelle des outils. GPT-6.1 Sol ne prend en charge Chat Completions que pour les requêtes sans outils. Le guide de l’API Responses détaille la structure des requêtes.

Choisir reasoning.effort

medium est la valeur par défaut. L’effort est votre principal levier de compromis entre coût, latence et qualité.

Effort Cas d’usage de départ Résultats rapportés par OpenAI pour GPT-6.1 Sol
low Chat, extraction, classification, anciens flux en none Sur des conversations précédemment signalées, les réponses avec erreur factuelle passent de 11,4 % à 7,7 %
medium Automatisations agentiques et appels d’outils AutomationBench 1.0.6 : +2,2 points vs Claude Opus 5.5 pour environ un tiers du coût ; +4,8 points vs GPT-6 Sol au même réglage
high Débogage complexe et planification approfondie Pas de revendication spécifique au réglage
xhigh Livrables peaufinés et longues exécutions asynchrones Pas de revendication spécifique au réglage
max Utilisation d’ordinateur et tâches scientifiques complexes OSWorld 2.0 : +7 points vs GPT-6 Sol au maximum ; Terminal-Bench Science 0.1 : 5,47 $ par tâche

Deux précautions :

  1. Les données factuelles concernent des conversations déjà signalées pour des erreurs, pas nécessairement votre trafic courant.
  2. Sur Terminal-Bench Science, GPT-6 Astra conserve le score le plus élevé à 68,1 %. OpenAI recommande Astra pour les travaux scientifiques les plus complexes.

Pour les flux à faible latence qui utilisaient none, commencez avec low, puis mesurez la qualité et la latence sur des cas représentatifs.

Pour modifier l’effort au cours d’une conversation sans casser le cache d’invite, ajoutez un élément d’entrée configuration_update au lieu de modifier reasoning.effort au niveau de la requête.

Migrer depuis gpt-6-sol en quatre changements

1. Changer l’ID du modèle

Centralisez l’ID dans une variable d’environnement ou une configuration :

OPENAI_MODEL_ID=gpt-6.1-sol
Enter fullscreen mode Exit fullscreen mode

Cela permet un retour arrière en une seule modification.

2. Remapper none et minimal

GPT-6.1 Sol ne prend en charge ni none ni minimal.

function normalizeEffort(effort) {
  if (effort === "none" || effort === "minimal") {
    return "low";
  }

  return effort || "medium";
}
Enter fullscreen mode Exit fullscreen mode

Commencez par mapper none et minimal vers low, puis comparez les résultats sur vos requêtes réelles. L’envoi d’une valeur non prise en charge peut produire une erreur HTTP 400.

3. Supprimer les paramètres d’échantillonnage incompatibles

Lorsque l’effort n’est pas none, retirez :

  • temperature
  • top_p
  • top_logprobs
  • logprobs dans Chat Completions

Exemple de nettoyage de payload :

function buildRequest({ model, effort, input }) {
  return {
    model,
    reasoning: { effort: normalizeEffort(effort) },
    input,
  };
}
Enter fullscreen mode Exit fullscreen mode

4. Déplacer les appels d’outils vers Responses

GPT-6 Sol permettait les appels de fonction dans Chat Completions uniquement avec reasoning_effort: "none". Cette combinaison n’existe pas avec GPT-6.1 Sol.

Utilisez Responses pour les outils :

response = client.responses.create(
    model="gpt-6.1-sol",
    reasoning={"effort": "medium"},
    input="Look up the order status and summarize the result.",
    tools=[
        {
            "type": "function",
            "name": "get_order_status",
            "description": "Retourne le statut d'une commande.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"}
                },
                "required": ["order_id"]
            }
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Enfin, réexécutez les tests dépendant de la récence des connaissances : la date limite passe du 20 au 30 avril 2026. Si vous migrez depuis Astra, consultez le guide de migration Astra vers Sol.

Tarifs Batch, Flex, Fast et cache

Les tarifs par million de jetons proviennent de la page de tarification de l’API.

Niveau Entrée Entrée mise en cache Écritures de cache Sortie
Standard 2,00 $ 0,10 $ 2,50 $ 10,00 $
Batch 1,00 $ 0,05 $ 1,25 $ 5,00 $
Flex 1,00 $ 0,05 $ 1,25 $ 5,00 $
Fast 4,00 $ 0,20 $ 5,00 $ 20,00 $
Standard, invite de plus de 272K jetons 4,00 $ 0,20 $ 5,00 $ 15,00 $

Pour les invites dépassant 272 000 jetons d’entrée, la page du modèle indique que la requête complète applique le double des tarifs d’entrée et de cache, ainsi que 1,5 fois le tarif de sortie.

Utilisez les niveaux de service par requête :

{
  "model": "gpt-6.1-sol",
  "service_tier": "flex",
  "input": "..."
}
Enter fullscreen mode Exit fullscreen mode 
{
  "model": "gpt-6.1-sol",
  "service_tier": "fast",
  "input": "..."
}
Enter fullscreen mode Exit fullscreen mode

"priority" est accepté comme alias de "fast". Fast n’est pas disponible avec la résidence des données dans l’UE. Ultrafast est annoncé comme « à venir » pour GPT-6.1 Sol ; consultez le mode Ultrafast d’OpenAI. Pour les tâches différables, consultez le guide de l’API Batch.

Mesurer l’économie de cache

D’après le guide de mise en cache des invites :

  • GPT-6 Sol facture les lectures de cache à 0,1x le tarif d’entrée.
  • GPT-6.1 Sol facture les lectures de cache à 0,05x.
  • Les écritures de cache restent facturées à 1,25x le tarif d’entrée.
  • Le préfixe cachable minimal est de 1 024 jetons visibles.
  • Un préfixe reste éligible au moins 30 minutes après sa dernière écriture ou réutilisation.

Exemple : pour une invite système de 50 000 jetons réutilisée sur 1 000 requêtes :

  • une écriture coûte 0,125 $ sur les deux modèles ;
  • 999 lectures coûtent 9,99 $ sur GPT-6 Sol ;
  • 999 lectures coûtent environ 5,00 $ sur GPT-6.1 Sol.

Pour concevoir vos préfixes stables, consultez mise en cache des invites GPT-6.

Tester le basculement dans Apidog

Ne déplacez pas la production en vous basant uniquement sur les tarifs. Exécutez la même requête enregistrée avec les deux IDs de modèle, puis comparez sortie, utilisation et coût.

Dans Apidog :

  1. Créez un environnement contenant :

    • OPENAI_API_KEY, enregistrée comme secret ;
    • MODEL_ID=gpt-6-sol ;
    • EFFORT=medium.

  2. Créez la requête suivante et enregistrez-la :

   POST https://api.openai.com/v1/responses
   Authorization: Bearer {{OPENAI_API_KEY}}
   Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode 
   {
     "model": "{{MODEL_ID}}",
     "reasoning": {"effort": "{{EFFORT}}"},
     "max_output_tokens": 25000,
     "input": "Return a JSON object with keys risk and fix for this policy: retry any 5xx three times with no idempotency key."
   }
Enter fullscreen mode Exit fullscreen mode

  1. Ajoutez des assertions sur :

    • le statut HTTP 200 ;
    • $.status égal à completed ;
    • $.output[*].type contenant message ;
    • $.usage.output_tokens supérieur à 0 ;
    • l’existence de $.usage.output_tokens_details.reasoning_tokens ;
    • la structure de sortie attendue par votre application, par exemple un JSON valide avec les clés risk et fix.

  2. Ajoutez un script de post-traitement pour calculer le coût de l’appel :

   const u = pm.response.json().usage;
   const d = u.input_tokens_details || {};
   const cached = d.cached_tokens || 0;
   const writes = d.cache_write_tokens || 0;
   const model = pm.environment.get("MODEL_ID");

   const cachedRate = model === "gpt-6.1-sol" ? 0.10 : 0.20;

   const cost = (
     (u.input_tokens - cached - writes) * 2 +
     cached * cachedRate +
     writes * 2.5 +
     u.output_tokens * 10
   ) / 1e6;

   console.log(model, "cost per call $", cost.toFixed(5));
Enter fullscreen mode Exit fullscreen mode
  1. Exécutez une première fois avec MODEL_ID=gpt-6-sol, puis remplacez-le par gpt-6.1-sol et relancez exactement la même requête.

Comparez au minimum :

  • reasoning_tokens ;
  • output_tokens ;
  • le JSON ou texte retourné ;
  • le coût calculé ;
  • les assertions métier.

Si votre référence utilisait none, comparez gpt-6-sol avec none contre gpt-6.1-sol avec low.

Exécuter les deux modèles en CI

Ajoutez des invites enregistrées et quelques requêtes issues de votre trafic réel à un scénario de test. Lancez ensuite les deux exécutions avec la CLI Apidog :

npm install -g apidog-cli

apidog run \
  --access-token "$APIDOG_ACCESS_TOKEN" \
  -t "$SCENARIO_ID" \
  -e "$ENV_ID" \
  --env-var "MODEL_ID=gpt-6-sol" \
  -r cli,junit

apidog run \
  --access-token "$APIDOG_ACCESS_TOKEN" \
  -t "$SCENARIO_ID" \
  -e "$ENV_ID" \
  --env-var "MODEL_ID=gpt-6.1-sol" \
  -r cli,junit
Enter fullscreen mode Exit fullscreen mode

--env-var remplace la variable uniquement pour l’exécution courante : un seul scénario suffit donc à comparer les deux modèles. Une assertion échouée fait échouer le job CI, tandis que les rapports JUnit conservent les deux exécutions. Pour tester des sorties variables, consultez le test des agents IA non déterministes.

FAQ

GPT-6.1 Sol coûte-t-il plus cher que GPT-6 Sol ?

Non. Les deux modèles sont facturés 2 $ en entrée et 10 $ en sortie par million de jetons. GPT-6.1 Sol réduit toutefois l’entrée mise en cache de 0,20 $ à 0,10 $.

Que faire avec reasoning.effort: "none" ?

GPT-6.1 Sol ne prend pas en charge none ni minimal. Mappez ces valeurs vers low, retirez temperature et top_p, puis réexécutez vos évaluations avant le basculement.

Puis-je utiliser GPT-6.1 Sol avec Chat Completions ?

Oui, pour les requêtes sans outils. Utilisez l’API Responses pour les appels d’outils.

Existe-t-il un niveau gratuit pour l’API GPT-6.1 Sol ?

Non. Les appels API sont facturés par jeton dès la première requête. Consultez GPT-6.1 Sol est-il gratuit ? pour les options les moins coûteuses.

Étape suivante

Enregistrez une requête représentative de votre trafic. Exécutez-la d’abord avec gpt-6-sol et votre effort actuel, puis avec gpt-6.1-sol. Comparez la sortie, usage, les jetons de raisonnement et le coût avant de déplacer le trafic de production.

Téléchargez Apidog pour conserver ces comparaisons comme assertions réexécutables en CI. Pour comparer avec Anthropic, consultez GPT-6.1 Sol vs Claude Sonnet 5.5.

Top comments (0)