이미지와 비전 | OpenAI API

개요

Create images

Use GPT Image models to generate or edit images.

Process image inputs

Use our models' vision capabilities to analyze images.

최근 언어 모델은 이미지를 입력받아 분석할 수 있습니다. 이 기능을 비전이라고 합니다. GPT Image 모델은 텍스트와 이미지를 입력받아 새 이미지를 만들거나 기존 이미지를 편집할 수 있습니다.

이미지를 분석할지 생성할지에 따라 엔드포인트를 선택하세요.

API	지원하는 용도
Responses API	이미지 분석 또는 이미지 생성 도구를 이용한 이미지 생성 및 편집
Images API	이미지를 생성해 출력하며, 필요하면 이미지도 입력으로 사용
Chat Completions API	이미지 분석 및 텍스트 응답 생성

각 모델이 지원하는 입력 및 출력 유형은 모델 페이지에서 확인하세요.

이미지 생성 또는 편집

Images API에서는 gpt-image-2.5-sunburst 모델을 선택해 텍스트로 이미지를 생성하거나 기존 이미지를 편집하세요. Responses API에서는 이미지 생성 도구를 지원하는 주력 모델을 선택하세요. 사용할 GPT Image 모델은 도구가 선택합니다.

Responses API로 이미지 생성

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import 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"));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from 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))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package 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")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28using OpenAI.Responses;
#pragma warning disable 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()
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "base64"
require "openai"

client = OpenAI::Client.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)
)

1
2
3
4
5
6
7
8openai responses create \
  --model gpt-6-astra \
  --raw-output \
  --transform 'output.#(type=="image_generation_call").result' <<'YAML' | base64 --decode > cat_and_otter.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로 인코딩한 데이터 URL로 전달하세요.

content 배열에 이미지를 여러 개 포함하면 한 번의 요청으로 여러 이미지를 입력할 수 있습니다. 이미지도 토큰으로 집계되며 그에 따라 요금이 부과됩니다.

이미지 내용 분석

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What is in this image?" },
        {
          type: "image_url",
          image_url: {
            url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
          },
        },
      ],
    },
  ],
});

console.log(response.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23from openai import OpenAI

client = OpenAI()

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

print(response.choices[0].message.content)

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
29package main

import (
	"context"
	"fmt"

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

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

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
				openai.TextContentPart("What's in this image?"),
				openai.ImageContentPart(openai.ChatCompletionContentPartImageImageURLParam{
					URL: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
				}),
			}),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

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
32import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartImage;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.util.List;

String imageUrl =
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg";
ChatCompletionContentPart text =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("What's in this image?").build());
ChatCompletionContentPart image =
    ChatCompletionContentPart.ofImageUrl(
        ChatCompletionContentPartImage.builder()
            .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder().url(imageUrl).build())
            .build());

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(List.of(text, image))
                .build())
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

Uri imageUrl = new(
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What is in this image?"),
        ChatMessageContentPart.CreateImagePart(imageUrl),
    ]
);

ChatCompletion completion = await client.CompleteChatAsync(message);

Console.WriteLine(completion.Content[0].Text);

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
26require "openai"

client = OpenAI::Client.new

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

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
            }
          }
        ]
      }
    ],
    "max_completion_tokens": 300
  }'

이미지 내용 분석

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
27import fs from "fs";
import OpenAI from "openai";

const openai = new OpenAI();

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

const completion = await openai.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "what's in this image?" },
        {
          type: "image_url",
          image_url: {
            url: `data:image/jpeg;base64,${base64Image}`,
          },
        },
      ],
    },
  ],
});

console.log(completion.choices[0].message.content);

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
37import 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)

completion = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "what's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}",
                    },
                },
            ],
        }
    ],
)

print(completion.choices[0].message.content)

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
34package main

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

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

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)

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
				openai.TextContentPart("What's in this image?"),
				openai.ImageContentPart(openai.ChatCompletionContentPartImageImageURLParam{URL: imageURL}),
			}),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

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
39import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartImage;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String imageUrl =
    "data:image/jpeg;base64,"
        + Base64.getEncoder()
            .encodeToString(
                Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH"))));
ChatCompletionContentPart text =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("What's in this image?").build());
ChatCompletionContentPart image =
    ChatCompletionContentPart.ofImageUrl(
        ChatCompletionContentPartImage.builder()
            .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder().url(imageUrl).build())
            .build());

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(List.of(text, image))
                .build())
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

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

using HttpClient http = new();
BinaryData image = BinaryData.FromBytes(
    await http.GetByteArrayAsync(imageUrl)
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What's in this image?"),
        ChatMessageContentPart.CreateImagePart(image, "image/png"),
    ]
);

ChatCompletion completion = await client.CompleteChatAsync(message);

Console.WriteLine(completion.Content[0].Text);

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
26require "base64"
require "openai"

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

completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :text,
          text: "What's in this image?"
        },
        {
          type: :image_url,
          image_url: { url: "data:image/png;base64,#{image}" }
        }
      ]
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23BASE64_IMAGE=$(base64 < path_to_your_image.jpg) && curl https://api.openai.com/v1/chat/completions   -H "Content-Type: application/json"   -H "Authorization: Bearer $OPENAI_API_KEY"   -d @- <<EOF
  {
    "model": "gpt-6-astra",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "data:image/jpeg;base64,$BASE64_IMAGE"
            }
          }
        ]
      }
    ],
    "max_completion_tokens": 300
  }
EOF

분석할 이미지는 다음 중 한 가지 방법으로 전달하세요.

이미지 파일의 절대 URL 전달
이미지를 Base64로 인코딩한 데이터 URL로 전달
Files API로 생성한 파일 ID 전달

이미지 내용 분석

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: [
    {
      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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21from 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)

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
36package 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())
}

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
31import 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()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23using 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());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25require "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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18curl 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"
          }
        ]
      }
    ]
  }'

1
2
3
4
5
6
7
8
9
10
11
12openai 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

이미지 내용 분석

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
26import 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);

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
36import 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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package 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())
}

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
39import 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()));

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
47using 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);
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);
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()}");

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.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)

이미지 내용 분석

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
36import 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);

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
35from 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)

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
50package 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())
}

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
43import 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()));

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
38using 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());

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
30require "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(`.png`), JPEG(`.jpeg` 또는 `.jpg`), WEBP(`.webp`), 애니메이션이 없는 GIF(`.gif`)
요청 크기	요청당 전체 페이로드 최대 512MB
이미지 수	요청당 최대 1,500개

패치 기반 이미지 입력의 경우, 선택한 모델과 detail 수준에 맞는 크기 조정 규칙을 적용한 후 API가 지원하는 패치 수는 이미지당 최대 30,000개입니다. 이 한도는 지원되는 모든 세부 수준에서 각 이미지에 개별적으로 적용됩니다. 요청에 포함된 이미지의 패치 수를 합산하지 않습니다.

모델과 세부 수준에 따라 크기 조정에 사용하는 패치 한도가 더 낮을 수 있으며, 이 한도도 그대로 적용됩니다. 처리 후 패치 수가 30,000개를 초과하면 API는 이미지를 한도에 맞춰 자동으로 축소하지 않고 요청을 거부합니다. 이미지의 가로·세로 크기를 줄인 후 다시 시도하세요.

이미지 토큰과 나머지 프롬프트를 합한 크기도 모델의 입력 한도와 컨텍스트 한도 내에 있어야 합니다. 예상 토큰 수만으로는 요청이 모든 입력 요건을 충족하는지 확인할 수 없습니다. 이미지를 사용할 때는 OpenAI의 사용 정책을 준수해야 합니다.

이미지 세부 수준 선택

detail 매개변수는 이미지 전처리 방식을 제어합니다. 설정값은 low, high, original, auto이며, 지원되는 값은 모델에 따라 다릅니다. 매개변수를 생략하면 Responses API와 Chat Completions API 모두 기본값으로 auto를 사용합니다. 각 설정에 따른 동작은 모델별 크기 조정 표에서 확인하세요.

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

다음 기준에 따라 세부 수준을 선택하세요.

세부 수준	적합한 용도
`low`	이미지 내용을 대략적으로 파악할 때 적합합니다. 크기 조정 방식과 토큰 사용량은 모델에 따라 다르며, `low`가 항상 `high`보다 토큰을 적게 사용하는 것은 아닙니다.
`high`	원본 이미지의 정확한 좌표까지는 필요 없지만 세부 내용을 충실하게 파악해야 하는 일반적인 작업에 적합합니다.
`original`	모델이 지원하는 경우, 크기가 크거나 정보가 밀집된 이미지, 위치 정확도가 중요한 이미지, 컴퓨터 사용 작업에 쓰이는 이미지에 적합합니다.
`auto`	모델별 크기 조정 표에 나온 기본 방식을 사용합니다.

광학 문자 인식(OCR), 작은 객체 탐지, 컴퓨터 사용처럼 미세한 시각 정보나 정확한 좌표가 필요한 작업에서는 모델이 지원하는 경우 "detail": "original"을 사용하세요. 원본 세부 수준에서도 모델의 픽셀 크기 한도나 크기 조정용 패치 한도에 맞춰 이미지를 축소할 수 있습니다. 다만 요청 거부 기준인 패치 30,000개 한도에 맞춰 이미지를 추가로 축소하지는 않습니다. 좌표 정확도가 중요한 작업에서는 이미지를 보내기 전에 이러한 한도에 맞춰 크기를 조정하고, 반환된 좌표를 원본 이미지의 좌표로 변환하세요. 좌표 처리 방법은 컴퓨터 사용 가이드를 참고하세요.

모델별 크기 조정 방식

다음 표는 범용 비전 모델의 이미지 크기 조정 방식을 정리한 것입니다. 다른 모델이나 특화 베리언트에는 다른 한도가 적용될 수 있습니다. 크기를 조정할 때는 항상 가로세로 비율을 유지하며 작은 이미지를 확대하지 않습니다.

모델 계열	지원하는 세부 수준	패치 및 크기 조정 방식
`gpt-6-astra`	`low`, `high`, `original`, `auto`	`low`에서는 이미지를 512 × 512픽셀 이내로 조정합니다. `high`에서는 패치 수가 최대 2,500개이고 한 변의 길이가 최대 65,535픽셀입니다. 두 한도가 모두 적용됩니다. `original`에서는 원본 크기를 유지하되, 가로나 세로가 65,535픽셀을 넘으면 한도에 맞게 축소합니다. 이렇게 처리한 이미지에 필요한 패치 수가 30,000개를 초과하면 API는 요청을 거부합니다. 패치 한도에 맞춰 이미지를 다시 축소하지 않습니다. `auto`의 크기 조정 방식은 `original`과 같습니다.
`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`	`low`, `high`, `original`, `auto`	`low`에서는 이미지를 512 × 512픽셀 이내로 조정합니다. `high`에서는 2048 × 2048픽셀 이내이면서 패치 수가 2,500개 이하가 되도록 조정합니다. `original` 설정은 원본 크기를 유지하되, 가로나 세로가 65,535픽셀을 넘으면 한도에 맞게 축소합니다. 이렇게 처리한 이미지에 필요한 패치 수가 30,000개를 초과하면 API는 요청을 거부합니다. 패치 한도에 맞춰 이미지를 다시 축소하지 않습니다. `auto`의 크기 조정 방식은 `original`과 같습니다.
`gpt-5.5`	`low`, `high`, `original`, `auto`	`low`에서는 이미지를 512 × 512픽셀 이내로 조정합니다. `high`에서는 패치 수가 최대 2,500개이고 한 변의 길이가 최대 2048픽셀입니다. `original` 설정에서는 패치 수가 최대 10,000개이고 한 변의 길이가 최대 6000픽셀입니다. 두 한도가 모두 적용됩니다. `auto`의 크기 조정 방식은 `original`과 같습니다.
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`	`low`, `high`, `original`, `auto`	`low`에서는 한 변의 길이가 최대 2048픽셀이고 패치 한도가 6,144개이므로 `high`보다 토큰을 더 많이 사용할 수 있습니다. `high`에서는 패치 수가 최대 2,500개이고 한 변의 길이가 최대 2048픽셀입니다. `original`에서는 패치 수가 최대 10,000개이고 한 변의 길이가 최대 6000픽셀입니다. 두 한도가 모두 적용됩니다. `auto`의 크기 조정 방식은 `high`와 같습니다.
`gpt-5.2`, `gpt-4.1-mini`	`low`, `high`, `auto`	지원되는 모든 세부 수준에 같은 한도가 적용됩니다. 한 변의 길이는 최대 2048픽셀이고 패치 한도는 6,144개입니다. `original`은 지원하지 않습니다.
`gpt-5.1`, `gpt-4.1`, `gpt-4o`, `gpt-4o-mini`	`low`, `high`, `auto`	`low`에서는 토큰 수가 고정됩니다. `high`와 `auto`에서는 타일 기반 크기 조정 규칙을 사용합니다.

비용 계산

비전 모델은 입력 이미지를 과금 대상인 입력 토큰으로 변환합니다. 이미지 입력 비용 계산기와 이 섹션의 패치 및 타일 규칙은 비전 모델의 입력에 적용됩니다. GPT Image로 이미지를 생성하거나 편집할 때 적용되는 별도 요금은 GPT Image 모델 입력을 참고하세요.

이미지 토큰은 분당 토큰 수(TPM) 한도에도 포함됩니다. 계산기는 표준 입력 요금을 기준으로 이미지 한 장의 비용을 추정합니다. 나머지 프롬프트와 모델 출력은 계산에 포함하지 않습니다.

이미지 입력 비용 계산기

이미지 입력 비용 계산기에서 모델, 이미지 크기, 세부 수준에 따른 이미지 한 장의 예상 입력 토큰 수와 비용을 확인하세요.

패치 기반 이미지 토큰화

일부 모델은 이미지를 32 × 32픽셀 패치로 덮어 토큰화합니다. 많은 모델과 세부 수준 조합에는 크기 조정용 패치 한도가 정해져 있습니다. 먼저 API는 선택한 세부 수준의 픽셀 크기 한도에 맞춰 이미지를 조정합니다. 이때 가로세로 비율을 유지하고 픽셀 수를 정수로 반올림하며 작은 이미지는 확대하지 않습니다. 이후 다음과 같이 과금할 토큰 수를 계산합니다.

A. 픽셀 크기 한도를 적용한 이미지를 덮는 데 필요한 32 × 32픽셀 패치 수를 계산합니다. 패치 일부가 이미지 경계를 벗어날 수 있습니다.

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

B. 선택한 모델과 세부 수준에 크기 조정용 패치 한도가 있고 이미지가 그 한도를 초과하면 가로세로 비율을 유지하면서 축소합니다. 그렇지 않으면 이 단계를 건너뜁니다. 가로·세로 픽셀 수를 정수로 변환한 후에도 이미지를 덮는 데 필요한 패치 수가 한도 이내가 되도록 축소 비율을 조정합니다. 최종 크기를 계산할 때까지 중간값의 정밀도를 그대로 유지하세요.

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단계에서 이미지 크기를 조정했다면 최종 가로·세로 길이를 각각 정수 픽셀 단위로 내림합니다. 그 크기의 이미지를 덮는 데 필요한 패치 수를 계산합니다. 이 값이 모델별 배수를 적용하기 전의 이미지 토큰 수입니다. 크기 조정용 패치 한도가 적용되는 경우 이 값은 해당 한도를 넘지 않습니다.

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

패치 수가 30,000개를 초과하면 API는 요청을 거부합니다. 토큰 배수를 적용하기 전에 이 한도를 확인하세요.

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 스냅샷에 적용됩니다.

* 사용 중단 예정(deprecated) 상태이며 서비스 종료가 예정되어 있습니다. 종료일과 대체 모델은 사용 중단 일정에서 확인하세요. 이 모델들은 계산기와 위의 모델별 크기 조정 표에 포함되지 않습니다.

gpt-6-astra에서 detail: high를 사용할 때의 이미지 토큰 계산 예시

이 조합에서는 한 변의 길이가 최대 65,535픽셀이고 패치 한도는 2,500개이며 배수는 1.2입니다.

1024 × 1024 이미지에는 32 × 32 = 1024개의 패치가 필요합니다. 크기를 조정할 필요가 없습니다. 과금 대상 이미지 입력 토큰 수는 ceil(1024 × 1.2) = 1229개입니다.
2048 × 2048 이미지에는 처음에 64 × 64 = 4096개의 패치가 필요합니다. 패치 한도에 맞춰 1600 × 1600픽셀로 축소하면 패치 수가 50 × 50 = 2500개가 됩니다. 예상 토큰 수는 ceil(2500 × 1.2) = 3000개입니다.
4096 × 512 이미지는 원본 크기를 유지합니다. 패치 수는 128 × 16 = 2048개이고 토큰 수는 ceil(2048 × 1.2) = 2458개입니다.

과금 시 부동소수점 반올림으로 인해 최종 토큰 수가 예상치와 1개 차이 날 수 있습니다.

타일 기반 이미지 토큰화

다음 표의 모델은 기본 토큰 수에 이미지 타일에 해당하는 토큰 수를 더합니다.

모델	기본 토큰 수	타일당 토큰 수
`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

"detail": "low"를 사용하면 이미지 크기와 관계없이 모델의 기본 토큰 수만큼만 과금됩니다. "detail": "high" 또는 "detail": "auto"를 사용할 때는 다음과 같이 계산합니다.

가로세로 비율을 유지하면서 2048 × 2048픽셀 안에 들어오도록 축소합니다. 작은 이미지는 확대하지 않습니다.
짧은 변이 768픽셀을 초과하면 해당 변이 768픽셀이 되도록 축소하고 다른 변의 픽셀 수는 내림합니다.
이미지를 덮는 데 필요한 한 변이 512픽셀인 정사각형 타일의 수를 계산합니다. 각 타일에는 모델별 타일당 토큰 수가 적용됩니다.
전체 타일의 토큰 수에 모델의 기본 토큰 수를 더합니다.

GPT Image 모델 입력

GPT Image 모델에는 이미지 생성 및 편집을 위한 별도의 이미지 토큰 요금이 적용됩니다. 비전 모델용 계산기로는 이 모델들의 입력 또는 출력 비용을 추정할 수 없습니다. 현재 요금은 이미지 생성 요금에서 확인하고, 생성 및 편집 워크플로우는 이미지 생성 가이드를 참고하세요.

GPT Image 1

gpt-image-1은 2026년 10월 23일에 서비스가 종료되었습니다. 과거 비용을 비교할 수 있도록 당시의 입력 토큰 계산 규칙을 아래에 남겨 두었습니다. 대체 모델은 사용 중단 공지에서 확인하세요.

이전 요청의 토큰 수를 계산할 때는 타일 기반 크기 조정 방식을 사용하되, 짧은 변의 축소 기준을 768픽셀 대신 512픽셀로 적용하세요. 토큰 사용량은 이미지의 가로·세로 크기와 input_fidelity 매개변수 설정에 따라 달라집니다. 이 매개변수는 Images API에서 설정합니다.

입력 충실도를 낮게 설정하면 기본 비용은 이미지 토큰 65개이며, 타일당 이미지 토큰 129개가 부과됩니다. 입력 충실도를 높게 설정하면 위에서 계산한 이미지 토큰에 가로세로 비율에 따라 정해진 수의 토큰이 추가됩니다.

정사각형 이미지에는 입력 이미지 토큰 4160개가 추가됩니다.
세로형이나 가로형에 가까운 이미지에는 토큰 6240개가 추가됩니다.

당시 이미지 입력 토큰 단가는 GPT Image 1 모델 페이지에서 확인하세요.

한계

비전 모델도 잘못된 답변을 할 수 있습니다. 애플리케이션을 설계할 때는 다음 한계를 고려하세요.

의료 영상: 모델은 CT 영상과 같은 전문 의료 영상을 판독하는 데 적합하지 않으며, 의료 조언에 사용해서는 안 됩니다.
영어 이외의 언어: 일본어나 한국어처럼 라틴 문자를 사용하지 않는 언어의 텍스트가 포함된 이미지를 처리할 때는 성능이 떨어질 수 있습니다.
작은 글자: 읽기 쉽도록 이미지 속 글자를 확대하세요. 모델이 지원한다면 "detail": "original"을 사용하는 것도 도움이 될 수 있습니다.
회전: 모델은 회전되어 있거나 거꾸로 된 텍스트와 이미지를 잘못 해석할 수 있습니다.
시각적 요소: 색상이나 스타일이 다양한 그래프나 텍스트는 모델이 이해하기 어려울 수 있습니다. 실선, 파선, 점선 등으로 구분한 그래프가 한 예입니다.
공간 추론: 체스판에서 기물의 위치를 파악하는 것처럼 공간상의 위치를 정확히 식별해야 하는 작업에는 어려움이 있습니다.
정확성: 상황에 따라 모델이 잘못된 설명이나 캡션을 생성할 수 있습니다.
이미지 형태: 모델은 파노라마 이미지와 어안 렌즈로 촬영한 이미지를 분석하는 데 어려움이 있습니다.
메타데이터 및 크기 조정: 모델은 원본 파일 이름이나 메타데이터를 처리하지 않습니다. 분석 전에 이미지 크기가 조정될 수 있으며, original을 선택한 경우에도 마찬가지입니다. 모델별 한도는 모델별 크기 조정 방식을 참고하세요.
개수 세기: 이미지 속 사물의 개수를 물으면 모델이 대략적인 수를 답할 수 있습니다.
CAPTCHA: 안전상의 이유로 시스템에서 CAPTCHA 제출을 차단합니다.

추천

시작하기

핵심 개념

SDK 및 CLI

클라우드 제공업체

자료

레거시 API

모델 선택하기

텍스트 및 코드

프롬프트 작성

추론

이미지

실시간 처리 및 오디오

특화 모델

Agents API

Agents SDK

ChatKit

검색 및 정보 조회

도구와 데이터 연결하기

도구를 활용한 워크플로우 구축하기

컴퓨터 및 코드

미디어

GPT-Live

Realtime API

음성 기능 개발

연결

오디오 처리

서비스 출시하기

성능 및 품질

평가

비용 및 처리량

안전 및 거버넌스

인프라 및 접근 권한

운영

핵심 개념

기획

개발

테스트 및 게시

전환 명세

가이드

자료

사용자 식별

ChatGPT 요금제 사용량

가이드

파일 업로드

API

성과 측정

광고주 API

API 레퍼런스

시작하기

시작하기

기초

둘러보기

지원 플랫폼

릴리스

워크플로우

주요 기능

Sites

dot

ChatGPT 스페이스

레퍼런스

맞춤 설정

설정 파일

에이전트 설정

ChatGPT와 Codex 확장하기

Linux

Windows

개발 워크플로우

확장 및 자동화

환경

Codex Cloud

Codex로 개발하기

서드 파티 통합

레퍼런스

권한

Codex Security

사이버 안전

시작하기

기능 설정

ID 및 액세스