Qu'est-ce que ChatGPT Images 2.6 ? GIF, export SVG et génération 50 % plus rapide

ChatGPT Images 2.6 est la mise à jour de génération d'images d'OpenAI, publiée le 4 novembre 2026 pour ChatGPT, Codex et l'API. Elle ajoute les GIF animés, la sortie SVG pour les développeurs, le balisage d'image et un paramètre complexity, et OpenAI annonce une génération d'images 50 % plus rapide. L'API la propose sous la forme de deux modèles : GPT-Image-2.6 Flare et GPT-Image-2.6 Sunburst.

Si vous avez lu notre article explicatif sur ChatGPT Images 2.5, ce billet ne couvre que ce qui a changé. Un détail n'est pas mentionné dans l'annonce de lancement : les tarifs par token restent identiques, mais une image en qualité low consomme désormais environ 4,2 fois plus de tokens de sortie que sur la 2.5.

ChatGPT Images 2.6 en un coup d'œil

Les nouveautés par rapport à Images 2.5

Images 2.5 a introduit Flare et Sunburst, les niveaux de qualité xhigh et max, ainsi que des fonctionnalités ChatGPT comme Sketch et Templates. La version 2.6 conserve la séparation en deux modèles et les cinq niveaux de qualité, puis y ajoute ceci :

La fiche système d'OpenAI indique également que les deux modèles améliorent la cohérence des retouches, la préservation des détails et la réponse aux croquis et aux annotations. L'annonce de lancement ne mesure rien de tout cela avec un benchmark public et ne précise pas à quelle base de référence se rapporte le « 50 % plus rapide » : considérez donc ce chiffre comme une affirmation d'OpenAI jusqu'à ce que vous ayez chronométré vos propres prompts.

Qui peut utiliser ChatGPT Images 2.6 ?

OpenAI indique qu'Images 2.6 est disponible mondialement dans ChatGPT et Codex « pour tous les niveaux d'abonnement », sur ordinateur, mobile et web. L'accès à l'API passe par les deux modèles ci-dessus, et vous devrez peut-être terminer la vérification de votre organisation API avant de pouvoir les appeler.

Deux questions restent en suspens pour les utilisateurs de ChatGPT :

• Les limites de GIF dans l'offre gratuite. Ni l'annonce de lancement ni la page de tarifs de ChatGPT n'indique de quota de GIF. La page de tarifs qualifie la génération d'images de « limitée » dans l'offre gratuite.
• Le mode Thinking. La même page, consultée le 5 novembre, mentionne « la génération d'images avec Thinking » pour Plus et Pro, mais pas pour Free ni Go.

Dans Codex, vous invoquez la génération d'images avec la compétence $imagegen. Cette page ne mentionne pas encore la sortie GIF ou SVG.

Flare vs Sunburst : quel modèle fait quoi ?

Flare est le modèle rapide pour le travail interactif. OpenAI précise qu'il améliore aussi la qualité de mise en page des affiches et des visuels de produits. Sunburst est destiné aux compositions détaillées, avec une qualité supérieure et une meilleure cohérence d'une retouche à l'autre en qualité medium ou high.

Les deux modèles coûtent le même prix par token et partagent une seule entrée dans le calculateur. Notre comparaison Flare vs Sunburst pour la 2.5 détaille davantage cette répartition, et l'essentiel reste valable.

Comment fonctionne la génération de GIF

L'API renvoie une animation terminée, et non une planche de sprites que vous assemblez vous-même. Les exemples de prompts de l'annonce de lancement demandent une planche de six images en grille 3x2, mais le guide de génération d'images documente une méthode directe :

1. Appelez POST /v1/images/generations avec output_format: "gif".
2. Décrivez le sujet, le mouvement et la boucle dans votre prompt.
3. Définissez frame_count (de 2 à 64, valeur par défaut 9).
4. Définissez frame_duration_ms (de 20 à 2 000, arrondi à 10 ms, valeur par défaut 200).
5. Décodez b64_json depuis le base64 et enregistrez-le avec une extension .gif.

curl --fail --silent --show-error https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A small orange robot waves, blinks, and returns to its starting pose. Loop it.",
    "output_format": "gif",
    "frame_count": 9,
    "frame_duration_ms": 200,
    "size": "auto"
  }' | jq -er '.data[0].b64_json' | base64 --decode > robot.gif

Nous avons construit cette requête à partir de la liste de champs du guide et ne l'avons pas exécutée avec une clé réelle. Testez-la donc avant de la mettre en production.

Anticipez ces limites :

• /v1/images/edits ne peut pas renvoyer de GIF : vous ne pouvez donc pas animer une image importée via ce point de terminaison.
• La sortie GIF ne prend pas en charge le streaming, les images partielles, un output_compression personnalisé ni prompt_rewriter.
• Le nombre d'images, leur taille et n doivent respecter un budget total de pixels. Si une requête échoue, réduisez l'un de ces paramètres.

Export SVG : ce que vous obtenez

Définissez output_format: "svg" sur POST /v1/images/generations pour les icônes, logos et illustrations nécessitant des tracés, des formes et des couleurs modifiables. L'API crée d'abord une image de référence, puis produit le SVG à partir de celle-ci, et quality contrôle cette image de référence.

La sortie est un contenu vectoriel statique, sans scripts, ressources externes ni images matricielles intégrées. Les contraintes sont strictes : n doit valoir 1, il n'y a pas de streaming, et ni output_compression ni prompt_rewriter ne fonctionnent. Le point de terminaison de retouche ne peut pas produire de SVG, et un SVG ne peut pas servir d'entrée matricielle pour les retouches.

La facturation diffère également. Vous payez le tarif du modèle d'image pour l'image de référence, plus le tarif d'un modèle de rédaction pour les tokens qui écrivent le SVG. OpenAI ne publie pas de prix fixe par SVG ; mesurez-le donc sur vos propres prompts.

Le paramètre complexity et le balisage d'image

complexity détermine l'ampleur de la planification du modèle avant le rendu. quality définit le niveau de détail du rendu. Ce sont deux contrôles distincts, et ajuster complexity n'entraîne aucun frais supplémentaire.

Attention à la valeur par défaut. Si vous omettez complexity, les deux modèles utilisent high, alors qu'OpenAI recommande low pour la plupart des retouches, associé à la qualité dont vous avez besoin. Le guide avertit qu'une complexité plus élevée peut ajouter de la latence et introduire des modifications non souhaitées. Pour remplacer un arrière-plan ou corriger un panneau, définissez explicitement low. Réservez medium ou high aux textes denses, aux mises en page complexes et aux scènes comportant de nombreux éléments contraints.

Le balisage d'image arrive sur POST /v1/images/edits sous la forme d'un champ markup. Vous envoyez une superposition transparente qui entoure la cible, puis décrivez la modification dans prompt. L'exemple d'OpenAI entoure un vase, le recolore et demande au modèle de supprimer le cercle de la photo finale. Le balisage fonctionne aussi sur les modèles 2.5 pris en charge, coûte le même prix que les autres retouches et n'est pas disponible via l'API Responses, où le guide vous oriente plutôt vers les masques.

Tarification de GPT-Image-2.6 : mêmes tarifs, plus de tokens en qualité low

Les prix par token correspondent à ceux de la 2.5 sur la page de tarifs : 8 $ pour 1 M de tokens d'entrée d'image, 2 $ en cache, 30 $ en sortie, 5 $ en entrée de texte, 1,25 $ pour le texte en cache. Ce qui change, c'est la consommation de tokens. Le calculateur d'OpenAI applique un multiplicateur de 4,2 en low et de 3,3 en medium pour la 2.6, et aucun au-delà.

Ces chiffres proviennent du calculateur et excluent les tokens d'entrée. Le format paysage est moins cher : low en 1536x1024 consomme 664 tokens, soit environ 0,02 $.

Ainsi, si vous exécutez des tâches low à fort volume sur la 2.5, passer à la 2.6 multiplie votre facture de sortie par environ 4,2. En 2.6, medium coûte désormais presque autant que high, ce qui rend high intéressant à tester. L'onglet Batch de la page de tarifs indique la 2.5 à moitié prix, mais pas la 2.6 : une charge de travail par lots peut donc être moins chère sur la 2.5 pour l'instant. Le guide ne fournit pas non plus de formule de facturation propre aux GIF ; lancez donc un test avec un petit frame_count et vérifiez votre consommation avant de passer à l'échelle. Notre guide de l'API gpt-image-2.5 couvre les bases de requête qui restent valables.

Sécurité et provenance

OpenAI a testé les deux modèles sur 3 077 prompts adversariaux. Ces résultats ne reflètent pas les taux en production. La part de générations dangereuses non bloquées est passée de 1,92 % à 1,72 % pour Sunburst, et de 1,49 % à 2,14 % pour Flare, bien qu'OpenAI ne considère aucun de ces changements comme statistiquement significatif.

Les GIF introduisent un nouveau risque, car un contenu préjudiciable peut apparaître au fil des images plutôt que sur une seule image fixe. OpenAI rapporte un rappel de modération de 77,7 % sur un ensemble de GIF adversariaux et indique que les infractions liées au mouvement restent difficiles à détecter.

Pour la provenance, Images 2.6 utilise des métadonnées C2PA ainsi qu'un filigrane invisible SynthID sur ChatGPT, Codex et l'API.

Laissez votre agent de codage le tester avec Apidog CLI

Cette version a modifié la consommation de tokens sans changer la grille tarifaire. Un test enregistré permet de détecter une rupture dans une requête dont vous dépendez, et votre agent de codage peut l'écrire avec Apidog CLI. Configurez-le une fois :

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

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

Add POST https://api.openai.com/v1/images/generations to Apidog project <id>.
Create a test case that sends model gpt-image-2.6-flare, quality low,
complexity low, output_format gif and frame_count 6, with the bearer token
read from the OPENAI_API_KEY environment variable. Assert status 200 and that
data[0].b64_json exists. Run it against environment <envId> and summarize failures.

L'agent lit chaque schéma, valide sa charge utile, puis écrit et exécute le test :

apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <id> --file endpoint.json
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> \
  --env-var "OPENAI_API_KEY=$OPENAI_API_KEY" -r cli,json

Chaque exécution produit une génération réelle et facturée : gardez donc un nombre d'images et une qualité faibles. Dupliquez le cas avec gpt-image-2.6-sunburst pour comparer les deux modèles. Remplacez -r cli,json par -r junit pour l'exécuter dans un pipeline CI, et consultez le guide de configuration de Claude Code pour les détails côté agent.

FAQ

ChatGPT Images 2.6 est-il gratuit ? OpenAI indique qu'il est disponible pour tous les niveaux d'abonnement, et la page de tarifs mentionne une génération d'images limitée dans l'offre gratuite. Aucune des deux sources ne précise de quota de GIF pour les utilisateurs de l'offre gratuite. L'usage de l'API est facturé au token.

L'API renvoie-t-elle un GIF ou une planche de sprites ? Un GIF terminé. Définissez output_format: "gif" sur le point de terminaison generations, puis décodez b64_json. Les planches de sprites de l'annonce de lancement proviennent d'exemples de prompts.

GPT-Image-2.6 est-il plus cher que la 2.5 ? Les tarifs par token sont identiques, mais les images en low et medium consomment plus de tokens. Le coût de sortie d'une image low en 1024x1024 passe d'environ 0,006 $ à environ 0,025 $. Les niveaux high, xhigh et max ne changent pas.

Quelle est la différence entre quality et complexity ? quality contrôle le niveau de détail du rendu et détermine le coût en tokens. complexity contrôle l'ampleur de la planification du modèle et vaut high par défaut. OpenAI suggère une complexité low pour la plupart des retouches.

Puis-je transformer une image existante en GIF ou en SVG via l'API ? Non. Le point de terminaison de retouche ne prend en charge ni la sortie GIF ni la sortie SVG, et les fichiers SVG ne sont pas acceptés comme entrées matricielles. Ces deux formats ne proviennent que du point de terminaison generations.