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.
Ermögliche Modellen, Bilder zu generieren oder zu bearbeiten.
Mit dem Tool zur Bildgenerierung kannst du Bilder anhand eines Textprompts generieren. Optional kannst du auch Bilder als Eingabe übergeben. Das Tool nutzt Modelle der GPT Image-Familie, darunter gpt-image-2.5-sunburst, gpt-image-2.5-flare, gpt-image-2, gpt-image-1.5 und gpt-image-1-mini. Es optimiert Texteingaben automatisch, um bessere Ergebnisse zu erzielen.
Setze beim Tool image_generation den Parameter model auf gpt-image-2.5-sunburst, wenn du Bilder präzise bearbeiten möchtest, oder auf gpt-image-2.5-flare, wenn du schnell hochwertige Bilder generieren möchtest. Gib im Feld model auf der obersten Ebene der Responses-Anfrage ein unterstütztes Hauptmodell an.
Wenn du das Tool image_generation in deiner Anfrage angibst, kann das Modell im Gespräch selbst entscheiden, wann und wie es Bilder generiert. Dabei berücksichtigt es deinen Prompt und alle Bilder, die du als Eingabe übergibst.
Das Ergebnis des Toolaufrufs image_generation_call enthält ein Base64-kodiertes Bild.
Wenn einzelne Personen deine Anwendung nutzen, gib bei jeder Responses-Anfrage auf der obersten Ebene einen stabilen, datenschutzfreundlichen safety_identifier an. Das gilt auch für spätere Bildbearbeitungen. Der Parameter gehört zur Anfrage und wird außerhalb der Optionen für das Tool image_generation angegeben. Hinweise für beide Bild-APIs findest du im Abschnitt zu Sicherheitskennungen für die Bildgenerierung.
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))
Größe: Bildabmessungen, zum Beispiel 1024 × 1024 oder 1024 × 1536
Qualität: Renderqualität, zum Beispiel niedrig, mittel oder hoch
Format: Dateiformat für die Ausgabe
Komprimierung: Komprimierungsgrad (0–100 %) für JPEG und WebP
Hintergrund: transparent, undurchsichtig oder automatisch gewählt
Aktion: Bildgenerierung oder Bildbearbeitung vorgeben oder die Auswahl dem Modell überlassen
size, quality und background unterstützen die Option auto. Damit wählt das Modell anhand des Prompts automatisch die am besten geeignete Einstellung.
Bei gpt-image-2.5-sunburst und gpt-image-2.5-flare akzeptiert quality auch die Werte xhigh und max. Frühere Modelle der GPT Image-Familie unterstützen diese Werte nicht. Die Standardeinstellung für die Qualität bleibt auto.
gpt-image-2 unterstützt flexible Werte für size, sofern sie die Vorgaben zur Auflösung erfüllen. Transparente Hintergründe sind als Vorschaufunktion verfügbar. Mit background: "transparent" forderst du einen transparenten Hintergrund an. Verwende dafür png (Standard) oder webp. Das Format jpeg unterstützt keine transparenten Hintergründe.
Wenn du das Tool zur Bildgenerierung in der Responses API verwendest, können unterstützte Modelle der GPT Image-Familie entscheiden, ob sie ein neues Bild generieren oder ein Bild aus dem bisherigen Gespräch bearbeiten. Dieses Verhalten steuerst du mit dem optionalen Parameter action. Lass action auf auto, damit das Modell selbst entscheidet. Mit generate oder edit gibst du die jeweilige Aktion vor. Wenn du keinen Wert angibst, gilt auto.
Überarbeiteter Prompt
Wenn du das Tool zur Bildgenerierung 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 Toolaufrufs zur Bildgenerierung:
1234567{ "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": "..."}
Tipps für Prompts
Die Bildgenerierung funktioniert am besten, wenn du in deinem Prompt Begriffe wie draw oder edit verwendest.
Wenn du zum Beispiel Bilder kombinieren möchtest, kannst du anstelle von combine oder merge eine konkrete Anweisung geben, etwa „Bearbeite das erste Bild, indem du dieses Element aus dem zweiten Bild hinzufügst.“
Bilder in mehreren Schritten bearbeiten
Du kannst Bilder schrittweise bearbeiten, indem du auf die ID einer früheren Antwort oder eines früheren Bildes verweist. So kannst du ein Bild im Laufe des Gesprächs weiter verfeinern.
Während das Tool zur Bildgenerierung das endgültige Bild erstellt, kann es Zwischenstände per Streaming übertragen. So sehen Nutzende früher ein erstes Ergebnis und die Wartezeit wirkt kürzer.
Mit dem Parameter partial_images legst du fest, wie viele Zwischenbilder übertragen werden (1–3).
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
Unterstützte Modelle
Die folgenden Modelle sind nicht als veraltet eingestuft und unterstützen laut Dokumentation das Tool zur Bildgenerierung in der Responses API. Gib die jeweilige Modell-ID im Feld model auf der obersten Ebene an. Informationen zur Verfügbarkeit und zu den Zugangsvoraussetzungen findest du auf der Seite des jeweiligen Modells.