Comment utiliser l'API GPT-Image-2.5 dans CometAPI

TL;DR

GPT-Image-2.5 est une famille d’API d’images avec deux modèles : Flare privilégie une génération rapide et quotidienne, tandis que Sunburst privilégie la précision d’édition et la fidélité du rendu final. Via CometAPI, les intégrations existantes du SDK OpenAI peuvent généralement migrer en ne changeant que l’URL de base, la clé API et l’ID de modèle. Commencez avec Flare en qualité medium, mesurez la latence et le coût par image acceptée, et orientez les éditions exigeantes ou les rendus premium vers Sunburst.

Points clés

• Flare est le choix axé sur la vitesse pour les produits interactifs, l’itération rapide et la génération à grand volume.
• Sunburst est le choix axé sur la précision pour les éditions localisées, la préservation des références et les compositions finales complexes.
• Les deux modèles acceptent des entrées texte et image, prennent en charge six niveaux de qualité et génèrent ou éditent des images via l’API Images.
• CometAPI prend en charge les deux ID de modèle via une URL de base et un schéma de SDK compatibles OpenAI.
• Les résultats actuels d’Arena favorisent Sunburst pour la génération et l’édition, tandis que les deux nouveaux modèles restent marqués comme préliminaires.
• Le choix en production doit se baser sur la latence, le taux d’acceptation, la fidélité d’édition, l’usage de jetons et le coût effectif par image approuvée.

Le 8 septembre 2026, OpenAI a présenté ChatGPT Images 2.5 et lancé deux nouveaux modèles de génération d’images dans l’API : GPT Image 2.5 Flare pour une génération rapide et quotidienne, et GPT Image 2.5 Sunburst pour les workflows qui privilégient la qualité d’image et un contrôle d’édition plus strict. OpenAI positionne Flare comme défaut pour la plupart des applications, tandis que Sunburst est son modèle de génération et d’édition d’images le plus performant.

Les deux modèles sont désormais disponibles via CometAPI. L’avantage pratique est que les développeurs peuvent les appeler via l’interface familière du SDK OpenAI tout en remplaçant la clé API et l’URL de base par des identifiants CometAPI. L’API compatible OpenAI de CometAPI permet à une application de génération d’images existante de n’exiger qu’un petit changement d’intégration au lieu d’un nouveau SDK ou d’une nouvelle architecture de requêtes.

Ce guide montre comment générer et éditer des images avec GPT-Image-2.5 via CometAPI en cURL, Python et JavaScript, et comment choisir le bon modèle, niveau de qualité, dimensions et format de sortie pour un workflow de production.

Qu’est-ce que l’API GPT-Image-2.5 ?

GPT-Image-2.5 est la famille actuelle de génération d’images d’OpenAI. Elle accepte des entrées texte et image et renvoie des images. La famille comporte deux modèles : GPT-Image-2.5 Flare, optimisé pour la vitesse et l’usage quotidien, et GPT-Image-2.5 Sunburst, optimisé pour la capacité maximale et l’édition précise.

Comment l’API GPT-Image-2.5 se compare-t-elle à l’API GPT Image 2 ?

Le changement clé n’est pas un simple remplacement plus rapide. GPT-Image-2.5 sépare la charge de travail en deux choix dédiés. Flare cible la génération de routine avec une latence plus faible, tandis que Sunburst cible les tâches de génération et d’édition les plus exigeantes. Les deux modèles exposent la même surface de contrôle générale, y compris des niveaux de qualité de low à max, des entrées image pour l’édition et le streaming d’images partielles.

Pour la migration, commencez par conserver vos prompts et votre structure de requête actuels, puis choisissez un modèle en fonction des exigences de latence et de fidélité. Re-testez le rendu du texte, les instructions de préservation, les masques, l’ordre des images de référence, la taille de sortie et le coût avant de modifier le trafic de production.

Pourquoi utiliser GPT-Image-2.5 via CometAPI ?

CometAPI fournit une couche d’accès compatible OpenAI qui peut réduire le travail d’intégration lorsqu’une équipe utilise déjà sa passerelle. Les avantages pratiques sont une gestion centralisée des clés, un format de requête familier, la visibilité sur l’usage et la possibilité d’acheminer la génération et l’édition d’images via une seule URL de base.

Les prix des fournisseurs et la disponibilité des modèles peuvent changer. Confirmez l’identifiant du modèle, le comportement de l’endpoint et la facturation actuelle dans le tableau de bord CometAPI avant le déploiement en production.

Comment utiliser l’API GPT-Image-2.5 dans CometAPI

Étape 1 : Obtenir une clé API CometAPI

Créez ou connectez-vous à votre compte CometAPI et générez un jeton depuis la console des jetons API CometAPI.

Stockez la clé dans une variable d’environnement plutôt que de l’intégrer en dur dans le code source de l’application :

Sous Windows PowerShell :

N’exposez pas la clé API dans du JavaScript côté navigateur, des dépôts publics, des captures d’écran ou des applications clientes. Les variables d’environnement côté serveur ou un gestionnaire de secrets sont des choix plus sûrs en production.

Étape 2 : Générer votre première image avec cURL

Pour la plupart des applications, commencez avec Flare. Une requête de génération minimale ressemble à ceci :

Les éléments spécifiques à CometAPI essentiels sont l’endpoint et la clé API. L’API GPT Image 2.5 Flare dans CometAPI utilise l’endpoint api.cometapi.com/v1/images/generations avec une authentification Bearer.

Les modèles GPT Image renvoient généralement le contenu d’image généré via data[].b64_json plutôt que d’exiger que votre application télécharge une URL d’image permanente.

Une réponse simplifiée ressemble à :

Votre application doit décoder le champ Base64 et enregistrer les octets renvoyés au lieu de stocker la chaîne Base64 comme ressource finale.

Étape 3 : Générer une image avec Python

C’est l’un des plus grands avantages pratiques de CometAPI pour un projet existant basé sur le SDK OpenAI : l’exemple officiel CometAPI utilise le même client OpenAI, en modifiant base_url, la clé et l’ID de modèle plutôt que de remplacer la couche SDK de l’application.

Étape 4 : Utiliser plusieurs images de référence avec l’API Responses

Attribuez un rôle stable à chaque image avant d’écrire le prompt. Un ordre utile est : sujet d’abord, style ensuite, puis arrière-plan ou référence de mise en page. Nommez explicitement ces rôles dans le prompt afin que le modèle n’ait pas à déduire quelles propriétés copier.

import base64
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

response = client.responses.create(
    model="gpt-6-astra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Create a campaign image. Use image 1 only for the product "
                "shape and colors; image 2 only for lighting and visual style; "
                "image 3 only for the background composition. Preserve the "
                "product logo exactly and add no other text."
            )},
            {"type": "input_image", "image_url": "https://example.com/product.png"},
            {"type": "input_image", "image_url": "https://example.com/style.png"},
            {"type": "input_image", "image_url": "https://example.com/background.png"},
        ],
    }],
    tools=[{
        "type": "image_generation",
        "model": "gpt-image-2.5-sunburst",
    }],
)

for item in response.output:
    if item.type == "image_generation_call":
        with open("campaign.png", "wb") as file:
            file.write(base64.b64decode(item.result))

L’API Responses utilise un modèle principal pris en charge au niveau supérieur et sélectionne GPT-Image-2.5 dans l’outil de génération d’images. Si la passerelle n’expose pas encore le modèle principal ou le schéma d’outil sélectionné, consultez le catalogue de modèles CometAPI actuel et utilisez son équivalent documenté.

Remarque : plusieurs images de référence peuvent être fournies en même temps, chacune servant un rôle distinct ; précisez clairement la fonction de chaque image dans le prompt. Lors d’éditions multi-images, prêtez attention à l’ordre des entrées et à la correspondance sémantique.

Comment modifier des images existantes

Utilisez la route d’édition lorsqu’une ressource existante doit être préservée et modifiée. Indiquez ce qui doit rester fixe avant de décrire le changement demandé.

curl https://api.cometapi.com/v1/images/edits \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=gpt-image-2.5-sunburst" \
  -F "image[]=@product.png" \
  -F "prompt=Preserve the product shape, label, and camera angle. Replace only the background with a warm studio gradient. Add no new text." \
  -F "quality=high" \
  -F "output_format=png"

Entrée

Sortie

Attribuer des rôles à plusieurs images d’entrée

Ne vous fiez pas uniquement à l’ordre de téléversement. Dites « l’image 1 est le sujet », « l’image 2 est la référence de style » et « l’image 3 est la référence d’arrière-plan ». Énumérez ensuite les attributs autorisés à être transférés depuis chaque image. Cela réduit la copie accidentelle de visages, logos, texte ou mise en page depuis la mauvaise référence.

Utiliser un masque pour des éditions localisées

Un masque guide la zone éditable : les pixels transparents indiquent où le changement est autorisé, tandis que le reste doit être préservé. Le masque doit correspondre à la taille et au format de l’image source, inclure un canal alpha et rester dans la limite de taille de fichier de l’API. Avec plusieurs images d’entrée, le masque s’applique à la première image.

Un masque est un guidage plutôt qu’une sélection au pixel près. Renforcez-le avec un langage de préservation tel que « ne modifier que la région transparente ; préserver tous les autres pixels, le texte et la géométrie ».

Conseils de production pour GPT-Image-2.5 dans CometAPI

La spécification du modèle n’énumère pas un streaming générique au niveau modèle comme fonctionnalité prise en charge, mais l’API Images et l’API Responses prennent en charge le streaming de génération d’images avec partial_images. Cela fournit des aperçus d’image progressifs plutôt qu’un streaming texte token par token : l’API Images accepte des valeurs partial_images de 0 à 3 et peut renvoyer autant d’aperçus pendant la génération. Chaque image partielle ajoute 100 jetons de sortie. Les équipes peuvent utiliser ces aperçus pour une interface de progression ; les applications qui n’en ont pas besoin peuvent continuer à utiliser le flux standard de génération et d’édition.

Même si

partial_images: 3

est défini, rien ne garantit que trois images partielles exactes seront reçues ; si l’image finale est générée suffisamment vite, le nombre réel reçu peut être inférieur à la quantité demandée.

Paramètres de l’API GPT-Image-2.5

GPT-Image-2.5 expose plus de contrôle de sortie que le simple choix d’un prompt et d’un modèle.

API Images vs API Responses

Règle générale : commencez par l’API Images. Passez à l’API Responses lorsque le workflow a besoin d’un état de conversation, de plusieurs références sémantiques ou d’autres outils autour de la génération d’images.

Choisir la qualité

L’échelle de qualité prise en charge est :

auto laisse le modèle décider. Pour le développement, toutefois, choisir explicitement medium rend les tests A/B plus contrôlés.

Un schéma de déploiement utile est :

N’utilisez pas automatiquement max sous prétexte qu’il est disponible. Davantage de jetons de sortie d’image augmentent le coût, et un prompt faible ne devient pas bon simplement en augmentant la qualité.

Choisir la taille d’image

Les préréglages courants sont :

Les modèles 2.5 prennent également en charge des dimensions arbitraires valides, utiles pour des bannières, pages produit, créations mobiles et autres ressources non carrées. La spécification actuelle d’OpenAI autorise jusqu’à 3840 pixels par côté dans les limites de nombre de pixels et de ratio d’aspect. Guide de création d’images d’OpenAI

Créer des images transparentes

Utilisez :

ou WebP. La sortie transparente nécessite un format qui prend en charge la transparence alpha, donc JPEG n’est pas approprié. Exigences pour les arrière-plans transparents

C’est particulièrement utile pour les détourages de produits, les ressources d’interface, les icônes, les stickers et les pipelines de composition.

Comment rédiger des prompts pour GPT-Image-2.5

Un prompt fiable en production sépare l’objectif créatif des contraintes. Rédigez d’abord les instructions positives, puis les éléments à préserver et les contraintes négatives.

Définir la composition

Précisez le sujet, l’angle de prise de vue, le cadrage, la profondeur, l’arrière-plan et la position relative des objets importants. Exemple : « Vue produit trois-quarts, centrée, grand espace négatif à droite, caméra à hauteur d’œil, rendu type objectif 50 mm. »

Décrire l’éclairage et les matériaux

Nommez la direction de la lumière, sa douceur, son contraste, la température de couleur et la réponse des matériaux. Exemple : « Grand softbox en haut à gauche, léger liseré lumineux, aluminium brossé réaliste, reflets contrôlés. »

Contrôler le texte exact

Placez le texte requis entre guillemets et précisez sa position, hiérarchie, capitalisation et typographie. Demandez l’absence de texte additionnel. Exemple : « Placez le titre exact ‘BUILD WITH CLARITY’ en haut au centre, en sans serif gras capitales. Préserver l’orthographe exactement. N’ajouter aucun autre mot, lettre, libellé ou filigrane. »

Indiquer ce qui doit être préservé

Pour l’édition, nommez les éléments qui ne peuvent pas changer : identité, pose, géométrie du produit, logo, texte de l’étiquette, proportions, angle de caméra ou arrière-plan. Placez ces contraintes avant la modification demandée.

Ajouter des contraintes négatives

Listez les modes d’échec probables en langage clair : « Pas de doigts supplémentaires, pas de produits dupliqués, pas de logo déformé, pas de texte mal orthographié, pas de bordure, pas de filigrane. » Les contraintes négatives sont les plus utiles lorsqu’elles traitent de risques spécifiques plutôt que de termes de qualité génériques.

Combien coûte GPT-Image-2.5 ?

Coûts officiels de l’API OpenAI

Au moment de la vérification, Flare et Sunburst affichent les mêmes prix par jeton : 5 $ par million de jetons d’entrée texte, 1,25 $ par million de jetons d’entrée texte mis en cache, 8 $ par million de jetons d’entrée image, 2 $ par million de jetons d’entrée image mis en cache, et 30 $ par million de jetons de sortie image. Le coût final dépend des jetons effectivement utilisés, pas seulement du nombre de requêtes.

Tarification CometAPI et moyens de réduire les coûts

CometAPI annonce actuellement une remise de 20 % pour GPT-Image-2.5 Flare dans son catalogue de modèles. Considérez le tableau de bord et la facture comme source de vérité, car les prix de la passerelle peuvent changer. Pour réduire les dépenses, utilisez Flare pour le travail de routine, commencez à medium ou high, réservez xhigh ou max pour des cas approuvés, réutilisez les entrées mises en cache lorsque c’est pris en charge, évitez les variantes inutiles et définissez partial_images à 0 sauf si les aperçus améliorent l’expérience utilisateur.

Autres facteurs de coût et exemple chiffré

Le coût est influencé par la longueur du prompt, le nombre et la résolution des images de référence, les dimensions de sortie, la qualité, les jetons de sortie finaux, les variantes demandées, les aperçus partiels, les réessais et les résultats rejetés. Suivez à la fois la dépense par requête et la dépense par image acceptée.

Coût par image acceptée = dépense totale de génération ÷ nombre de sorties qui passent la revue.
Exemple illustratif : 10 tentatives à 0,18 $ chacune coûtent 1,80 $. Si 6 images sont acceptées, le coût par image acceptée est de 0,30 $, pas 0,18 $. Si un meilleur prompt réduit à 8 tentatives pour 6 images acceptées, le coût par image acceptée tombe à 0,24 $.

Flare vs Sunburst : quel modèle utiliser ?

La décision doit être guidée par la charge de travail plutôt que de traiter Sunburst comme un remplacement automatique de Flare.

Pour de nombreux produits, l’architecture optimale n’est pas « choisir un seul modèle pour toujours ». Acheminez la plupart des requêtes vers Flare, puis envoyez les révisions exigeantes ou les sorties finales à forte valeur vers Sunburst.

Comment migrer de GPT Image 2 vers GPT-Image-2.5 ?

Si vous utilisez déjà GPT Image 2 via CometAPI, la migration est relativement limitée car la génération et l’édition restent sur les routes de l’API Images.

Le changement le plus simple est :

Mais ne vous arrêtez pas à l’échange d’ID. Réévaluez la qualité, les dimensions de sortie, la latence, la préservation du sujet, la correction du texte, la localité de l’édition et l’usage réel des jetons à l’aide d’un jeu d’évaluation fixe.

OpenAI recommande spécifiquement de maintenir constants le prompt, les références, les dimensions et le format de sortie lors de la comparaison des modèles afin que le modèle soit la seule variable mesurée. Recommandations de migration d’OpenAI

Conseils de production pour GPT-Image-2.5 dans CometAPI

Pour un service de production, gardez l’implémentation autour de GPT-Image-2.5 volontairement minimale : stocker la clé API côté serveur, conserver l’image décodée dans votre propre stockage, journaliser modèle/qualité/taille/latence/usage, plafonner les réessais et traiter différemment les erreurs 400 des erreurs transitoires 429 ou 5xx.

CometAPI a déjà publié un guide dédié couvrant la mise en file d’attente, la concurrence bornée, l’exponentiel backoff, les identifiants durables, le stockage, les manifestes et le suivi des coûts par lot. Plutôt que de dupliquer cette implémentation ici, consultez Comment automatiser la génération d’images à l’échelle lors du passage d’un appel unique à la production en lot.

Cette distinction est particulièrement importante lors de l’adaptation d’exemples écrits pour l’API native d’OpenAI directement vers un endpoint tiers compatible OpenAI.

Erreurs courantes de l’API GPT-Image-2.5

Ne retentez pas automatiquement chaque échec. Une requête 400 mal formée restera généralement mal formée, tandis que retenter une erreur d’authentification ne fera que générer plus de trafic échoué.

Limites de débit et concurrence

Conclusion

GPT-Image-2.5 offre aux développeurs une répartition des modèles plus utile qu’une simple mise à niveau générationnelle : Flare est optimisé pour les charges d’images quotidiennes rapides, tandis que Sunburst offre une option de plus haute précision pour les workflows de génération et d’édition exigeants.

Via CometAPI, les deux peuvent s’intégrer dans une application compatible OpenAI existante avec un effort d’intégration minimal. Commencez avec l’endpoint /v1/images/generations, Flare, un réglage de qualité contrôlé et un ensemble représentatif de prompts. Ajoutez /v1/images/edits et Sunburst lorsque votre produit nécessite une meilleure préservation des références ou des modifications visuelles précises.

L’optimisation clé ne consiste pas simplement à sélectionner le réglage le plus puissant. Mesurez la latence, l’usage de jetons, le taux d’acceptation, la précision des éditions et le coût effectif par image approuvée sur la charge réelle de votre application. C’est cela qui détermine si Flare ou Sunburst est le meilleur modèle de production.

FAQ

GPT-Image-2.5 est-il disponible sur CometAPI ?

Oui. GPT Image 2.5 Flare et GPT Image 2.5 Sunburst sont tous deux disponibles via CometAPI.

Ai-je besoin d’une clé API OpenAI distincte ?

Non. Lors de l’appel du modèle via CometAPI, l’authentification utilise votre clé CometAPI contre l’endpoint CometAPI.

Dois-je utiliser Flare ou Sunburst ?

Commencez avec Flare pour la plupart des charges de génération. Utilisez Sunburst lorsque la précision d’édition, les compositions complexes ou la préservation des détails des images de référence ont un impact mesurable sur l’acceptation des sorties. Cela suit le positionnement d’OpenAI pour les deux modèles.

GPT-Image-2.5 peut-il éditer des images existantes ?

Oui. Les spécifications actuelles des modèles prennent en charge l’entrée image et l’édition d’image, et CometAPI expose la capacité d’édition pour cette famille. API GPT Image 2.5 Flare dans CometAPI

GPT-Image-2.5 prend-il en charge les images transparentes ?

Oui. Définissez background sur transparent et utilisez PNG ou WebP comme format de sortie. Guide de création d’images d’OpenAI

Puis-je utiliser le SDK Python OpenAI avec CometAPI ?

Oui. Les exemples actuels de CometAPI instancient le client OpenAI standard avec base_url="https://api.cometapi.com/v1" et une clé CometAPI. Exemple de SDK CometAPI