Comment utiliser GPT-6.1 Sol APl

Pour appeler l'API GPT-6.1 Sol, envoyez une requête POST à https://api.openai.com/v1/responses avec "model": "gpt-6.1-sol" et votre clé comme jeton Bearer. Il est facturé au même prix de 2 $ pour l'entrée et 10 $ pour la sortie par million de jetons que GPT-6 Sol, et le coût de l'entrée mise en cache passe de 0,20 $ à 0,10 $. La migration depuis gpt-6-sol est principalement un simple échange de chaîne de caractères. Le changement majeur concerne l'effort : GPT-6.1 Sol n'accepte pas none ou minimal, ces requêtes sont donc déplacées vers low, ainsi que tout code qui reposait sur none.

OpenAI a lancé GPT-6.1 Sol lors du DevDay le 29 septembre 2026. Le récapitulatif du DevDay 2026 couvre les autres lancements, et qu'est-ce que GPT-6.1 Sol détaille les benchmarks. Ce guide couvre votre première requête, le niveau d'effort à adopter, chaque changement de migration, les niveaux Batch, Flex et Fast, ainsi qu'une exécution de régression côte à côte des deux ID de modèle dans Apidog avant de basculer le trafic de production.

GPT-6 Sol vs GPT-6.1 Sol : ce qui change dans l'API

La majeure partie des spécifications est identique. Voici le comparatif complet basé sur la page du modèle GPT-6.1 Sol, la page du modèle GPT-6 Sol et le guide de migration d'OpenAI pour l'utilisation de GPT-6 :

La page de GPT-6 Sol redirige désormais les lecteurs vers GPT-6.1 Sol en tant que « nouveau modèle Sol ».

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

Exportez votre clé en tant que OPENAI_API_KEY, puis appelez 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."
  }'

Le SDK Python lit 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)

Quatre parties de la réponse sont importantes :

• status est completed en cas de succès. Si le modèle manque de budget de sortie, vous obtenez incomplete avec incomplete_details.reason défini sur max_output_tokens, parfois avant tout texte visible. Le guide de raisonnement suggère de réserver au moins 25 000 jetons pour le raisonnement et la sortie pendant que vous expérimentez.
• output est un tableau. La réponse est l'élément avec type: "message", dont le contenu contient output_text. Lisez-le par type, et non par index.
• usage.output_tokens inclut les jetons de raisonnement, facturés au taux de sortie. usage.output_tokens_details.reasoning_tokens indique leur nombre.
• usage.input_tokens_details rapporte cached_tokens et cache_write_tokens. C'est là que le cache moins cher apparaît.

Utilisez l'API Responses pour tout ce qui concerne les outils ; GPT-6.1 Sol ne prend en charge les complétions de chat que pour les requêtes sans outils. Le guide de l'API Responses couvre la structure des requêtes plus en détail.

Choisissez un niveau d'effort de raisonnement

L'effort est votre principal levier de coût et de qualité, et medium est la valeur par défaut si vous l'omettez. Le guide de sélection de modèle d'OpenAI associe medium à « un travail technique complexe et des livrables coordonnés que vous prévoyez de réviser », et xhigh à des livrables peaufinés et des décisions construites à partir de preuves contradictoires. Le message de lancement d'OpenAI ajoute des résultats par paramètre. Ces benchmarks sont rapportés par OpenAI, et le tableau cite les écarts qu'OpenAI indique dans son texte :

Deux mises en garde. L'ensemble de données factuelles concerne des conversations précédemment signalées pour des erreurs, et non un trafic typique. Et sur Terminal-Bench Science, GPT-6 Astra obtient toujours le score le plus élevé (68,1 %), c'est pourquoi OpenAI recommande Astra pour les travaux scientifiques les plus complexes.

Pour les appels sensibles à la latence qui utilisaient none, commencez par low et mesurez. Le guide de raisonnement décrit low comme un raisonnement efficace « avec une légère augmentation de la latence ». Pour modifier l'effort en cours de conversation sans rompre le cache d'invite, ajoutez un élément d'entrée configuration_update plutôt que de modifier le reasoning.effort au niveau de la requête.

Migrer depuis gpt-6-sol : quatre changements de code

1. Échangez l'ID du modèle. Remplacez gpt-6-sol par gpt-6.1-sol, et conservez-le dans une configuration ou une variable d'environnement afin qu'une annulation soit possible en une seule modification.
2. Re-mappez none et minimal. Recommandation d'OpenAI : utilisez low au lieu de none, et commencez minimal à low puis comparez sur des tâches représentatives. Sur GPT-6 Astra, qui n'a pas non plus none, l'envoi de cette valeur renvoie un HTTP 400, donc corrigez cela avant de déplacer le trafic.
3. Supprimez les paramètres d'échantillonnage. Lorsque l'effort n'est pas none, supprimez temperature, top_p et top_logprobs (ainsi que logprobs dans les complétions de chat). Le code qui associait temperature à none sur GPT-6 Sol a besoin de cette modification.
4. Déplacez les appels d'outils des complétions de chat vers les réponses. GPT-6 Sol autorisait l'appel de fonctions dans les complétions de chat uniquement avec reasoning_effort: "none". Cette combinaison n'a pas d'équivalent sur 6.1 Sol.

Ensuite, réexécutez tout ce qui dépend de la récence : la date limite passe du 20 avril au 30 avril 2026. Si vous êtes passé à Sol depuis Astra, le guide de migration Astra vers Sol couvre cette étape précédente.

Tarification Batch, Flex, Fast et entrée mise en cache

Chaque niveau conserve la structure de GPT-6 Sol, la colonne d'entrée mise en cache étant réduite de moitié. Les prix par 1 million de jetons proviennent de la page de tarification de l'API. La page du modèle ajoute qu'une invite de plus de 272 000 jetons d'entrée est facturée au double des taux d'entrée et de cache et à 1,5 fois le taux de sortie pour la requête complète, la même règle que GPT-6 Sol utilise :

Flex est un service_tier: "flex" par requête. Fast est service_tier: "fast", avec "priority" accepté comme alias. Le mode Fast n'est pas disponible avec la résidence des données de l'UE. Ultrafast pour GPT-6.1 Sol est « à venir » et n'est largement disponible que pour GPT-6 Astra aujourd'hui ; voir mode Ultrafast d'OpenAI. Pour les tâches nocturnes, le guide de l'API Batch d'OpenAI explique une exécution par lots.

Le cache est l'endroit où la mise à niveau permet d'économiser de l'argent. Les lectures coûtent 0,05x le taux d'entrée sur 6.1 Sol contre 0,1x sur GPT-6 Sol, et les écritures coûtent 1,25x sur les deux, selon le guide de mise en cache des invites. Prenez une invite système de 50 000 jetons réutilisée sur 1 000 requêtes. Une écriture coûte 0,125 $ sur l'un ou l'autre modèle ; les 999 lectures coûtent 9,99 $ sur GPT-6 Sol et 5,00 $ sur GPT-6.1 Sol. Le préfixe minimal cachable est de 1 024 jetons visibles, et un préfixe mis en cache reste éligible pendant au moins 30 minutes après sa dernière écriture ou réutilisation. Pour la stratégie de point d'arrêt, voir mise en cache des invites GPT-6.

Testez l'échange dans Apidog

Ne basculez pas la production uniquement sur la base des prix affichés. Envoyez la même requête enregistrée aux deux ID et comparez les résultats. Dans Apidog :

1. Créez un environnement avec OPENAI_API_KEY (stockée comme secret), MODEL_ID défini sur gpt-6-sol, et EFFORT défini sur medium.
2. Créez une requête POST https://api.openai.com/v1/responses avec l'en-tête Authorization: Bearer {{OPENAI_API_KEY}} et ce corps, puis enregistrez-la :

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

3. Ajoutez des assertions : HTTP 200, $.status est égal à completed, $.output[*].type contient message, $.usage.output_tokens est supérieur à 0, et $.usage.output_tokens_details.reasoning_tokens existe. Ensuite, vérifiez la forme de sortie dont dépend votre code, telle qu'un JSON valide avec les clés que vous analysez.
4. Ajoutez un script de post-traitement qui convertit l'utilisation (usage) en dollars, en utilisant la répartition d'entrée du guide de mise en cache des invites d'OpenAI :

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

5. Envoyez-la, définissez MODEL_ID sur gpt-6.1-sol, et envoyez-la à nouveau. Comparez reasoning_tokens, output_tokens, la réponse et le coût enregistré. Si vous remappez depuis none, exécutez la base de référence à none et le candidat à low.

Ensuite, déplacez la requête et quelques invites réelles dans un scénario de test et exécutez la paire depuis l'interface CLI d'Apidog en CI. --env-var remplace une variable pour une seule exécution, de sorte qu'un seul scénario couvre les deux modèles :

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

Une assertion échouée fait échouer la tâche, et les rapports JUnit vous donnent les deux exécutions côte à côte. Pour les assertions sur les sorties qui varient d'une exécution à l'autre, consultez le test des agents IA non déterministes.

FAQ

GPT-6.1 Sol est-il plus cher que GPT-6 Sol ? Non. Les deux sont listés à 2 $ d'entrée et 10 $ de sortie par 1 million de jetons. L'entrée mise en cache de GPT-6.1 Sol est de 0,10 $ contre 0,20 $, donc les charges de travail intensives en cache deviennent moins chères.

Que dois-je faire avec reasoning.effort: "none" ? GPT-6.1 Sol ne prend en charge ni none ni minimal. Mappez les deux à low, supprimez temperature et top_p, et réexécutez vos évaluations avant de basculer.

Puis-je utiliser GPT-6.1 Sol avec les complétions de chat ? Oui, pour les requêtes sans outils. L'appel d'outils nécessite l'API Responses.

Existe-t-il un niveau d'API GPT-6.1 Sol gratuit ? Non. Les appels d'API sont facturés par jeton dès la première requête. GPT-6.1 Sol est-il gratuit ? couvre les routes les moins chères.

Étape suivante

Enregistrez la première requête, exécutez-la sur gpt-6-sol avec votre effort actuel, puis sur gpt-6.1-sol, et comparez l'utilisation (usage) et la sortie sur une invite de votre propre trafic. Téléchargez Apidog pour conserver les deux exécutions comme des assertions que vous pouvez réexécuter en CI. Vous hésitez avec Anthropic ? Voir GPT-6.1 Sol vs Claude Sonnet 5.5.