Repository Public
1# Image generation23> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.45The image generation tool allows you to generate images using a text prompt, and optionally image inputs. It uses GPT Image models, including `gpt-image-2.5-sunburst`, `gpt-image-2.5-flare`, `gpt-image-2`, `gpt-image-1.5`, `gpt-image-1`, and `gpt-image-1-mini`, and automatically optimizes text inputs for improved performance.67Set the `image_generation` tool's `model` to `gpt-image-2.5-sunburst` for precise editing, or `gpt-image-2.5-flare` for fast, high-quality image generation. Use a supported mainline model in the top-level Responses `model` field.89To learn more about image generation, refer to our dedicated [image generation10 guide](https://developers.openai.com/api/docs/guides/image-generation?api=responses).1112## Usage1314When you include the `image_generation` tool in your request, the model can decide when and how to generate images as part of the conversation, using your prompt and any provided image inputs.1516The `image_generation_call` tool call result will include a base64-encoded image.1718Generate an image1920```javascript21import OpenAI from "openai";22const openai = new OpenAI();2324const response = await openai.responses.create({25 model: "gpt-6-astra",26 input:27 "Generate an image of gray tabby cat hugging an otter with an orange scarf",28 tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst" }],29});3031// Save the image to a file32const imageData = response.output33 .filter((output) => output.type === "image_generation_call")34 .map((output) => output.result);3536if (imageData.length > 0) {37 const imageBase64 = imageData[0];38 const fs = await import("fs");39 fs.writeFileSync("otter.png", Buffer.from(imageBase64, "base64"));40}41```4243```python44from openai import OpenAI45import base644647client = OpenAI()4849response = client.responses.create(50 model="gpt-6-astra",51 input="Generate an image of gray tabby cat hugging an otter with an orange scarf",52 tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],53)5455# Save the image to a file56image_data = [57 output.result58 for output in response.output59 if output.type == "image_generation_call"60]6162if image_data:63 image_base64 = image_data[0]64 with open("otter.png", "wb") as f:65 f.write(base64.b64decode(image_base64))66```6768```go69package main7071import (72 "context"73 "encoding/base64"74 "os"7576 "github.com/openai/openai-go/v3"77 "github.com/openai/openai-go/v3/responses"78)7980func main() {81 client := openai.NewClient()82 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{83 Model: "gpt-6-astra",84 Input: responses.ResponseNewParamsInputUnion{85 OfString: openai.String("Generate an image of gray tabby cat hugging an otter with an orange scarf"),86 },87 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}},88 })89 if err != nil {90 panic(err)91 }92 saveFirstGeneratedImage(response, "otter.png")93}9495func saveFirstGeneratedImage(response *responses.Response, filename string) {96 for _, output := range response.Output {97 if output.Type != "image_generation_call" {98 continue99 }100 image, err := base64.StdEncoding.DecodeString(output.AsImageGenerationCall().Result)101 if err != nil {102 panic(err)103 }104 if err := os.WriteFile(filename, image, 0o600); err != nil {105 panic(err)106 }107 return108 }109 panic("response did not include an image generation call")110}111```112113```java114import com.openai.client.OpenAIClient;115import com.openai.client.okhttp.OpenAIOkHttpClient;116import com.openai.models.responses.ResponseCreateParams;117import com.openai.models.responses.Tool;118import java.nio.file.Files;119import java.nio.file.Path;120import java.util.Base64;121122ResponseCreateParams params =123 ResponseCreateParams.builder()124 .model("gpt-6-astra")125 .input("Generate an image of a gray tabby cat hugging an otter with an orange scarf.")126 .addTool(Tool.ImageGeneration.builder().build())127 .build();128129var image =130 client.responses().create(params).output().stream()131 .flatMap(item -> item.imageGenerationCall().stream())132 .findFirst()133 .orElseThrow(() -> new IllegalStateException("No image generation call returned"));134String encoded =135 image.result().orElseThrow(() -> new IllegalStateException("No image returned"));136Files.write(Path.of("otter.png"), Base64.getDecoder().decode(encoded));137```138139```csharp140using OpenAI.Responses;141#pragma warning disable OPENAI001142143string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;144ResponsesClient client = new(key);145146CreateResponseOptions options = new() { Model = "gpt-6-astra" };147options.InputItems.Add(148 ResponseItem.CreateUserMessageItem(149 "Generate an image of a gray tabby cat hugging an otter with an orange scarf."150 )151);152options.Tools.Add(ResponseTool.CreateImageGenerationTool(model: "gpt-image-2.5-sunburst"));153154ResponseResult response = await client.CreateResponseAsync(options);155ImageGenerationCallResponseItem image = response156 .OutputItems.OfType<ImageGenerationCallResponseItem>()157 .FirstOrDefault()158 ?? throw new InvalidOperationException("No generated image was returned.");159await File.WriteAllBytesAsync("otter.png", image.ImageResultBytes.ToArray());160```161162```ruby163require "base64"164require "openai"165166client = OpenAI::Client.new167response = client.responses.create(168 model: "gpt-6-astra",169 input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",170 tools: [171 {172 type: :image_generation,173 model: "gpt-image-2.5-sunburst"174 }175 ]176)177178image_call = response.output.find do |item|179 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)180end181unless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)182 raise "No image generation call returned"183end184185encoded_image = image_call.result or raise "No image returned"186File.binwrite("otter.png", Base64.strict_decode64(encoded_image))187```188189190You can [provide input images](https://developers.openai.com/api/docs/guides/image-generation?image-generation-model=gpt-image#edit-images) using file IDs or base64 data.191192To force the image generation tool call, you can set the parameter `tool_choice` to `{"type": "image_generation"}`.193194### Tool options195196You can configure the following output options as parameters for the [image generation tool](https://developers.openai.com/api/reference/resources/responses/methods/create#responses-create-tools):197198- Size: Image dimensions, for example, 1024 × 1024 or 1024 × 1536199- Quality: Rendering quality, for example, low, medium, or high200- Format: File output format201- Compression: Compression level (0-100%) for JPEG and WebP formats202- Background: Transparent, opaque, or automatic203- Action: Whether the request should automatically choose, generate, or edit an image204205`size`, `quality`, and `background` support the `auto` option, where the model will automatically select the best option based on the prompt.206207For `gpt-image-2.5-sunburst` and `gpt-image-2.5-flare`, `quality` also accepts `xhigh` and `max`. These values are not supported by earlier GPT Image models. The default quality remains `auto`.208209`gpt-image-2` supports flexible `size` values that meet its [resolution constraints](https://developers.openai.com/api/docs/guides/image-generation#earlier-gpt-image-models). Transparent backgrounds are available in preview; set `background: "transparent"` to request one. Use `png` (the default) or `webp`; `jpeg` isn't supported with transparent backgrounds.210211For more details on available options, refer to the [image generation guide](https://developers.openai.com/api/docs/guides/image-generation#customize-image-output).212213When using the Responses API image generation tool, supported GPT Image models can choose whether to generate a new image or edit one already in the conversation. The optional `action` parameter controls this behavior: keep `action` set to `auto` so the model chooses whether to generate or edit, or set it to `generate` or `edit` to force that behavior. If not specified, the default is `auto`.214215### Revised prompt216217When using the image generation tool, the mainline model, for example, `gpt-5.5`, will automatically revise your prompt for improved performance.218219You can access the revised prompt in the `revised_prompt` field of the image generation call:220221```json222{223 "id": "ig_123",224 "type": "image_generation_call",225 "status": "completed",226 "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.",227 "result": "..."228}229```230231### Prompting tips232233Image generation works best when you use terms like `draw` or `edit` in your prompt.234235For example, if you want to combine images, instead of saying `combine` or `merge`, you can say something like "edit the first image by adding this element from the second image."236237## Multi-turn editing238239You can iteratively edit images by referencing previous response or image IDs. This allows you to refine images across conversation turns.240241242243Using previous response ID244245 Multi-turn image generation246247```javascript248import OpenAI from "openai";249const openai = new OpenAI();250251const response = await openai.responses.create({252 model: "gpt-6-astra",253 input:254 "Generate an image of gray tabby cat hugging an otter with an orange scarf",255 tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst" }],256});257258const imageData = response.output259 .filter((output) => output.type === "image_generation_call")260 .map((output) => output.result);261262if (imageData.length > 0) {263 const imageBase64 = imageData[0];264 const fs = await import("fs");265 fs.writeFileSync("cat_and_otter.png", Buffer.from(imageBase64, "base64"));266}267268// Follow up269270const response_fwup = await openai.responses.create({271 model: "gpt-6-astra",272 previous_response_id: response.id,273 input: "Now make it look realistic",274 tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst" }],275});276277const imageData_fwup = response_fwup.output278 .filter((output) => output.type === "image_generation_call")279 .map((output) => output.result);280281if (imageData_fwup.length > 0) {282 const imageBase64 = imageData_fwup[0];283 const fs = await import("fs");284 fs.writeFileSync(285 "cat_and_otter_realistic.png",286 Buffer.from(imageBase64, "base64")287 );288}289```290291```python292from openai import OpenAI293import base64294295client = OpenAI()296297response = client.responses.create(298 model="gpt-6-astra",299 input="Generate an image of gray tabby cat hugging an otter with an orange scarf",300 tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],301)302303image_data = [304 output.result305 for output in response.output306 if output.type == "image_generation_call"307]308309if image_data:310 image_base64 = image_data[0]311312 with open("cat_and_otter.png", "wb") as f:313 f.write(base64.b64decode(image_base64))314315316# Follow up317318response_fwup = client.responses.create(319 model="gpt-6-astra",320 previous_response_id=response.id,321 input="Now make it look realistic",322 tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],323)324325image_data_fwup = [326 output.result327 for output in response_fwup.output328 if output.type == "image_generation_call"329]330331if image_data_fwup:332 image_base64 = image_data_fwup[0]333 with open("cat_and_otter_realistic.png", "wb") as f:334 f.write(base64.b64decode(image_base64))335```336337```go338package main339340import (341 "context"342 "encoding/base64"343 "os"344345 "github.com/openai/openai-go/v3"346 "github.com/openai/openai-go/v3/responses"347)348349func main() {350 client := openai.NewClient()351 first, err := client.Responses.New(context.Background(), responses.ResponseNewParams{352 Model: "gpt-6-astra",353 Input: responses.ResponseNewParamsInputUnion{354 OfString: openai.String("Generate an image of gray tabby cat hugging an otter with an orange scarf"),355 },356 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}},357 })358 if err != nil {359 panic(err)360 }361 saveFirstGeneratedImage(first, "cat_and_otter.png")362363 followUp, err := client.Responses.New(context.Background(), responses.ResponseNewParams{364 Model: "gpt-6-astra",365 PreviousResponseID: openai.String(first.ID),366 Input: responses.ResponseNewParamsInputUnion{367 OfString: openai.String("Now make it look realistic"),368 },369 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}},370 })371 if err != nil {372 panic(err)373 }374 saveFirstGeneratedImage(followUp, "cat_and_otter_realistic.png")375}376377func saveFirstGeneratedImage(response *responses.Response, filename string) {378 for _, output := range response.Output {379 if output.Type != "image_generation_call" {380 continue381 }382 image, err := base64.StdEncoding.DecodeString(output.AsImageGenerationCall().Result)383 if err != nil {384 panic(err)385 }386 if err := os.WriteFile(filename, image, 0o600); err != nil {387 panic(err)388 }389 return390 }391 panic("response did not include an image generation call")392}393```394395```java396import com.openai.client.OpenAIClient;397import com.openai.client.okhttp.OpenAIOkHttpClient;398import com.openai.models.responses.ResponseCreateParams;399import com.openai.models.responses.Tool;400import java.nio.file.Files;401import java.nio.file.Path;402import java.util.Base64;403404var first =405 client406 .responses()407 .create(408 ResponseCreateParams.builder()409 .model("gpt-6-astra")410 .input(411 "Generate an image of a gray tabby cat hugging an otter with an orange scarf.")412 .addTool(Tool.ImageGeneration.builder().build())413 .build());414var firstImage =415 first.output().stream()416 .flatMap(item -> item.imageGenerationCall().stream())417 .findFirst()418 .orElseThrow(() -> new IllegalStateException("No image generation call returned"));419Files.write(420 Path.of("cat_and_otter.png"),421 Base64.getDecoder()422 .decode(423 firstImage424 .result()425 .orElseThrow(() -> new IllegalStateException("No image returned"))));426427var second =428 client429 .responses()430 .create(431 ResponseCreateParams.builder()432 .model("gpt-6-astra")433 .input("Now make it look realistic.")434 .previousResponseId(first.id())435 .addTool(Tool.ImageGeneration.builder().build())436 .build());437var secondImage =438 second.output().stream()439 .flatMap(item -> item.imageGenerationCall().stream())440 .findFirst()441 .orElseThrow(442 () -> new IllegalStateException("No follow-up image generation call returned"));443Files.write(444 Path.of("cat_and_otter_realistic.png"),445 Base64.getDecoder()446 .decode(447 secondImage448 .result()449 .orElseThrow(() -> new IllegalStateException("No follow-up image returned"))));450```451452```csharp453using OpenAI.Responses;454#pragma warning disable OPENAI001455456string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;457ResponsesClient client = new(key);458459CreateResponseOptions options = new() { Model = "gpt-6-astra" };460options.Tools.Add(ResponseTool.CreateImageGenerationTool(model: "gpt-image-2.5-sunburst"));461options.InputItems.Add(462 ResponseItem.CreateUserMessageItem(463 "Generate an image of a gray tabby cat hugging an otter with an orange scarf."464 )465);466467ResponseResult first = await client.CreateResponseAsync(options);468ImageGenerationCallResponseItem initialImage = first469 .OutputItems.OfType<ImageGenerationCallResponseItem>()470 .First();471await File.WriteAllBytesAsync("cat_and_otter.png", initialImage.ImageResultBytes.ToArray());472473CreateResponseOptions followUp = new()474{475 Model = "gpt-6-astra",476 PreviousResponseId = first.Id,477};478followUp.Tools.Add(ResponseTool.CreateImageGenerationTool(model: "gpt-image-2.5-sunburst"));479followUp.InputItems.Add(ResponseItem.CreateUserMessageItem("Now make it look realistic."));480481ResponseResult second = await client.CreateResponseAsync(followUp);482ImageGenerationCallResponseItem updatedImage = second483 .OutputItems.OfType<ImageGenerationCallResponseItem>()484 .First();485await File.WriteAllBytesAsync(486 "cat_and_otter_realistic.png",487 updatedImage.ImageResultBytes.ToArray()488);489```490491```ruby492require "base64"493require "openai"494495client = OpenAI::Client.new496first = client.responses.create(497 model: "gpt-6-astra",498 input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",499 tools: [500 {501 type: :image_generation,502 model: "gpt-image-2.5-sunburst"503 }504 ]505)506507first_image = first.output.find do |item|508 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)509end510unless first_image.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)511 raise "No image generation call returned"512end513514encoded_image = first_image.result or raise "No image returned"515File.binwrite("cat_and_otter.png", Base64.strict_decode64(encoded_image))516517follow_up = client.responses.create(518 model: "gpt-6-astra",519 input: "Now make it look realistic.",520 previous_response_id: first.id,521 tools: [522 {523 type: :image_generation,524 model: "gpt-image-2.5-sunburst"525 }526 ]527)528529follow_up_image = follow_up.output.find do |item|530 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)531end532unless follow_up_image.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)533 raise "No follow-up image generation call returned"534end535536encoded_image = follow_up_image.result or raise "No follow-up image returned"537File.binwrite("cat_and_otter_realistic.png", Base64.strict_decode64(encoded_image))538```539540 541542 543544 545Using image ID546547 Multi-turn image generation548549```javascript550import OpenAI from "openai";551const openai = new OpenAI();552553const response = await openai.responses.create({554 model: "gpt-6-astra",555 input:556 "Generate an image of gray tabby cat hugging an otter with an orange scarf",557 tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst" }],558});559560const imageGenerationCalls = response.output.filter(561 (output) => output.type === "image_generation_call"562);563564const imageData = imageGenerationCalls.map((output) => output.result);565566if (imageData.length > 0) {567 const imageBase64 = imageData[0];568 const fs = await import("fs");569 fs.writeFileSync("cat_and_otter.png", Buffer.from(imageBase64, "base64"));570}571572// Follow up573574const response_fwup = await openai.responses.create({575 model: "gpt-6-astra",576 input: [577 {578 role: "user",579 content: [{ type: "input_text", text: "Now make it look realistic" }],580 },581 {582 type: "image_generation_call",583 id: imageGenerationCalls[0].id,584 },585 ],586 tools: [{ type: "image_generation", model: "gpt-image-2.5-sunburst" }],587});588589const imageData_fwup = response_fwup.output590 .filter((output) => output.type === "image_generation_call")591 .map((output) => output.result);592593if (imageData_fwup.length > 0) {594 const imageBase64 = imageData_fwup[0];595 const fs = await import("fs");596 fs.writeFileSync(597 "cat_and_otter_realistic.png",598 Buffer.from(imageBase64, "base64")599 );600}601```602603```python604import openai605import base64606607response = openai.responses.create(608 model="gpt-6-astra",609 input="Generate an image of gray tabby cat hugging an otter with an orange scarf",610 tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],611)612613image_generation_calls = [614 output for output in response.output if output.type == "image_generation_call"615]616617image_data = [output.result for output in image_generation_calls]618619if image_data:620 image_base64 = image_data[0]621622 with open("cat_and_otter.png", "wb") as f:623 f.write(base64.b64decode(image_base64))624625626# Follow up627628response_fwup = openai.responses.create(629 model="gpt-6-astra",630 input=[631 {632 "role": "user",633 "content": [{"type": "input_text", "text": "Now make it look realistic"}],634 },635 {636 "type": "image_generation_call",637 "id": image_generation_calls[0].id,638 },639 ],640 tools=[{"type": "image_generation", "model": "gpt-image-2.5-sunburst"}],641)642643image_data_fwup = [644 output.result645 for output in response_fwup.output646 if output.type == "image_generation_call"647]648649if image_data_fwup:650 image_base64 = image_data_fwup[0]651 with open("cat_and_otter_realistic.png", "wb") as f:652 f.write(base64.b64decode(image_base64))653```654655```go656package main657658import (659 "context"660 "encoding/base64"661 "encoding/json"662 "os"663664 "github.com/openai/openai-go/v3"665 "github.com/openai/openai-go/v3/responses"666)667668func main() {669 client := openai.NewClient()670 first, err := client.Responses.New(context.Background(), responses.ResponseNewParams{671 Model: "gpt-6-astra",672 Input: responses.ResponseNewParamsInputUnion{673 OfString: openai.String("Generate an image of gray tabby cat hugging an otter with an orange scarf"),674 },675 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}},676 })677 if err != nil {678 panic(err)679 }680 call := firstImageGenerationCall(first)681 saveImage("cat_and_otter.png", call.Result)682 input := outputAsInput(first.Output)683 input = append(input, responses.ResponseInputItemParamOfMessage(684 responses.ResponseInputMessageContentListParam{responses.ResponseInputContentParamOfInputText("Now make it look realistic")},685 responses.EasyInputMessageRoleUser,686 ))687688 followUp, err := client.Responses.New(context.Background(), responses.ResponseNewParams{689 Model: "gpt-6-astra",690 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: input},691 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst"}}},692 })693 if err != nil {694 panic(err)695 }696 saveImage("cat_and_otter_realistic.png", firstImageGenerationCall(followUp).Result)697}698699func firstImageGenerationCall(response *responses.Response) responses.ResponseOutputItemImageGenerationCall {700 for _, output := range response.Output {701 if output.Type == "image_generation_call" {702 return output.AsImageGenerationCall()703 }704 }705 panic("response did not include an image generation call")706}707708func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {709 input := make([]responses.ResponseInputItemUnionParam, 0, len(output))710 for _, item := range output {711 var converted responses.ResponseInputItemUnion712 if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {713 panic(err)714 }715 input = append(input, converted.ToParam())716 }717 return input718}719720func saveImage(filename, encoded string) {721 image, err := base64.StdEncoding.DecodeString(encoded)722 if err != nil {723 panic(err)724 }725 if err := os.WriteFile(filename, image, 0o600); err != nil {726 panic(err)727 }728}729```730731```java732import com.openai.client.OpenAIClient;733import com.openai.client.okhttp.OpenAIOkHttpClient;734import com.openai.core.JsonValue;735import com.openai.models.responses.ResponseCreateParams;736import com.openai.models.responses.ResponseInputItem;737import com.openai.models.responses.Tool;738import java.nio.file.Files;739import java.nio.file.Path;740import java.util.Base64;741import java.util.List;742import java.util.Map;743744var first =745 client746 .responses()747 .create(748 ResponseCreateParams.builder()749 .model("gpt-6-astra")750 .input(751 "Generate an image of a gray tabby cat hugging an otter with an orange scarf.")752 .addTool(Tool.ImageGeneration.builder().build())753 .build());754var firstImage =755 first.output().stream()756 .flatMap(item -> item.imageGenerationCall().stream())757 .findFirst()758 .orElseThrow(() -> new IllegalStateException("No image generation call returned"));759Files.write(760 Path.of("cat_and_otter.png"),761 Base64.getDecoder()762 .decode(763 firstImage764 .result()765 .orElseThrow(() -> new IllegalStateException("No image returned"))));766767var second =768 client769 .responses()770 .create(771 ResponseCreateParams.builder()772 .model("gpt-6-astra")773 .inputOfResponse(774 List.of(775 ResponseInputItem.ofMessage(776 ResponseInputItem.Message.builder()777 .role(ResponseInputItem.Message.Role.USER)778 .addInputTextContent("Now make it look realistic.")779 .build()),780 JsonValue.from(781 Map.of("type", "image_generation_call", "id", firstImage.id()))782 .convert(ResponseInputItem.class)))783 .addTool(Tool.ImageGeneration.builder().build())784 .build());785var secondImage =786 second.output().stream()787 .flatMap(item -> item.imageGenerationCall().stream())788 .findFirst()789 .orElseThrow(790 () -> new IllegalStateException("No follow-up image generation call returned"));791Files.write(792 Path.of("cat_and_otter_realistic.png"),793 Base64.getDecoder()794 .decode(795 secondImage796 .result()797 .orElseThrow(() -> new IllegalStateException("No follow-up image returned"))));798```799800```csharp801using OpenAI.Responses;802#pragma warning disable OPENAI001803804string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;805ResponsesClient client = new(key);806807CreateResponseOptions options = new() { Model = "gpt-6-astra" };808options.Tools.Add(ResponseTool.CreateImageGenerationTool(model: "gpt-image-2.5-sunburst"));809options.InputItems.Add(810 ResponseItem.CreateUserMessageItem(811 "Generate an image of a gray tabby cat hugging an otter with an orange scarf."812 )813);814815ResponseResult first = await client.CreateResponseAsync(options);816ImageGenerationCallResponseItem initialImage = first817 .OutputItems.OfType<ImageGenerationCallResponseItem>()818 .First();819await File.WriteAllBytesAsync("cat_and_otter.png", initialImage.ImageResultBytes.ToArray());820821CreateResponseOptions followUp = new() { Model = "gpt-6-astra" };822followUp.Tools.Add(ResponseTool.CreateImageGenerationTool(model: "gpt-image-2.5-sunburst"));823followUp.InputItems.Add(ResponseItem.CreateUserMessageItem("Now make it look realistic."));824followUp.InputItems.Add(ResponseItem.CreateReferenceItem(initialImage.Id));825826ResponseResult second = await client.CreateResponseAsync(followUp);827ImageGenerationCallResponseItem updatedImage = second828 .OutputItems.OfType<ImageGenerationCallResponseItem>()829 .First();830await File.WriteAllBytesAsync(831 "cat_and_otter_realistic.png",832 updatedImage.ImageResultBytes.ToArray()833);834```835836```ruby837require "base64"838require "openai"839840client = OpenAI::Client.new841first = client.responses.create(842 model: "gpt-6-astra",843 input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",844 tools: [845 {846 type: :image_generation,847 model: "gpt-image-2.5-sunburst"848 }849 ]850)851852first_image = first.output.find do |item|853 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)854end855unless first_image.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)856 raise "No image generation call returned"857end858859encoded_image = first_image.result or raise "No image returned"860File.binwrite("cat_and_otter.png", Base64.strict_decode64(encoded_image))861862follow_up = client.responses.create(863 model: "gpt-6-astra",864 input: [865 {866 role: :user,867 content: [868 {869 type: :input_text,870 text: "Now make it look realistic."871 }872 ]873 },874 {875 type: :image_generation_call,876 id: first_image.id877 }878 ],879 tools: [880 {881 type: :image_generation,882 model: "gpt-image-2.5-sunburst"883 }884 ]885)886887follow_up_image = follow_up.output.find do |item|888 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)889end890unless follow_up_image.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)891 raise "No follow-up image generation call returned"892end893894encoded_image = follow_up_image.result or raise "No follow-up image returned"895File.binwrite("cat_and_otter_realistic.png", Base64.strict_decode64(encoded_image))896```897898899900## Streaming901902The image generation tool supports streaming partial images while it generates the final result. This provides faster visual feedback for users and improves perceived latency.903904You can set the number of partial images (1-3) with the `partial_images` parameter.905906Stream an image907908```javascript909import OpenAI from "openai";910import fs from "fs";911const openai = new OpenAI();912913function saveBase64Image(filename, imageBase64) {914 const imageBuffer = Buffer.from(imageBase64, "base64");915 fs.writeFileSync(filename, imageBuffer);916}917918const stream = await openai.responses.create({919 model: "gpt-6-astra",920 input:921 "Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape",922 stream: true,923 tools: [924 { type: "image_generation", model: "gpt-image-2.5-sunburst", partial_images: 2 },925 ],926});927928for await (const event of stream) {929 if (event.type === "response.image_generation_call.partial_image") {930 const idx = event.partial_image_index;931 saveBase64Image(`river-partial-${idx}.png`, event.partial_image_b64);932 } else if (event.type === "response.completed") {933 const imageData = event.response.output934 .filter((output) => output.type === "image_generation_call")935 .map((output) => output.result);936937 if (imageData.length > 0) {938 saveBase64Image("river-final.png", imageData[0]);939 }940 }941}942```943944```python945from openai import OpenAI946import base64947948client = OpenAI()949950951def save_base64_image(filename, image_base64):952 image_bytes = base64.b64decode(image_base64)953 with open(filename, "wb") as f:954 f.write(image_bytes)955956957stream = client.responses.create(958 model="gpt-6-astra",959 input="Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape",960 stream=True,961 tools=[962 {"type": "image_generation", "model": "gpt-image-2.5-sunburst", "partial_images": 2}963 ],964)965966for event in stream:967 if event.type == "response.image_generation_call.partial_image":968 idx = event.partial_image_index969 save_base64_image(f"river-partial-{idx}.png", event.partial_image_b64)970 elif event.type == "response.completed":971 image_data = [972 output.result973 for output in event.response.output974 if output.type == "image_generation_call"975 ]976977 if image_data:978 save_base64_image("river-final.png", image_data[0])979```980981```go982package main983984import (985 "context"986 "encoding/base64"987 "fmt"988 "os"989990 "github.com/openai/openai-go/v3"991 "github.com/openai/openai-go/v3/responses"992)993994func main() {995 client := openai.NewClient()996 stream := client.Responses.NewStreaming(context.Background(), responses.ResponseNewParams{997 Model: "gpt-6-astra",998 Input: responses.ResponseNewParamsInputUnion{999 OfString: openai.String("Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape"),1000 },1001 Tools: []responses.ToolUnionParam{{OfImageGeneration: &responses.ToolImageGenerationParam{Model: "gpt-image-2.5-sunburst", PartialImages: openai.Int(2)}}},1002 })1003 for stream.Next() {1004 event := stream.Current()1005 if event.Type == "response.image_generation_call.partial_image" {1006 partial := event.AsResponseImageGenerationCallPartialImage()1007 saveImage(fmt.Sprintf("river-partial-%d.png", partial.PartialImageIndex), partial.PartialImageB64)1008 }1009 if event.Type == "response.completed" {1010 for _, output := range event.AsResponseCompleted().Response.Output {1011 if output.Type == "image_generation_call" {1012 saveImage("river-final.png", output.AsImageGenerationCall().Result)1013 }1014 }1015 }1016 }1017 if err := stream.Err(); err != nil {1018 panic(err)1019 }1020}10211022func saveImage(filename, encoded string) {1023 image, err := base64.StdEncoding.DecodeString(encoded)1024 if err != nil {1025 panic(err)1026 }1027 if err := os.WriteFile(filename, image, 0o600); err != nil {1028 panic(err)1029 }1030}1031```10321033```java1034import com.openai.client.OpenAIClient;1035import com.openai.client.okhttp.OpenAIOkHttpClient;1036import com.openai.core.http.StreamResponse;1037import com.openai.models.responses.ResponseCreateParams;1038import com.openai.models.responses.ResponseStreamEvent;1039import com.openai.models.responses.Tool;1040import java.io.IOException;1041import java.nio.file.Files;1042import java.nio.file.Path;1043import java.util.Base64;10441045ResponseCreateParams params =1046 ResponseCreateParams.builder()1047 .model("gpt-6-astra")1048 .input("Generate an image of a river made of white owl feathers.")1049 .addTool(Tool.ImageGeneration.builder().partialImages(2).build())1050 .build();10511052try (StreamResponse<ResponseStreamEvent> stream = client.responses().createStreaming(params)) {1053 var events = stream.stream().iterator();1054 while (events.hasNext()) {1055 ResponseStreamEvent event = events.next();1056 if (event.imageGenerationCallPartialImage().isPresent()) {1057 var partial = event.imageGenerationCallPartialImage().orElseThrow();1058 Files.write(1059 Path.of("river-partial-" + partial.partialImageIndex() + ".png"),1060 Base64.getDecoder().decode(partial.partialImageB64()));1061 }1062 if (event.completed().isPresent()) {1063 var image =1064 event.completed().orElseThrow().response().output().stream()1065 .flatMap(item -> item.imageGenerationCall().stream())1066 .findFirst()1067 .orElseThrow(() -> new IllegalStateException("No generated image returned"));1068 Files.write(1069 Path.of("river-final.png"),1070 Base64.getDecoder()1071 .decode(1072 image1073 .result()1074 .orElseThrow(1075 () -> new IllegalStateException("No final image returned"))));1076 }1077 }1078}1079```10801081```ruby1082require "base64"1083require "openai"10841085client = OpenAI::Client.new1086stream = client.responses.stream(1087 model: "gpt-6-astra",1088 input: "Generate an image of a river made of white owl feathers.",1089 tools: [1090 {1091 type: :image_generation,1092 model: "gpt-image-2.5-sunburst",1093 partial_images: 21094 }1095 ]1096)10971098stream.each do |event|1099 case event1100 when OpenAI::Models::Responses::ResponseImageGenCallPartialImageEvent1101 image = Base64.strict_decode64(event.partial_image_b64)1102 File.binwrite("river-partial-#{event.partial_image_index}.png", image)1103 when OpenAI::Models::Responses::ResponseCompletedEvent1104 image_call = event.response.output.find do |item|1105 item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)1106 end1107 next unless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)11081109 File.binwrite(1110 "river-final.png",1111 Base64.strict_decode64(image_call.result)1112 )1113 end1114end1115```111611171118## Supported models11191120The following models support the image generation tool:11211122- `gpt-5.5`1123- `gpt-5.4-mini`1124- `gpt-5.4-nano`1125- `gpt-5.2`1126- `gpt-5`1127- `gpt-5-nano`1128- `o3`1129- `gpt-4.1`1130- `gpt-4.1-mini`1131- `gpt-4.1-nano`1132- `gpt-4o`1133- `gpt-4o-mini`