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.
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:
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.
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.
Image API
Ein Bild generieren
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";import fs from "fs";const openai = new OpenAI();const prompt = `A children's book drawing of a veterinarian using a stethoscope tolisten to the heartbeat of a baby otter.`;const result = await openai.images.generate({ model: "gpt-image-2.5-sunburst", prompt,});// Save the image to a fileconst image_base64 = result.data?.[0]?.b64_json;if (!image_base64) throw new Error("Image generation returned no image.");const image_bytes = Buffer.from(image_base64, "base64");fs.writeFileSync("otter.png", image_bytes);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18from openai import OpenAIimport base64client = OpenAI()prompt ="""A children's book drawing of a veterinarian using a stethoscope tolisten 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_jsonimage_bytes = base64.b64decode(image_base64)# Save the image to a filewithopen("otter.png", "wb") as f: f.write(image_bytes)
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
28package mainimport ( "context" "encoding/base64" "os" "github.com/openai/openai-go/v3")func main() { client := openai.NewClient() result, err := client.Images.Generate(context.Background(), openai.ImageGenerateParams{ Model: openai.ImageModel("gpt-image-2.5-sunburst"), Prompt: "A children's book drawing of a veterinarian using a stethoscope to " + "listen to the heartbeat of a baby otter.", }) if err != nil { panic(err) } image, err := base64.StdEncoding.DecodeString(result.Data[0].B64JSON) if err != nil { panic(err) } if err := os.WriteFile("otter.png", image, 0o600); err != nil { panic(err) }}
1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Images;string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;string model = "gpt-image-2.5-sunburst";ImageClient client = new(model, key);GeneratedImage image = await client.GenerateImageAsync( "A children's book drawing of a veterinarian using a stethoscope to " + "listen to the heartbeat of a baby otter.");await File.WriteAllBytesAsync("otter.png", image.ImageBytes.ToArray());
1
2
3
4
5
6
7
8
9
10
11
12
13require "base64"require "openai"client = OpenAI::Client.newresult = client.images.generate( model: "gpt-image-2.5-sunburst", prompt: "A watercolor robot reading in a library")generated_image = result.data&.first or raise "No image returned"File.binwrite( "generated-image.png", Base64.strict_decode64(generated_image.b64_json))
1
2
3
4
5
6
7curl -X POST "https://api.openai.com/v1/images/generations" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-type: application/json" \ -d '{ "model": "gpt-image-2.5-sunburst", "prompt": "A children'\''s book drawing of a veterinarian using a stethoscope to listen to the heartbeat of a baby otter." }' | jq -r '.data[0].b64_json' | base64 --decode > otter.png
1
2
3
4
5openai images generate \ --model gpt-image-2.5-sunburst \ --prompt "A children's book drawing of a veterinarian using a stethoscope to listen to the heartbeat of a baby otter." \ --raw-output \ --transform 'data.0.b64_json' | base64 --decode > otter.png
Responses API
Ein Bild 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", model: "gpt-image-2.5-sunburst" }],});// 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("Image generation returned no image."); const fs = await import("fs"); fs.writeFileSync("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", "model": "gpt-image-2.5-sunburst"}],)# 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("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
42package 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 gray tabby cat hugging an otter with an orange scarf"), }, Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}}, }) if err != nil { panic(err) } saveFirstGeneratedImage(response, "otter.png")}func saveFirstGeneratedImage(response *responses.Response, filename string) { 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(filename, 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
20using 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.5-sunburst"));ResponseResult response = await client.CreateResponseAsync(options);ImageGenerationCallResponseItem image = response .OutputItems.OfType<ImageGenerationCallResponseItem>() .FirstOrDefault() ?? throw new InvalidOperationException("No generated image was returned.");await File.WriteAllBytesAsync("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
21
22
23
24require "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, model: "gpt-image-2.5-sunburst" } ])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"endencoded_image = image_call.result or raise "No image returned"File.binwrite("otter.png", Base64.strict_decode64(encoded_image))
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
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import 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", model: "gpt-image-2.5-sunburst", action: "generate" }, ],});// 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("Image generation returned no image."); const fs = await import("fs"); fs.writeFileSync("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
22
23
24from 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", "model": "gpt-image-2.5-sunburst", "action": "generate"} ],)# 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("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
38package 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 gray tabby cat hugging an otter with an orange scarf"), }, Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst", Action: "generate"}}}, }) 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("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
23
24
25using 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.5-sunburst", action: ImageGenerationToolAction.Generate ));ResponseResult response = await client.CreateResponseAsync(options);ImageGenerationCallResponseItem image = response .OutputItems.OfType<ImageGenerationCallResponseItem>() .FirstOrDefault() ?? throw new InvalidOperationException("No generated image was returned.");await File.WriteAllBytesAsync("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
21
22
23
24
25
26
27require "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, model: "gpt-image-2.5-sunburst", action: :generate } ])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"endencoded_image = image_call.result or raise "No image returned"output_path = ENV.fetch("OPENAI_EXAMPLE_OUTPUT_PATH", "otter.png")File.binwrite(output_path, Base64.decode64(encoded_image))puts(output_path)
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.
„Generiere ein Bild, auf dem eine grau getigerte Katze einen Otter umarmt, der einen orangefarbenen Schal trägt.“
„Lass das Bild jetzt realistisch aussehen.“
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.
Responses API
Ein Bild streamen
Python
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
34import OpenAI from "openai";import fs from "fs";const openai = new OpenAI();function saveBase64Image(filename: string, imageBase64: string | null) { if (!imageBase64) throw new Error("Image generation returned no image."); const imageBuffer = Buffer.from(imageBase64, "base64"); fs.writeFileSync(filename, imageBuffer);}const stream = await openai.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 await (const event of stream) { if (event.type === "response.image_generation_call.partial_image") { const idx = event.partial_image_index; saveBase64Image(`river-partial-${idx}.png`, event.partial_image_b64); } else if (event.type === "response.completed") { const imageData = event.response.output .filter((output) => output.type === "image_generation_call") .map((output) => output.result); if (imageData.length > 0) { saveBase64Image("river-final.png", imageData[0]); } }}
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
34from openai import OpenAIimport base64client = OpenAI()defsave_base64_image(filename, image_base64): image_bytes = base64.b64decode(image_base64)withopen(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.resultfor output in event.response.outputif output.type =="image_generation_call" ]if image_data: save_base64_image("river-final.png", image_data[0])
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
43
44
45
46
47
48
49package mainimport ( "context" "encoding/base64" "fmt" "os" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses")func main() { client := openai.NewClient() stream := client.Responses.NewStreaming(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Input: responses.ResponseNewParamsInputUnion{ OfString: openai.String("Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape"), }, Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst", PartialImages: openai.Int(2)}}}, }) for stream.Next() { event := stream.Current() if event.Type == "response.image_generation_call.partial_image" { partial := event.AsResponseImageGenerationCallPartialImage() saveImage(fmt.Sprintf("river-partial-%d.png", partial.PartialImageIndex), partial.PartialImageB64) } if event.Type == "response.completed" { for _, output := range event.AsResponseCompleted().Response.Output { if output.Type == "image_generation_call" { saveImage("river-final.png", output.AsImageGenerationCall().Result) } } } } if err := stream.Err(); err != nil { panic(err) }}func saveImage(filename, encoded string) { image, err := base64.StdEncoding.DecodeString(encoded) if err != nil { panic(err) } if err := os.WriteFile(filename, image, 0o600); err != nil { panic(err) }}
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
33require "base64"require "openai"client = OpenAI::Client.newstream = client.responses.stream( model: "gpt-6-astra", input: "Generate an image of a river made of white owl feathers.", tools: [ { type: :image_generation, model: "gpt-image-2.5-sunburst", partial_images: 2 } ])stream.each do |event| case event when OpenAI::Models::Responses::ResponseImageGenCallPartialImageEvent image = Base64.strict_decode64(event.partial_image_b64) File.binwrite("river-partial-#{event.partial_image_index}.png", image) when OpenAI::Models::Responses::ResponseCompletedEvent image_call = event.response.output.find do |item| item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall) end next unless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall) File.binwrite( "river-final.png", Base64.strict_decode64(image_call.result) ) endend
Image API
Ein Bild streamen
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import fs from "fs";import OpenAI from "openai";const openai = new OpenAI();const prompt = "Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape";const stream = await openai.images.generate({ prompt: prompt, model: "gpt-image-2.5-sunburst", stream: true, partial_images: 2,});for await (const event of stream) { if (event.type === "image_generation.partial_image") { const idx = event.partial_image_index; const imageBase64 = event.b64_json; if (!imageBase64) throw new Error("Image generation returned no image."); const imageBuffer = Buffer.from(imageBase64, "base64"); fs.writeFileSync(`river${idx}.png`, imageBuffer); }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19from openai import OpenAIimport base64client = OpenAI()stream = client.images.generate(prompt="Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape",model="gpt-image-2.5-sunburst",stream=True,partial_images=2,)for event in stream:if event.type =="image_generation.partial_image": idx = event.partial_image_index image_base64 = event.b64_json image_bytes = base64.b64decode(image_base64)withopen(f"river{idx}.png", "wb") as f: f.write(image_bytes)
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
40package mainimport ( "context" "encoding/base64" "fmt" "os" "github.com/openai/openai-go/v3")func main() { client := openai.NewClient() stream := client.Images.GenerateStreaming(context.Background(), openai.ImageGenerateParams{ Model: openai.ImageModel("gpt-image-2.5-sunburst"), Prompt: "Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape", PartialImages: openai.Int(2), }) for stream.Next() { event := stream.Current() if event.Type != "image_generation.partial_image" { continue } partial := event.AsImageGenerationPartialImage() saveImage(fmt.Sprintf("river%d.png", partial.PartialImageIndex), partial.B64JSON) } if err := stream.Err(); err != nil { panic(err) }}func saveImage(filename, encoded string) { image, err := base64.StdEncoding.DecodeString(encoded) if err != nil { panic(err) } if err := os.WriteFile(filename, image, 0o600); err != nil { panic(err) }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.images.ImageGenerateParams;import java.nio.file.Files;import java.nio.file.Path;import java.util.Base64;var params = ImageGenerateParams.builder() .prompt( "Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape") .model("gpt-image-2.5-sunburst") .partialImages(2) .build();try (var stream = client.images().generateStreaming(params)) { var events = stream.stream().iterator(); while (events.hasNext()) { var event = events.next(); if (event.generationPartialImage().isPresent()) { var partial = event.generationPartialImage().orElseThrow(); Files.write( Path.of("river" + partial.partialImageIndex() + ".png"), Base64.getDecoder().decode(partial.b64Json())); } }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "base64"require "openai"client = OpenAI::Client.newstream = client.images.generate_stream_raw( model: "gpt-image-2.5-sunburst", prompt: "A river made of white owl feathers in a winter landscape", partial_images: 2)stream.each do |event| next unless event.is_a?(OpenAI::Models::ImageGenPartialImageEvent) image = Base64.strict_decode64(event.b64_json) File.binwrite("river#{event.partial_image_index}.png", image)end
Ergebnis
Zwischenbild 1
Zwischenbild 2
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
1
2
3
4
5
6
7{"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": "..."}
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.
Responses API
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
Python
1
2
3
4
5
6
7
8
9
10
11
12
13import fs from "fs";import OpenAI from "openai";const openai = new OpenAI();async function createFile(filePath: fs.PathLike) { const fileContent = fs.createReadStream(filePath); const result = await openai.files.create({ file: fileContent, purpose: "vision", }); return result.id;}
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58require "base64"require "openai"require "pathname"client = OpenAI::Client.newbase64_images = ["body-lotion.png", "soap.png"].map do |path| Base64.strict_encode64(File.binread(path))endfile_ids = [ client.files.create(file: Pathname("bath-bomb.png"), purpose: :vision).id, client.files.create(file: Pathname("incense-kit.png"), purpose: :vision).id]prompt = <<~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.PROMPTresponse = client.responses.create( model: "gpt-6-astra", input: [ { role: :user, content: [ { type: :input_text, text: prompt }, *base64_images.map do |image| { type: :input_image, image_url: "data:image/png;base64,#{image}" } end, *file_ids.map do |file_id| { type: :input_image, file_id: file_id } end ] } ], tools: [ { type: :image_generation, model: "gpt-image-2.5-sunburst" } ])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("gift-basket.png", Base64.strict_decode64(image_call.result))
Image API
Ein Bild bearbeiten
Python
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
38import fs from "fs";import OpenAI, { toFile } from "openai";const client = new OpenAI();const prompt = `Generate a photorealistic image of a gift basket on a white backgroundlabeled 'Relax & Unwind' with a ribbon and handwriting-like font,containing all the items in the reference pictures.`;const imageFiles = [ "fixtures/bath-bomb.png", "fixtures/body-lotion.png", "fixtures/incense-kit.png", "fixtures/soap.png",];const images = await Promise.all( imageFiles.map( async (file) => await toFile(fs.createReadStream(file), null, { type: "image/png", }) ));const response = await client.images.edit({ model: "gpt-image-2.5-sunburst", image: images, prompt,});// Save the image to a fileconst image_base64 = response.data?.[0]?.b64_json;if (!image_base64) throw new Error("Image generation returned no image.");const image_bytes = Buffer.from(image_base64, "base64");fs.writeFileSync("basket.png", image_bytes);
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
28import base64from openai import OpenAIclient = OpenAI()prompt ="""Generate a photorealistic image of a gift basket on a white backgroundlabeled 'Relax & Unwind' with a ribbon and handwriting-like font,containing all the items in the reference pictures."""result = client.images.edit(model="gpt-image-2.5-sunburst",image=[open("body-lotion.png", "rb"),open("bath-bomb.png", "rb"),open("incense-kit.png", "rb"),open("soap.png", "rb"), ],prompt=prompt,)image_base64 = result.data[0].b64_jsonimage_bytes = base64.b64decode(image_base64)# Save the image to a filewithopen("gift-basket.png", "wb") as f: f.write(image_bytes)
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65package mainimport ( "context" "encoding/base64" "io" "os" "github.com/openai/openai-go/v3")func main() { client := openai.NewClient() files, closeFiles := openImages( "bath-bomb.png", "body-lotion.png", "incense-kit.png", "soap.png", ) defer closeFiles() response, err := client.Images.Edit(context.Background(), openai.ImageEditParams{ Model: openai.ImageModel("gpt-image-2.5-sunburst"), Image: openai.ImageEditParamsImageUnion{OfFileArray: files}, 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.", }) if err != nil { panic(err) } saveImage("basket.png", response.Data[0].B64JSON)}func openImages(names ...string) ([]io.Reader, func()) { images := make([]io.Reader, 0, len(names)) files := make([]*os.File, 0, len(names)) for _, name := range names { file, err := os.Open(name) if err != nil { closeFiles(files) panic(err) } images = append(images, openai.File(file, name, "image/png")) files = append(files, file) } return images, func() { closeFiles(files) }}func closeFiles(files []*os.File) { for _, file := range files { if err := file.Close(); err != nil { panic(err) } }}func saveImage(filename, encoded string) { image, err := base64.StdEncoding.DecodeString(encoded) if err != nil { panic(err) } if err := os.WriteFile(filename, image, 0o600); err != nil { panic(err) }}
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
43
44
45import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.MultipartField;import com.openai.models.images.ImageEditParams;import java.io.IOException;import java.io.InputStream;import java.nio.file.Files;import java.nio.file.Path;import java.util.Base64;import java.util.List;Path lotion = Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH"));Path soap = Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH_2"));Path bathBomb = Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH_3"));Path incense = Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH_4"));try (InputStream lotionImage = Files.newInputStream(lotion); InputStream bathBombImage = Files.newInputStream(bathBomb); InputStream incenseImage = Files.newInputStream(incense); InputStream soapImage = Files.newInputStream(soap)) { var images = client .images() .edit( ImageEditParams.builder() .model("gpt-image-2.5-sunburst") .image( MultipartField.<ImageEditParams.Image>builder() .value( ImageEditParams.Image.ofInputStreams( List.of(lotionImage, bathBombImage, incenseImage, soapImage))) .contentType("image/png") .filename("gift-basket-reference.png") .build()) .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. """) .build()); Files.write( Path.of("gift-basket.png"), Base64.getDecoder().decode(images.data().orElseThrow().get(0).b64Json().orElseThrow()));}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "base64"require "openai"require "pathname"client = OpenAI::Client.newimages = %w[body-lotion.png bath-bomb.png incense-kit.png soap.png].map do |path| OpenAI::FilePart.new(Pathname(path), content_type: "image/png")endresult = client.images.edit( image: images, model: "gpt-image-2.5-sunburst", prompt: <<~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. PROMPT)generated_image = result.data&.first or raise "No image returned"File.binwrite("gift-basket.png", Base64.strict_decode64(generated_image.b64_json))
1
2
3
4
5
6
7
8
9
10curl -s -D >(grep -i x-request-id >&2) \ -o >(jq -r '.data[0].b64_json' | base64 --decode > gift-basket.png) \ -X POST "https://api.openai.com/v1/images/edits" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -F "model=gpt-image-2.5-sunburst" \ -F "image[]=@body-lotion.png" \ -F "image[]=@bath-bomb.png" \ -F "image[]=@incense-kit.png" \ -F "image[]=@soap.png" \ -F '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'
1
2
3
4
5
6
7
8
9openai images edit \ --model gpt-image-2.5-sunburst \ --image body-lotion.png \ --image bath-bomb.png \ --image incense-kit.png \ --image soap.png \ --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' \ --raw-output \ --transform 'data.0.b64_json' | base64 --decode > gift-basket.png
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
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import base64from pathlib import Pathfrom openai import OpenAIclient = OpenAI()overlay = Path("markup-vase-overlay-gpt-image-2-6.png")withopen("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))
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
31client := openai.NewClient()image, err := os.Open("kitchen.webp")if err != nil { panic(err)}defer image.Close()markup, err := os.Open("markup-vase-overlay-gpt-image-2-6.png")if err != nil { panic(err)}defer markup.Close()response, err := client.Images.Edit(context.Background(), openai.ImageEditParams{ Model: openai.ImageModel("gpt-image-2.6-flare"), Image: openai.ImageEditParamsImageUnion{OfFile: openai.File(image, "kitchen.webp", "image/webp")}, Markup: openai.File(markup, "markup-vase-overlay-gpt-image-2-6.png", "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.",})if err != nil { panic(err)}result, err := base64.StdEncoding.DecodeString(response.Data[0].B64JSON)if err != nil { panic(err)}if err := os.WriteFile("vase.png", result, 0o600); err != nil { panic(err)}
1
2
3
4
5
6
7
8
9
10set -euo pipefailcurl --fail --silent --show-error https://api.openai.com/v1/images/edits \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -F model=gpt-image-2.6-flare \ -F quality=medium \ -F 'image=@kitchen.webp;type=image/webp' \ -F 'markup=@markup-vase-overlay-gpt-image-2-6.png;type=image/png' \ -F '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.' | jq -er '.data[0].b64_json' | base64 --decode > vase.png
Foto mit Markierungsebene
Ergebnis von Flare
Verwende das Originalbild als erstes Eingabebild.
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.
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.
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.
Responses API
Ein Bild mit einer Maske bearbeiten
Python
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
43
44
45
46
47
48
49
50
51
52
53
54
55import fs from "fs";import OpenAI from "openai";const openai = new OpenAI();async function createFile(filePath: fs.PathLike) { const result = await openai.files.create({ file: fs.createReadStream(filePath), purpose: "vision", }); return result.id;}const fileId = await createFile("fixtures/sunlit_lounge.png");const maskId = await createFile("fixtures/mask.png");const response = await openai.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, detail: "auto", }, ], }, ], tools: [ { type: "image_generation", model: "gpt-image-2.5-sunburst", quality: "high", input_image_mask: { file_id: maskId, }, }, ],});const 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("Image generation returned no image."); fs.writeFileSync("lounge.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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54from openai import OpenAIimport base64client = OpenAI()defcreate_file(file_path):withopen(file_path, "rb") as file_content: result = client.files.create(file=file_content, purpose="vision")return result.idfileId = 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.resultfor output in response.outputif output.type =="image_generation_call"]if image_data: image_base64 = image_data[0]withopen("lounge.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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67package mainimport ( "context" "encoding/base64" "os" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses")func main() { client := openai.NewClient() imageID := uploadImage(client, "sunlit_lounge.png") maskID := uploadImage(client, "mask.png") response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{ responses.ResponseInputItemParamOfMessage( responses.ResponseInputMessageContentListParam{ responses.ResponseInputContentParamOfInputText("Generate an image of the same sunlit indoor lounge area with a pool, but the pool should contain a flamingo."), {OfInputImage: &responses.ResponseInputImageParam{FileID: openai.String(imageID), Detail: responses.ResponseInputImageDetailAuto}}, }, responses.EasyInputMessageRoleUser, ), }}, Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{ Model: "gpt-image-2.5-sunburst", Quality: "high", InputImageMask: responses.ToolImageGenerationInputImageMaskParam{FileID: openai.String(maskID)}, }}}, }) if err != nil { panic(err) } saveFirstGeneratedImage(response, "lounge.png")}func uploadImage(client openai.Client, filename string) string { file, err := os.Open(filename) if err != nil { panic(err) } defer file.Close() uploaded, err := client.Files.New(context.Background(), openai.FileNewParams{File: file, Purpose: openai.FilePurposeVision}) if err != nil { panic(err) } return uploaded.ID}func saveFirstGeneratedImage(response *responses.Response, filename string) { 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(filename, 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
15require "openai"require "pathname"require "base64"client = OpenAI::Client.newimage = OpenAI::FilePart.new(Pathname("sunlit_lounge.png"), content_type: "image/png")mask = OpenAI::FilePart.new(Pathname("mask.png"), content_type: "image/png")result = client.images.edit( image: image, mask: mask, model: "gpt-image-2.5-sunburst", prompt: "A sunlit indoor lounge area with a pool containing a flamingo")generated_image = result.data&.first or raise "No image returned"File.binwrite("lounge.png", Base64.strict_decode64(generated_image.b64_json))
1
2
3
4
5
6
7
8curl -s -D >(grep -i x-request-id >&2) \ -o >(jq -r '.data[0].b64_json' | base64 --decode > lounge.png) \ -X POST "https://api.openai.com/v1/images/edits" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -F "model=gpt-image-2.5-sunburst" \ -F "mask=@mask.png" \ -F "image[]=@sunlit_lounge.png" \ -F 'prompt=A sunlit indoor lounge area with a pool containing a flamingo'
1
2
3
4
5
6
7openai images edit \ --model gpt-image-2.5-sunburst \ --image sunlit_lounge.png \ --mask mask.png \ --prompt "A sunlit indoor lounge area with a pool containing a flamingo" \ --raw-output \ --transform 'data.0.b64_json' | base64 --decode > out.png
Bild
Maske
Ausgabe
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
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21fromPILimport Imagefrom io import BytesIO# 1. Load your black & white mask as a grayscale imagemask = Image.open("mask.png").convert("L")# 2. Convert it to RGBA so it has space for an alpha channelmask_rgba = mask.convert("RGBA")# 3. Then use the mask itself to fill that alpha channelmask_rgba.putalpha(mask)# 4. Convert the mask into bytesbuf = BytesIO()mask_rgba.save(buf, format="PNG")mask_bytes = buf.getvalue()# 5. Save the resulting fileimg_path_mask_alpha ="mask_alpha.png"withopen(img_path_mask_alpha, "wb") as f: f.write(mask_bytes)
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.
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:
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
TypeScript
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
43
44
45
46
47
48
49
50
51import OpenAI from"openai";constopenai=newOpenAI();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 instanceofOpenAI.APIError) || error.code !=="moderation_blocked" ) {throw error; }constmoderationDetails= error.error &&"moderation_details"in error.error? (error.error.moderation_details as {categories?:string[];moderation_stage?:string; }):undefined;constcategories= moderationDetails?.categories ?? [];conststage= 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."; } elseif (stage ==="input") { hint ="Try revising the prompt or input images and submit the request again."; } elseif (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);}
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
40import openaifrom openai import OpenAIclient = OpenAI()try: # The same error handling pattern applies to image generation requests, # image edits, and Responses API tool calls that generate images. client.images.generate( model="gpt-image-2.5-sunburst", prompt="Create a poster humiliating my coworker with insulting captions", )except openai.BadRequestError as error: if error.code != "moderation_blocked": raise error_body = error.body if isinstance(error.body, dict) else {} moderation_details = error_body.get("moderation_details") or {} categories = moderation_details.get("categories") or [] stage = moderation_details.get("moderation_stage") hint = "This request could not be completed because it did not meet safety requirements." if "harassment" in categories: hint = "Try removing abusive or targeting language and focus on neutral visual details instead." elif stage == "input": hint = "Try revising the prompt or input images and submit the request again." elif stage == "output": hint = "The generated result was blocked by a safety check. Try changing the prompt and generating again." print( "Image generation blocked", { "request_id": error.request_id, "code": error.code, "moderation_details": moderation_details, }, ) print(hint)
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
43
44
45
46
47
48package mainimport ( "context" "encoding/json" "errors" "fmt" "slices" "github.com/openai/openai-go/v3")func main() { client := openai.NewClient() _, err := client.Images.Generate(context.Background(), openai.ImageGenerateParams{ Model: openai.ImageModel("gpt-image-2.5-sunburst"), Prompt: "Create a poster humiliating my coworker with insulting captions", }) if err == nil { return } var apiError *openai.Error if !errors.As(err, &apiError) || apiError.Code != "moderation_blocked" { panic(err) } var body struct { ModerationDetails struct { Categories []string `json:"categories"` ModerationStage string `json:"moderation_stage"` } `json:"moderation_details"` } if err := json.Unmarshal([]byte(apiError.RawJSON()), &body); err != nil { panic(err) } hint := "This request could not be completed because it did not meet safety requirements." if slices.Contains(body.ModerationDetails.Categories, "harassment") { hint = "Try removing abusive or targeting language and focus on neutral visual details instead." } else if body.ModerationDetails.ModerationStage == "input" { hint = "Try revising the prompt or input images and submit the request again." } else if body.ModerationDetails.ModerationStage == "output" { hint = "The generated result was blocked by a safety check. Try changing the prompt and generating again." } fmt.Printf("Image generation blocked (%s): %s\n", apiError.Code, hint)}
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
38import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.errors.BadRequestException;import com.openai.models.images.ImageGenerateParams;import java.util.List;import java.util.Map;try { var images = client .images() .generate( ImageGenerateParams.builder() .model("gpt-image-2.5-sunburst") .prompt("Create a poster humiliating my coworker with insulting captions") .build()); System.out.println(images.data().orElseThrow().get(0).b64Json().orElseThrow());} catch (BadRequestException error) { if (!error.code().orElse("").equals("moderation_blocked")) { throw error; } Map<?, ?> body = error.body().convert(Map.class); Object detailsValue = body.get("moderation_details"); Map<?, ?> details = detailsValue instanceof Map<?, ?> values ? values : Map.of(); Object categories = details.get("categories"); Object stage = details.get("moderation_stage"); String hint = "This request did not meet safety requirements."; if (categories instanceof List<?> values && values.contains("harassment")) { hint = "Remove abusive or targeting language and focus on neutral visual details."; } else if ("input".equals(stage)) { hint = "Revise the prompt or input images, then submit the request again."; } else if ("output".equals(stage)) { hint = "Change the prompt and generate again; the generated result was blocked."; } System.err.println("Image generation blocked (" + error.code().orElseThrow() + "): " + hint);}
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
28require "openai"client = OpenAI::Client.newbegin client.images.generate( model: "gpt-image-2.5-sunburst", prompt: "Create a poster humiliating my coworker with insulting captions" )rescue OpenAI::Errors::BadRequestError => error raise unless error.code == "moderation_blocked" body = Hash.try_convert(error.body) || {} body = Hash.try_convert(body[:error] || body["error"]) || body moderation_details = body[:moderation_details] || body["moderation_details"] || {} categories = moderation_details[:categories] || moderation_details["categories"] || [] stage = moderation_details[:moderation_stage] || moderation_details["moderation_stage"] hint = "This request did not meet safety requirements." if categories.include?("harassment") hint = "Remove abusive or targeting language and focus on neutral visual details." elsif stage == "input" hint = "Revise the prompt or input images, then submit the request again." elsif stage == "output" hint = "Change the prompt and generate again; the generated result was blocked." end warn("Image generation blocked (#{error.code}): #{hint}")end
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.
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.
ModellModellGPT-Image-2.6 (Sunburst and Flare)
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.