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.
Neuere Sprachmodelle können Bilder als Eingabe verarbeiten und analysieren. Diese Fähigkeit heißt Bildverständnis. GPT Image-Modelle können anhand von Text- und Bildeingaben neue Bilder erstellen oder vorhandene Bilder bearbeiten.
Wähle den Endpunkt danach aus, ob du Bilder analysieren oder generieren möchtest.
Bilder analysieren und Antworten in Textform generieren
Welche Arten von Ein- und Ausgaben unsere Modelle unterstützen, erfährst du in der Modellübersicht.
Bilder generieren oder bearbeiten
Wähle in der Images API gpt-image-2.5-sunburst, um Bilder aus Text zu generieren oder vorhandene Bilder zu bearbeiten. Wähle in der Responses API ein Modell der Hauptreihe, das das Tool zur Bildgenerierung unterstützt. Das Tool wählt das GPT Image-Modell aus.
Bilder mit der Responses API generieren
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import OpenAI from "openai";const openai = new OpenAI();const response = await openai.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" }],});// Save the image to a fileconst imageData = response.output .filter((output) => output.type === "image_generation_call") .map((output) => output.result);if (imageData.length > 0) { const imageBase64 = imageData[0]; if (!imageBase64) throw new Error("The image generation result is empty."); const fs = await import("fs"); fs.writeFileSync("cat_and_otter.png", Buffer.from(imageBase64, "base64"));}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from openai import OpenAIimport base64client = 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"}],)# Save the image to a fileimage_data = [ output.resultfor output in response.outputif output.type =="image_generation_call"]if image_data: image_base64 = image_data[0]withopen("cat_and_otter.png", "wb") as f: f.write(base64.b64decode(image_base64))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package mainimport ( "context" "encoding/base64" "os" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses")func main() { client := openai.NewClient() response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Input: responses.ResponseNewParamsInputUnion{ OfString: openai.String("Generate an image of a gray tabby cat hugging an otter with an orange scarf."), }, Tools: []responses.ToolUnionParam{{ OfImageGeneration: &responses.ToolImageGenerationParam{}, }}, }) if err != nil { panic(err) } for _, output := range response.Output { if output.Type != "image_generation_call" { continue } image, err := base64.StdEncoding.DecodeString(output.AsImageGenerationCall().Result) if err != nil { panic(err) } if err := os.WriteFile("cat_and_otter.png", image, 0o600); err != nil { panic(err) } return } panic("response did not include an image generation call")}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.Tool;import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.Base64;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input("Generate an image of a gray tabby cat hugging an otter with an orange scarf.") .addTool(Tool.ImageGeneration.builder().build()) .build();String imageResult = client.responses().create(params).output().stream() .flatMap(item -> item.imageGenerationCall().stream()) .flatMap(call -> call.result().stream()) .findFirst() .orElseThrow(() -> new IllegalStateException("No generated image returned"));Files.write(Path.of("cat_and_otter.png"), Base64.getDecoder().decode(imageResult));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new(){ Model = "gpt-6-astra",};options.InputItems.Add( ResponseItem.CreateUserMessageItem( "Generate an image of a gray tabby cat hugging an otter with an orange scarf." ));options.Tools.Add( ResponseTool.CreateImageGenerationTool(model: "gpt-image-2"));ResponseResult response = await client.CreateResponseAsync(options);ImageGenerationCallResponseItem image = response .OutputItems.OfType<ImageGenerationCallResponseItem>() .FirstOrDefault() ?? throw new InvalidOperationException("No generated image was returned.");await File.WriteAllBytesAsync( "cat_and_otter.png", image.ImageResultBytes.ToArray());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "base64"require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.", tools: [{ type: :image_generation }])image_call = response.output.find do |item| item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)endunless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall) raise "No image generation call returned"endFile.binwrite( "cat_and_otter.png", Base64.strict_decode64(image_call.result))
1
2
3
4
5
6
7
8openai responses create \ --model gpt-6-astra \ --raw-output \ --transform 'output.#(type=="image_generation_call").result' <<'YAML' | base64 --decode > cat_and_otter.pngtools: - type: image_generationinput: Generate an image of a gray tabby cat hugging an otter with an orange scarf.YAML
GPT Image-Modelle können auch ohne Referenzbild auf Weltwissen zurückgreifen. Beschreibst du im Prompt beispielsweise eine Vitrine mit Halbedelsteinen, kann das Modell eine Szene erzeugen, in der sich Steine wie Amethyst, Rosenquarz und Jade erkennen lassen.
Bilder analysieren
Nutze ein Modell mit Bildverständnis, um Bilder zu beschreiben, sichtbaren Text zu lesen und Fragen zu Objekten, Formen, Farben oder Texturen zu beantworten. Berücksichtige die Einschränkungen des Modells, wenn du seine Antworten verwendest.
Bilder als Modelleingabe übergeben
Übergib ein Bild zur Analyse entweder über eine vollständig qualifizierte Bild-URL oder als Base64-kodierte Daten-URL.
Du kannst in einer einzigen Anfrage mehrere Bilder übergeben, indem du sie in das content-Array aufnimmst. Beachte, dass Bilder als Token zählen und entsprechend abgerechnet werden.
Du kannst ein Bild auf drei Arten zur Analyse übergeben:
Als vollständig qualifizierte URL einer Bilddatei
Als Base64-kodierte Daten-URL des Bildes
Als Datei-ID, die du mit der Files API erstellt hast
Du kannst in einer einzigen Anfrage mehrere Bilder übergeben, indem du sie in das content-Array aufnimmst. Beachte, dass Bilder als Token zählen und entsprechend abgerechnet werden.
Verwende ein unterstütztes Dateiformat und achte darauf, dass der Bildinhalt für das Modell klar erkennbar ist.
Anforderung
Unterstützte Eingaben
Dateitypen
PNG (.png), JPEG (.jpeg oder .jpg), WEBP (.webp) und nicht animierte GIFs (.gif)
Anfragegröße
Insgesamt bis zu 512 MB Nutzdaten pro Anfrage
Bildanzahl
Bis zu 1.500 Bilder pro Anfrage
Bei patchbasierten Bildeingaben unterstützt die API bis zu 30.000 Patches pro Bild. Maßgeblich ist die Anzahl nach der Größenanpassung für das gewählte Modell und die mit detail festgelegte Detailstufe. Die Grenze gilt bei allen unterstützten Detailstufen für jedes Bild einzeln. Die Patches der Anfrage werden dafür nicht über alle Bilder hinweg addiert.
Niedrigere Patchbudgets für die Größenanpassung gelten je nach Modell und Detailstufe weiterhin. Überschreitet ein Bild nach der Verarbeitung die Grenze von 30.000 Patches, lehnt die API die Anfrage ab. Sie verkleinert das Bild nicht automatisch, um diese Grenze einzuhalten. Verringere die Bildabmessungen und versuche es erneut.
Die Bildtoken müssen zusammen mit dem restlichen Prompt auch innerhalb der Eingabe- und Kontextgrenzen des Modells liegen. Eine Schätzung der Tokenanzahl garantiert nicht, dass die Anfrage alle Eingabegrenzen einhält. Halte bei der Verwendung von Bildern unsere Nutzungsrichtlinien ein.
Detailstufe für Bilder wählen
Der Parameter detail steuert die Vorverarbeitung von Bildern. Je nach Modell werden die Werte low, high, original oder auto unterstützt. Wenn du den Parameter weglässt, verwenden sowohl die Responses API als auch die Chat Completions API den Standardwert auto. Wie die Bildgröße jeweils angepasst wird, zeigt die Tabelle zur Größenanpassung.
Für einen groben Überblick über den Bildinhalt. Größenanpassung und Tokenverbrauch hängen vom Modell ab. low verbraucht nicht immer weniger Token als high.
high
Die übliche Einstellung für eine detailgetreue Bildanalyse, wenn du keine exakten Koordinaten im Originalbild brauchst.
original
Für große oder detailreiche Bilder, Aufgaben mit hohen Anforderungen an die räumliche Genauigkeit oder Bilder für die Computernutzung, sofern das Modell diese Stufe unterstützt.
auto
Für die standardmäßige Größenanpassung des Modells, wie in der Tabelle zur Größenanpassung beschrieben.
Verwende "detail": "original", sofern das Modell diese Einstellung unterstützt und feine Bilddetails oder präzise Koordinaten wichtig sind, etwa bei der optischen Zeichenerkennung (OCR), der Erkennung kleiner Objekte oder der Computernutzung. Auch bei dieser Detailstufe kann die API Bilder verkleinern, um die maximale Seitenlänge in Pixeln oder das Patchbudget des Modells für die Größenanpassung einzuhalten. Für die separate Grenze von 30.000 Patches erfolgt keine weitere Verkleinerung. Wenn es auf genaue Koordinaten ankommt, passe die Bildgröße vor dem Senden an die geltenden Grenzen an und rechne die zurückgegebenen Koordinaten auf das Originalbild um. Mehr zum Umgang mit Koordinaten findest du im Leitfaden zur Computernutzung.
Größenanpassung nach Modell
Die Tabelle zeigt, wie universell einsetzbare Modelle mit Bildverständnis die Bildgröße anpassen. Für andere Modelle und spezialisierte Varianten können andere Grenzen gelten. Bei jeder Größenanpassung bleibt das Seitenverhältnis erhalten. Kleinere Bilder werden nicht vergrößert.
Modellfamilie
Unterstützte Detailstufen
Patchgrenzen und Größenanpassung
gpt-6-astra
low, high, original,
auto
Bei low ist das Bild höchstens 512 × 512 Pixel groß. Bei high sind bis zu 2.500 Patches und eine maximale Seitenlänge von 65.535 Pixeln zulässig. Beide Grenzen gelten gleichzeitig.
original behält die Bildabmessungen bei. Ist eine Seite länger als 65.535 Pixel, wird das Bild so verkleinert, dass es diese Grenze einhält. Benötigt das Bild danach mehr als
30.000 Patches, lehnt die API die Anfrage ab. Das Bild wird nicht weiter verkleinert, um die Patchgrenze einzuhalten.
Bei auto gelten dieselben Größenregeln wie bei original.
gpt-5.6-sol, gpt-5.6-terra,
gpt-5.6-luna
low, high, original,
auto
Bei low ist das Bild höchstens 512 × 512 Pixel groß. Bei high gelten Obergrenzen von 2.048 × 2.048 Pixeln und 2.500 Patches. original
behält die Bildabmessungen bei. Ist eine Seite länger als 65.535 Pixel, wird das Bild so verkleinert, dass es diese Grenze einhält. Benötigt das Bild danach mehr als
30.000 Patches, lehnt die API die Anfrage ab. Das Bild wird nicht weiter verkleinert, um die Patchgrenze einzuhalten.
Bei auto gelten dieselben Größenregeln wie bei original.
gpt-5.5
low, high, original,
auto
Bei low ist das Bild höchstens 512 × 512 Pixel groß. Bei high sind bis zu 2.500 Patches und eine maximale Seitenlänge von 2.048 Pixeln zulässig. original
erlaubt bis zu 10.000 Patches und eine maximale Seitenlänge von 6.000 Pixeln. Beide Grenzen gelten gleichzeitig. Bei auto gelten dieselben Größenregeln wie bei
original.
gpt-5.4, gpt-5.4-mini, gpt-5.4-nano
low, high, original,
auto
Bei low gelten eine maximale Seitenlänge von 2.048 Pixeln und ein Budget von 6.144 Patches. Der Tokenverbrauch kann daher höher sein als bei high.
high erlaubt bis zu 2.500 Patches und eine maximale Seitenlänge von 2.048 Pixeln. original erlaubt bis zu 10.000 Patches und eine maximale Seitenlänge von 6.000 Pixeln. Beide Grenzen gelten gleichzeitig. Bei auto gelten dieselben Größenregeln wie bei high.
gpt-5.2, gpt-4.1-mini
low, high, auto
Für alle diese Detailstufen gelten eine maximale Seitenlänge von 2.048 Pixeln und ein Budget von 6.144 Patches. original wird nicht unterstützt.
Modelle mit Bildverständnis wandeln Bildeingaben in abrechenbare Eingabetoken um. Der Kostenrechner für Bildeingaben und die Regeln für Patches und Kacheln in diesem Abschnitt gelten für Bildeingaben dieser Modelle. Für das Generieren und Bearbeiten von Bildern mit GPT Image gelten eigene Preise, die im Abschnitt Bildeingaben für GPT Image-Modelle beschrieben sind.
Bildtoken zählen auch für deine Limits für Token pro Minute (TPM). Der Rechner schätzt die Kosten für ein einzelnes Bild zu den Standardpreisen für Eingabetoken. Der übrige Prompt und die Modellausgabe sind in der Schätzung nicht enthalten.
Kostenrechner für Bildeingaben
Mit dem Kostenrechner für Bildeingaben kannst du anhand von Modell, Bildgröße und Detailstufe die Anzahl der Eingabetoken und die Kosten für ein Bild schätzen.
Patchbasierte Tokenisierung von Bildern
Einige Modelle tokenisieren Bilder, indem sie die Bildfläche mit Patches von 32 × 32 Pixeln abdecken. Für viele Kombinationen aus Modell und Detailstufe gilt bei der Größenanpassung ein Patchbudget. Zunächst passt die API das Bild an die maximale Seitenlänge der gewählten Detailstufe an. Dabei behält sie das Seitenverhältnis bei und rundet auf ganze Pixel. Kleinere Bilder werden nicht vergrößert. Der Tokenverbrauch ergibt sich dann wie folgt:
A. Berechne, wie viele Patches von 32 × 32 Pixeln nötig sind, um das Bild nach Anwendung der Größenbegrenzung abzudecken. Ein Patch darf über den Bildrand hinausragen.
patch_count = ceil(width/32)×ceil(height/32)
B. Falls für das gewählte Modell und die Detailstufe ein Patchbudget für die Größenanpassung gilt und das Bild dieses Budget überschreitet, verkleinere es proportional. Andernfalls überspringe diesen Schritt. Passe den Skalierungsfaktor so an, dass die Anzahl der benötigten Patches auch nach der Umrechnung in ganze Pixel innerhalb des Budgets bleibt. Rechne bis zur Ermittlung der endgültigen Abmessungen mit voller Genauigkeit.
C. Falls du das Bild in Schritt B verkleinert hast, runde die skalierte Breite und Höhe auf ganze Pixel ab. Berechne, wie viele Patches nötig sind, um das resultierende Bild abzudecken. Das ist die Anzahl der Bildtoken vor Anwendung des Modellmultiplikators. Gilt ein Patchbudget, bleibt diese Anzahl innerhalb des Budgets.
Liegt die Anzahl über 30.000 Patches, lehnt die API die Anfrage ab. Prüfe diese Grenze, bevor du den Tokenmultiplikator anwendest.
D. Multipliziere die Patchanzahl mit dem Multiplikator des Modells und runde auf. So erhältst du die Anzahl der abrechenbaren Eingabetoken für das Bild. Wende auf diese Token einmal den Eingabepreis des Modells an. Der Multiplikator gilt weder für andere Token im Prompt noch für den Preis pro Token.
Modell
Multiplikator
gpt-6-astra
1,2
gpt-5.6-sol
1,2
gpt-5.6-terra
1,2
gpt-5.6-luna
1,2
gpt-5.5
1,2
gpt-5.4
1,2
gpt-5.4-mini
1,2
gpt-5.4-nano
1,2
gpt-5.2
1,2
gpt-5-mini*
1,2
gpt-5-nano*
1,5
gpt-4.1-mini
1,62
gpt-4.1-nano* (Snapshot vom 14. April 2025)
2,46
o4-mini*
1,72
Bei gpt-4.1-mini gilt dies für den Snapshot vom 14. April 2025.
* Diese Modelle sind veraltet und zur Abschaltung vorgesehen. Termine und Ersatzmodelle findest du im Zeitplan für die Abschaltung. Der Rechner und die obige Tabelle zur Größenanpassung enthalten diese Modelle nicht.
Beispiele zur Berechnung der Bildtoken für gpt-6-astra mit detail: high
Für diese Kombination gelten eine maximale Seitenlänge von 65.535 Pixeln, ein Budget von 2.500 Patches und ein Multiplikator von 1,2.
Ein Bild mit 1.024 × 1.024 Pixeln benötigt 32 × 32 = 1024 Patches. Eine Größenanpassung ist nicht nötig. Für die Bildeingabe werden ceil(1024 × 1.2) = 1229 Token abgerechnet.
Ein Bild mit 2.048 × 2.048 Pixeln benötigt zunächst 64 × 64 = 4096 Patches. Um das Patchbudget einzuhalten, wird es auf 1.600 × 1.600 Pixel verkleinert. Das entspricht 50 × 50 = 2500 Patches. Die Schätzung ergibt ceil(2500 × 1.2) = 3000 Token.
Ein Bild mit 4.096 × 512 Pixeln behält seine ursprüngliche Größe. Es benötigt 128 × 16 = 2048 Patches und damit ceil(2048 × 1.2) = 2458 Token.
Durch Rundung bei der Gleitkommaberechnung kann die abgerechnete Anzahl um ein Token von der Schätzung abweichen.
Kachelbasierte Tokenisierung von Bildern
Bei den Modellen in dieser Tabelle kommen zu einer festen Anzahl von Basistoken weitere Token für die Bildkacheln hinzu:
Modell
Basistoken
Token pro Kachel
gpt-5.1
70
140
gpt-5*
70
140
gpt-4o, gpt-4.1
85
170
gpt-4o-mini
2.833
5.667
o1*, o1-pro*, o3*
75
150
* Diese Modelle sind veraltet und zur Abschaltung vorgesehen. Termine und Ersatzmodelle findest du im Zeitplan für die Abschaltung. Der Rechner und die obige Tabelle zur Größenanpassung enthalten diese Modelle nicht.
Bei "detail": "low" fallen unabhängig von den Bildabmessungen nur die Basistoken des Modells an. Bei "detail": "high" oder "detail": "auto" gehst du so vor:
Verkleinere das Bild unter Beibehaltung des Seitenverhältnisses so weit, dass es in ein Quadrat von 2.048 × 2.048 Pixeln passt. Kleinere Bilder werden nicht vergrößert.
Ist die kürzere Seite länger als 768 Pixel, verkleinere sie auf 768 Pixel und runde die Länge der anderen Seite ab.
Zähle, wie viele Quadrate mit 512 Pixeln Seitenlänge nötig sind, um das Bild abzudecken. Für jedes Quadrat fällt die in der Tabelle angegebene Anzahl an Token pro Kachel an.
Addiere die Basistoken des Modells zur Gesamtzahl der Token für die Kacheln.
Bildeingaben für GPT Image-Modelle
Für GPT Image-Modelle gelten bei der Bildgenerierung und -bearbeitung eigene Preise für Bildtoken. Der Kostenrechner für Bildeingaben ermittelt weder die Eingabe- noch die Ausgabekosten dieser Modelle. Die aktuellen Preise findest du in der Preisübersicht zur Bildgenerierung. Wie du Bilder generierst und bearbeitest, erfährst du im Leitfaden zur Bildgenerierung.
GPT Image 1
gpt-image-1 wurde am 23. Oktober 2026 abgeschaltet. Mit den folgenden Regeln für Eingabetoken kannst du frühere Kosten vergleichen. Ersatzmodelle findest du in der Mitteilung zur Abschaltung.
Verwende für frühere Anfragen die kachelbasierte Größenanpassung, verkleinere die kürzere Seite jedoch auf 512 statt auf 768 Pixel. Der Tokenverbrauch hängt von den Bildabmessungen und vom Parameter input_fidelity der Images API ab.
Bei niedriger Eingabetreue fallen als Grundkosten 65 Bildtoken an. Jede Kachel kostet weitere 129 Bildtoken.
Bei hoher Eingabetreue kommt zu den oben beschriebenen Bildtoken eine feste Anzahl an Token hinzu, die sich nach dem Seitenverhältnis des Bildes richtet.
Bei einem quadratischen Bild kommen 4.160 Eingabetoken für das Bild hinzu.
Hat das Bild eher Hoch- oder Querformat, kommen 6.240 Token hinzu.
Modelle mit Bildverständnis können Fehler machen. Berücksichtige bei der Entwicklung deiner Anwendung die folgenden Einschränkungen:
Medizinische Bilder: Das Modell eignet sich nicht zur Interpretation medizinischer Spezialaufnahmen wie CT-Aufnahmen. Verwende es nicht für medizinische Beratung.
Nicht englischsprachige Inhalte: Bei Bildern mit Text in nicht lateinischen Schriftsystemen, etwa Japanisch oder Koreanisch, kann die Leistung des Modells nachlassen.
Kleine Schrift: Vergrößere den Text im Bild, damit er besser lesbar ist. Sofern verfügbar, kann "detail": "original" die Erkennung ebenfalls verbessern.
Drehung: Das Modell kann gedrehte oder auf dem Kopf stehende Texte und Bilder falsch interpretieren.
Visuelle Elemente: Unterschiedliche Farben oder Darstellungsweisen in Diagrammen oder Texten, etwa durchgezogene, gestrichelte oder gepunktete Linien, können dem Modell die Interpretation erschweren.
Räumliches Verständnis: Aufgaben, die eine präzise räumliche Zuordnung erfordern, fallen dem Modell schwer. Dazu gehört etwa das Erkennen von Stellungen auf einem Schachbrett.
Genauigkeit: Das Modell kann in bestimmten Situationen fehlerhafte Bildbeschreibungen oder Bildunterschriften erzeugen.
Bildform: Panorama- und Fischaugenaufnahmen sind für das Modell schwer zu interpretieren.
Metadaten und Größenanpassung: Das Modell verarbeitet weder die ursprünglichen Dateinamen noch die Metadaten. Die Bildgröße kann vor der Analyse angepasst werden, auch bei der Detailstufe original. Die Grenzen für die einzelnen Modelle findest du im Abschnitt Größenanpassung nach Modell.
Zählen: Beim Zählen von Objekten in Bildern liefert das Modell unter Umständen nur Näherungswerte.
CAPTCHAs: Aus Sicherheitsgründen blockiert unser System die Übermittlung von CAPTCHAs.