API GPT Image 2.6 Flare : Génération, édition et tarification

À quoi sert Flare

Flare est conçu pour les ébauches rapides, les prévisualisations fréquentes et les révisions interactives. Parmi les usages pratiques, on trouve l'exploration d'arrière-plans pour des photos de produits, le test de compositions de campagnes et la génération de plusieurs directions visuelles avant d'en choisir une pour la finalisation. GPT Image 2.6 Sunburst est l'alternative axée sur les détails et la cohérence au sein de la même famille. Il ne s'agit pas simplement d'un « mode illustration », et Flare ne se limite pas au photoréalisme. Comparez-les sur les détails qui déterminent l'approbation : fidélité des étiquettes, mise en page, préservation d'un sujet approuvé et nombre de révisions nécessaires. Utilisez le catalogue de modèles pour vérifier la disponibilité actuelle. Un compte partagé ne rend pas identiques les entrées, les routes de tâches ou les paramètres de sortie de chaque modèle.

Configurez votre clé API

Créez une clé dans le tableau de bord des clés API GPT Proto, puis rendez-la disponible pour votre application côté serveur :

export GPTPROTO_API_KEY="votre_clé_api_ici"

Gardez la clé hors du code du navigateur et du contrôle de version. Chargez-la à partir d'une variable d'environnement ou du coffre-fort de secrets de votre déploiement. Si vous utilisez un fichier local .env, excluez ce fichier des commits. Pour ce guide, l'origine de l'API est https://gptproto.com. Les chemins de génération et d'édition ci-dessous contiennent déjà /api/v3 ; n'ajoutez pas /v1 au début et ne substituez pas une URL de base de chat-completions. Une requête réussie de liste de modèles ne prouve pas qu'une route d'image peut terminer une tâche. Vérifiez le flux complet de soumission et de résultat avec une petite requête avant d'ajouter le traitement par lots.

Générer une image

La route texte-vers-image de Flare publie ce point de terminaison :

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image

Commencez avec une image et des paramètres explicites afin que la requête soit facile à inspecter :

curl --request POST \
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image" \
  --header "Authorization: Bearer $GPTPROTO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "prompt": "Une photo de produit studio carrée d'une bouteille isotherme bleu marine mat sur un socle gris pâle. Éclairage latéral doux, arrière-plan blanc cassé chaud, espace pour du texte sur la gauche. Pas de texte.",
    "n": 1,
    "quality": "medium",
    "size": "1024x1024",
    "enable_sync_mode": false,
    "response_format": "url"
  }'

Le modèle est sélectionné par l'URL. Cette route publiée ne nécessite pas de champ model séparé, et size est optionnel plutôt qu'un troisième champ obligatoire.

Champs de requête

Récupérer le résultat

La soumission et la récupération des résultats utilisent une enveloppe contenant code, message et data. Un succès HTTP ne signifie pas nécessairement que la génération est terminée. Vérifiez le code au niveau métier ainsi que le statut de la prédiction.

GET https://gptproto.com/api/v3/predictions/{result_id}/result

Utilisez la même authentification Bearer lors du polling. Pour response_format: "url", les sorties terminées sont des URL de fichiers. Pour b64_json, le tableau de sortie documenté peut contenir des chaînes Base64. Aucun de ces cas n'utilise l'hypothèse native d'OpenAI data[0].b64_json pour cette route GPT Proto. Enregistrez les ressources que vous devez conserver, préservez leur type de média réel et ne vous fiez pas à une durée de vie d'URL hébergée non documentée.

Python : Soumettre et interroger

Installez requests dans votre environnement d'application. L'exemple suivant effectue une soumission, interroge l'URL de résultat renvoyée et affiche les URL de sortie une fois terminées. Le délai de cinq minutes est un délai d'expiration d'application utilisé dans cet exemple, et non une garantie de service.

import os
import time
from urllib.parse import urlparse
import requests
ORIGIN = "https://gptproto.com"
API_KEY = os.environ["GPTPROTO_API_KEY"]
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
def read_envelope(response):
    response.raise_for_status()
    body = response.json()
    if body.get("code") != 200:
        raise RuntimeError(f"GPT Proto request failed: {body.get('message')}")
    data = body.get("data")
    if not isinstance(data, dict):
        raise RuntimeError("Missing prediction data")
    return data
def submit_and_poll(scene, payload, timeout_seconds=300):
    if scene not in {"text-to-image", "image-edit"}:
        raise ValueError("Unsupported scene")
    endpoint = f"{ORIGIN}/api/v3/openai/gpt-image-2.6-flare/{scene}"
    response = requests.post(
        endpoint,
        headers={**HEADERS, "Content-Type": "application/json"},
        json=payload,
        timeout=(10, 120),
    )
    prediction = read_envelope(response)
    prediction_id = prediction.get("id")
    deadline = time.monotonic() + timeout_seconds
    while True:
        status = prediction.get("status")
        if status == "completed":
            outputs = prediction.get("outputs")
            if not isinstance(outputs, list) or not outputs:
                raise RuntimeError("Completed prediction has no outputs")
            return outputs
        if status == "failed":
            raise RuntimeError(
                f"Prediction {prediction_id} failed: {prediction.get('error')}"
            )
        if status not in {"created", "running"}:
            raise RuntimeError(f"Unexpected prediction status: {status}")
        if time.monotonic() >= deadline:
            raise TimeoutError(f"Check prediction {prediction_id} before resubmitting")
        result_url = prediction.get("urls", {}).get("get")
        parsed = urlparse(result_url or "")
        if (
            parsed.scheme != "https"
            or parsed.netloc != "gptproto.com"
            or not parsed.path.startswith("/api/v3/predictions/")
        ):
            raise RuntimeError("Unexpected result URL; check the route documentation")
        time.sleep(2)
        prediction = read_envelope(
            requests.get(result_url, headers=HEADERS, timeout=(10, 60))
        )
if __name__ == "__main__":
    outputs = submit_and_poll(
        "text-to-image",
        {
            "prompt": "A square product photo of a navy bottle on a pale plinth, soft side lighting, no text",
            "n": 1,
            "quality": "medium",
            "size": "1024x1024",
            "enable_sync_mode": False,
            "response_format": "url",
        },
    )
    for output_url in outputs:
        print(output_url)

Enregistrez le script sous flare_example.py si vous souhaitez réutiliser son assistant dans l'exemple d'édition ci-dessous. Il s'arrête intentionnellement en cas d'erreurs de requête plutôt que de soumettre à nouveau automatiquement une génération potentiellement facturable. Ajoutez une gestion des tentatives en production autour de l'opération appropriée après avoir vérifié si la prédiction originale existe.

Node.js : Soumettre une génération

Avec un environnement d'exécution Node.js actuel prenant en charge fetch et AbortSignal.timeout, vous pouvez soumettre le même JSON sans wrapper d'image spécifique au SDK. Enregistrez cet exemple dans un fichier .mjs :

const apiKey = process.env.GPTPROTO_API_KEY;
if (!apiKey) throw new Error("Définissez d'abord GPTPROTO_API_KEY");
const response = await fetch(
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      prompt: "A square product photo of a navy bottle, soft side lighting, no text",
      n: 1,
      quality: "medium",
      size: "1024x1024",
      enable_sync_mode: false,
      response_format: "url",
    }),
    signal: AbortSignal.timeout(120000),
  },
);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const body = await response.json();
if (body.code !== 200 || !body.data) {
  throw new Error(body.message || "La soumission de la prédiction a échoué");
}
console.log(JSON.stringify(body.data, null, 2));

Ceci affiche la prédiction, et non un fichier image finalisé. Utilisez sa valeur urls.get pour le polling authentifié et ne lisez les outputs qu'une fois que le statut devient completed, en suivant le flux de travail ci-dessus.

Modifier des images de référence

La route Flare image-edit est distincte de la génération :

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/image-edit

Elle accepte du JSON avec les champs obligatoires images et prompt. GPT Proto décrit images comme un tableau de chaînes et autorise jusqu'à 16 images de référence. Elle répertorie les mêmes paramètres de qualité, de taille, de synchronisation et de livraison que la route de génération. Préparez les images de référence via le flux de téléchargement pris en charge et inspectez la requête générée. Utilisez ces chaînes de référence dans images ; ne substituez pas un chemin de fichier local, un encodage Base64 arbitraire ou un champ multipart nommé image sans vérifier la représentation d'entrée attendue. Par exemple, stockez les chaînes de référence de ce flux sous forme de tableau JSON dans GPTPROTO_REFERENCE_IMAGES, puis réutilisez l'assistant Python :

import json
import os
from flare_example import submit_and_poll
references = json.loads(os.environ["GPTPROTO_REFERENCE_IMAGES"])
if (
    not isinstance(references, list)
    or not 1 <= len(references) <= 16
    or not all(isinstance(item, str) and item for item in references)
):
    raise ValueError("Fournissez 1 à 16 chaînes de référence valides issues du flux de téléchargement")
outputs = submit_and_poll(
    "image-edit",
    {
        "images": references,
        "prompt": "Replace only the tabletop with light oak. Preserve the bottle shape, printed label, camera angle, reflections, and shadow direction.",
        "n": 1,
        "quality": "medium",
        "size": "1024x1024",
        "enable_sync_mode": False,
        "response_format": "url",
    },
)
print(outputs)

Les masques et le balisage ne sont pas interchangeables

Le schéma d'édition actuel de GPT Proto ne répertorie pas les champs mask ou markup. N'envoyez pas de masque en noir et blanc ou de calque d'annotation transparent en supposant qu'ils seront interprétés comme une limite d'édition. OpenAI documente l'édition guidée par balisage dans son guide de génération d'images, mais la prise en charge en amont ne prouve pas que la route JSON de GPT Proto expose les mêmes contrôles. Pour cette route, commencez avec des entrées de référence prises en charge et une instruction d'édition précise. Comparez le résultat avec l'original, y compris les zones qui devaient rester inchangées.

Choisissez la qualité, la taille et la livraison séparément

Utilisez low pour des brouillons peu coûteux lorsque cela correspond au brief, puis comparez les paramètres medium et supérieurs pour les ressources finales. Il s'agit d'une recommandation de flux de travail, et non d'une garantie mesurée qu'un paramètre plus élevé produit toujours la meilleure image ou une latence particulière.

Le sélecteur de taille publié inclut des options carrées, paysage et portrait. Ses directives de dimension exigent des bords divisibles par 16, un bord maximum de 3 840 pixels, un rapport hauteur/largeur ne dépassant pas 3:1, et un nombre total de pixels compris entre 655 360 et 8 294 400. Commencez par les préréglages répertoriés plutôt que de supposer que toute largeur et hauteur personnalisée sera acceptée.

response_format contrôle la livraison : url ou b64_json. Il ne permet pas de sélectionner PNG, JPEG, WebP, GIF ou SVG. Le schéma de requête actuel de GPT Proto ne répertorie pas output_format, frame_count, frame_duration_ms, complexity, ou negative_prompt.

OpenAI documente des fonctionnalités supplémentaires, notamment la sortie SVG et GIF animé. Considérez-les comme des capacités en amont jusqu'à ce que la route GPT Proto que vous utilisez les expose explicitement. N'ajoutez pas de champs non documentés à la requête et ne décrivez pas ces formats comme des sorties confirmées de cette route.

Tarification et coût par image approuvée

Tarifs vérifiés le 8 novembre 2026, heure du Pacifique. La référence actuelle du modèle GPT Proto indique ces tarifs par jeton d'image ; les prix sont susceptibles de changer.

L'entrée de texte est facturée séparément. Vérifiez le tarif en vigueur et sa précision affichée avant d'estimer un travail complet. La page du modèle annonce actuellement des tarifs 5 % inférieurs au prix catalogue ; il s'agit d'une déclaration de prix spécifique au modèle, et non d'une remise garantie sur tous les modèles ou d'une économie fixe sur chaque image générée. À titre d'illustration, 1 000 jetons de sortie d'image facturables à 28,50 $ par million coûtent 0,0285 $. Il s'agit d'un exemple arithmétique couvrant uniquement la sortie, et non une prévision du nombre de jetons qu'une image particulière utilisera. L'entrée de texte, le traitement des images de référence et les générations répétées s'ajoutent au total.

La référence de route actuelle ne documente pas de champ usage dans son enveloppe de prédiction. Utilisez les informations de facturation disponibles pour votre compte ; ne construisez pas de rapports de coûts basés sur un champ de réponse non confirmé. Une qualité supérieure, des sorties plus grandes et des références supplémentaires peuvent modifier la consommation, mais aucun multiplicateur fixe ou prix d'image par palier n'est établi ici.

Suivez les dépenses totales divisées par les actifs approuvés pour comparer les flux de travail. Un brouillon moins cher qui nécessite plusieurs révisions peut coûter plus cher qu'un premier résultat de meilleure qualité. Commencez avec n: 1, utilisez les dimensions requises par l'emplacement et augmentez le volume uniquement après avoir vérifié à la fois la qualité de sortie et la facturation. Consultez la tarification GPT Proto pour connaître les conditions de paiement actuelles au niveau du compte.

Rédigez des prompts que vous pouvez évaluer

Décrivez l'actif, le sujet, la composition, l'éclairage, le style et les contraintes en langage clair. Pour une modification, séparez le changement demandé des détails qui doivent rester inchangés. Ne supposez pas qu'un ordre de mots fixe présente un avantage documenté en termes de pondération des jetons.

Campagne produit : « Créez une publicité de studio carrée pour une bouteille isotherme bleu marine mat. Placez-la sur le tiers droit sur un socle gris pâle. Laissez la moitié gauche libre pour le texte. Utilisez un éclairage latéral doux et un fond blanc cassé chaud. L'image ne doit contenir aucun texte. »

Révision ciblée : « Changez uniquement le plateau de la table pour du chêne clair. Gardez l'angle de la caméra, la forme de la bouteille, l'étiquette imprimée, les reflets et la direction de l'ombre inchangés. Accordez l'éclairage existant. »

Texte exact : « Créez une affiche d'événement portrait avec le titre 'NIGHT MARKET' écrit exactement comme indiqué. Utilisez un grand titre en haut, une photo de produit au centre et un espace libre en bas pour ajouter une date plus tard. »

Vérifiez le lettrage en taille réelle et inspectez le recadrage final. Une sortie visuellement convaincante peut toujours contenir une étiquette incorrecte ou une zone de texte inutilisable. Le guide de prompt GPT Image 2.5 fournit des exercices de prompting connexes ; ses exemples ne constituent pas une référence pour Flare 2.6.

Gérer les erreurs sans créer de tâches en double

Vérifiez à la fois la réponse HTTP et l'enveloppe de prédiction. L'acceptation de la requête, l'achèvement de la génération et la récupération des ressources sont des étapes distinctes.

Utilisez une politique de nouvelle tentative bornée avec jitter pour les opérations pouvant être réessayées. Le délai, le nombre de tentatives et le délai d'exécution de l'application sont vos choix de configuration, et non des valeurs par défaut garanties par GPT Proto. Ne partez pas du principe que chaque réponse contient un ensemble particulier d'en-têtes de limitation de débit.

Enregistrez les ID de prédiction, le statut de la réponse, le timing et les détails d'erreur nettoyés. Ne journalisez pas la clé API, les images de référence complètes ou chaque charge utile de requête complète. Après un délai d'expiration réseau, récupérez la prédiction connue si possible avant de soumettre à nouveau ; les générations en double peuvent entraîner des frais supplémentaires.

Déplacer un flux de travail existant vers Flare 2.6

Une mise à niveau ne se limite pas au remplacement d'une chaîne de modèle. GPT Proto sélectionne ce modèle et cette tâche via le chemin de route. Gardez une intégration existante disponible pendant que vous testez la nouvelle génération ou la route d'édition avec des invites et des références représentatives.

Utilisez des paramètres explicites de taille, de qualité, de nombre d'images et de livraison. Comparez la précision du texte, la préservation des détails du produit, le temps nécessaire pour obtenir un résultat approuvé et les dépenses totales entre les révisions. Vérifiez à nouveau l'analyse des réponses et le comportement d'interrogation avant de déplacer le trafic de production récurrent.

Si vous migrez depuis un client d'image natif OpenAI, adaptez la charge utile et le traitement des résultats à l'enveloppe data.status et data.outputs de GPT Proto. Ne partez pas du principe que client.images.generate() ou client.images.edit() peuvent appeler ces routes natives GPT Proto sans modification.