GPT Image 2.6

Mit CometAPI entwickelnEine API für mehrere Modelle erforderlich?Teste den Workflow im Playground und erstelle anschließend einen API-Schlüssel, sobald Modell und Kosten zu deinem Anwendungsfall passen.

guide/CometAPI Research

So verwenden Sie die GPT Image 2.6 API: SVG-Generierung und Bildbearbeitung

Lernen Sie die GPT Image 2.6 API-Workflows mit CometAPI kennen: SVG-Erstellung, transparente PNGs, Bearbeitung mehrerer Bilder, Markup, Parameter, Preisgestaltung und Migration.

Deon GoodwinForschungsteam für KI-Modelle und API

Aktualisiert Nov 6, 2026 12 Min. Lesezeit

So verwenden Sie die GPT Image 2.6 API: SVG-Generierung und Bildbearbeitung

Dieses Muster verwenden

Den ersten API-Aufruf ausführen.

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

GPT Image 2.6 API in CometAPI bietet Entwicklerinnen und Entwicklern einen praxisnahen Weg zur Bildgenerierung und -bearbeitung mit zwei Varianten: Sunburst und Flare.

Erstellen Sie Bild-Assets mit Python und einem CometAPI-Schlüssel: Starten Sie mit einer Rasteranfrage und fügen Sie dann bei unterstützter Route SVG-Ausgabe, Referenzbilder oder eine transparente PNG-Anmerkungsebene hinzu. Die Beispiele verwenden Python 3.10 oder höher und halten den API-Schlüssel auf Ihrem Server.

Die entscheidende Unterscheidung: Ein transparentes PNG-Ausgabeformat ist ein fertiges Asset; eine transparente PNG-Markup-Datei ist eine Eingabe, die dem Modell sagt, wo es bearbeiten soll.

Key Takeaways

Verwenden Sie GPT Image 2.6 Flare für schnelle Entwürfe und Sunburst für detaillierte Überarbeitungen.
Senden Sie Generierungs- und Bearbeitungsanfragen an die jeweiligen Image-API-Endpunkte.

Weiterlernen

Diesen Artikel mit der nächsten Entscheidung verknüpfen.

Alle Themen anzeigen

AI API-Anleitungen

Vom Modell-Shortlist bis zu einer funktionierenden Produktionsanfrage.

LLM-Infrastruktur

Baue eine AI-Anfrageschicht, die Provider- und Modellwechsel übersteht.

AI Agent

Wechsle von einer Prompt-Demo zu einem beobachtbaren Agenten-Workflow.

Kostenoptimierung

Senk die Kosten, ohne Qualitäts- oder Zuverlässigkeitskompromisse zu verstecken.

Veröffentlicht am Nov 6, 2026

Zuletzt aktualisiert Nov 6, 2026

4 Aufrufe

Auf Klarheit, Quellenangabe und aktuelle API-Terminologie geprüft.

Spezifikation	Sunburst	Flare
API-Bezeichner	gpt-image-2.6-sunburst	gpt-image-2.6-flare
Primärer Fokus	Detaillierte visuelle Arbeit	Schnelle Iteration
Eingabemodalitäten	Text und Bilder	Text und Bilder
Ausgabemodalität	Bilder	Bilder
Praktischer Einstieg	Finale Assets und sorgfältige Edits	Entwürfe und interaktives Editing
Audio-Unterstützung	Nein	Nein

Parameter	Generierungsanfrage	Praktischer Einsatz
model	Expliziter Variantenbezeichner	Modellwahl reproduzierbar halten
prompt	Textanweisungen	Asset und Constraints beschreiben
quality	Mit low, medium oder high starten	Rendering-Qualität anpassen
complexity	low, medium oder high	Planungsaufwand steuern
size	Zum Beispiel 1024x1024	Abmessungen für Vergleiche fixieren
n	Zunächst 1 verwenden	Tests und Kostenkontrolle vereinfachen
output_format	PNG, JPEG, WebP, SVG oder GIF, je nach Endpoint-Unterstützung	Dem Downstream-Asset anpassen
background	auto, opaque oder transparent	Raster-Hintergrundverhalten steuern

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")

Token-Kategorie	Sunburst-Rate pro 1 Mio. Tokens	Flare-Rate pro 1 Mio. Tokens
Texteingabe	$5.00	$5.00
Gecachte Texteingabe	$1.25	$1.25
Bildeingabe	$8.00	$8.00
Gecachte Bildeingabe	$2.00	$2.00
Bildausgabe	$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

Mehr lesen

So verwenden Sie die GPT Image 2.6 API: SVG-Generierung und Bildbearbeitung

Den ersten API-Aufruf ausführen.

TL;DR

Key Takeaways

Diesen Artikel mit der nächsten Entscheidung verknüpfen.

What Is the GPT Image 2.6 API?

What Parameters Does the GPT Image 2.6 API Support?

How Do You Use GPT Image 2.6 API with CometAPI?

Install the dependencies

Create shared request helpers

Generate a first image

How Do You Generate SVG with GPT Image 2.6?

How Do You Create Transparent PNG Assets with GPT Image 2.6?

How Do You Edit Images with Multiple GPT Image 2.6 References?

How Does Transparent PNG Markup Work in GPT Image 2.6?

Prepare an annotation layer

Submit the guided edit

GPT Image 2.6 API Pricing: Token Rates and SVG Costs

How Do You Migrate an Existing Image Workflow to GPT Image 2.6?

Conclusion

FAQ

How should I handle a GPT Image 2.6 request timeout?

Why does my application fail to save the returned image?

How can I keep edit files from being overwritten?

What should I check before embedding a generated SVG?