OpenAI 图像与视觉

概述

创建图像：使用GPT Image生成或编辑图像。
处理图像输入：使用模型的视觉能力分析图像。

创建图像的官方示意

处理图像输入的官方示意

较新的语言模型能处理、分析图像输入，这种能力称为视觉。GPT Image则能根据文本与图像输入创建新图，或编辑已有图像。

根据分析或生成的需求选择端点：

API	支持的任务
Responses API	分析图像，或通过图像生成工具生成与编辑图像
Images API	输出生成的图像，可选用图像作为输入
Chat Completions API	分析图像并生成文本响应

不同模型的输入输出模态见模型目录。

生成或编辑图像

Images API可选择gpt-image-2.5-sunburst进行文生图或编辑。Responses API则选择支持图像生成工具的主模型，由工具处理GPT Image模型选择。

来源示例1（javascript）

程序中的自然语言译释3：

生成灰色虎斑猫抱着戴橙色围巾水獭的图像。

// [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input:
    "Generate an image of gray tabby cat hugging an otter with an orange scarf",
  tools: [{ type: "image_generation" }],
});

// Save the image to a file
const imageData = response.output
  .filter((output) => output.type === "image_generation_call")
  .map((output) => output.result);

if (imageData.length > 0) {
  const imageBase64 = imageData[0];
  const fs = await import("fs");
  fs.writeFileSync("cat_and_otter.png", Buffer.from(imageBase64, "base64"));
}

来源示例2（python）

本段复用的中文释义：译释3。

## [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
from openai import OpenAI
import base64

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Generate an image of gray tabby cat hugging an otter with an orange scarf",
    tools=[{"type": "image_generation"}],
)

## Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    image_base64 = image_data[0]
    with open("cat_and_otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

来源示例3（go）

程序中的自然语言译释4：

生成一张灰色虎斑猫抱着戴橙色围巾水獭的图像。

程序中的自然语言译释30：

响应未包含图像生成调用。

// [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
package main

import (
    "context"
    "encoding/base64"
    "os"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Input: responses.ResponseNewParamsInputUnion{
            OfString: openai.String("Generate an image of a gray tabby cat hugging an otter with an orange scarf."),
        },
        Tools: []responses.ToolUnionParam{{
            OfImageGeneration: &responses.ToolImageGenerationParam{},
        }},
    })
    if err != nil {
        panic(err)
    }

    for _, output := range response.Output {
        if output.Type != "image_generation_call" {
            continue
        }
        image, err := base64.StdEncoding.DecodeString(output.AsImageGenerationCall().Result)
        if err != nil {
            panic(err)
        }
        if err := os.WriteFile("cat_and_otter.png", image, 0o600); err != nil {
            panic(err)
        }
        return
    }

    panic("response did not include an image generation call")
}

来源示例4（java）

程序中的自然语言译释26：

没有返回生成的图像。

本段复用的中文释义：译释4。

// [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
// [中文] 原例是API片段，使用前需已有client以及适当外层程序；本地仅保留源代码并检查注释，未独立编译。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Generate an image of a gray tabby cat hugging an otter with an orange scarf.")
        .addTool(Tool.ImageGeneration.builder().build())
        .build();

String imageResult =
    client.responses().create(params).output().stream()
        .flatMap(item -> item.imageGenerationCall().stream())
        .flatMap(call -> call.result().stream())
        .findFirst()
        .orElseThrow(() -> new IllegalStateException("No generated image returned"));
Files.write(Path.of("cat_and_otter.png"), Base64.getDecoder().decode(imageResult));

来源示例5（csharp）

程序中的自然语言译释25：

没有返回生成的图像。

本段复用的中文释义：译释4。

// [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem(
        "Generate an image of a gray tabby cat hugging an otter with an orange scarf."
    )
);
options.Tools.Add(
    ResponseTool.CreateImageGenerationTool(model: "gpt-image-2")
);

ResponseResult response = await client.CreateResponseAsync(options);
ImageGenerationCallResponseItem image = response
    .OutputItems.OfType<ImageGenerationCallResponseItem>()
    .FirstOrDefault()
    ?? throw new InvalidOperationException("No generated image was returned.");
await File.WriteAllBytesAsync(
    "cat_and_otter.png",
    image.ImageResultBytes.ToArray()
);

来源示例6（ruby）

程序中的自然语言译释24：

没有返回图像生成调用。

本段复用的中文释义：译释4。

## [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
require "base64"
require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
  tools: [{ type: :image_generation }]
)

image_call = response.output.find do |item|
  item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)
end
unless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)
  raise "No image generation call returned"
end

File.binwrite(
  "cat_and_otter.png",
  Base64.strict_decode64(image_call.result)
)

来源示例7（bash）

本段复用的中文释义：译释4。

## [中文] 在Responses中调用图像生成工具并保存结果；图像工具的模型与顶层主模型分开设置。
openai responses create \
  --model gpt-6-astra \
  --raw-output \
  --transform 'output.#(type=="image_generation_call").result' <<'YAML' | base64 --decode > cat_and_otter.png
tools:
  - type: image_generation
input: Generate an image of a gray tabby cat hugging an otter with an orange scarf.
YAML

完整流程参见图像生成指南。

使用世界知识生成图像

GPT Image能够借助世界知识生成图像，不一定需要参考图。例如，要求生成陈列半宝石的柜子，可以得到包含可辨认的紫水晶、蔷薇石英和玉石的场景。

分析图像

使用支持视觉的模型描述图像、读取可见文字，或回答有关物体、形状、颜色、纹理的问题。使用回答时应考虑模型的局限。

向模型提供图像输入

可以通过以下方式传入图像：

完整的图像文件URL。
Base64编码的data URL。
通过Files API创建的文件ID。

在content数组中放入多张图像，即可在一次请求中提供多图。图像会计入词元并产生费用。

使用URL分析图像：

来源示例8（javascript）

程序中的自然语言译释34：

这张图像里有什么？

// [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          image_url:
            "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例9（python）

本段复用的中文释义：译释34。

## [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
                },
            ],
        }
    ],
)

print(response.output_text)

来源示例10（go）

程序中的自然语言译释35：

这张图像里有什么？

// [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
package main

import (
    "context"
    "fmt"

    "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{
            OfInputItemList: responses.ResponseInputParam{
                responses.ResponseInputItemParamOfMessage(
                    responses.ResponseInputMessageContentListParam{
                        responses.ResponseInputContentParamOfInputText("What's in this image?"),
                        {OfInputImage: &responses.ResponseInputImageParam{
                            Detail:   responses.ResponseInputImageDetailAuto,
                            ImageURL: openai.String("https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"),
                        }},
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例11（java）

本段复用的中文释义：译释35。

// [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
// [中文] 原例是API片段，使用前需已有client以及适当外层程序；本地仅保留源代码并检查注释，未独立编译。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;

ResponseInputItem imageInput =
    ResponseInputItem.ofMessage(
        ResponseInputItem.Message.builder()
            .role(ResponseInputItem.Message.Role.USER)
            .addInputTextContent("What's in this image?")
            .addContent(
                ResponseInputImage.builder()
                    .detail(ResponseInputImage.Detail.AUTO)
                    .imageUrl(
                        "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg")
                    .build())
            .build());

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(List.of(imageInput))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例12（csharp）

程序中的自然语言译释36：

这张图像里有什么？

// [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

Uri imageUrl = new(
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageUrl),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

来源示例13（ruby）

本段复用的中文释义：译释35。

## [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          image_url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
        }
      ]
    }
  ]
)

puts(response.output_text)

来源示例14（bash）

程序中的自然语言译释37：

这张图像里有什么？

## [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": [
          {"type": "input_text", "text": "what is in this image?"},
          {
            "type": "input_image",
            "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
          }
        ]
      }
    ]
  }'

来源示例15（bash）

本段复用的中文释义：译释36。

## [中文] 把图像URL与问题作为内容数组提交，读取文本分析结果；本语言原例所用API和模型保持不变。
openai responses create \
  --model gpt-6-astra \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text' <<'YAML'
input:
  - role: user
    content:
      - type: input_text
        text: What is in this image?
      - type: input_image
        image_url: https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg
YAML

使用Base64编码图像：

来源示例16（javascript）

本段复用的中文释义：译释34。

// [中文] 读取图像并编码成Base64 data URL，再将图像和问题提交给模型分析。
import fs from "fs";
import OpenAI from "openai";

const openai = new OpenAI();

const imagePath = "fixtures/example.jpg";
const base64Image = fs.readFileSync(imagePath, "base64");

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          image_url: `data:image/jpeg;base64,${base64Image}`,
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例17（python）

本段复用的中文释义：译释34。

## [中文] 读取图像并编码成Base64 data URL，再将图像和问题提交给模型分析。
import base64
from openai import OpenAI

client = OpenAI()


## Function to encode the image
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


## Path to your image
image_path = "path_to_your_image.jpg"

## Getting the Base64 string
base64_image = encode_image(image_path)


response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                },
            ],
        }
    ],
)

print(response.output_text)

来源示例18（go）

本段复用的中文释义：译释35。

// [中文] 读取图像并编码成Base64 data URL，再将图像和问题提交给模型分析。
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "os"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()
    image, err := os.ReadFile("image.png")
    if err != nil {
        panic(err)
    }
    imageURL := "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)

    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("What's in this image?"),
                        {OfInputImage: &responses.ResponseInputImageParam{
                            Detail:   responses.ResponseInputImageDetailAuto,
                            ImageURL: openai.String(imageURL),
                        }},
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例19（java）

本段复用的中文释义：译释35。

// [中文] 读取图像并编码成Base64 data URL，再将图像和问题提交给模型分析。
// [中文] 原例是API片段，使用前需已有client以及适当外层程序；本地仅保留源代码并检查注释，未独立编译。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String imageBase64 =
    Base64.getEncoder()
        .encodeToString(
            Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH"))));

ResponseInputItem imageInput =
    ResponseInputItem.ofMessage(
        ResponseInputItem.Message.builder()
            .role(ResponseInputItem.Message.Role.USER)
            .addInputTextContent("What's in this image?")
            .addContent(
                ResponseInputImage.builder()
                    .detail(ResponseInputImage.Detail.AUTO)
                    .imageUrl("data:image/png;base64," + imageBase64)
                    .build())
            .build());

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(List.of(imageInput))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例20（csharp）

本段复用的中文释义：译释36。

// [中文] 使用HttpClient下载图像，分别以流和字节数组构造BinaryData，再交给SDK的图像内容部件；本例不显式拼接Base64 data URL。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

Uri imageUrl = new(
    "https://openai-documentation.vercel.app/images/cat_and_otter.png"
);

using HttpClient http = new();

// Download an image as a stream.
// [中文] 通过流读取下载结果，供第一种输入方式使用。
using Stream stream = await http.GetStreamAsync(imageUrl);
// [中文] 将流与图像MIME类型封装为SDK可接受的BinaryData。
BinaryData imageData = BinaryData.FromStream(stream, "image/png");

ResponseResult response1 = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageData),
            ]
        ),
    ]
);

Console.WriteLine($"From image stream: {response1.GetOutputText()}");

// Download an image as a byte array.
// [中文] 第二种方式把同一图像下载为字节数组。
byte[] bytes = await http.GetByteArrayAsync(imageUrl);
// [中文] 把字节数组封装为图像数据；随后交给SDK创建图像内容部件。
imageData = BinaryData.FromBytes(bytes, "image/png");

ResponseResult response2 = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageData),
            ]
        ),
    ]
);

Console.WriteLine($"From byte array: {response2.GetOutputText()}");

来源示例21（ruby）

本段复用的中文释义：译释35。

## [中文] 读取图像并编码成Base64 data URL，再将图像和问题提交给模型分析。
require "base64"
require "openai"

client = OpenAI::Client.new
image = Base64.strict_encode64(File.binread("image.png"))

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          image_url: "data:image/png;base64,#{image}"
        }
      ]
    }
  ]
)

puts(response.output_text)

使用文件ID：

来源示例22（javascript）

本段复用的中文释义：译释34。

// [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI();

// Function to create a file with the Files API
async function createFile(filePath) {
  const fileContent = fs.createReadStream(filePath);
  const result = await openai.files.create({
    file: fileContent,
    purpose: "vision",
  });
  return result.id;
}

// Getting the file ID
const fileId = await createFile("fixtures/example.jpg");

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          file_id: fileId,
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例23（python）

本段复用的中文释义：译释34。

## [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
from openai import OpenAI

client = OpenAI()


## Function to create a file with the Files API
def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(
            file=file_content,
            purpose="vision",
        )
        return result.id


## Getting the file ID
file_id = create_file("path_to_your_image.jpg")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "file_id": file_id,
                },
            ],
        }
    ],
)

print(response.output_text)

来源示例24（go）

本段复用的中文释义：译释35。

// [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()
    file, err := os.Open("image.png")
    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)
    }

    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("What's in this image?"),
                        {OfInputImage: &responses.ResponseInputImageParam{
                            Detail: responses.ResponseInputImageDetailAuto,
                            FileID: openai.String(uploaded.ID),
                        }},
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例25（java）

本段复用的中文释义：译释35。

// [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
// [中文] 原例是API片段，使用前需已有client以及适当外层程序；本地仅保留源代码并检查注释，未独立编译。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FilePurpose;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Path;
import java.util.List;

var file =
    client
        .files()
        .create(
            FileCreateParams.builder()
                .file(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH")))
                .purpose(FilePurpose.VISION)
                .build());

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder()
                .model("gpt-6-astra")
                .inputOfResponse(
                    List.of(
                        ResponseInputItem.ofMessage(
                            ResponseInputItem.Message.builder()
                                .role(ResponseInputItem.Message.Role.USER)
                                .addInputTextContent("What's in this image?")
                                .addContent(
                                    ResponseInputImage.builder()
                                        .detail(ResponseInputImage.Detail.AUTO)
                                        .fileId(file.id())
                                        .build())
                                .build())))
                .build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例26（csharp）

本段复用的中文释义：译释34。

// [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
using OpenAI.Files;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

string filename = "cat_and_otter.png";
Uri imageUrl = new(
    $"https://openai-documentation.vercel.app/images/{filename}"
);

using HttpClient http = new();

// Download an image as a stream.
using Stream stream = await http.GetStreamAsync(imageUrl);

OpenAIFileClient files = new(key);

OpenAIFile file = await files.UploadFileAsync(
    stream,
    filename,
    FileUploadPurpose.Vision
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("what's in this image?"),
                ResponseContentPart.CreateInputImagePart(file.Id),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

来源示例27（ruby）

本段复用的中文释义：译释35。

## [中文] 先上传图像获取文件ID，再以文件ID作为图像输入提出问题；上传与模型分析是两个步骤。
require "openai"
require "pathname"

client = OpenAI::Client.new
uploaded = client.files.create(
  file: Pathname("image.png"),
  purpose: :vision
)

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          file_id: uploaded.id
        }
      ]
    }
  ]
)

puts(response.output_text)

图像输入要求

使用受支持且清晰到足以分析的图像文件。

要求	支持范围
格式	PNG、JPEG（.jpeg或.jpg）、WEBP、非动画GIF
请求大小	每次请求总载荷最多512MB
图像数量	每次请求最多1500张

对于按图像块计量的输入，应用所选模型和detail的缩放规则后，每张图像最多30000个图像块。这个拒绝上限适用于支持的细节级别，逐张图像判断，不是把一次请求的所有块数相加。

各模型、细节级别可能还有更小的缩放预算，仍须遵守。处理后超过30000个图像块会被拒绝，不会为了这个独立上限自动缩小；应自行减小尺寸后重试。

图像词元和其他提示内容还必须同时符合模型输入与上下文限制。词元估算有效不等于请求满足所有输入约束。图像使用也须符合使用政策。

选择图像细节级别

detail控制预处理。支持值因模型而异，包括low、high、original、auto。在Responses和Chat Completions中省略该参数时均默认auto，实际行为见模型缩放规则。

来源示例28（plain）：以下保留协议载荷、配置、返回示意或语法定义；省略号及片段不代表完整可运行程序。

{
    "type": "input_image",
    "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
    "detail": "original"
}

级别	适用场景
low	粗略理解；缩放和词元使用随模型变化，并不总比high更省词元
high	不需要精确原图坐标时的标准高保真理解
original	模型支持时，用于大图、密集内容、空间敏感或计算机操作图像
auto	使用模型默认缩放行为

OCR、小物体检测、计算机操作等需要精细内容或精确坐标时，模型支持的情况下使用original。但它仍可能为了像素边长或缩放块预算而缩小，并非绝不缩放；独立的30000块拒绝上限不会触发自动缩放。对坐标敏感任务，应先把图像缩放到符合限制，再将返回坐标映射回原图。参见计算机使用指南。

模型缩放规则

下表针对通用视觉模型；其他模型和专用变体可能有不同限制。所有缩放均保持宽高比，不放大小图。

模型系列	支持的detail	图像块与缩放规则
gpt-6-astra	low、high、original、auto	low缩至512×512范围内；high最多2500块、最长边65535像素，两个限制同时适用。original保留尺寸，单边超过65535才等比缩小；处理后超过30000块则拒绝，不按该上限缩放。auto与original相同
gpt-5.6-sol、gpt-5.6-terra、gpt-5.6-luna	low、high、original、auto	low缩至512×512内；high同时受2048×2048和2500块限制。original单边超过65535时缩小，若处理后超过30000块则拒绝。auto与original相同
gpt-5.5	low、high、original、auto	low缩至512×512内；high最多2500块、最长边2048；original最多10000块、最长边6000，两个限制同时适用。auto与original相同
gpt-5.4、gpt-5.4-mini、gpt-5.4-nano	low、high、original、auto	low最长边2048、预算6144块，因此可能比high使用更多词元。high最多2500块、最长边2048；original最多10000块、最长边6000。auto与high相同
gpt-5.2、gpt-4.1-mini	low、high、auto	三种级别均为最长边2048、预算6144块；不支持original
gpt-5.1、gpt-4.1、gpt-4o、gpt-4o-mini	low、high、auto	low使用固定词元数；high和auto使用切片计量规则

费用计算

视觉模型将图像转换为计费输入词元。本节图像输入计算器与图像块/切片规则针对视觉模型输入，不适用于GPT Image生成或编辑，后者见独立定价说明。

图像词元也占用每分钟词元数（TPM）限制。计算器按标准输入费率估算一张图像，不包括其他提示内容与模型输出。

图像输入成本计算器

在计算器选择模型、尺寸和细节级别，估算单张图像的输入词元及费用。

按图像块计算词元

部分模型用32×32像素图像块覆盖图像。许多模型/detail组合有缩放块预算。先在不放大小图的情况下，保持比例，把图像缩至细节级别的边长限制内，并取整数像素。

A. 计算覆盖缩放后图像所需的32×32块数；边界块可以超出图像边缘。

来源示例29（text）：以下保留协议载荷、配置、返回示意或语法定义；省略号及片段不代表完整可运行程序。

patch_count = ceil(width/32)×ceil(height/32)

B. 如果该模型和细节级别规定了缩放块预算，且当前块数超预算，则等比缩小；否则跳过。调整缩放比例，使取整像素尺寸后覆盖的块数仍在预算内。计算最终尺寸前保留完整精度。

来源示例30（text）：以下保留协议载荷、配置、返回示意或语法定义；省略号及片段不代表完整可运行程序。

shrink_factor = sqrt((32^2 * patch_budget) / (width * height))
adjusted_shrink_factor = shrink_factor * min(
  floor(width * shrink_factor / 32) / (width * shrink_factor / 32),
  floor(height * shrink_factor / 32) / (height * shrink_factor / 32)
)

C. 若B执行了缩放，将最终宽高向下取整为整数像素，再计算覆盖块数。这是乘模型倍率前的图像词元数；存在预算时，该数不应超预算。

来源示例31（text）：以下保留协议载荷、配置、返回示意或语法定义；省略号及片段不代表完整可运行程序。

resized_patch_count = ceil(resized_width/32)×ceil(resized_height/32)

若此时超过30000块，请求被拒绝；必须在应用词元倍率前检查。

D. 将块数乘以模型倍率并向上取整，得到计费图像输入词元；对这些词元应用一次输入价格。倍率不作用于其他提示词元，也不应再次乘到价格上。

模型	倍率
gpt-6-astra	1.2
gpt-5.6-sol	1.2
gpt-5.6-terra	1.2
gpt-5.6-luna	1.2
gpt-5.5	1.2
gpt-5.4	1.2
gpt-5.4-mini	1.2
gpt-5.4-nano	1.2
gpt-5.2	1.2
gpt-5-mini*	1.2
gpt-5-nano*	1.5
gpt-4.1-mini	1.62
gpt-4.1-nano*（2025-04-14快照）	2.46
o4-mini*	1.72

gpt-4.1-mini的规则对应2025-04-14快照。星号模型已弃用并安排关闭，日期与替代项见弃用计划；上面的缩放规则表与计算器不含这些模型。

以gpt-6-astra、detail: high为例：最长边65535、预算2500块、倍率1.2。

1024×1024：32×32＝1024块，无需缩放，ceil(1024×1.2)=1229词元。
2048×2048：最初64×64＝4096块，按预算缩至1600×1600，50×50＝2500块，预计3000词元。
4096×512：保持原尺寸，128×16＝2048块，预计2458词元。

浮点舍入可能使实际计费与估算相差一个词元。

按切片计算词元

下表模型采用“基础词元＋切片词元”的方式。

模型	基础词元	每片词元
gpt-5.1	70	140
gpt-5*	70	140
gpt-4o、gpt-4.1	85	170
gpt-4o-mini	2833	5667
o1、o1-pro、o3*	75	150

星号模型已弃用并安排关闭，参见计划，计算器与上方模型缩放表不包含它们。

low无论图像尺寸如何，都只使用该模型的基础词元。high和auto按以下步骤计算：

保持宽高比，缩至2048×2048范围内，不放大小图。
若最短边超过768，将其缩至768，并将另一边向下取整。
计算覆盖图像需要多少个512像素正方形，每片使用对应切片词元。
将基础词元加到切片词元总量上。

GPT Image模型的输入

GPT Image生成与编辑使用独立图像词元费率，视觉计算器不估算其输入或输出费用。见图像生成定价与图像生成指南。

GPT Image 1

gpt-image-1已于2026年10月23日关闭。以下输入词元规则仅为历史成本比较保留，替代模型见弃用公告。

对于历史请求，使用切片规则，但最短边缩至512而不是768像素，词元量还取决于Images API的input_fidelity。

低输入保真度时，基础65词元，每片129词元。高输入保真度还按宽高比增加固定数量：正方形额外4160个输入图像词元，接近竖版或横版时额外6240个。历史图像输入词元价格见GPT Image 1模型页。这不是GPT Image 2.5的通用输入公式。

局限

视觉模型可能出错，设计应用时应考虑：

医学图像：不适合解释CT等专门医学图像，不应用于医疗建议。
非英语：对日文、韩文等非拉丁字母文字图像，表现可能不理想。
小字：放大图中文字可以改善可读性；支持时可用original帮助理解。
旋转：可能误读旋转或倒置的文字与图像。
视觉元素：对颜色或实线、虚线、点线样式变化的图表与文字可能理解困难。
空间推理：对精确空间定位任务（例如识别棋局位置）较困难。
准确性：某些场景可能生成错误描述或图注。
图像形状：全景和鱼眼图像可能较难处理。
元数据与缩放：不处理原始文件名或元数据；分析前可能缩放，包括original级别，具体看模型规则。
计数：图中物体数量可能只是近似值。
验证码：出于安全原因，系统阻止提交验证码。