Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

Bildgenerierung

Erfahre, wie du Bilder generierst und bearbeitest.

Überblick

Mit der API kannst du Bilder anhand von Text-Prompts generieren und bearbeiten. Dafür stehen dir gpt-image-2.5-sunburst und gpt-image-2.5-flare zur Verfügung. Wähle Sunburst, wenn es vor allem auf präzise Bearbeitungen ankommt. Mit Flare generierst du im Alltag schnell hochwertige Bilder. Für die Bildgenerierung stehen dir zwei APIs zur Verfügung.

Image API

Die Image API bietet zwei Endpunkte mit unterschiedlichen Funktionen:

Responses API

Mit der Responses API kannst du Bilder in Gesprächen oder mehrstufigen Abläufen generieren. Sie unterstützt die Bildgenerierung als integriertes Tool und kann sowohl Eingabe- als auch Ausgabebilder im Kontext verarbeiten.

Gegenüber der Image API bietet sie zusätzliche Möglichkeiten:

  • Schrittweise Bearbeitung: Nimm mit aufeinanderfolgenden Prompts detailgetreue Änderungen an Bildern vor.
  • Flexible Eingaben: Übergib Eingabebilder als Bytes oder gib die ID der jeweiligen Datei an.

Welche Hauptmodelle das Tool zur Bildgenerierung aufrufen können, erfährst du im Abschnitt Unterstützte Modelle.

Die passende API auswählen

  • Wenn du mit einem einzigen Prompt ein einzelnes Bild generieren oder bearbeiten möchtest, ist die Image API die beste Wahl.
  • Wenn du eine Anwendung entwickeln möchtest, in der sich Bilder im Gespräch mit GPT Image generieren und weiterbearbeiten lassen, verwende die Responses API.

Setze in der Image API model direkt auf gpt-image-2.5-sunburst oder gpt-image-2.5-flare. Wähle in der Responses API auf der obersten Ebene ein unterstütztes Hauptmodell und gib gpt-image-2.5-sunburst oder gpt-image-2.5-flare im Feld model des Tools zur Bildgenerierung an.

Mit beiden APIs kannst du die Bildausgabe anpassen, indem du Qualität, Größe, Format und Komprimierung festlegst.

Damit diese Modelle verantwortungsvoll eingesetzt werden, musst du möglicherweise die Verifizierung deiner API-Organisation in deiner Entwicklerkonsole abschließen, bevor du die Modelle von GPT Image verwenden kannst.

GPT-Image-2.6

GPT-Image-2.6 umfasst Sunburst für detailreiche Bildgestaltung und Flare, wenn du rasch mehrere Varianten ausprobieren möchtest. Mit beiden Modellen kannst du über die Image API die Komplexität einstellen, Bearbeitungen mit Markierungen steuern und Bilder als SVG oder animiertes GIF ausgeben. Die bereits vorhandenen Beispiele weiter unten verwenden GPT-Image-2.5.

Bildkomplexität einstellen

Mit dem Anfragefeld complexity legst du fest, wie viel das Bildmodell vor dem Rendern plant. Eine niedrigere Stufe kann sich für gezielte Änderungen eignen, etwa wenn du einen Hintergrund oder ein Schild ändern möchtest. Eine höhere Stufe kann helfen, wenn das Bild viel Text, ein komplexes Layout oder bestimmte Beziehungen zwischen Objekten darstellen soll. Sie kann aber auch die Latenz erhöhen und zu unerwünschten Änderungen führen. Vergleiche daher die Ergebnisse für deine Aufgabe.

Sunburst und Flare unterstützen die Komplexitätsstufen low, medium und high. Wenn du complexity weglässt, verwenden beide Modelle high. Die Darstellungsqualität steuerst du separat über quality.

Für das Anpassen der Komplexität fällt keine gesonderte Gebühr an.

Sunburst hat diese Fußballszenen im Scherenschnittstil mit demselben Prompt bei mittlerer Qualität generiert. Vergleiche bei den drei Komplexitätsstufen den Pokal, die Trikots und die Position des „CHAMPIONS“-Schilds.

Niedrige Komplexität

Mittlere Komplexität

Hohe Komplexität

Sicherheitskennungen

Wenn einzelne Personen deine Anwendung nutzen, sende für jede Person eine stabile, datenschutzfreundliche Kennung als safety_identifier in jeder Anfrage zur Bildgenerierung oder Bildbearbeitung mit. Bilde einen Hash aus dem Benutzernamen oder der E-Mail-Adresse, statt identifizierende Informationen zu senden. Die Kennung darf höchstens 128 Zeichen lang sein. Die Verwendung von Sicherheitskennungen wird empfohlen, ist aber freiwillig.

Der Parameter user der Images API ist veraltet. Sende dieselbe Kennung stattdessen als safety_identifier. Bestehende Anfragen mit user werden weiterhin unterstützt. Ein nicht leerer safety_identifier hat Vorrang vor user. Fehlt safety_identifier, ist der Wert null oder ist er eine leere Zeichenfolge, verwendet die API user, sofern der Parameter angegeben ist.

Ein beiger Kaffeebecher auf einem Holztisch

Bilder generieren

Mit dem Endpunkt für die Bildgenerierung kannst du Bilder anhand von Text-Prompts erstellen. Mit dem Tool zur Bildgenerierung in der Responses API kannst du Bilder im Gespräch generieren.

Wie du Größe, Qualität, Format und Komprimierung festlegst, erfährst du weiter unten im Abschnitt Bildausgabe anpassen.

Über den Parameter n kannst du mit einer einzigen Anfrage mehrere Bilder auf einmal generieren. Standardmäßig gibt die API ein einzelnes Bild zurück.

Ein Bild generieren
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)

Bildgenerierung über mehrere Gesprächsrunden

Mit der Responses API kannst du Bilder über mehrere Gesprächsrunden hinweg generieren. Übergib dazu die Ergebnisse vorheriger Aufrufe zur Bildgenerierung im Kontext (die Bild-ID allein reicht ebenfalls aus) oder verwende den Parameter previous_response_id. So kannst du ein Bild im Gespräch schrittweise weiterentwickeln, indem du deine Prompts präzisierst und neue Anweisungen gibst.

Wenn du das Tool zur Bildgenerierung in der Responses API verwendest, können unterstützte Tool-Modelle selbst entscheiden, ob sie ein neues Bild generieren oder ein Bild aus dem Gespräch bearbeiten. Mit dem optionalen Parameter action steuerst du dieses Verhalten. Lass action: "auto" eingestellt, damit das Modell entscheidet. Mit action: "generate" erstellst du immer ein neues Bild. Mit action: "edit" erzwingst du die Bearbeitung, wenn der Kontext ein Bild enthält.

Bildgenerierung mit action erzwingen
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))

Wenn du edit erzwingst, ohne ein Bild im Kontext bereitzustellen, gibt der Aufruf einen Fehler zurück. Lass action auf auto, damit das Modell entscheidet, wann es ein Bild generiert oder bearbeitet.

Bildgenerierung über mehrere Gesprächsrunden
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))

Ergebnis

„Generiere ein Bild, auf dem eine grau getigerte Katze einen Otter umarmt, der einen orangefarbenen Schal trägt.“

Eine Katze und ein Otter

„Lass das Bild jetzt realistisch aussehen.“

Eine Katze und ein Otter

Streaming

Die Responses API und die Image API unterstützen Streaming bei der Bildgenerierung. Du kannst Zwischenbilder schon während der Generierung streamen und so den Fortschritt interaktiv anzeigen.

Mit dem Parameter partial_images kannst du null bis drei Zwischenbilder anfordern.

  • Setzt du partial_images auf 0, erhältst du nur das fertige Bild.
  • Bei Werten größer als null erhältst du möglicherweise weniger Zwischenbilder als angefordert, wenn das fertige Bild schon früher vorliegt.
Ein Bild streamen
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])

Ergebnis

Zwischenbild 1 Zwischenbild 2 Fertiges Bild
Erstes Zwischenbild Zweites Zwischenbild Fertiges Bild

Prompt: Zeichne ein wunderschönes Bild von einem Fluss aus weißen Eulenfedern, der sich durch eine friedliche Winterlandschaft schlängelt.

Überarbeiteter Prompt

Wenn du das Tool zur Bildgenerierung in der Responses API verwendest, überarbeitet das Hauptmodell (zum Beispiel gpt-5.5) deinen Prompt automatisch, um bessere Ergebnisse zu erzielen.

Den überarbeiteten Prompt findest du im Feld revised_prompt des Aufrufs zur Bildgenerierung:

Antwort mit überarbeitetem Prompt
{
  "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": "..."
}

Bilder bearbeiten

Mit dem Endpunkt für die Bildbearbeitung kannst du:

  • vorhandene Bilder bearbeiten,
  • neue Bilder anhand von Referenzbildern generieren,
  • einzelne Bildbereiche bearbeiten, indem du das Bild zusammen mit einer Maske hochlädst, die die zu ersetzenden Bereiche kennzeichnet.

Ein neues Bild anhand von Referenzbildern erstellen

Du kannst ein oder mehrere Bilder als Referenz verwenden, um ein neues Bild zu generieren.

In diesem Beispiel verwenden wir vier Eingabebilder, um ein neues Bild eines Geschenkkorbs zu generieren. Der Korb enthält die Produkte aus den Referenzbildern.

KörperlotionSeifeRäuchersetBadekugel
Geschenkset mit Badeprodukten

Du kannst der Responses API Bilder auf drei Arten übergeben.

  • Gib die vollständige URL des Bildes an.
  • Übergib das Bild als Base64-kodierte Daten-URL.
  • Gib die Datei-ID an, die du beim Erstellen der Datei mit der Files API erhältst.

Datei erstellen

Datei erstellen
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

Base64-kodiertes Bild erstellen

Base64-kodiertes Bild erstellen
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
Bild bearbeiten
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)

Eine Bearbeitung mit Markierungen steuern

Verwende den Endpunkt POST /v1/images/edits der Image API für Bearbeitungen mit Markierungen. Dafür kannst du die unterstützten Modelle von GPT-Image-2.5 und GPT-Image-2.6 nutzen. Wenn du mit der Responses API einzelne Bildbereiche bearbeiten möchtest, verwende eine Maske. Kennzeichne auf einer separaten Ebene, wo sich etwas ändern soll, und beschreibe die Änderung in prompt.

Lade für das Beispiel das Küchenfoto und die transparente Markierungsebene in dasselbe Verzeichnis herunter. Auf der Markierungsebene ist die Vase eingekreist, deren Farbe sich ändern soll.

Die eingekreiste Vase mit der Image API bearbeiten
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))

Foto mit Markierungsebene

Ergebnis von Flare

  1. Verwende das Originalbild als erstes Eingabebild.
  2. Erstelle eine separate transparente PNG-Datei mit deinen Kreisen, Skizzen oder anderen Markierungen. Nach der Ausrichtung müssen die Markierungsebene und das erste Bild dieselbe Breite und Höhe haben. Die PNG-Datei muss transparente Pixel enthalten. Führe die Ebene nicht mit dem Originalbild zusammen.
  3. Sende die Markierungsebene als markup. Bei Multipart-Anfragen kannst du die Datei hochladen. Übergib bei JSON-Anfragen ein Objekt mit genau einem der beiden Felder image_url oder file_id. Das Feld image_url kann eine HTTPS-URL oder eine Base64-Daten-URL enthalten. Bei Bearbeitungsanfragen im JSON-Format übergibst du das Array der Eingabebilder in images.
  4. Beschreibe die gewünschte Änderung und die Details, die erhalten bleiben sollen. Prüfe das Ergebnis, bevor du es verwendest.

Die Markierungen beziehen sich auf das erste Eingabebild. Weitere Bilder dienen als Referenzen. Das erste Eingabebild und die Markierungsebene dürfen jeweils höchstens 16.777.216 Pixel enthalten. Für die Datei mit den Markierungen gilt außerdem eine Obergrenze von 50 MB. Kombiniere markup nicht mit mask.

Ein Bild mit einer Maske bearbeiten

Mit einer Maske kannst du angeben, welchen Bereich des Bildes das Modell bearbeiten soll.

Wenn du mit GPT Image eine Maske verwendest, erhält das Modell zusätzliche Anweisungen, die ihm helfen, den gewünschten Bereich zu bearbeiten.

Die Bearbeitung mit Masken in GPT Image wird vollständig über Prompts gesteuert. Das Modell orientiert sich an der Maske, hält sich aber möglicherweise nicht exakt an ihre Konturen.

Wenn du mehrere Eingabebilder übergibst, wird die Maske auf das erste Bild angewendet.

Ein Bild mit einer Maske bearbeiten
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))
Bild Maske Ausgabe
Ein rosafarbener Raum mit einem Pool Eine Maske über einem Teil des Pools Der ursprüngliche Pool mit einem aufblasbaren Flamingo an der Stelle der Maske

Prompt: Ein sonnendurchfluteter Loungebereich im Innenraum mit einem Pool, in dem sich ein Flamingo befindet.

Anforderungen an die Maske

Das zu bearbeitende Bild und die Maske müssen dasselbe Format und dieselben Abmessungen haben. Beide Dateien müssen jeweils kleiner als 50 MB sein.

Das Maskenbild muss außerdem einen Alphakanal enthalten. Wenn du die Maske in einem Bildbearbeitungsprogramm erstellst, achte darauf, sie mit Alphakanal zu speichern.

Du kannst einem Schwarz-Weiß-Bild auch per Code einen Alphakanal hinzufügen.

Einer Schwarz-Weiß-Maske einen Alphakanal hinzufügen
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)

Bildausgabe anpassen

Für die Ausgabe kannst du folgende Optionen festlegen:

  • Größe: Bildabmessungen (zum Beispiel 1024x1024, 1024x1536)
  • Qualität: Darstellungsqualität (zum Beispiel low, medium, high)
  • Format: Dateiformat des Ausgabebildes
  • Komprimierung: Komprimierungsgrad (0–100 %) für JPEG und WebP
  • Hintergrund: transparent, undurchsichtig oder automatisch

size, quality und background unterstützen die Option auto. Damit wählt das Modell anhand des Prompts automatisch die passende Einstellung.

Optionen für Größe und Qualität

gpt-image-2.5-sunburst und gpt-image-2.5-flare bieten zusätzlich die Qualitätsstufen xhigh und max. Bei beiden Modellen ist auto voreingestellt. Frühere Modelle von GPT Image unterstützen Qualitätsstufen bis einschließlich high.

Einstellung Optionen
Empfohlene Größen 1024x1024 (quadratisch), 1536x1024 (Querformat), 1024x1536 (Hochformat)
Qualität low, medium, high, xhigh, max, auto

Beide Modelle unterstützen auch benutzerdefinierte Abmessungen als Zeichenfolge im Format WIDTHxHEIGHT, zum Beispiel 1536x864. Breite und Höhe müssen durch 16 teilbar sein. Das Seitenverhältnis muss zwischen 1:3 und 3:1 liegen, und keine Seite darf länger als 3.840 Pixel sein. Insgesamt muss das Bild zwischen 655.360 und 8.294.400 Pixel (4K) haben. Auflösungen über 2560x1440 sind experimentell.

Für einen transparenten Hintergrund setze bei beiden Modellen background: "transparent" und verwende output_format: "png" oder "webp".

Verwende quality: "low" für schnelle Entwürfe. Vergleiche für die fertigen Bilder höhere Qualitätsstufen, um ein passendes Verhältnis zwischen Detailgrad, Latenz und Kosten zu finden.

Ausgabeformat

Die Image API gibt Base64-kodierte Bilddaten zurück. Das Standardformat ist png. Du kannst auch jpeg oder webp anfordern.

Bei jpeg oder webp kannst du über den Parameter output_compression den Komprimierungsgrad festlegen (0–100 %). Mit output_compression=50 wird das Bild beispielsweise um 50 % komprimiert.

Die Ausgabe als jpeg ist schneller als die Ausgabe als png. Wähle daher JPEG, wenn es auf kurze Antwortzeiten ankommt.

Bilder als SVG ausgeben

Gib output_format: "svg" bei POST /v1/images/generations an. Verwende SVG für Grafiken wie Symbole oder Illustrationen, deren Pfade, Formen und Farben sich nachträglich bearbeiten lassen sollen.

Setze n auf 1. Die SVG-Ausgabe unterstützt weder Streaming noch Zwischenbilder noch output_compression. Der Endpunkt für die Bildbearbeitung unterstützt keine SVG-Ausgabe. Auch als Rasterbildeingabe für die Bearbeitung lässt sich eine SVG-Datei nicht verwenden.

Die API erstellt ein Referenzbild und erzeugt daraus die SVG-Datei. Mit quality steuerst du die Qualität des Referenzbildes. Dekodiere data[0].b64_json aus Base64 und speichere die resultierenden Bytes als UTF-8-kodierte XML-Datei mit der Endung .svg. Das zurückgegebene Dokument enthält statische Vektorgrafiken. Skripte, externe Ressourcen und eingebettete Rasterbilder werden nicht unterstützt.

Flare und Sunburst haben diese SVG-Logos mit demselben Prompt für ein Logo der Bäckerei Field & Flour generiert.

GPT-Image-2.6 Flare

GPT-Image-2.6 Sunburst

Animierte GIFs generieren

Gib output_format: "gif" bei POST /v1/images/generations oder POST /v1/images/edits an. Beschreibe im Prompt das Motiv, die Bewegung und den gewünschten Ablauf der Schleife. Wenn du Standbilder als Referenz für die Animation verwenden möchtest, sende sie an den Endpunkt für die Bildbearbeitung.

Mit diesen Anfragefeldern steuerst du die GIF-Ausgabe bei beiden Endpunkten:

Feld Werte Standardwert
frame_count 2–16 Einzelbilder 9
frame_duration_ms 20–2.000 Millisekunden pro Einzelbild, auf ein Vielfaches von 10 ms gerundet 200
size auto oder WIDTHxHEIGHT, wobei Breite und Höhe positive Vielfache von 16 sein müssen auto

size gibt die Größe jedes fertigen Einzelbildes an. Wähle Anzahl und Abmessungen der Einzelbilder sowie die Anzahl der Animationen so, dass sie innerhalb der Größenbeschränkungen des Modells und der maximalen Gesamtpixelzahl pro Anfrage liegen. Überschreitet die Anfrage diese Grenzen, verringere frame_count, die Abmessungen der Einzelbilder oder n. Mit auto wählt die API eine Einzelbildgröße innerhalb der Modellgrenzen.

Die Antwort enthält die fertige Animation. Dekodiere für jedes Ergebnis den Wert von b64_json aus Base64 und speichere die Bytes in einer Datei mit der Endung .gif. Die GIF-Ausgabe unterstützt weder Streaming noch Zwischenbilder noch benutzerdefinierte Werte für output_compression. Verwende frame_count und frame_duration_ms nur für die GIF-Ausgabe.

Sunburst hat diese Laternenanimation mit frame_count=9 und frame_duration_ms=200 generiert. Nach 1,8 Sekunden nimmt der Affe wieder seine Ausgangshaltung ein.

Einschränkungen

Die Modelle von GPT Image sind leistungsfähig und vielseitig. Bei der Bildgenerierung solltest du folgende Einschränkungen berücksichtigen:

  • Latenz: Die Verarbeitung komplexer Prompts kann bis zu zwei Minuten dauern.
  • Textdarstellung: Trotz deutlicher Verbesserungen kann das Modell noch Schwierigkeiten haben, Text genau zu platzieren und gut lesbar darzustellen.
  • Konsistenz: Das Modell kann Bilder mit einheitlichem Erscheinungsbild erzeugen. Bei wiederkehrenden Figuren oder Markenelementen gelingt es ihm aber gelegentlich nicht, ihr Aussehen über mehrere Generierungen hinweg beizubehalten.
  • Steuerung des Bildaufbaus: Das Modell setzt Anweisungen inzwischen besser um. Bei strukturierten Bildkompositionen oder einem genau vorgegebenen Layout kann es dennoch Schwierigkeiten haben, Elemente präzise zu platzieren.

Inhaltsmoderation

Alle Prompts und generierten Bilder werden gemäß unseren Nutzungsrichtlinien gefiltert.

Bei der Bildgenerierung mit Modellen von GPT Image kannst du über den Parameter moderation festlegen, wie streng die Filterung ist. Der Parameter unterstützt zwei Werte:

  • auto (Standard): Die Standardfilterung soll die Erstellung bestimmter Kategorien von Inhalten einschränken, die für manche Altersgruppen ungeeignet sein könnten.
  • low: Weniger strenge Filterung.

Blockierte Anfragen und andere Fehler behandeln

Behandle Fehler bei der Bildgenerierung wie andere API-Fehler. Prüfe den HTTP-Status oder den Ausnahmetyp des SDK und protokolliere die Anfrage-ID. Informationen zu Authentifizierungsfehlern, ausgeschöpften Kontingenten, überschrittenen Ratenlimits und Serverfehlern findest du im Leitfaden zu Fehlercodes. Wiederhole Anfragen bei vorübergehend überschrittenen Ratenlimits oder temporären Serverfehlern mit zunehmender Wartezeit. Wiederhole Anfragen bei Kontingentfehlern oder bei Eingabefehlern, die eine Änderung der Anfrage erfordern, nicht automatisch.

Manche Fehler bei der Bildgenerierung lassen sich durch eine Korrektur der Eingabe beheben. In diesen Fällen kann die API error.type = "image_generation_user_error" zurückgeben. Wiederhole die Anfrage bei solchen Fehlern nicht automatisch, ohne den Prompt oder die Eingabebilder zu ändern. Verwende error.code, um Fehler im Code zuverlässig zu unterscheiden.

Bei error.code = "moderation_blocked" kann die Fehlermeldung zusätzlich das optionale Objekt error.moderation_details enthalten:

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

Das Objekt moderation_details liefert grundlegende Hinweise zur Fehlersuche, ohne interne Klassifikatorbezeichnungen oder Bewertungen offenzulegen.

moderation_stage kann folgende Werte haben:

  • input: Der Prompt oder andere Eingaben der Anfrage haben die Blockierung ausgelöst.
  • output: Ein generiertes Bild oder eine nachgelagerte Moderationsprüfung der Ausgabe hat die Blockierung ausgelöst.
  • unknown: Dieser Wert kommt in seltenen Fällen zum Einsatz, wenn sich der Ursprung der Blockierung schwer bestimmen lässt.

categories enthält allgemeine, öffentlich verwendete Kategoriebezeichnungen. Mögliche Werte sind beispielsweise harassment, self-harm, sexual oder violence.

In den meisten Apps solltest du die Meldung, die du den betroffenen Personen anzeigst, allgemein halten. Verwende moderation_details für Entwicklungsprotokolle, Supportabläufe, Analysen und kurze Hinweise zur Behebung des Problems.

Fehler bei einer durch die Moderation blockierten Bildgenerierung behandeln
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 instanceof OpenAI.APIError) ||
    error.code !== "moderation_blocked"
  ) {
    throw error;
  }

  const moderationDetails =
    error.error && "moderation_details" in error.error
      ? (error.error.moderation_details as {
          categories?: string[];
          moderation_stage?: string;
        })
      : undefined;
  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);
}

Unterstützte Modelle

In der Responses API sollten gpt-5 und neuere Modelle das Tool zur Bildgenerierung unterstützen. Prüfe auf der Detailseite deines Modells, ob das gewünschte Modell das Tool verwenden kann.

Kosten und Latenz

Kosten für GPT-Image-2.6

Die Bildausgabe kostet 30 USD pro Million abrechenbarer Token. Mit dem Rechner kannst du die Ausgabekosten für ein Bild schätzen.

Die Preise pro Million Text- und Bildtoken findest du in der Preisübersicht zur Bildgenerierung.

Für Bearbeitungen mit Markierungen gelten dieselben Tokenpreise wie für andere Bearbeitungen. Es fällt keine zusätzliche Gebühr an. Bei der SVG-Ausgabe zahlst du für das Referenzbild den Tokenpreis des Bildmodells. Für die Token, mit denen das zweite Modell das SVG-Dokument erstellt, gilt dessen Tokenpreis. Die Gesamtkosten hängen vom Tokenverbrauch beider Modelle ab.

Kosten für GPT-Image-2.5

Bei Anfragen an die Responses API fallen zusätzlich zu den Kosten für die Bildgenerierung Kosten für die Token des Hauptmodells an.

Für beide Modelle von GPT-Image-2.5 gelten dieselben Tokenpreise. Pro Million Token zahlst du 8 USD für Bildeingaben, 2 USD für zwischengespeicherte Bildeingaben, 30 USD für Bildausgaben, 5 USD für Texteingaben und 1,25 USD für zwischengespeicherte Texteingaben. Weitere Angaben findest du in der Preisübersicht.

Mit usage in der Antwort kannst du den Tokenverbrauch für deine Prompts, Bildgrößen und Qualitätsstufen messen. Auch bei identischen Tokenpreisen können die Kosten pro Bild variieren, da der Tokenverbrauch vom Modell und von der Qualitätsstufe abhängt. Preisbeispiele für ältere Modelle findest du im Abschnitt Frühere Modelle von GPT Image.

Preise für zwischengespeicherte Eingaben

Bei GPT-Image-2 und GPT-Image-2.5 gelten die Preise für zwischengespeicherte Eingaben ausschließlich für das Tool zur Bildgenerierung in der Responses API. Sie gelten nicht für direkte Anfragen an die Images API, auch nicht für /v1/images/edits.

Die Abrechnung berücksichtigt zwischengespeicherte Eingaben für die Bildgenerierung. Die Responses API gibt jedoch nicht aus, wie viele dieser Token aus dem Cache stammen. Anhand von usage in der Antwort kannst du diese Cache-Treffer daher nicht überprüfen.

Kosten berechnen

Wähle ein Modell, eine Qualitätsstufe und eine Größe, um die Anzahl der Ausgabetoken und die Kosten der Bildausgabe zu schätzen. Für Sunburst und Flare stehen sowohl bei GPT-Image-2.6 als auch bei GPT-Image-2.5 die Qualitätsstufen low, medium, high, xhigh und max zur Verfügung. Bei gpt-image-2 kannst du zwischen low, medium und high wählen. Bei gleicher Qualitätsstufe können die Modelle unterschiedlich viele Token verbrauchen. Der Preis pro Bildausgabetoken ist für alle gleich. Gib für die Schätzung konkrete Werte für Qualität und Größe an. Bei auto hängen diese Werte vom generierten Bild ab.

Modell
Qualität
Ausgabetoken
823
Geschätzte Kosten der Bildausgabe
0,02469 $

Kosten pro Bild bei einem Preis von 30 USD pro Million Bild-Ausgabetoken. Die Schätzung berücksichtigt weder Eingabetoken für Text und Bilder noch das Streaming von Teilbildern.

Kosten für Zwischenbilder

Wenn du die Bildgenerierung streamst und den Parameter partial_images verwendest, fallen pro Zwischenbild 100 zusätzliche Bildausgabetoken an.

Frühere Modelle von GPT Image

Die folgenden Angaben gelten für frühere Modelle und schließen Sunburst und Flare aus. Verwende für neue Integrationen GPT-Image-2.6 Sunburst oder Flare.

Einstellungen und Detailtreue bei Bildeingaben für GPT-Image-2

gpt-image-2 akzeptiert im Parameter size jede Auflösung, die die folgenden Bedingungen erfüllt. Quadratische Bilder lassen sich in der Regel am schnellsten generieren.

Häufig verwendete Größen
  • 1024x1024 (quadratisch)

  • 1536x1024 (Querformat)

  • 1024x1536 (Hochformat)

  • 2048x2048 (2K, quadratisch)

  • 2048x1152 (2K, Querformat)

  • 3840x2160 (4K, Querformat)

  • 2160x3840 (4K, Hochformat)

  • auto (Standard)

Größenbeschränkungen
  • Die maximale Seitenlänge beträgt 3840px

  • Zulässig sind für beide Seitenlängen nur Vielfache von 16px

  • Das Verhältnis der langen zur kurzen Seite beträgt höchstens 3:1

  • Die Gesamtzahl der Pixel beträgt mindestens 655,360 und höchstens 8,294,400

Qualitätsstufen
  • low
  • medium
  • high
  • auto (Standard)

Detailtreue bei Bildeingaben

Der Parameter input_fidelity steuert, wie genau ein Modell Details aus Eingabebildern übernimmt, wenn es Bilder bearbeitet oder mit Referenzbildern arbeitet. Lass diesen Parameter bei gpt-image-2 weg. Die API erlaubt keine Änderung, da das Modell jede Bildeingabe automatisch mit hoher Detailtreue verarbeitet.

Da gpt-image-2 Bildeingaben immer mit hoher Detailtreue verarbeitet, können Bearbeitungsanfragen mit Referenzbildern mehr Bildeingabetoken verbrauchen. Wie sich das auf die Kosten auswirkt, erfährst du im Abschnitt zu den Kosten für die Bildverarbeitung.

Preisbeispiele für ältere Modelle

Modelle vor gpt-image-2

Modelle von GPT Image vor gpt-image-2 generieren Bilder, indem sie zunächst spezielle Bildtoken erzeugen. Die Latenz und die endgültigen Kosten sind proportional zur Anzahl der Token, die für die Darstellung eines Bildes erforderlich sind. Größere Bilder und höhere Qualitätsstufen erfordern mehr Token.

Die Anzahl der generierten Token hängt von den Bildabmessungen und der Qualität ab:

Qualität Quadratisch (1024 × 1024) Hochformat (1024 × 1536) Querformat (1536 × 1024)
Niedrig 272 Token 408 Token 400 Token
Mittel 1.056 Token 1.584 Token 1.568 Token
Hoch 4.160 Token 6.240 Token 6.208 Token

Berücksichtige auch die Eingabetoken. Dazu zählen die Texttoken für den Prompt und bei der Bildbearbeitung zusätzlich die Bildtoken für die Eingabebilder. Da gpt-image-2 Bildeingaben immer mit hoher Detailtreue verarbeitet, können Bearbeitungsanfragen mit Referenzbildern mehr Eingabetoken verbrauchen.

Die aktuellen Preise für Text- und Bildtoken findest du in der Preisübersicht. Im Abschnitt Kosten berechnen kannst du die Kosten der Bildausgabe schätzen.

Die Gesamtkosten setzen sich aus den Kosten für folgende Token zusammen:

  • Texteingabetoken
  • Bildeingabetoken, wenn du den Endpunkt für die Bildbearbeitung verwendest
  • Bildausgabetoken

Historische Ausgabekosten

gpt-image-2 unterstützt Tausende von Auflösungen. Zum Vergleich führt die Tabelle die gleichen Größen wie bei früheren Modellen von GPT Image auf. Für GPT Image 1.5, GPT Image 1 und GPT Image 1 mini findest du unten auch die bisherigen Ausgabepreise pro Bild. Berücksichtige bei der Schätzung der Gesamtkosten einer Anfrage zusätzlich die Text- und Bildeingabetoken.

gpt-image-1 wurde am 23. Oktober 2026 abgeschaltet. Die Preise dieses Modells sind zum historischen Vergleich weiterhin aufgeführt. Informationen zu Ersatzmodellen findest du im Hinweis zur Einstellung des Modells.

Bei gleicher Qualitätsstufe kann ein größeres Bild im Hoch- oder Querformat manchmal weniger Ausgabetoken erfordern als ein kleineres oder quadratisches Bild.

Modell

Qualität

1024 × 10241024 × 15361536 × 1024

GPT-Image-2


Weitere Größen verfügbar
Niedrig0,006 USD0,005 USD0,005 USD
Mittel0,053 USD0,041 USD0,041 USD
Hoch0,211 USD0,165 USD0,165 USD

GPT Image 1.5

Niedrig0,009 USD0,013 USD0,013 USD
Mittel0,034 USD0,05 USD0,05 USD
Hoch0,133 USD0,2 USD0,2 USD

GPT Image 1

Niedrig0,011 USD0,016 USD0,016 USD
Mittel0,042 USD0,063 USD0,063 USD
Hoch0,167 USD0,25 USD0,25 USD

GPT Image 1 mini

Niedrig0,005 USD0,006 USD0,006 USD
Mittel0,011 USD0,015 USD0,015 USD
Hoch0,036 USD0,052 USD0,052 USD