Images et vision | OpenAI API

Vue d’ensemble

Utilisez les modèles GPT Image pour générer ou modifier des images.

Utilisez les capacités de vision de nos modèles pour analyser des images.

Les modèles de langage récents peuvent traiter et analyser des images en entrée : cette capacité est appelée vision. Les modèles GPT Image peuvent utiliser du texte et des images en entrée pour créer de nouvelles images ou modifier des images existantes.

Choisissez un point de terminaison selon que vous souhaitez analyser ou générer des images :

API	Cas d’utilisation pris en charge
API Responses	Analyse d’images, ou génération et modification d’images avec l’outil de génération d’images
API Images	Génération d’images en sortie, avec la possibilité d’utiliser des images en entrée
API Chat Completions	Analyse d’images et génération de réponses textuelles

Pour en savoir plus sur les modalités d’entrée et de sortie prises en charge par nos modèles, consultez notre page consacrée aux modèles.

Génération ou modification d’images

Avec l’API Images, choisissez gpt-image-2.5-sunburst pour générer des images à partir de texte ou modifier des images existantes. Avec l’API Responses, choisissez un modèle de la gamme principale qui prend en charge l’outil de génération d’images ; l’outil se charge de sélectionner le modèle GPT Image.

Génération d’images avec 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

Pour en savoir plus sur la génération d’images, consultez notre guide Génération d’images.

Utilisation des connaissances sur le monde pour générer des images

Les modèles GPT Image peuvent s’appuyer sur leurs connaissances du monde sans image de référence. Par exemple, un prompt décrivant une vitrine de pierres semi-précieuses peut produire une scène contenant des gemmes reconnaissables, comme l’améthyste, le quartz rose et le jade.

Analyse d’images

Utilisez un modèle doté de capacités de vision pour décrire des images, lire le texte visible et répondre à des questions sur les objets, les formes, les couleurs ou les textures. Tenez compte des limites du modèle lorsque vous utilisez ses réponses.

Transmission d’images en entrée à un modèle

Fournissez une image à analyser à l’aide d’une URL complète pointant vers l’image ou d’une URL de données encodées en Base64.

Vous pouvez fournir plusieurs images en entrée dans une seule requête en les incluant dans le tableau content, mais gardez à l’esprit que les images sont comptabilisées en tokens et seront facturées en conséquence.

Analyse du contenu d’une image

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

Analyse du contenu d’une image

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

Fournissez une image à analyser de l’une des façons suivantes :

En fournissant une URL complète pointant vers un fichier image
En fournissant une image sous forme d’URL de données encodées en Base64
En fournissant un identifiant de fichier (créé avec l’API Files)

Analyse du contenu d’une image

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

Analyse du contenu d’une image

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)

Analyse du contenu d’une image

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)

Exigences relatives aux images en entrée

Utilisez des fichiers image pris en charge et suffisamment nets pour que le modèle puisse les analyser.

Exigence	Entrées prises en charge
Types de fichiers	PNG (`.png`), JPEG (`.jpeg` ou `.jpg`), WEBP (`.webp`) et GIF non animés (`.gif`)
Taille de la requête	Jusqu’à 512 Mo de données au total par requête
Nombre d’images	Jusqu’à 1 500 images par requête

Pour les images en entrée traitées par patchs, l’API prend en charge jusqu’à 30 000 patchs par image après application des règles de redimensionnement du modèle et du niveau detail sélectionnés. Cette limite s’applique à tous les niveaux de détail pris en charge et à chaque image séparément, et non au nombre total de patchs de la requête.

Les budgets de redimensionnement inférieurs propres au modèle et au niveau de détail restent applicables. Les images qui dépassent la limite de 30 000 patchs après traitement sont rejetées, et non redimensionnées automatiquement pour la respecter. Réduisez les dimensions de l’image et réessayez.

Les tokens d’image et le reste de votre prompt doivent également respecter les limites d’entrée et de contexte du modèle. Une estimation du nombre de tokens ne garantit pas qu’une requête respecte toutes les limites d’entrée. L’utilisation des images doit être conforme à nos politiques d’utilisation.

Choisissez un niveau de détail pour l’image

Le paramètre detail contrôle le prétraitement des images. Les valeurs prises en charge dépendent du modèle : low, high, original ou auto. Si vous omettez ce paramètre, sa valeur par défaut est auto, aussi bien dans l’API Responses que dans l’API Chat Completions. Le tableau des règles de dimensionnement par modèle présente le comportement correspondant.

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

Utilisez les recommandations suivantes pour choisir un niveau de détail :

Niveau de détail	Idéal pour
`low`	Compréhension globale de l’image. Le redimensionnement et la consommation de tokens dépendent du modèle ; `low` n’utilise pas toujours moins de tokens que `high`.
`high`	Compréhension standard des images en haute fidélité, lorsque des coordonnées précises dans l’image d’origine ne sont pas nécessaires.
`original`	Images de grande taille, riches en détails, nécessitant une précision spatiale ou destinées à l’utilisation de l’ordinateur, lorsque le modèle les prend en charge.
`auto`	Utilisez les règles de dimensionnement par défaut du modèle, indiquées dans le tableau des règles de dimensionnement par modèle.

Pour les tâches qui nécessitent des détails visuels fins ou des coordonnées précises, comme la reconnaissance optique de caractères (OCR), la détection de petits objets ou l’utilisation de l’ordinateur, utilisez "detail": "original" lorsque cette option est prise en charge. Le niveau de détail original peut tout de même redimensionner les images pour respecter la limite de dimensions en pixels ou le budget de patchs pour le redimensionnement du modèle, mais pas pour respecter la limite de rejet distincte de 30 000 patchs. Pour les tâches nécessitant des coordonnées précises, redimensionnez les images afin de respecter ces limites avant de les envoyer, puis convertissez les coordonnées renvoyées en coordonnées dans l’image d’origine. Consultez le guide Utilisation de l’ordinateur pour la gestion des coordonnées.

Règles de dimensionnement par modèle

Le tableau suivant résume les règles de dimensionnement des modèles de vision généralistes. D’autres modèles et variantes spécialisées peuvent utiliser des limites différentes. Tout redimensionnement conserve les proportions, sans agrandir les images plus petites.

Famille de modèles	Niveaux de détail pris en charge	Règles de traitement des patchs et de redimensionnement
`gpt-6-astra`	`low`, `high`, `original`, `auto`	Avec `low`, les dimensions ne dépassent pas 512 × 512 pixels. `high` autorise jusqu’à 2 500 patchs et une dimension maximale de 65 535 pixels. Les deux limites s’appliquent. `original` conserve les dimensions de l’image, sauf pour les images dont un côté dépasse 65 535 pixels, qui sont réduites pour respecter cette limite. Si l’image obtenue nécessite plus de 30 000 patchs, l’API rejette la requête ; l’image n’est pas redimensionnée pour respecter la limite de patchs. `auto` applique les mêmes règles de dimensionnement que `original`.
`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`	`low`, `high`, `original`, `auto`	`low` limite l’image à 512 × 512 pixels. `high` la limite à 2048 × 2048 pixels et à 2 500 patchs. `original` conserve les dimensions de l’image, sauf si l’un de ses côtés dépasse 65 535 pixels : l’image est alors réduite pour respecter cette limite. Si l’image obtenue nécessite plus de 30 000 patchs, l’API rejette la requête ; l’image n’est pas redimensionnée pour respecter la limite de patchs. `auto` applique les mêmes règles de dimensionnement que `original`.
`gpt-5.5`	`low`, `high`, `original`, `auto`	`low` limite l’image à 512 × 512 pixels. `high` autorise jusqu’à 2 500 patchs et une dimension maximale de 2048 pixels. `original` autorise jusqu’à 10 000 patchs et une dimension maximale de 6000 pixels. Les deux limites s’appliquent. `auto` applique les mêmes règles de dimensionnement que `original`.
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`	`low`, `high`, `original`, `auto`	`low` applique une dimension maximale de 2048 pixels et un budget de 6 144 patchs, et peut donc utiliser plus de tokens que `high`. `high` autorise jusqu’à 2 500 patchs et une dimension maximale de 2048 pixels. `original` autorise jusqu’à 10 000 patchs et une dimension maximale de 6000 pixels. Les deux limites s’appliquent. `auto` applique les mêmes règles de dimensionnement que `high`.
`gpt-5.2`, `gpt-4.1-mini`	`low`, `high`, `auto`	Ces niveaux de détail appliquent les mêmes limites de dimensionnement : une dimension maximale de 2048 pixels et un budget de 6 144 patchs. `original` n’est pas pris en charge.
`gpt-5.1`, `gpt-4.1`, `gpt-4o`, `gpt-4o-mini`	`low`, `high`, `auto`	`low` utilise un nombre fixe de tokens. `high` et `auto` appliquent les règles de dimensionnement par tuiles.

Calcul des coûts

Les modèles de vision convertissent les images en entrée en tokens d’entrée facturables. Le calculateur du coût des images en entrée et les règles relatives aux patchs et aux tuiles de cette section concernent les entrées des modèles de vision, et non la génération ou la modification d’images avec GPT Image. Consultez la section Entrées des modèles GPT Image pour connaître cette tarification distincte.

Les tokens d’image sont également comptabilisés dans vos limites de tokens par minute (TPM). Le calculateur fournit une estimation pour une seule image aux tarifs d’entrée standard ; il n’inclut pas le reste de votre prompt ni la sortie du modèle.

Calculateur du coût des images en entrée

Utilisez le calculateur du coût des images en entrée pour estimer le nombre de tokens d’entrée et le coût d’une image en fonction du modèle, des dimensions de l’image et du niveau de détail.

Tokenisation des images par patchs

Certains modèles tokenisent les images en les recouvrant de patchs de 32 px × 32 px. De nombreuses combinaisons de modèle et de niveau de détail définissent un budget de patchs pour le redimensionnement. L’API ajuste d’abord l’image à la limite de dimensions en pixels du niveau de détail sélectionné, en conservant les proportions et en arrondissant à un nombre entier de pixels, sans agrandir les images plus petites. Le coût en tokens est ensuite déterminé comme suit :

A. Calculez le nombre de patchs de 32 px × 32 px nécessaires pour couvrir l’image après application de la limite de dimensions en pixels. Un patch peut dépasser les limites de l’image.

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

B. Lorsque le modèle et le niveau de détail sélectionnés définissent un budget de patchs pour le redimensionnement, réduisez proportionnellement l’image si elle dépasse ce budget. Sinon, passez cette étape. Ajustez le facteur d’échelle pour respecter le budget après conversion des dimensions en nombres entiers de pixels et calcul du nombre de patchs nécessaires pour couvrir l’image. Conservez toute la précision jusqu’au calcul des dimensions finales.

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. Si l’étape B a redimensionné l’image, arrondissez la largeur et la hauteur finales à l’entier inférieur, en pixels. Calculez le nombre de patchs nécessaires pour couvrir l’image obtenue. Il s’agit du nombre de tokens d’image avant application du multiplicateur du modèle. Lorsqu’un budget de patchs s’applique, ce nombre reste dans les limites de ce budget.

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

Si ce nombre dépasse 30 000 patchs, l’API rejette la requête. Vérifiez cette limite avant d’appliquer le multiplicateur de tokens.

D. Multipliez le nombre de patchs par le multiplicateur du modèle et arrondissez à l’entier supérieur pour obtenir le nombre de tokens d’image en entrée facturables. Appliquez une seule fois le tarif d’entrée du modèle à ces tokens ; le multiplicateur ne s’applique ni aux autres tokens du prompt ni de nouveau au tarif.

Modèle	Multiplicateur
`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`* (version du 2025-04-14)	2.46
`o4-mini`*	1.72

Pour gpt-4.1-mini, ces règles s’appliquent à la version du 2025-04-14.

* Modèles obsolètes dont l’arrêt est prévu. Consultez le calendrier de retrait pour connaître les dates et les modèles de remplacement. Ces modèles ne figurent ni dans le calculateur ni dans le tableau des règles de dimensionnement ci-dessus.

Exemples de calcul des tokens d’image pour gpt-6-astra avec detail: high

Cette combinaison utilise une dimension maximale de 65 535 pixels, un budget de 2 500 patchs et un multiplicateur de 1,2×.

Une image de 1024 × 1024 nécessite 32 × 32 = 1024 patchs. Aucun redimensionnement n’est nécessaire. L’image représente ceil(1024 × 1.2) = 1229 tokens d’entrée facturables.
Une image de 2048 × 2048 nécessite initialement 64 × 64 = 4096 patchs. Le budget de patchs impose de la réduire à 1600 × 1600 pixels, soit 50 × 50 = 2500 patchs. L’estimation est de ceil(2500 × 1.2) = 3000 tokens.
Une image de 4096 × 512 conserve ses dimensions d’origine : 128 × 16 = 2048 patchs et ceil(2048 × 1.2) = 2458 tokens.

Les arrondis en virgule flottante utilisés pour la facturation peuvent entraîner un écart d’un token entre le nombre final et l’estimation.

Tokenisation des images par tuiles

Les modèles de ce tableau utilisent un nombre de tokens de base auquel s’ajoutent les tokens des tuiles de l’image :

Modèle	Tokens de base	Tokens par tuile
`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

Avec "detail": "low", une image ne coûte que le nombre de tokens de base du modèle, quelles que soient ses dimensions. Avec "detail": "high" ou "detail": "auto" :

Réduisez l’image pour qu’elle tienne dans un carré de 2048 px × 2048 px, en conservant ses proportions. Les images plus petites ne sont pas agrandies.
Si le côté le plus court dépasse 768 px, réduisez-le à 768 px et arrondissez l’autre dimension à l’entier inférieur.
Comptez les carrés de 512 px de côté nécessaires pour couvrir l’image. Chaque carré utilise le nombre de tokens par tuile du modèle.
Ajoutez les tokens de base du modèle au total des tokens des tuiles.

Entrées des modèles GPT Image

Les modèles GPT Image appliquent une tarification distincte des tokens d’image pour la génération et la modification. Le calculateur de vision n’estime pas leurs coûts d’entrée ou de sortie. Pour connaître les tarifs actuels, consultez les tarifs de génération d’images ; pour les workflows de génération et de modification, consultez le guide de génération d’images.

GPT Image 1

Les règles suivantes concernant les tokens d’entrée s’appliquent à gpt-image-1. Utilisez le dimensionnement des images par tuiles, mais réduisez le côté le plus court à 512 px au lieu de 768 px. Le nombre de tokens utilisés dépend des dimensions de l’image et du paramètre input_fidelity de l’API Images.

Lorsque la fidélité d’entrée est réglée sur faible, le coût de base est de 65 tokens d’image, et chaque tuile coûte 129 tokens d’image. Lorsque la fidélité d’entrée est élevée, nous ajoutons aux tokens d’image décrits ci-dessus un nombre fixe de tokens déterminé par le rapport largeur/hauteur de l’image.

Si votre image est carrée, nous ajoutons 4160 tokens d’image en entrée supplémentaires.
Si elle se rapproche plutôt d’un format portrait ou paysage, nous ajoutons 6240 tokens supplémentaires.

Pour connaître les tarifs des tokens d’image en entrée, consultez la section sur la tarification des images.

Limites

Les modèles de vision peuvent commettre des erreurs. Tenez compte des limites suivantes lors de la conception de votre application :

Images médicales : le modèle n’est pas adapté à l’interprétation d’images médicales spécialisées, comme celles issues de scanners, et ne doit pas être utilisé pour fournir des conseils médicaux.
Langues autres que l’anglais : les performances du modèle peuvent être moins bonnes lorsqu’il traite des images contenant du texte dans des systèmes d’écriture non latins, comme le japonais ou le coréen.
Texte de petite taille : agrandissez le texte dans l’image pour améliorer sa lisibilité. Lorsque cette option est disponible, l’utilisation de "detail": "original" peut également améliorer les performances.
Rotation : le modèle peut mal interpréter les textes et les images qui ont subi une rotation ou sont à l’envers.
Éléments visuels : le modèle peut avoir du mal à comprendre les graphiques ou les textes dont les couleurs ou les styles varient, par exemple lorsqu’ils comportent des lignes continues, en tirets ou en pointillés.
Raisonnement spatial : le modèle a du mal à effectuer des tâches qui nécessitent une localisation spatiale précise, comme l’identification des positions aux échecs.
Exactitude : le modèle peut générer des descriptions ou des légendes incorrectes dans certaines situations.
Forme de l’image : le modèle a du mal à traiter les images panoramiques et celles prises avec un objectif fisheye.
Métadonnées et redimensionnement : le modèle ne traite ni les noms de fichiers d’origine ni les métadonnées. Les images peuvent être redimensionnées avant l’analyse, y compris avec le niveau de détail original. Consultez la section Règles de dimensionnement par modèle pour connaître les limites applicables à chaque modèle.
Comptage : le modèle peut fournir un décompte approximatif des objets présents dans les images.
CAPTCHAs : pour des raisons de sécurité, notre système bloque l’envoi de CAPTCHAs.

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog