Imagens e visão | OpenAI API

Visão geral

Use os modelos GPT Image para gerar ou editar imagens.

Use os recursos de visão dos nossos modelos para analisar imagens.

Os modelos de linguagem recentes conseguem processar e analisar imagens recebidas como entrada. Essa capacidade é conhecida como visão. Os modelos GPT Image podem usar texto e imagens como entrada para criar imagens ou editar as existentes.

Escolha o endpoint de acordo com a tarefa: analisar ou gerar imagens.

API	Casos de uso compatíveis
API Responses	Analisar imagens ou usar a ferramenta de geração de imagens para gerar e editar imagens
API Images	Gerar imagens como saída, com a opção de usar imagens como entrada
API chat completions	Analisar imagens e gerar respostas em texto

Para saber quais modalidades de entrada e saída nossos modelos aceitam, consulte a página de modelos.

Gerar ou editar imagens

Na API Images, escolha gpt-image-2.5-sunburst para gerar imagens a partir de texto ou editar imagens existentes. Na API Responses, escolha um modelo da linha principal compatível com a ferramenta de geração de imagens. A própria ferramenta seleciona o modelo GPT Image.

Gerar imagens com a API Responses

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

Saiba mais no guia de geração de imagens.

Usar o conhecimento sobre o mundo para gerar imagens

Os modelos GPT Image podem recorrer ao conhecimento que têm sobre o mundo sem precisar de uma imagem de referência. Por exemplo, um prompt que peça uma vitrine de pedras semipreciosas pode gerar uma cena com pedras reconhecíveis, como ametista, quartzo rosa e jade.

Analisar imagens

Use um modelo com recursos de visão para descrever imagens, ler o texto visível e responder a perguntas sobre objetos, formas, cores ou texturas. Leve em conta as limitações do modelo ao usar as respostas.

Enviar imagens ao modelo como entrada

Para enviar uma imagem para análise, informe a URL completa da imagem ou uma URL de dados com a imagem codificada em Base64.

Você pode enviar várias imagens em uma única requisição. Para isso, inclua as imagens no array content. Lembre-se de que as imagens são contabilizadas como tokens e cobradas com base nessa contagem.

Analisar o conteúdo de uma imagem

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
  }'

Analisar o conteúdo de uma imagem

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

Para enviar uma imagem para análise, use uma destas opções:

Informe a URL completa de um arquivo de imagem.
Envie uma URL de dados com a imagem codificada em Base64.
Informe o ID de um arquivo criado com a API Files.

Analisar o conteúdo de uma imagem

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

Analisar o conteúdo de uma imagem

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)

Analisar o conteúdo de uma imagem

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)

Requisitos para imagens de entrada

Use arquivos de imagem em formatos compatíveis e com nitidez suficiente para que o modelo possa analisá-los.

Requisito	Entradas aceitas
Tipos de arquivo	PNG (`.png`), JPEG (`.jpeg` ou `.jpg`), WEBP (`.webp`) e GIF sem animação (`.gif`)
Tamanho da requisição	Até 512 MB de dados no total por requisição
Quantidade de imagens	Até 1.500 imagens por requisição

Para imagens de entrada processadas em blocos, a API aceita até 30.000 blocos por imagem após aplicar as regras de redimensionamento correspondentes ao modelo e ao valor de detail selecionados. Esse limite vale para todos os níveis de detalhe compatíveis e se aplica a cada imagem individualmente, independentemente do total de blocos na requisição.

Se o modelo e o nível de detalhe tiverem um limite menor de blocos para redimensionamento, esse limite continua valendo. Se uma imagem exceder 30.000 blocos após o processamento, a API a rejeitará sem redimensioná-la automaticamente para atender a esse limite. Reduza as dimensões da imagem e tente novamente.

Os tokens de imagem e o restante do prompt, juntos, também precisam respeitar os limites de entrada e de contexto do modelo. Uma estimativa de tokens não garante que a requisição atenda a todos os limites de entrada. O uso de imagens deve seguir nossas políticas de uso.

Escolher o nível de detalhe da imagem

O parâmetro detail controla o pré-processamento da imagem. Os valores aceitos dependem do modelo: low, high, original ou auto. Se você omitir o parâmetro, o valor padrão será auto tanto na API Responses quanto na API chat completions. Consulte a tabela de redimensionamento por modelo para ver as regras correspondentes.

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"
}

Escolha o nível de detalhe de acordo com a tarefa:

Nível de detalhe	Quando usar
`low`	Para uma análise geral da imagem. O redimensionamento e o consumo de tokens dependem do modelo. O nível `low` nem sempre consome menos tokens que `high`.
`high`	Para análises de alta fidelidade em tarefas comuns que dispensam coordenadas precisas na imagem original.
`original`	Para imagens grandes ou com muitos detalhes, tarefas que exigem precisão espacial ou imagens usadas no recurso Uso do computador, quando o modelo aceita esse nível.
`auto`	Para usar as regras padrão de redimensionamento do modelo, descritas na tabela de redimensionamento por modelo.

Em tarefas que exigem detalhes visuais finos ou coordenadas precisas, como reconhecimento óptico de caracteres (OCR), detecção de objetos pequenos ou Uso do computador, use "detail": "original" quando o modelo aceitar essa opção. Mesmo nesse nível, a API pode redimensionar imagens para respeitar o limite de dimensão em pixels ou o limite de blocos para redimensionamento do modelo. O limite de rejeição de 30.000 blocos é independente e não aciona o redimensionamento. Em tarefas que dependem de coordenadas precisas, redimensione as imagens antes do envio para respeitar esses limites e converta as coordenadas retornadas para a escala da imagem original. Para saber como lidar com coordenadas, consulte o guia de Uso do computador.

Regras de redimensionamento por modelo

A tabela a seguir resume as regras de redimensionamento dos modelos de visão de uso geral. Outros modelos e variantes especializadas podem ter limites diferentes. O redimensionamento sempre preserva a proporção entre largura e altura e nunca amplia imagens menores.

Família de modelos	Níveis de detalhe aceitos	Regras de contagem de blocos e redimensionamento
`gpt-6-astra`	`low`, `high`, `original`, `auto`	`low` limita a imagem a 512 × 512 pixels. `high` permite até 2.500 blocos e no máximo 65.535 pixels em cada dimensão. Os dois limites se aplicam. `original` preserva as dimensões da imagem, mas reduz proporcionalmente as imagens cuja largura ou altura excede 65.535 pixels para respeitar esse limite. Se a imagem resultante exigir mais de 30.000 blocos, a API rejeitará a requisição sem redimensionar a imagem para adequá-la ao limite de blocos. `auto` segue as mesmas regras de redimensionamento de `original`.
`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`	`low`, `high`, `original`, `auto`	`low` limita a imagem a 512 × 512 pixels. `high` limita a imagem a 2.048 × 2.048 pixels e a 2.500 blocos. `original` preserva as dimensões da imagem, mas reduz proporcionalmente as imagens cuja largura ou altura excede 65.535 pixels para respeitar esse limite. Se a imagem resultante exigir mais de 30.000 blocos, a API rejeitará a requisição sem redimensionar a imagem para adequá-la ao limite de blocos. `auto` segue as mesmas regras de redimensionamento de `original`.
`gpt-5.5`	`low`, `high`, `original`, `auto`	`low` limita a imagem a 512 × 512 pixels. `high` permite até 2.500 blocos e no máximo 2.048 pixels em cada dimensão. `original` permite até 10.000 blocos e no máximo 6.000 pixels em cada dimensão. Os dois limites se aplicam. `auto` segue as mesmas regras de redimensionamento de `original`.
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`	`low`, `high`, `original`, `auto`	`low` permite até 2.048 pixels em cada dimensão e até 6.144 blocos, por isso pode consumir mais tokens que `high`. `high` permite até 2.500 blocos e no máximo 2.048 pixels em cada dimensão. `original` permite até 10.000 blocos e no máximo 6.000 pixels em cada dimensão. Os dois limites se aplicam. `auto` segue as mesmas regras de redimensionamento de `high`.
`gpt-5.2`, `gpt-4.1-mini`	`low`, `high`, `auto`	Esses níveis de detalhe usam os mesmos limites de redimensionamento: até 2.048 pixels em cada dimensão e até 6.144 blocos. Esses modelos não aceitam `original`.
`gpt-5.1`, `gpt-4.1`, `gpt-4o`, `gpt-4o-mini`	`low`, `high`, `auto`	`low` usa uma quantidade fixa de tokens. `high` e `auto` seguem as regras de redimensionamento por ladrilhos.

Cálculo de custos

Os modelos de visão convertem imagens em tokens de entrada faturáveis. A calculadora de custo de imagens de entrada e as regras de blocos e ladrilhos desta seção se aplicam às entradas dos modelos de visão. A geração e a edição de imagens com GPT Image têm preços próprios. Consulte Entradas dos modelos GPT Image para saber como funciona essa cobrança.

Os tokens de imagem também contam para seus limites de tokens por minuto (TPM). A calculadora estima o custo de uma imagem usando os preços padrão de entrada. O cálculo exclui o restante do prompt e a saída do modelo.

Calculadora de custo de imagens de entrada

Use a calculadora de custo de imagens de entrada para estimar a quantidade de tokens de entrada e o custo de uma imagem com base no modelo, nas dimensões da imagem e no nível de detalhe.

Tokenização de imagens por blocos

Alguns modelos tokenizam imagens cobrindo-as com blocos de 32 × 32 pixels. Muitas combinações de modelo e nível de detalhe definem um limite de blocos para redimensionamento. Primeiro, a API ajusta a imagem ao limite de dimensão em pixels do nível de detalhe selecionado. Ela mantém a proporção entre largura e altura, arredonda as dimensões para números inteiros de pixels e não amplia imagens menores. O cálculo do custo em tokens segue estas etapas:

A. Calcule quantos blocos de 32 × 32 pixels são necessários para cobrir a imagem após aplicar o limite de dimensão em pixels. Um bloco pode ultrapassar a borda da imagem.

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

B. Se o modelo e o nível de detalhe selecionados definirem um limite de blocos para redimensionamento e a imagem ultrapassá-lo, reduza a imagem proporcionalmente. Caso contrário, pule esta etapa. Ajuste o fator de escala para que a contagem de blocos respeite o limite após a conversão das dimensões em números inteiros de pixels. Mantenha a precisão total até calcular as dimensões finais.

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. Se a etapa B redimensionou a imagem, arredonde a largura e a altura finais para baixo, em números inteiros de pixels. Calcule quantos blocos são necessários para cobrir a imagem resultante. Esse número corresponde à quantidade de tokens de imagem antes da aplicação do multiplicador do modelo. Quando há um limite de blocos para redimensionamento, a contagem fica dentro desse limite.

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

Se a contagem ultrapassar 30.000 blocos, a API rejeitará a requisição. Verifique esse limite antes de aplicar o multiplicador de tokens.

D. Multiplique a quantidade de blocos pelo multiplicador do modelo e arredonde para cima para obter o número de tokens de entrada faturáveis da imagem. Aplique o preço de entrada do modelo a esses tokens uma única vez. O multiplicador não se aplica aos demais tokens do prompt e não deve ser reaplicado ao preço.

Modelo	Multiplicador
`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`* (versão de 2025-04-14)	2,46
`o4-mini`*	1,72

Para gpt-4.1-mini, o multiplicador se aplica à versão de 2025-04-14.

* Modelos obsoletos com desativação programada. Consulte o cronograma de desativação para ver as datas e os modelos substitutos. Esses modelos não aparecem na calculadora nem na tabela de redimensionamento acima.

Exemplos de cálculo de tokens de imagem para gpt-6-astra com detail: high

Essa combinação permite até 65.535 pixels em cada dimensão e até 2.500 blocos, com um multiplicador de 1,2×.

Uma imagem de 1.024 × 1.024 pixels precisa de 32 × 32 = 1024 blocos. Não é necessário redimensioná-la. A entrada de imagem corresponde a ceil(1024 × 1.2) = 1229 tokens faturáveis.
Uma imagem de 2.048 × 2.048 pixels precisa inicialmente de 64 × 64 = 4096 blocos. Para respeitar o limite de blocos, a imagem é reduzida para 1.600 × 1.600 pixels, o que corresponde a 50 × 50 = 2500 blocos. A estimativa é de ceil(2500 × 1.2) = 3000 tokens.
Uma imagem de 4.096 × 512 pixels mantém as dimensões originais, com 128 × 16 = 2048 blocos e ceil(2048 × 1.2) = 2458 tokens.

Devido ao arredondamento de números de ponto flutuante na cobrança, a contagem final pode diferir da estimativa em um token.

Tokenização de imagens por ladrilhos

Os modelos desta tabela usam uma quantidade base de tokens e somam a ela os tokens de cada ladrilho da imagem:

Modelo	Tokens de base	Tokens por ladrilho
`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

Com "detail": "low", o custo da imagem corresponde apenas aos tokens de base do modelo, independentemente das dimensões. Com "detail": "high" ou "detail": "auto", siga estas etapas:

Reduza a imagem para que caiba em um quadrado de 2.048 × 2.048 pixels, mantendo a proporção entre largura e altura. Não amplie imagens menores.
Se o lado mais curto exceder 768 pixels, reduza-o para 768 pixels e arredonde a outra dimensão para baixo.
Conte quantos quadrados de 512 pixels de lado são necessários para cobrir a imagem. Cada quadrado consome a quantidade de tokens por ladrilho definida pelo modelo.
Some os tokens de base do modelo ao total de tokens dos ladrilhos.

Entradas dos modelos GPT Image

Os modelos GPT Image têm preços específicos para tokens de imagem em tarefas de geração e edição. A calculadora de visão não estima os custos de entrada nem de saída desses modelos. Consulte os preços de geração de imagens para ver as tarifas atuais. Para conhecer os fluxos de geração e edição, consulte o guia de geração de imagens.

GPT Image 1

O modelo gpt-image-1 foi desativado em 23 de outubro de 2026. As regras de tokens de entrada a seguir servem para comparações com custos históricos. Consulte o aviso de desativação para ver os modelos substitutos.

Para calcular o custo de requisições antigas, use as regras de redimensionamento por ladrilhos, mas reduza o lado mais curto para 512 pixels em vez de 768 pixels. O consumo de tokens depende das dimensões da imagem e do parâmetro input_fidelity da API Images.

Quando a fidelidade de entrada é baixa, o custo base é de 65 tokens de imagem e cada ladrilho custa 129 tokens de imagem. Quando a fidelidade de entrada é alta, somamos aos tokens de imagem descritos acima uma quantidade fixa de tokens que depende da proporção entre largura e altura da imagem.

Se a imagem for quadrada, acrescentamos 4.160 tokens de imagem de entrada.
Se o formato se aproximar de retrato ou paisagem, acrescentamos 6.240 tokens.

Para consultar os preços históricos dos tokens de imagem de entrada, acesse a página do modelo GPT Image 1.

Limitações

Os modelos de visão podem cometer erros. Considere estas limitações ao projetar seu aplicativo:

Imagens médicas: o modelo não é adequado para interpretar imagens médicas especializadas, como tomografias computadorizadas, e não deve ser usado para dar orientações médicas.
Idiomas além do inglês: o desempenho do modelo pode ser inferior ao analisar imagens com texto em sistemas de escrita não latinos, como os do japonês ou do coreano.
Texto pequeno: amplie o texto na imagem para facilitar a leitura. Quando disponível, a opção "detail": "original" também pode melhorar o desempenho.
Rotação: o modelo pode interpretar incorretamente textos e imagens girados ou de cabeça para baixo.
Elementos visuais: o modelo pode ter dificuldade para interpretar gráficos ou textos que usam cores ou estilos diferentes, como linhas contínuas, tracejadas ou pontilhadas.
Raciocínio espacial: o modelo tem dificuldade em tarefas que exigem localização espacial precisa, como identificar a posição das peças em um tabuleiro de xadrez.
Exatidão: em algumas situações, o modelo pode gerar descrições ou legendas incorretas.
Formato da imagem: o modelo tem dificuldade para interpretar imagens panorâmicas ou captadas com lentes olho de peixe.
Metadados e redimensionamento: o modelo não processa os nomes originais dos arquivos nem seus metadados. As imagens podem ser redimensionadas antes da análise, inclusive no nível de detalhe original. Consulte as regras de redimensionamento por modelo para ver os limites de cada modelo.
Contagem: o modelo pode fornecer contagens aproximadas dos objetos em uma imagem.
CAPTCHAs: por motivos de segurança, nosso sistema bloqueia o envio de CAPTCHAs.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Provedores de nuvem

Recursos

APIs legadas

Escolha um modelo

Texto e código

Como escrever prompts

Raciocínio

Imagens

Tempo real e áudio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Busca e recuperação de informações

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolver aplicações de voz

Conexões

Processamento de áudio

Coloque em produção

Desempenho e qualidade

Avaliação

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Planejar

Desenvolver

Testar e publicar

Especificações de conversão

Guias

Recursos

Identidade

Uso do plano do ChatGPT

Guias

Envio de arquivos

API

Mensuração

API para anunciantes

Referência da API

Primeiros passos

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Sites

dots

ChatGPT Space

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Ampliar os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Ampliar recursos e automatizar tarefas

Ambientes

Codex Cloud

Desenvolver com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

Configuração de recursos

Identidade e acesso