Blog

Comment utiliser l'API gpt-image-2 ?

Ashley Innocent

Ashley Innocent

22 April 2026

Comment utiliser l'API gpt-image-2 ?

Apidog pour les entreprises

Déploiement sur site

SSO & RBAC

Conforme SOC 2

Réserver une démo

L'API gpt-image-2 est le nouveau point d'accès de génération d'images d'OpenAI, lancé parallèlement à ChatGPT Images 2.0 le 21 avril 2026. Si vous utilisez déjà les API de chat ou d'embeddings d'OpenAI, l'ajout de la génération d'images ne nécessite qu'une nouvelle forme de requête, une clé API avec le bon champ d'application, et environ dix minutes.

Ce guide concerne strictement l'API : authentification, paramètres de requête, exemples de code en trois langues, mode de réflexion, génération par lots, gestion des réponses, codes d'erreur, limites de débit, et le flux de travail de test qui vous évite de gaspiller des crédits sur des invites défectueuses. Pour un aperçu au niveau produit des nouveautés de ChatGPT Images 2.0, consultez notre analyse de ChatGPT Images 2.0.

À la fin, vous aurez des appels fonctionnels, une collection Apidog réutilisable pour l'itération, et une idée claire du coût de chaque paramètre.

bouton

Prérequis

Avant votre première requête, vous avez besoin de quatre choses :

Définissez la clé une fois dans votre shell pour que tous les exemples de ce guide s'exécutent sans modifications :

export OPENAI_API_KEY="sk-proj-..."

Point d'accès et authentification

gpt-image-2 utilise le même point d'accès de génération d'images que le modèle précédent :

POST https://api.openai.com/v1/images/generations

L'authentification est un jeton porteur dans l'en-tête Authorization. Chaque requête contient également un corps JSON avec l'ID du modèle, l'invite et les paramètres de sortie.

curl https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "A sharp product hero image for an API testing platform, dark background",
    "size": "1024x1024",
    "n": 1,
    "quality": "high"
  }'

Si l'appel réussit, vous recevez un objet JSON avec un tableau data d'images. Les échecs renvoient une enveloppe d'erreur OpenAI standard avec un code et un message lisible par l'homme ; le tableau d'erreurs plus loin dans ce guide couvre les plus courants.

Paramètres de requête

Chaque champ du corps de la requête modifie ce que vous payez et ce que vous obtenez. Voici la carte complète des paramètres pour gpt-image-2.

Paramètre Type Valeurs Remarques
model chaîne gpt-image-2 Obligatoire.
prompt chaîne Jusqu'à 32 000 caractères Obligatoire. Les invites plus longues consomment plus de jetons d'entrée.
size chaîne 1024x1024, 1024x1536, 1536x1024, 2000x1000, 1000x2000, 2000x667, 667x2000 Détermine le nombre de jetons de sortie.
quality chaîne standard, high high coûte environ 2 fois plus mais gère les textes fins et les éléments d'interface utilisateur.
n entier 1–10 Les requêtes par lots partagent le style de l'ensemble.
thinking chaîne off, low, medium, high Budget de raisonnement avant le rendu.
response_format chaîne url, b64_json Les URL expirent en une heure.
user chaîne Forme libre Utilisé pour la détection des abus ; passez un ID utilisateur haché.
background chaîne auto, transparent, opaque La sortie transparente est un PNG avec canal alpha.
seed entier N'importe quel int32 Contrôle lâche ; même seed plus même invite est proche, pas identique.

Les trois paramètres qui modifient le plus le coût sont size, quality et thinking. Une image de haute qualité (high) de 2000 pixels de large avec thinking: "high" peut coûter 4 à 5 fois plus qu'un rendu de base 1024x1024 standard.

Exemple Python

Le SDK officiel (openai>=1.50.0) ajoute un support natif pour gpt-image-2 :

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI()

response = client.images.generate(
    model="gpt-image-2",
    prompt=(
        "A minimalist diagram of an OAuth 2.1 authorization code flow with PKCE. "
        "Five boxes labeled in English: User, Client, Auth Server, Resource Server, Token. "
        "Sharp sans-serif text, off-white background, teal accent arrows."
    ),
    size="1536x1024",
    quality="high",
    n=2,
    thinking="medium",
    response_format="b64_json",
)

out_dir = Path("out")
out_dir.mkdir(exist_ok=True)

for i, image in enumerate(response.data):
    png_bytes = base64.b64decode(image.b64_json)
    (out_dir / f"oauth_{i}.png").write_bytes(png_bytes)

print(f"Généré {len(response.data)} images dans {out_dir.resolve()}")

Deux points à noter :

Exemple Node.js / TypeScript

import fs from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.images.generate({
  model: "gpt-image-2",
  prompt:
    "Dashboard UI mockup for a REST client, sentence-case labels, latency sparkline in the top-right, cool grey palette.",
  size: "1536x1024",
  quality: "high",
  n: 4,
  thinking: "medium",
  response_format: "b64_json",
});

await Promise.all(
  response.data.map(async (image, i) => {
    if (!image.b64_json) return;
    await fs.writeFile(`dash_${i}.png`, Buffer.from(image.b64_json, "base64"));
  }),
);

console.log(`Enregistré ${response.data.length} images`);

Utilisez le SDK officiel plutôt que fetch brut, à moins d'avoir une bonne raison de ne pas le faire. Le SDK gère les tentatives, les en-têtes d'idempotence et le streaming, et il suit les modifications de schéma majeures entre les révisions de modèle.

Mode de réflexion : quand l'utiliser

thinking contrôle la quantité de calcul que le modèle consacre à la planification de la mise en page avant le rendu. Quatre valeurs, approximativement :

Une règle pratique : si l'invite contient un nombre, une étiquette ou une contrainte de position, passez au niveau supérieur. Si elle dit simplement "une scène chaleureuse", descendez d'un niveau.

Le mode de réflexion ajoute des jetons de raisonnement à la facture en plus des jetons de sortie d'image. La page de tarification d'OpenAI liste les tarifs actuels par jeton ; prévoyez un budget de 1,2 à 2 fois le coût de votre image de base lorsque medium ou high est activé.

Génération par lots

Définir n > 1 renvoie plusieurs images dans une seule réponse qui partagent la composition et le style. Ce n'est pas la même chose qu'appeler le point d'accès n fois en parallèle ; cela vous donnerait quatre images sans rapport. La sortie par lots est cohérente, ce qui correspond à la façon dont une équipe de conception itère.

response = client.images.generate(
    model="gpt-image-2",
    prompt="Four different hero illustrations for an API documentation landing page, shared color palette, shared line weight.",
    size="1536x1024",
    quality="high",
    n=4,
    thinking="low",
)

Vous payez par image, donc n=4 coûte environ 4 fois n=1. L'avantage est la cohérence, pas le débit.

Format de réponse et stockage

Deux formats, deux cas d'utilisation :

Pour la production, téléchargez l'URL et téléchargez-la immédiatement sur votre propre bucket S3, R2 ou Cloudflare Images. Ne livrez pas d'URL OpenAI aux utilisateurs finaux ; elles expirent.

Gestion des erreurs et limites de débit

gpt-image-2 renvoie des formats d'erreur OpenAI standards. Voici ceux que vous rencontrerez :

HTTP code Cause Correction
400 invalid_request_error Mauvaise taille, rapport non supporté, invite de plus de 32k caractères Vérifiez la liste des tailles et raccourcissez l'invite.
401 invalid_api_key Clé manquante ou incorrecte Ré-exportez OPENAI_API_KEY.
403 insufficient_quota Pas de crédits, ou niveau Gratuit Ajoutez la facturation, vérifiez le niveau.
429 rate_limit_exceeded Trop de requêtes par minute Faites une pause avec jitter ; réessayez avec Retry-After.
429 image_generation_user_error Refus de politique de contenu Reformulez l'invite.
500 server_error Problème OpenAI transitoire Réessayez deux fois avec une temporisation exponentielle.
503 overloaded Pic d'utilisation régional Attendez et réessayez.

Les limites de débit sur gpt-image-2 sont basées sur les niveaux. Au niveau 1, vous commencez à environ 50 requêtes par minute ; les niveaux supérieurs augmentent. Lisez toujours les en-têtes x-ratelimit-remaining-requests et x-ratelimit-remaining-tokens sur chaque réponse et ralentissez avant d'atteindre la limite.

Erreurs re-tentables en production :

import time
from openai import OpenAI, RateLimitError, APIStatusError

client = OpenAI()

def generate_with_retry(prompt: str, tries: int = 3):
    delay = 1.0
    for attempt in range(tries):
        try:
            return client.images.generate(
                model="gpt-image-2",
                prompt=prompt,
                size="1024x1024",
                quality="high",
                n=1,
            )
        except RateLimitError:
            time.sleep(delay)
            delay *= 2
        except APIStatusError as e:
            if 500 <= e.status_code < 600 and attempt < tries - 1:
                time.sleep(delay)
                delay *= 2
                continue
            raise
    raise RuntimeError("gpt-image-2 retries exhausted")

Ne réessayez pas les erreurs 400, 401 ou les 429 de politique de contenu ; celles-ci échouent pour une raison et réessayer gaspille des crédits.

Tester l'API avec Apidog

L'itération sur les invites de génération d'images depuis un terminal est lente : vous ne pouvez pas voir le résultat, ni comparer les changements de paramètres, ni versionner les bonnes invites. Un client API dédié résout ces trois problèmes.

Apidog traite le point d'accès gpt-image-2 comme une requête de première classe. Flux de travail typique :

  1. Créez une nouvelle requête dans votre collection OpenAI, méthode POST, URL https://api.openai.com/v1/images/generations.
  2. Ajoutez Authorization: Bearer {{OPENAI_API_KEY}} comme en-tête ; définissez OPENAI_API_KEY dans une variable d'environnement afin qu'elle ne figure jamais dans le code source.
  3. Collez le corps JSON avec votre invite ; Apidog valide par rapport à la spécification OpenAPI et signale les incohérences de type avant l'envoi.
  4. Cliquez sur Envoyer. Les réponses d'images s'affichent en ligne ; enregistrez les bonnes, étiquetez les mauvaises, dupliquez la requête pour des variantes.
  5. Enregistrez des environnements pour thinking: off, thinking: medium et thinking: high afin de comparer la même invite sur différents niveaux de raisonnement.

La comparaison des requêtes d'Apidog est la partie la plus importante ici. Vous ajustez un paramètre ; vous voyez l'image avant et après côte à côte ; vous enregistrez le résultat gagnant dans une bibliothèque d'invites que toute votre équipe partage. C'est le flux de travail que le terminal ne peut pas vous offrir.

Si vous venez d'un client HTTP générique ou d'un espace de travail Postman corrompu, Téléchargez Apidog et configurez-le avec votre clé OpenAI ; l'installation prend moins de cinq minutes. Les équipes évaluant des alternatives peuvent également lire notre guide de test d'API sans Postman et l'aperçu de l'extension Apidog pour VS Code.

Pièges courants

Quelques erreurs courantes gaspillent des crédits et du temps la première semaine avec gpt-image-2.

FAQ

En quoi gpt-image-2 diffère-t-il de gpt-image-1 au niveau de l'API ? Même point d'accès, même authentification. Nouveaux paramètres : thinking (off/low/medium/high), valeurs size supplémentaires jusqu'à 2000 px, et n jusqu'à 10 avec un style partagé. Les intégrations SDK existantes continuent de fonctionner après un changement d'ID de modèle ; vous n'ajoutez les nouveaux paramètres que là où ils sont utiles. Pour la différence complète, consultez l'aperçu de ChatGPT Images 2.0.

Quelle est la manière la plus rapide de prototyper une intégration `gpt-image-2` ? Créez une requête dans Apidog, enregistrez deux environnements (standard vs thinking), et itérez sur les invites sans toucher au code. Exportez la requête finale en tant que code curl ou SDK lorsque vous êtes prêt à valider.

L'API prend-elle en charge l'édition ou l'inpainting d'images ? Les points d'accès d'édition et de variation suivent le même modèle que la génération précédente sous le nouvel ID de modèle. Consultez la référence du modèle gpt-image-2 pour le schéma le plus récent ; les paramètres pour les masques et les images d'entrée y sont documentés.

Puis-je utiliser `gpt-image-2` pour une production commerciale ? Oui, selon les politiques d'utilisation standard d'OpenAI. Vous possédez les images générées ; OpenAI conserve le droit d'utiliser les entrées et les sorties pour la surveillance des abus. Les personnages sous marque déposée et les personnalités publiques nommées déclenchent toujours les garde-fous.

Quel est le coût pour une charge de travail de production ? À environ 0,21 $ par image de haute qualité 1024×1024 en mode standard, 10 000 images par mois coûtent environ 2 100 $ sans le mode de réflexion. Ajoutez 20 à 80 % pour le mode de réflexion. Comparez cela avec des alternatives auto-hébergées comme notre guide de l'API GLM 5V Turbo et l'intégration Qwen 3.5 Omni si le budget est plus important que la qualité maximale.

Existe-t-il une alternative moins chère avec un rendu de texte similaire ? Pas encore à la même qualité pour le texte multilingue. Les modèles open-weight ont comblé l'écart en matière de composition mais restent en retard sur les écritures CJK et indiennes.

bouton

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger