Étiquettes

Modèles associés

GPT Image 2.6

Construire avec CometAPIBesoin d'une seule API pour plusieurs modèles ?Testez le workflow dans Playground, puis créez une clé API lorsque le modèle et le coût correspondent à votre cas d'usage.

guide/Recherche CometAPI

Comment utiliser l’API GPT Image 2.6 : génération de SVG et édition d’images

Apprenez les flux de travail de l'API GPT Image 2.6 avec CometAPI : génération de SVG, PNG transparents, édition multi-images, balisage, paramètres, tarification et migration.

Deon GoodwinÉquipe de recherche sur les modèles IA et API

Mis à jour Nov 6, 2026 12 min de lecture

Comment utiliser l’API GPT Image 2.6 : génération de SVG et édition d’images

Utiliser ce modèle

Passez le premier appel API.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_COMETAPI_KEY",
    base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[{"role": "user", "content": "Build this workflow."}],
)

print(response.choices[0].message.content)

TL;DR

L’API GPT Image 2.6 dans CometAPI offre aux développeurs une voie pratique pour générer et éditer des images avec deux variantes : Sunburst et Flare.

Créez des assets image avec Python et une clé CometAPI : commencez par une requête raster, puis ajoutez une sortie SVG, des images de référence, ou une couche d’annotation PNG transparente lorsque votre route les prend en charge. Les exemples utilisent Python 3.10 ou ultérieur et conservent la clé API sur votre serveur.

La distinction la plus importante : un PNG transparent en sortie est un asset final ; un fichier PNG transparent de marquage est un input qui indique au modèle où éditer.

Points clés

Utilisez GPT Image 2.6 Flare pour des brouillons rapides et Sunburst pour des révisions détaillées.
Envoyez les requêtes de génération et les requêtes d’édition vers leurs endpoints Image API respectifs.

Continuer à apprendre

Reliez cet article à la décision suivante.

Voir tous les sujets

Guides d'API IA

Passez d'une sélection de modèles à une requête de production opérationnelle.

Infrastructure LLM

Construisez une couche de requêtes IA qui résiste aux changements de fournisseur et de modèle.

Agent IA

Passez d'une démo de prompt à un workflow d'agent observable.

Optimisation des coûts

Réduisez les coûts sans masquer les compromis de qualité ou de fiabilité.

Publié le Nov 6, 2026

Dernière mise à jour Nov 6, 2026

2 vues

Revu pour la clarté, l'attribution des sources et la terminologie API actuelle.

Spécification	Sunburst	Flare
Identifiant API	gpt-image-2.6-sunburst	gpt-image-2.6-flare
Focalisation principale	Travail visuel détaillé	Itération rapide
Modalités d’entrée	Texte et images	Texte et images
Modalité de sortie	Images	Images
Point de départ pratique	Assets finaux et révisions soignées	Brouillons et édition interactive
Prise en charge audio	Non	Non

Paramètre	Requête de génération	Usage pratique
model	Identifiant de variante explicite	Garder la sélection du modèle reproductible
prompt	Instructions textuelles	Décrire l’asset et ses contraintes
quality	Commencer par low, medium ou high	Ajuster la qualité de rendu
complexity	low, medium ou high	Ajuster l’effort de planification
size	Par exemple, 1024x1024	Fixer les dimensions pour comparer
n	Utiliser 1 au départ	Simplifier les tests et la revue des coûts
output_format	PNG, JPEG, WebP, SVG ou GIF, selon l’endpoint	Faire correspondre l’asset aval
background	auto, opaque ou transparent	Contrôler le comportement du fond raster

pip install requests pillow

export COMETAPI_KEY="YOUR_COMETAPI_KEY"

$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"

import base64
import os
from pathlib import Path
import requests

BASE_URL = "https://api.cometapi.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"}
MODEL = "gpt-image-2.6-flare"

def save_result(response, destination):
    response.raise_for_status()
    payload = response.json()
    Path(destination).write_bytes(
        base64.b64decode(payload["data"][0]["b64_json"], validate=True)
    )
    print(f"Saved: {destination}; usage: {payload.get('usage', 'Not returned')}")

def generate(prompt, destination, **options):
    response = requests.post(
        f"{BASE_URL}/images/generations", headers=HEADERS,
        json={"model": MODEL, "prompt": prompt, "n": 1, "size": "1024x1024",
              "quality": "medium", "complexity": "low", **options},
        timeout=(15, 300),
    )
    save_result(response, destination)

generate(
    prompt=(
        "Create a studio product photograph of an unbranded teal "
        "ceramic travel cup on a warm cream background. "
        "Show one cup, a clean silhouette, and a soft contact shadow. "
        "No text or decorative objects."
    ),
    destination="cup.png",
    output_format="png",
)

generate(
    prompt=(
        "Design an original minimalist icon of a teal travel cup "
        "with a small leaf motif. Use simple closed vector shapes, "
        "two flat colors, and generous negative space. "
        "No text, gradients, photographs, or background scenery."
    ),
    destination="cup-icon.svg",
    output_format="svg",
)

generate(
    prompt=(
        "Create a single teal ceramic travel cup as an isolated "
        "e-commerce asset. Center the entire cup with generous padding. "
        "Keep clean edges and a fully transparent background. "
        "No floor, backdrop, checkerboard pattern, or text."
    ),
    destination="cup-transparent.png",
    output_format="png",
    background="transparent",
)

from PIL import Image

with Image.open("cup-transparent.png") as image:
    alpha = image.convert("RGBA").getchannel("A")
    minimum, maximum = alpha.getextrema()

    if minimum == 255:
        raise RuntimeError("The output contains no transparent pixels.")

    if maximum == 0:
        raise RuntimeError("The output is entirely transparent.")

    print("The output contains visible content and transparency.")

with (
    open("product.png", "rb") as product,
    open("setting.png", "rb") as setting,
):
    response = requests.post(
        f"{BASE_URL}/images/edits",
        headers=HEADERS,
        data={
            "model": "gpt-image-2.6-sunburst",
            "prompt": (
                "Use the cup in the first image as the exact product "
                "reference. Use the second image only for the setting. "
                "Place the cup naturally in that setting. Preserve its "
                "silhouette, lid, color, and printed details. "
                "Do not copy other products from the second image."
            ),
            "quality": "high",
            "complexity": "medium",
            "output_format": "png",
        },
        files=[
            ("image[]", ("product.png", product, "image/png")),
            ("image[]", ("setting.png", setting, "image/png")),
        ],
        timeout=(15, 300),
    )

save_result(response, "product-in-setting.png")

from PIL import Image, ImageDraw, ImageOps

with Image.open("product.png") as source:
    oriented = ImageOps.exif_transpose(source).convert("RGBA")
    oriented.save("product-oriented.png")

overlay = Image.new("RGBA", oriented.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(overlay)

width, height = oriented.size
region = (
    int(width * 0.25),
    int(height * 0.15),
    int(width * 0.75),
    int(height * 0.85),
)

draw.ellipse(region, outline=(255, 0, 0, 255), width=6)
overlay.save("markup.png")

with (
    open("product-oriented.png", "rb") as source,
    open("markup.png", "rb") as markup,
):
    response = requests.post(
        f"{BASE_URL}/images/edits",
        headers=HEADERS,
        data={
            "model": MODEL,
            "prompt": (
                "Change the body of the cup inside the red circle "
                "to matte cobalt blue. Preserve the lid, shape, "
                "lighting, and surrounding scene. "
                "Remove the annotation from the finished image."
            ),
            "quality": "medium",
            "complexity": "low",
            "output_format": "png",
        },
        files={
            "image": ("product.png", source, "image/png"),
            "markup": ("markup.png", markup, "image/png"),
        },
        timeout=(15, 300),
    )

save_result(response, "cup-edited.png")

Catégorie de tokens	Tarif Sunburst pour 1 M de tokens	Tarif Flare pour 1 M de tokens
Text input	$5.00	$5.00
Cached text input	$1.25	$1.25
Image input	$8.00	$8.00
Cached image input	$2.00	$2.00
Image output	$30.00	$30.00

Cost =
(text input tokens × $5
 + image input tokens × $8
 + image output tokens × $30)
÷ 1,000,000

Cost per accepted asset =
total workflow spending ÷ number of approved assets

GPT Image 2.6

GPT Image 2.6

En savoir plus

Comment utiliser l’API GPT Image 2.6 : génération de SVG et édition d’images

Passez le premier appel API.

TL;DR

Points clés

Reliez cet article à la décision suivante.

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

Quels paramètres l’API GPT Image 2.6 prend-elle en charge ?

Comment utiliser l’API GPT Image 2.6 avec CometAPI ?

Installer les dépendances

Créer des helpers de requêtes partagés

Générer une première image

Comment générer du SVG avec GPT Image 2.6 ?

Comment créer des assets PNG transparents avec GPT Image 2.6 ?

Comment éditer des images avec plusieurs références GPT Image 2.6 ?

Comment fonctionne le PNG transparent de marquage dans GPT Image 2.6 ?

Préparer une couche d’annotation

Soumettre l’édition guidée

Tarification de l’API GPT Image 2.6 : taux de tokens et coûts SVG

Comment migrer un workflow d’image existant vers GPT Image 2.6 ?

Conclusion

FAQ

Comment gérer un timeout de requête GPT Image 2.6 ?

Pourquoi mon application échoue-t-elle à enregistrer l’image renvoyée ?

Comment éviter d’écraser les fichiers d’édition ?

Que vérifier avant d’intégrer un SVG généré ?