Comment utiliser l'API GPT-Image-2.6

L'API GPT-Image-2.6 génère et modifie des images via deux modèles OpenAI, gpt-image-2.6-flare et gpt-image-2.6-sunburst. Envoyez un prompt à POST /v1/images/generations avec votre clé API, puis décodez le champ b64_json de la réponse. La version 2.6 ajoute le markup d'image, la sortie SVG et GIF, ainsi qu'un paramètre complexity.

Ce guide couvre l'authentification, une première génération, une édition par markup, l'export SVG, ainsi que les réglages quality et complexity. Il se concentre sur les nouveautés : consultez notre guide de l'API gpt-image-2.5 pour le streaming et l'outil Responses API, et notre présentation de ChatGPT Images 2.6 pour tous les détails de la sortie. Toutes les requêtes ci-dessous ont été rédigées à partir de la documentation OpenAI du 5 novembre 2026. Nous ne les avons pas exécutées avec une clé active, alors testez-les avant de passer en production.

L'API GPT-Image-2.6 en un coup d'œil

Les tarifs proviennent de la page de tarification d'OpenAI. Les deux modèles coûtent le même prix par token : choisissez donc en fonction de la vitesse et de la précision d'édition.

Flare ou Sunburst : quel modèle appeler ?

Appelez Flare pour itérer rapidement et pour la génération du quotidien. OpenAI indique qu'il peut renvoyer une image en seulement six secondes en qualité low, et qu'il améliore la mise en page pour les affiches et les visuels produits. Appelez Sunburst pour les travaux détaillés et les éditions répétées, où OpenAI promet une meilleure cohérence en qualité medium ou high.

Ce sont les affirmations d'OpenAI, pas des benchmarks indépendants. Notre comparatif Flare vs Sunburst pour la 2.5 détaille cette distinction.

Authentification et configuration

Trois choses sont nécessaires avant votre premier appel :

1. Créez une clé API dans le tableau de bord OpenAI et exportez-la sous le nom OPENAI_API_KEY.
2. Effectuez la vérification d'organisation API si votre organisation en a besoin. OpenAI précise que cela peut être requis avant de pouvoir utiliser les modèles GPT Image.
3. Installez jq pour les exemples curl, ou le package openai pour Python.

Si votre application sert des utilisateurs individuels, envoyez également un safety_identifier haché de 128 caractères maximum. Il remplace le paramètre user, désormais obsolète.

Générez votre première image

Cette requête utilise Flare en qualité low, ce qui convient aux brouillons.

curl --fail-with-body --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 minimal poster for a developer meetup, with the words SHIP IT in bold type",
    "size": "1024x1536",
    "quality": "low",
    "complexity": "low"
  }' | jq -er '.data[0].b64_json' | base64 --decode > poster.png

Le même appel en Python :

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.6-sunburst",
    prompt="A product shot of a ceramic mug on a walnut desk, soft morning light",
    size="1536x1024",
    quality="medium",
    extra_body={"complexity": "low"},
)

Path("mug.png").write_bytes(base64.b64decode(result.data[0].b64_json))

Nous passons complexity via extra_body pour que l'appel ne dépende pas de la version de votre SDK qui l'exposerait comme argument nommé. Les modèles GPT Image renvoient toujours du base64 : n'envoyez donc pas response_format et ne cherchez pas de champ url.

Le guide d'OpenAI recommande de lire l'objet usage de la réponse pour mesurer la consommation de tokens. La référence API décrit ce champ comme réservé à gpt-image-1, bien que son exemple de réponse l'inclue : vérifiez donc qu'il apparaît bien dans vos réponses 2.6 avant de bâtir un suivi de coûts dessus.

Éditez une image avec le markup

Le markup indique au modèle où effectuer une modification. Vous envoyez l'image d'origine, un PNG transparent avec vos cercles ou croquis, et un prompt décrivant l'édition.

curl --fail-with-body --silent --show-error \
  https://api.openai.com/v1/images/edits \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "images": [{"image_url": "https://your-bucket.example/kitchen.png"}],
    "markup": {"image_url": "https://your-bucket.example/vase-overlay.png"},
    "prompt": "Recolor the vase inside the red circle to solid cobalt blue. Keep everything else unchanged. Remove the red circle.",
    "quality": "medium",
    "complexity": "low"
  }' | jq -er '.data[0].b64_json' | base64 --decode > vase.png

Les requêtes JSON utilisent le tableau images et un objet markup qui contient exactement l'un des deux champs image_url ou file_id. Un image_url peut être une URL HTTPS ou une data URL base64. Les requêtes multipart acceptent un upload de fichier à la place, et le guide de génération d'images contient cette version en Python.

L'overlay obéit à des règles strictes :

• Après orientation, il doit correspondre à la largeur et à la hauteur de la première image.
• Il doit contenir des pixels transparents : ne l'aplatissez donc pas sur la photo.
• Il s'applique à la première image d'entrée. Les autres servent de références.
• Chacune des deux images peut contenir au maximum 16 777 216 pixels, et le fichier overlay ne peut pas dépasser 50 Mo.
• Vous ne pouvez pas combiner markup avec mask ou prompt_rewriter.

Demandez au modèle de supprimer l'annotation, comme le fait l'exemple d'OpenAI lui-même. Le markup coûte le même prix que n'importe quelle autre édition. L'API Responses ne le prend pas en charge : utilisez-y un masque.

Exporter en SVG

Définissez output_format sur svg sur l'endpoint de génération pour les icônes, logos et illustrations nécessitant des tracés éditables.

curl --fail-with-body --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-sunburst",
    "prompt": "A flat two-color wheat logo for a bakery called Field and Flour",
    "output_format": "svg",
    "quality": "medium",
    "n": 1
  }' | jq -er '.data[0].b64_json' | base64 --decode > logo.svg

L'API génère d'abord une image de référence, contrôlée par quality, puis écrit le SVG à partir de celle-ci. Les octets décodés forment un XML UTF-8 sans scripts, ressources externes ni images matricielles intégrées.

Quatre limites s'appliquent :

• n doit valoir 1.
• Le streaming, les images partielles, output_compression et prompt_rewriter ne fonctionnent pas.
• L'endpoint d'édition ne peut pas produire de SVG, et n'accepte pas un SVG en entrée matricielle.
• L'objet svg optionnel permet de choisir le modèle d'écriture, mais uniquement si votre compte dispose de la sélection de modèle SVG. Sinon, omettez-le.

Vous payez deux fois : le tarif image pour l'image de référence et le tarif du modèle d'écriture pour ses tokens. La référence API mentionne un objet svg_usage distinct pour cette seconde partie : pensez à le journaliser.

Générer un GIF

L'API renvoie un GIF finalisé, pas une planche de sprites. Ajoutez trois champs à une requête de génération :

{
  "model": "gpt-image-2.6-flare",
  "prompt": "A small orange robot waves, blinks and returns to its starting pose. Make it loop.",
  "output_format": "gif",
  "frame_count": 9,
  "frame_duration_ms": 200,
  "size": "auto"
}

Décodez b64_json de la même manière et enregistrez le fichier en .gif. Vérifiez d'abord deux points :

• Limite de frames. Le guide indique que frame_count va de 2 à 64. La référence API indique 2 à 16. Restez à 16 ou moins tant que vous n'avez pas testé des valeurs supérieures.
• Accès. La référence précise que la sortie GIF nécessite l'accès à l'aperçu GIF pour le modèle sélectionné, tandis que le guide n'en parle pas. Une requête GIF rejetée peut donc relever d'un problème d'accès, et non d'un payload incorrect.

La sortie GIF ne prend pas en charge le streaming, les images partielles ni un output_compression personnalisé, et l'endpoint d'édition ne peut pas en renvoyer. OpenAI ne publie aucune formule de facturation spécifique aux GIF : faites donc un petit test et vérifiez votre facture avant de monter en charge.

Régler quality et complexity

quality contrôle le niveau de détail du rendu et détermine le coût en tokens. complexity contrôle le temps de planification du modèle avant le rendu, et le modifier n'entraîne pas de frais supplémentaires.

Définissez complexity sur chaque requête. La valeur par défaut est high, mais OpenAI recommande low pour la plupart des éditions. Le guide avertit que des valeurs élevées peuvent augmenter la latence et introduire des modifications non désirées.

La qualité détermine aussi votre facture de sortie. Ce tableau utilise le calculateur d'OpenAI pour une image 1024x1024, consulté le 5 novembre, et exclut les tokens d'entrée :

L'écart entre medium et high est d'environ un centime : comparez donc les deux. L'onglet Batch de la page de tarification ne mentionne pas encore la 2.6 : ne partez donc pas du principe que la remise Batch de la 2.5 s'applique.

Gérer les erreurs et les timeouts

Classez les échecs selon qu'une nouvelle tentative peut aider ou non :

Utilisez error.code comme point de contrôle stable, et journalisez l'ID de requête. moderation_details contient moderation_stage et des categories grossières, qui ont leur place dans vos logs, pas dans les messages destinés aux utilisateurs. Réglez les timeouts client au-delà de deux minutes, car OpenAI indique que des prompts complexes peuvent prendre ce temps.

Laissez votre agent de codage tester avec Apidog CLI

Votre agent de codage peut transformer ces requêtes et limites en suite de tests avec Apidog CLI. Configurez-le une fois :

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

Puis donnez un seul prompt à Claude Code, Codex ou Cursor :

In Apidog project <id>, add POST /v1/images/generations and POST /v1/images/edits
on https://api.openai.com. Read the bearer token from OPENAI_API_KEY.
Create test cases for gpt-image-2.6-flare at low quality and low complexity:
1. PNG generation: assert status 200 and data[0].b64_json exists.
2. SVG generation: assert status 200 and output_format equals svg.
3. GIF with frame_count 6: assert status 200 and output_format equals gif.
4. SVG with n set to 2: assert a 4xx status and that error.message exists.
5. GIF with frame_count 17: record the status, because OpenAI's docs disagree.
Put them in a test suite named "GPT-Image-2.6", run it against environment
<envId>, and summarize every failure.

L'agent lit chaque schéma, valide son payload, puis écrit et exécute la suite :

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 cli-schema validate test-suite-create --file suite.json
apidog test-suite create --project <id> --file suite.json
apidog test-suite run <suiteId> --project <id> -e <envId> \
  --env-var "OPENAI_API_KEY=$OPENAI_API_KEY" --on-error continue -r cli,json

Le cas 5 tranche la limite de frames pour votre compte, et le cas 3 indique si vous avez accès aux GIF. Les cas réussis produisent de vraies générations facturables : gardez donc une qualité basse. Remplacez par -r junit pour exécuter la suite dans un pipeline CI, et consultez le guide de configuration de Claude Code pour les détails côté agent.

FAQ

Quels sont les noms des modèles de l'API GPT-Image-2.6 ? gpt-image-2.6-flare et gpt-image-2.6-sunburst. La référence API ne liste encore aucun snapshot daté pour eux, contrairement aux modèles 2.5.

Combien coûte l'API GPT-Image-2.6 ? Les tokens d'image coûtent 8 $ pour 1 M en entrée et 30 $ pour 1 M en sortie. Une image 1024x1024 coûte environ 0,025 $ en sortie en low et environ 0,053 $ en high, hors tokens d'entrée.

Dois-je migrer depuis gpt-image-2.5 ? Migrez si vous avez besoin du SVG, du GIF ou de complexity. Testez d'abord vos coûts : une image en low consomme environ 4,2 fois plus de tokens qu'en 2.5, et les modèles 2.6 n'ont pas encore de tarification Batch listée.

Puis-je utiliser complexity sur l'endpoint d'édition ? Oui. OpenAI recommande low pour la plupart des éditions.

Puis-je transformer une image téléversée en GIF via l'API ? Non. L'endpoint d'édition ne renvoie ni GIF ni SVG : ces deux formats partent donc d'un prompt texte sur l'endpoint de génération.

L'API renvoie-t-elle une URL ? Non. Les modèles GPT Image renvoient toujours du base64 dans b64_json : décodez-le et stockez le fichier vous-même.