For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.
Navigation principale
Theme

Suggestions

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

Tableau de bord de l’API
Essayez ChatGPT

Génération d’images

Découvrez comment générer ou modifier des images.

Vue d’ensemble

L’API permet de générer et de modifier des images à partir de prompts textuels avec gpt-image-2.5-sunburst et gpt-image-2.5-flare. Choisissez Sunburst pour les workflows qui privilégient la précision des retouches, et Flare pour générer rapidement des images de qualité au quotidien. Deux API donnent accès à la génération d’images.

API Image

L’API Image propose deux points de terminaison aux fonctions distinctes.

API Responses

L’API Responses permet de générer des images au fil d’une conversation ou d’un workflow en plusieurs étapes. Elle propose la génération d’images sous forme d’outil intégré et accepte dans le contexte aussi bien les images fournies en entrée que celles produites en sortie.

Par rapport à l’API Image, elle offre deux possibilités supplémentaires.

  • Retouches successives : affinez une image au fil des prompts tout en préservant fidèlement ses détails.
  • Souplesse des entrées : pour fournir une image en entrée, vous pouvez aussi transmettre l’identifiant de son fichier au lieu des données en octets.

Pour savoir quels modèles principaux peuvent appeler l’outil de génération d’images, consultez la section Modèles compatibles.

Choix de l’API

  • Pour générer ou modifier une seule image à partir d’un seul prompt, choisissez l’API Image.
  • Pour permettre à vos utilisateurs de générer et de retoucher des images avec GPT Image au fil d’une conversation, choisissez l’API Responses.

Avec l’API Image, attribuez directement à model la valeur gpt-image-2.5-sunburst ou gpt-image-2.5-flare. Avec l’API Responses, sélectionnez un modèle principal compatible au premier niveau de la requête et indiquez gpt-image-2.5-sunburst ou gpt-image-2.5-flare dans le champ model de l’outil de génération d’images.

Les deux API permettent de personnaliser l’image de sortie en réglant la qualité, les dimensions, le format et la compression.

Pour garantir une utilisation responsable de ces modèles, vous devrez peut-être effectuer la vérification de votre organisation pour l’accès à l’API depuis votre console développeur avant d’utiliser les modèles GPT Image.

GPT-Image-2.6

GPT-Image-2.6 propose Sunburst pour les travaux visuels qui exigent de la précision et Flare pour affiner rapidement une image par retouches successives. Avec l’API Image, les deux modèles permettent de régler la complexité, de guider les retouches à l’aide d’annotations et de générer des images SVG et des GIF animés. Les exemples préexistants ci-dessous utilisent GPT-Image-2.5.

Réglage de la complexité de l’image

Utilisez le champ complexity de la requête pour régler l’effort de planification du modèle avant le rendu. Une complexité faible peut convenir aux retouches ciblées, comme la modification d’un arrière-plan ou d’un panneau. Une complexité élevée peut être utile lorsque l’image contient beaucoup de texte, que la mise en page est complexe ou que les relations entre les objets sont importantes. Elle peut aussi augmenter la latence et entraîner des modifications indésirables. Comparez les résultats pour votre tâche.

Sunburst et Flare acceptent les niveaux de complexité low, medium et high. Si vous omettez complexity, les deux modèles utilisent high. Le paramètre distinct quality règle la qualité du rendu.

Le réglage de la complexité n’entraîne aucuns frais supplémentaires.

Sunburst a généré ces scènes de football en papier découpé à partir du même prompt, avec une qualité moyenne. Comparez le trophée, les tenues et l’emplacement de l’inscription « CHAMPIONS » selon le niveau de complexité.

Complexité faible

Complexité moyenne

Complexité élevée

Identifiants de sécurité

Si votre application s’adresse à des utilisateurs finaux individuels, incluez un safety_identifier stable qui préserve leur confidentialité dans chaque requête de génération d’images ou de modification d’images. Hachez le nom d’utilisateur ou l’adresse e-mail pour éviter de transmettre des données identifiantes, et limitez l’identifiant à 128 caractères. Les identifiants de sécurité sont recommandés, mais facultatifs.

Le paramètre user de l’API Images est obsolète. Transmettez le même identifiant dans safety_identifier. L’API continue d’accepter les requêtes existantes qui utilisent user. Un safety_identifier non vide a priorité sur user. Si safety_identifier est absent, vaut null ou contient une chaîne vide, l’API utilise user s’il est fourni.

Une tasse à café beige sur une table en bois

Génération d’images

Utilisez le point de terminaison de génération d’images pour créer des images à partir de prompts textuels, ou l’outil de génération d’images de l’API Responses pour en générer au cours d’une conversation.

Pour régler les dimensions, la qualité, le format et la compression, consultez la section Personnalisation de l’image de sortie ci-dessous.

Réglez le paramètre n pour générer plusieurs images en une seule requête. Par défaut, l’API renvoie une seule image.
Générer une image
from openai import OpenAI
import base64

client = OpenAI()

prompt = """
A children's book drawing of a veterinarian using a stethoscope to
listen to the heartbeat of a baby otter.
"""

result = client.images.generate(model="gpt-image-2.5-sunburst", prompt=prompt)

image_base64 = result.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

# Save the image to a file
with open("otter.png", "wb") as f:
    f.write(image_bytes)

Génération d’images en plusieurs échanges

Avec l’API Responses, vous pouvez générer des images au fil d’une conversation en incluant dans le contexte les résultats des appels de génération d’images (l’identifiant de l’image suffit), ou en utilisant le paramètre previous_response_id. Vous pouvez ainsi affiner vos prompts, donner de nouvelles instructions et faire évoluer l’image d’un échange à l’autre.

Avec l’outil de génération d’images de l’API Responses, les modèles compatibles peuvent choisir de générer une nouvelle image ou d’en modifier une déjà présente dans la conversation. Le paramètre facultatif action contrôle ce comportement. Conservez action: "auto" pour laisser le modèle choisir, utilisez action: "generate" pour toujours créer une nouvelle image, ou action: "edit" pour imposer la modification lorsqu’une image figure dans le contexte.

Imposer la création d’une image avec action
from openai import OpenAI
import base64

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Generate an image of gray tabby cat hugging an otter with an orange scarf",
    tools=[
        {"type": "image_generation", "model": "gpt-image-2.5-sunburst", "action": "generate"}
    ],
)

# Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    image_base64 = image_data[0]
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Si vous imposez edit sans fournir d’image dans le contexte, l’appel renvoie une erreur. Laissez action sur auto pour que le modèle choisisse entre génération et modification.
Génération d’images en plusieurs échanges
from openai import OpenAI
import base64

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Generate an image of gray tabby cat hugging an otter with an orange scarf",
    tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],
)

image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    image_base64 = image_data[0]

    with open("cat_and_otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))


# Follow up

response_fwup = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=response.id,
    input="Now make it look realistic",
    tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],
)

image_data_fwup = [
    output.result
    for output in response_fwup.output
    if output.type == "image_generation_call"
]

if image_data_fwup:
    image_base64 = image_data_fwup[0]
    with open("cat_and_otter_realistic.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Résultat

« Génère une image d’un chat tigré gris qui serre dans ses pattes une loutre portant une écharpe orange. »

Un chat et une loutre

« Donne maintenant à l’image un aspect réaliste. »

Un chat et une loutre

Diffusion en continu

L’API Responses et l’API Image prennent en charge la génération d’images en continu. Pour rendre l’expérience plus interactive, vous pouvez diffuser des images partielles à mesure que les API les génèrent.

Réglez le paramètre partial_images pour recevoir de 0 à 3 images partielles.

  • Si vous réglez partial_images sur 0, vous recevrez uniquement l’image finale.
  • Pour les valeurs supérieures à zéro, vous pouvez recevoir moins d’images partielles que demandé si l’image finale est prête plus tôt.
Diffuser une image en continu
from openai import OpenAI
import base64

client = OpenAI()


def save_base64_image(filename, image_base64):
    image_bytes = base64.b64decode(image_base64)
    with open(filename, "wb") as f:
        f.write(image_bytes)


stream = client.responses.create(
    model="gpt-6-astra",
    input="Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape",
    stream=True,
    tools=[
        {"type": "image_generation", "model": "gpt-image-2.5-sunburst", "partial_images": 2}
    ],
)

for event in stream:
    if event.type == "response.image_generation_call.partial_image":
        idx = event.partial_image_index
        save_base64_image(f"river-partial-{idx}.png", event.partial_image_b64)
    elif event.type == "response.completed":
        image_data = [
            output.result
            for output in event.response.output
            if output.type == "image_generation_call"
        ]

        if image_data:
            save_base64_image("river-final.png", image_data[0])

Résultat

Première image partielle Deuxième image partielle Image finale
Première image partielle Deuxième image partielle Image finale

Prompt : Dessine une magnifique rivière de plumes blanches de hibou qui serpente dans un paisible paysage d’hiver.

Prompt révisé

Lorsque vous utilisez l’outil de génération d’images de l’API Responses, le modèle principal (par exemple gpt-5.5) révise automatiquement votre prompt pour améliorer les résultats.

Vous trouverez le prompt révisé dans le champ revised_prompt de l’appel de génération d’images.

Réponse contenant le prompt révisé
{
  "id": "ig_123",
  "type": "image_generation_call",
  "status": "completed",
  "revised_prompt": "A gray tabby cat hugging an otter. The otter is wearing an orange scarf. Both animals are cute and friendly, depicted in a warm, heartwarming style.",
  "result": "..."
}

Modification d’images

Le point de terminaison de modification d’images permet de :

  • modifier des images existantes ;
  • générer de nouvelles images à partir d’images de référence ;
  • modifier certaines parties d’une image en envoyant l’image et un masque qui délimite les zones à remplacer.

Création d’une image à partir d’images de référence

Vous pouvez utiliser une ou plusieurs images de référence pour en générer une nouvelle.

Dans cet exemple, nous utilisons quatre images en entrée pour générer une image de panier cadeau contenant les articles représentés sur les images de référence.

Lait pour le corpsSavonCoffret d’encensBombe de bain
Coffret cadeau pour le bain

Avec l’API Responses, vous pouvez fournir des images en entrée de trois façons :

  • Indiquez l’URL complète de l’image.
  • Fournissez une URL de données contenant l’image encodée en Base64.
  • Indiquez l’identifiant d’un fichier créé avec l’API Files.

Créez un fichier

Créez un fichier
from openai import OpenAI

client = OpenAI()


def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(
            file=file_content,
            purpose="vision",
        )
        return result.id

Créez une image encodée en Base64

Créez une image encodée en Base64
import base64


def encode_image(file_path):
    with open(file_path, "rb") as f:
        base64_image = base64.b64encode(f.read()).decode("utf-8")
    return base64_image
Modifiez une image
from openai import OpenAI
import base64

client = OpenAI()


def encode_image(file_path):
    with open(file_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(file=file_content, purpose="vision")
    return result.id


prompt = """Generate a photorealistic image of a gift basket on a white background
labeled 'Relax & Unwind' with a ribbon and handwriting-like font,
containing all the items in the reference pictures."""

base64_image1 = encode_image("body-lotion.png")
base64_image2 = encode_image("soap.png")
file_id1 = create_file("bath-bomb.png")
file_id2 = create_file("incense-kit.png")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": prompt},
                {
                    "type": "input_image",
                    "image_url": f"data:image/png;base64,{base64_image1}",
                },
                {
                    "type": "input_image",
                    "image_url": f"data:image/png;base64,{base64_image2}",
                },
                {
                    "type": "input_image",
                    "file_id": file_id1,
                },
                {
                    "type": "input_image",
                    "file_id": file_id2,
                },
            ],
        }
    ],
    tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],
)

image_generation_calls = [
    output for output in response.output if output.type == "image_generation_call"
]

image_data = [output.result for output in image_generation_calls]

if image_data:
    image_base64 = image_data[0]
    with open("gift-basket.png", "wb") as f:
        f.write(base64.b64decode(image_base64))
else:
    print(response.output_text)

Retouches guidées par des annotations

Utilisez le point de terminaison POST /v1/images/edits de l’API Image pour guider les retouches à l’aide d’annotations avec les modèles GPT-Image-2.5 et GPT-Image-2.6 compatibles. Pour retoucher une zone précise avec l’API Responses, utilisez un masque. Indiquez la zone à modifier sur un calque d’annotations et décrivez la modification dans prompt.

Pour suivre cet exemple, téléchargez la photo de la cuisine et le calque transparent dans le même répertoire. Le cercle tracé sur le calque entoure le vase dont vous allez changer la couleur.

Modifier le vase entouré avec l’API Image
import base64
from pathlib import Path

from openai import OpenAI

client = OpenAI()
overlay = Path("markup-vase-overlay-gpt-image-2-6.png")
with open("kitchen.webp", "rb") as image, overlay.open("rb") as markup:
    result = client.images.edit(
        model="gpt-image-2.6-flare",
        image=("kitchen.webp", image, "image/webp"),
        markup=(overlay.name, markup, "image/png"),
        quality="medium",
        prompt=(
            "Recolor the striped vase inside the red circle to solid cobalt blue ceramic. "
            "Keep its shape, the dried stems, and the rest of the kitchen unchanged. "
            "Remove the red circle from the finished photo."
        ),
    )

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

Photo avec le calque d’annotations

Résultat avec Flare

  1. Gardez l’image d’origine en première position parmi les images d’entrée.
  2. Créez un fichier PNG transparent distinct contenant vos cercles, croquis ou autres annotations. Une fois l’orientation appliquée, le calque d’annotations et la première image doivent avoir la même largeur et la même hauteur. Le PNG doit contenir des pixels transparents. Ne le fusionnez pas avec l’image d’origine.
  3. Envoyez le calque d’annotations dans markup. Dans une requête multipart, vous pouvez transmettre directement le fichier. Dans une requête JSON, fournissez un objet contenant exactement un des deux champs image_url ou file_id. Le champ image_url accepte une URL HTTPS ou une URL de données en base64. Dans les requêtes de modification au format JSON, utilisez images pour le tableau des images d’entrée.
  4. Décrivez la modification souhaitée et les détails à préserver. Vérifiez le résultat avant de l’utiliser.

Les annotations s’appliquent à la première image d’entrée. Les images supplémentaires servent de références. La première image et le calque d’annotations peuvent contenir au maximum 16 777 216 pixels chacun. La taille du fichier d’annotations est également limitée à 50 Mo. Ne combinez pas markup avec mask.

Modification d’une image à l’aide d’un masque

Fournissez un masque pour indiquer quelle partie de l’image modifier.

Lorsque vous utilisez un masque avec GPT Image, le modèle reçoit des instructions supplémentaires pour guider la retouche.

Avec GPT Image, le masquage repose entièrement sur le prompt. Le modèle se sert du masque comme repère, mais peut s’écarter de ses contours exacts.

Si vous fournissez plusieurs images en entrée, le masque s’applique à la première.
Modifier une image à l’aide d’un masque
from openai import OpenAI
import base64

client = OpenAI()


def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(file=file_content, purpose="vision")
    return result.id


fileId = create_file("sunlit_lounge.png")
maskId = create_file("mask.png")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "generate an image of the same sunlit indoor lounge area with a pool but the pool should contain a flamingo",
                },
                {
                    "type": "input_image",
                    "file_id": fileId,
                },
            ],
        },
    ],
    tools=[
        {
            "type": "image_generation",
            "model": "gpt-image-2.5-sunburst",
            "quality": "high",
            "input_image_mask": {
                "file_id": maskId,
            },
        },
    ],
)

image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    image_base64 = image_data[0]
    with open("lounge.png", "wb") as f:
        f.write(base64.b64decode(image_base64))
Image Masque Résultat
Une pièce rose avec une piscine Un masque couvrant une partie de la piscine La piscine d’origine avec un flamant rose gonflable à la place du masque

Prompt : un espace de détente intérieur baigné de soleil, avec un flamant rose dans la piscine

Contraintes du masque

L’image à modifier et le masque doivent avoir le même format et les mêmes dimensions. Chaque fichier doit peser moins de 50 Mo.

L’image du masque doit aussi comporter un canal alpha. Si vous créez le masque dans un logiciel de retouche, veillez à l’enregistrer avec un canal alpha.

Vous pouvez ajouter un canal alpha à une image en noir et blanc par programmation.

Ajouter un canal alpha à un masque en noir et blanc
from PIL import Image
from io import BytesIO

# 1. Load your black & white mask as a grayscale image
mask = Image.open("mask.png").convert("L")

# 2. Convert it to RGBA so it has space for an alpha channel
mask_rgba = mask.convert("RGBA")

# 3. Then use the mask itself to fill that alpha channel
mask_rgba.putalpha(mask)

# 4. Convert the mask into bytes
buf = BytesIO()
mask_rgba.save(buf, format="PNG")
mask_bytes = buf.getvalue()

# 5. Save the resulting file
img_path_mask_alpha = "mask_alpha.png"
with open(img_path_mask_alpha, "wb") as f:
    f.write(mask_bytes)

Personnalisation de l’image de sortie

Vous pouvez configurer les options de sortie suivantes :

  • Dimensions : largeur et hauteur de l’image (par exemple 1024x1024 ou 1024x1536).
  • Qualité : qualité du rendu (par exemple low, medium ou high).
  • Format : format du fichier de sortie.
  • Compression : taux de compression (de 0 à 100 %) pour les formats JPEG et WebP.
  • Arrière-plan : transparent, opaque ou choisi automatiquement.

Les paramètres size, quality et background acceptent l’option auto, qui laisse le modèle choisir la valeur la plus adaptée au prompt.

Dimensions et qualité

Les modèles gpt-image-2.5-sunburst et gpt-image-2.5-flare ajoutent les niveaux de qualité xhigh et max. Tous deux utilisent auto par défaut. Les modèles GPT Image antérieurs acceptent des niveaux de qualité allant jusqu’à high.

Paramètre Options
Dimensions recommandées 1024x1024 (carré), 1536x1024 (paysage), 1024x1536 (portrait)
Qualité low, medium, high, xhigh, max, auto

Les deux modèles acceptent également des dimensions personnalisées sous forme de chaînes au format WIDTHxHEIGHT, par exemple 1536x864. La largeur et la hauteur doivent être des multiples de 16 et ne doivent pas dépasser 3 840 pixels chacune. Le rapport largeur/hauteur doit être compris entre 1:3 et 3:1. Le nombre total de pixels doit être compris entre 655 360 et 8 294 400 (4K). Les résolutions supérieures à 2560x1440 sont expérimentales.

Pour obtenir un arrière-plan transparent avec l’un ou l’autre modèle, indiquez background: "transparent" et utilisez output_format: "png" ou "webp".

Utilisez quality: "low" pour produire rapidement des ébauches. Pour les images finales, comparez les niveaux de qualité supérieurs afin de trouver le bon équilibre entre niveau de détail, latence et coût.

Format de sortie

L’API Image renvoie les données de l’image encodées en base64. Le format par défaut est png, mais vous pouvez aussi demander jpeg ou webp.

Avec jpeg ou webp, le paramètre output_compression permet de régler le taux de compression de 0 à 100 %. Par exemple, output_compression=50 applique une compression de 50 % à l’image.

Le format jpeg est plus rapide que le format png. Privilégiez-le si la latence est un critère important.

Génération d’images SVG

Indiquez output_format: "svg" dans votre requête POST /v1/images/generations. Utilisez le format SVG pour les éléments graphiques dont vous souhaitez pouvoir modifier les tracés, les formes et les couleurs, comme les icônes et les illustrations.

Réglez n sur 1. Le format de sortie SVG ne prend en charge ni la diffusion en continu, ni les images partielles, ni output_compression. Le point de terminaison de modification d’images ne produit pas de SVG et n’accepte pas de fichier SVG comme image matricielle en entrée.

L’API crée une image de référence, puis l’utilise pour produire le SVG. Le paramètre quality règle la qualité de cette image de référence. Décodez la valeur en base64 de data[0].b64_json et enregistrez les octets obtenus, qui représentent du XML en UTF-8, dans un fichier portant l’extension .svg. Le document renvoyé contient des éléments vectoriels statiques. Il ne prend en charge ni les scripts, ni les ressources externes, ni les images matricielles intégrées.

Flare et Sunburst ont généré ces logos SVG à partir du même prompt demandant un logo pour la boulangerie Field & Flour.

GPT-Image-2.6 Flare

GPT-Image-2.6 Sunburst

Génération de GIF animés

Indiquez output_format: "gif" dans votre requête POST /v1/images/generations ou POST /v1/images/edits. Dans votre prompt, décrivez le sujet, le mouvement et la boucle souhaitée. Pour guider l’animation à l’aide d’images de référence fixes, envoyez ces images au point de terminaison de modification d’images.

Pour obtenir un GIF avec l’un ou l’autre point de terminaison, utilisez les champs de requête suivants :

Champ Valeurs Valeur par défaut
frame_count De 2 à 16 images 9
frame_duration_ms De 20 à 2 000 millisecondes par image, avec un arrondi au multiple de 10 ms le plus proche 200
size auto ou WIDTHxHEIGHT, avec une largeur et une hauteur strictement positives, multiples de 16 auto

size indique les dimensions de chaque image de l’animation finale. Le nombre d’images, leurs dimensions et le nombre d’animations doivent respecter les limites de taille du modèle et le nombre total de pixels autorisé par requête. Si la requête dépasse ces limites, réduisez frame_count, les dimensions des images ou n. Utilisez auto pour laisser l’API choisir des dimensions compatibles avec les limites du modèle.

La réponse contient l’animation finale. Pour chaque résultat, décodez la valeur en base64 du champ b64_json et enregistrez les octets obtenus dans un fichier portant l’extension .gif. Le format de sortie GIF ne permet ni la diffusion en continu, ni les images partielles, ni le réglage de output_compression. Utilisez frame_count et frame_duration_ms uniquement pour une sortie au format GIF.

Sunburst a généré cette animation de lanterne avec frame_count=9 et frame_duration_ms=200. Le singe reprend sa pose initiale au bout de 1,8 seconde.

Limites

Les modèles GPT Image sont des modèles de génération d’images puissants et polyvalents, mais présentent encore certaines limites.

  • Latence : le traitement d’un prompt complexe peut prendre jusqu’à deux minutes.
  • Rendu du texte : malgré des progrès importants, le modèle peut encore avoir du mal à placer le texte avec précision et à le rendre lisible.
  • Cohérence : le modèle peut produire des images cohérentes, mais l’apparence d’un personnage récurrent ou d’un élément de marque peut parfois varier d’une génération à l’autre.
  • Maîtrise de la composition : le modèle suit mieux les instructions, mais peut avoir du mal à placer précisément les éléments lorsque la composition obéit à une structure ou à une mise en page particulière.

Modération du contenu

Tous les prompts et toutes les images générées sont filtrés conformément à notre politique d’utilisation.

Pour la génération d’images avec les modèles GPT Image, le paramètre moderation permet de régler le niveau de filtrage. Il accepte deux valeurs.

  • auto (par défaut) : filtrage standard visant à limiter la création de certaines catégories de contenus potentiellement inadaptés à l’âge du public.
  • low : filtrage moins restrictif.

Gestion des requêtes bloquées et des autres erreurs

Traitez les échecs de génération d’images comme les autres erreurs de l’API. Vérifiez le code de statut HTTP ou le type d’exception du SDK, consignez l’identifiant de la requête et consultez le guide des codes d’erreur en cas d’échec d’authentification, de dépassement de quota ou de limite de débit, ou d’erreur serveur. Pour les erreurs temporaires de limite de débit ou de serveur, réessayez en espaçant progressivement les tentatives. Ne relancez pas automatiquement une requête en cas d’erreur de quota ou d’erreur de génération d’images qui exige que l’utilisateur modifie la requête.

Certaines erreurs de génération d’images peuvent être corrigées par l’utilisateur. L’API peut alors renvoyer error.type = "image_generation_user_error". Dans ce cas, ne relancez pas automatiquement la requête sans modifier le prompt ou les images d’entrée. Pour distinguer ces erreurs dans votre code, utilisez le champ stable error.code.

Lorsque error.code = "moderation_blocked", l’erreur peut aussi inclure un objet facultatif error.moderation_details.

{
  "error": {
    "type": "image_generation_user_error",
    "code": "moderation_blocked",
    "moderation_details": {
      "moderation_stage": "input",
      "categories": ["harassment"]
    }
  }
}

L’objet moderation_details fournit des indications générales pour le débogage sans exposer les libellés ni les scores des classificateurs internes.

Le champ moderation_stage peut prendre les valeurs suivantes :

  • input : le blocage provient du prompt ou des données d’entrée de la requête.
  • output : le blocage provient d’une image générée ou d’une étape ultérieure de modération des sorties.
  • unknown : valeur de repli utilisée dans les rares cas où l’origine du blocage est difficile à déterminer.

Le champ categories contient des libellés publics correspondant à de grandes catégories. Vous pouvez par exemple y trouver harassment, self-harm, sexual ou violence.

Dans la plupart des applications, gardez le message principal destiné à l’utilisateur suffisamment général. Utilisez moderation_details dans les journaux de développement, les workflows d’assistance et les analyses, ou pour suggérer des corrections simples.

Gérer les erreurs de génération d’images bloquées par la modération
import OpenAI from "openai";

const openai = new OpenAI();

try {
  // The same error handling pattern applies to image generation requests,
  // image edits, and Responses API tool calls that generate images.
  await openai.images.generate({
    model: "gpt-image-2.5-sunburst",
    prompt: "Create a poster humiliating my coworker with insulting captions",
  });
} catch (error) {
  if (error?.code !== "moderation_blocked") {
    throw error;
  }

  const moderationDetails = error.error?.moderation_details;
  const categories = moderationDetails?.categories ?? [];
  const stage = moderationDetails?.moderation_stage;

  let hint =
    "This request could not be completed because it did not meet safety requirements.";

  if (categories.includes("harassment")) {
    hint =
      "Try removing abusive or targeting language and focus on neutral visual details instead.";
  } else if (stage === "input") {
    hint =
      "Try revising the prompt or input images and submit the request again.";
  } else if (stage === "output") {
    hint =
      "The generated result was blocked by a safety check. Try changing the prompt and generating again.";
  }

  console.error("Image generation blocked", {
    request_id: error?.requestID,
    code: error?.code,
    moderation_details: moderationDetails,
  });

  console.log(hint);
}

Modèles compatibles

Dans l’API Responses, gpt-5 et les modèles plus récents devraient prendre en charge l’outil de génération d’images. Consultez la fiche de votre modèle pour vérifier sa compatibilité avec cet outil.

Coût et latence

Coûts de GPT-Image-2.6

Les images en sortie coûtent 30 $ par million de tokens facturables. Utilisez le calculateur pour estimer le coût de sortie d’une image.

Consultez les tarifs de génération d’images pour connaître les prix par million de tokens de texte et d’image.

Les retouches guidées par des annotations sont facturées au même tarif par token que les autres retouches, sans supplément. Pour une sortie SVG, l’image de référence est facturée au tarif du modèle de génération d’images. Les tokens que le modèle de rédaction utilise pour produire le SVG sont facturés au tarif de ce dernier. Le coût total dépend du nombre de tokens consommés par chaque modèle.

Coûts de GPT-Image-2.5

Pour les requêtes envoyées à l’API Responses, le coût des tokens consommés par le modèle principal s’ajoute au coût de génération des images.

Les deux modèles GPT-Image-2.5 appliquent les mêmes tarifs par million de tokens : 8 $ pour les images en entrée, 2 $ pour les images en entrée mises en cache, 30 $ pour les images en sortie, 5 $ pour le texte en entrée et 1,25 $ pour le texte en entrée mis en cache. Consultez la grille tarifaire.

Utilisez le champ usage de la réponse pour mesurer la consommation de tokens selon vos prompts, les dimensions et la qualité choisies. Même si le tarif par token est identique, le coût par image peut varier, car la consommation de tokens dépend du modèle et du niveau de qualité. Pour des exemples de tarifs des modèles antérieurs, consultez la section Modèles GPT Image antérieurs.

Tarification des entrées mises en cache

Pour GPT-Image-2 et GPT-Image-2.5, le tarif des entrées mises en cache s’applique uniquement à l’outil de génération d’images de l’API Responses. Il ne s’applique pas aux requêtes envoyées directement à l’API Images, y compris à /v1/images/edits.

La facturation tient compte des entrées de génération d’images mises en cache, mais l’API Responses ne renvoie pas le nombre de tokens correspondants. Le champ usage de la réponse ne permet donc pas de vérifier si ces entrées ont été lues depuis le cache.

Calcul des coûts

Sélectionnez un modèle, un niveau de qualité et des dimensions pour estimer le nombre de tokens de sortie et le coût de l’image produite. Pour les modèles Sunburst et Flare des familles GPT-Image-2.6 et GPT-Image-2.5, les niveaux de qualité disponibles sont low, medium, high, xhigh et max. Pour gpt-image-2, les options sont low, medium et high. À qualité égale, les modèles peuvent consommer des nombres de tokens différents, mais le tarif par token d’image en sortie est identique. Pour cette estimation, indiquez des valeurs explicites de qualité et de dimensions. Avec auto, le résultat dépend de l’image générée.

Modèle
Qualité
Tokens de sortie
823
Coût estimé par image générée
0,02469 $US

Par image, au tarif de 30 USD par million de tokens d’image en sortie. L’estimation exclut les tokens de texte et d’image en entrée ainsi que les images partielles diffusées en streaming.

Coût des images partielles

Si vous souhaitez diffuser la génération d’images en continu avec le paramètre partial_images, chaque image partielle coûte 100 tokens d’image en sortie supplémentaires.

Modèles GPT Image antérieurs

Les informations ci-dessous concernent les modèles antérieurs à Sunburst et Flare. Pour les nouvelles intégrations, utilisez GPT-Image-2.6 Sunburst ou Flare.

Paramètres de GPT-Image-2 et fidélité aux images d’entrée

Avec gpt-image-2, le paramètre size accepte toute résolution qui respecte les contraintes ci-dessous. Les images carrées sont généralement les plus rapides à générer.

Dimensions courantes

  • 1024x1024 (carré)

  • 1536x1024 (paysage)

  • 1024x1536 (portrait)

  • 2048x2048 (carré 2K)

  • 2048x1152 (paysage 2K)

  • 3840x2160 (paysage 4K)

  • 2160x3840 (portrait 4K)

  • auto (par défaut)

Contraintes de dimensions

  • La longueur du plus grand côté doit être inférieure ou égale à 3840px

  • La largeur et la hauteur doivent être des multiples de 16px

  • Le rapport entre le côté le plus long et le côté le plus court ne doit pas dépasser 3:1

  • Le nombre total de pixels doit être au moins égal à 655,360 et ne pas dépasser 8,294,400

Niveaux de qualité
  • low
  • medium
  • high

  • auto (par défaut)

Fidélité aux images d’entrée

Le paramètre input_fidelity détermine dans quelle mesure le modèle préserve les détails des images d’entrée lors des retouches et de la génération à partir d’images de référence. Pour gpt-image-2, omettez ce paramètre. L’API ne permet pas de le modifier, car le modèle traite automatiquement chaque image d’entrée en haute fidélité.

Comme gpt-image-2 traite toujours les images d’entrée en haute fidélité, les requêtes de modification qui incluent des images de référence peuvent consommer davantage de tokens d’image en entrée. Pour évaluer l’incidence sur le coût, consultez la section sur les coûts du traitement des images.

Exemples de tarifs des modèles antérieurs

Modèles antérieurs à gpt-image-2

Pour générer des images, les modèles GPT Image antérieurs à gpt-image-2 produisent d’abord des tokens spécialisés pour les images. La latence et le coût final sont proportionnels au nombre de tokens nécessaires au rendu. Une image plus grande ou un niveau de qualité supérieur nécessite davantage de tokens.

Le nombre de tokens générés dépend des dimensions et de la qualité de l’image.

Qualité Carré (1024×1024) Portrait (1024×1536) Paysage (1536×1024)
Faible 272 tokens 408 tokens 400 tokens
Moyenne 1 056 tokens 1 584 tokens 1 568 tokens
Élevée 4 160 tokens 6 240 tokens 6 208 tokens

Tenez également compte des tokens d’entrée, qui comprennent les tokens de texte du prompt et, pour les retouches, les tokens d’image des images fournies. Comme gpt-image-2 traite toujours les images d’entrée en haute fidélité, les requêtes de modification qui incluent des images de référence peuvent consommer davantage de tokens d’entrée.

Consultez la grille tarifaire pour connaître les tarifs actuels des tokens de texte et d’image. Utilisez la section Calcul des coûts pour estimer le coût des images en sortie.

Le coût final correspond à la somme des coûts suivants :

  • tokens de texte en entrée ;
  • tokens d’image en entrée si vous utilisez le point de terminaison de modification ;
  • tokens d’image en sortie.

Historique des coûts des images en sortie

gpt-image-2 accepte des milliers de résolutions. Pour faciliter la comparaison, le tableau présente les mêmes dimensions que pour les modèles GPT Image précédents. Il indique également les anciens tarifs de sortie par image pour GPT-Image-1.5, GPT-Image-1 et GPT-Image-1 Mini. Pour estimer le coût total d’une requête, tenez également compte des tokens de texte et d’image en entrée.

gpt-image-1 a été mis hors service le 23 octobre 2026. Ses tarifs figurent ci-dessous à titre de comparaison historique. Consultez l’avis de retrait pour connaître les modèles de remplacement.

À qualité égale, une image non carrée de résolution supérieure peut parfois produire moins de tokens de sortie qu’une image de résolution inférieure ou qu’une image carrée.

Modèle

Qualité

1024 × 10241024 × 15361536 × 1024

GPT-Image-2


Autres dimensions disponibles		Faible0,006 $0,005 $0,005 $
Moyenne0,053 $0,041 $0,041 $
Élevée0,211 $0,165 $0,165 $

GPT-Image-1.5

Faible0,009 $0,013 $0,013 $
Moyenne0,034 $0,05 $0,05 $
Élevée0,133 $0,2 $0,2 $

GPT-Image-1

Faible0,011 $0,016 $0,016 $
Moyenne0,042 $0,063 $0,063 $
Élevée0,167 $0,25 $0,25 $

GPT-Image-1 Mini

Faible0,005 $0,006 $0,006 $
Moyenne0,011 $0,015 $0,015 $
Élevée0,036 $0,052 $0,052 $