Images et vision | OpenAI API

Vue d’ensemble

Use GPT Image models to generate or edit images.

Use our models' vision capabilities to analyze images.

Les modèles de langage récents peuvent traiter et analyser des images fournies en entrée. Cette capacité s’appelle la 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	Analyser des images, ou en générer et en modifier avec l’outil de génération d’images
API Images	Générer des images en sortie, éventuellement à partir d’images fournies en entrée
API Chat Completions	Analyser des images et générer des réponses textuelles

Pour connaître les modalités d’entrée et de sortie prises en charge par nos modèles, consultez la page des modèles.

Générer ou modifier des 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 sélectionne lui-même le modèle GPT Image.

Générer des 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 de génération d’images.

Générer des images à partir des connaissances du modèle

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 où l’on reconnaît des pierres comme l’améthyste, le quartz rose et le jade.

Analyser des 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.

Fournir des images en entrée à un modèle

Pour fournir une image à analyser, utilisez son URL absolue ou une URL de données contenant l’image encodée en Base64.

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

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

Analyser le 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

Pour fournir une image à analyser, utilisez l’une des méthodes suivantes :

Fournissez l’URL absolue d’un fichier image.
Fournissez une URL de données contenant l’image encodée en Base64.
Fournissez l’identifiant d’un fichier créé avec l’API Files.

Analyser le 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

Analyser le 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)

Analyser le 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 dans un format pris en charge et suffisamment nets pour que le modèle puisse les analyser.

Critère	Entrées prises en charge
Types de fichiers	PNG (`.png`), JPEG (`.jpeg` ou `.jpg`), WEBP (`.webp`) et GIF non animé (`.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 traitées par patchs, l’API accepte 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 vaut pour tous les niveaux de détail pris en charge. Elle s’applique à chaque image individuellement, indépendamment du nombre total de patchs dans la requête.

Les budgets de redimensionnement inférieurs propres à certains modèles et niveaux de détail restent applicables. Si une image dépasse la limite de 30 000 patchs après traitement, l’API la rejette sans la redimensionner automatiquement pour respecter cette limite. Réduisez les dimensions de l’image et réessayez.

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

Choisir un niveau de détail pour les images

Le paramètre detail détermine le prétraitement des images. Selon le modèle, les valeurs prises en charge sont low, high, original ou auto. Si vous omettez ce paramètre, sa valeur par défaut est auto dans l’API Responses comme dans l’API Chat Completions. Le tableau des règles de redimensionnement par modèle indique 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"
}

Pour choisir un niveau de détail, appuyez-vous sur les indications suivantes :

Niveau de détail	Utilisation recommandée
`low`	Analyse globale de l’image. Le redimensionnement et le nombre de tokens utilisés dépendent du modèle. Le niveau `low` ne consomme pas toujours moins de tokens que `high`.
`high`	Analyse détaillée de l’image pour les usages courants qui ne nécessitent pas de coordonnées précises dans l’image d’origine.
`original`	Images de grande taille, riches en détails, nécessitant une localisation précise ou servant à l’utilisation de l’ordinateur, si le modèle prend en charge ce niveau.
`auto`	Application des règles de redimensionnement par défaut du modèle, indiquées dans le tableau ci-dessous.

Pour les tâches qui exigent 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" si le modèle le prend en charge. À ce niveau de détail, l’image peut encore être redimensionnée pour respecter les dimensions maximales en pixels ou le budget de patchs du modèle. La limite de rejet distincte de 30 000 patchs ne déclenche aucun redimensionnement supplémentaire. Pour les tâches qui dépendent de la précision des coordonnées, redimensionnez les images avant l’envoi pour respecter ces limites, puis convertissez les coordonnées renvoyées dans le repère de l’image d’origine. Pour la gestion des coordonnées, consultez le guide d’utilisation de l’ordinateur.

Règles de redimensionnement par modèle

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

Famille de modèles	Niveaux de détail pris en charge	Règles de redimensionnement et limites de patchs
`gpt-6-astra`	`low`, `high`, `original`, `auto`	`low` limite l’image à 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 si sa largeur ou sa hauteur dépasse 65 535 pixels. Dans ce cas, l’image est réduite pour respecter cette limite. Si l’image obtenue nécessite plus de 30 000 patchs, l’API rejette la requête sans redimensionner l’image pour respecter la limite de patchs. `auto` applique les mêmes règles de redimensionnement 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` limite l’image à 2 048 × 2 048 pixels et à 2 500 patchs. `original` conserve les dimensions de l’image, sauf si sa largeur ou sa hauteur dépasse 65 535 pixels. Dans ce cas, l’image est réduite pour respecter cette limite. Si l’image obtenue nécessite plus de 30 000 patchs, l’API rejette la requête sans redimensionner l’image pour respecter la limite de patchs. `auto` applique les mêmes règles de redimensionnement 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 2 048 pixels. `original` autorise jusqu’à 10 000 patchs et une dimension maximale de 6 000 pixels. Les deux limites s’appliquent. `auto` applique les mêmes règles de redimensionnement que `original`.
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`	`low`, `high`, `original`, `auto`	`low` fixe une dimension maximale de 2 048 pixels et un budget de 6 144 patchs. Il peut donc consommer plus de tokens que `high`. `high` autorise jusqu’à 2 500 patchs et une dimension maximale de 2 048 pixels. `original` autorise jusqu’à 10 000 patchs et une dimension maximale de 6 000 pixels. Les deux limites s’appliquent. `auto` applique les mêmes règles de redimensionnement que `high`.
`gpt-5.2`, `gpt-4.1-mini`	`low`, `high`, `auto`	Ces niveaux de détail appliquent les mêmes limites de redimensionnement, avec une dimension maximale de 2 048 pixels et un budget de 6 144 patchs. Le niveau `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 redimensionnement par tuiles.

Calcul des coûts

Les modèles de vision convertissent les images en tokens d’entrée facturables. Le calculateur de coût des images en entrée et les règles de calcul par patchs ou par tuiles de cette section s’appliquent aux images fournies aux modèles de vision. Pour la tarification distincte de la génération et de la modification d’images avec GPT Image, consultez la section Images en entrée des modèles GPT Image.

Les tokens d’image sont également pris en compte dans vos limites de tokens par minute (TPM). Le calculateur estime le coût d’une seule image au tarif standard des tokens d’entrée. Il exclut le reste du prompt et la sortie du modèle.

Calculateur de coût des images en entrée

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

Tokenisation des images par patchs

Certains modèles tokenisent les images en les recouvrant de patchs de 32 × 32 pixels. Pour de nombreuses combinaisons de modèle et de niveau de détail, un budget de patchs s’applique au redimensionnement. L’API ajuste d’abord l’image aux dimensions maximales en pixels du niveau de détail sélectionné. Elle conserve les proportions et arrondit les dimensions à un nombre entier de pixels sans agrandir les images plus petites. Calculez ensuite le coût en tokens comme suit.

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

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

B. Si le modèle et le niveau de détail sélectionnés fixent un budget de patchs pour le redimensionnement et que l’image le dépasse, réduisez-la en conservant ses proportions. Dans les autres cas, passez à l’étape suivante. Ajustez le facteur de réduction de manière à respecter le budget une fois les dimensions converties en nombres entiers de pixels et le nombre de patchs calculé. Conservez toute la précision des valeurs 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 vous avez redimensionné l’image à l’étape B, arrondissez la largeur et la hauteur obtenues au pixel entier inférieur. Calculez le nombre de patchs nécessaires pour couvrir l’image obtenue. Il correspond au 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 du 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 facturables en entrée. 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 au tarif lui-même.

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 14 avril 2025)	2,46
`o4-mini`*	1,72

Pour gpt-4.1-mini, ce multiplicateur s’applique à la version du 14 avril 2025.

* Ces modèles sont obsolètes et leur mise hors service est programmée. 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 redimensionnement ci-dessus.

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

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

Une image de 1 024 × 1 024 pixels 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 2 048 × 2 048 pixels nécessite initialement 64 × 64 = 4096 patchs. Pour respecter le budget de patchs, l’API réduit l’image à 1 600 × 1 600 pixels, soit 50 × 50 = 2500 patchs. L’estimation est de ceil(2500 × 1.2) = 3000 tokens.
Une image de 4 096 × 512 pixels conserve ses dimensions d’origine et représente 128 × 16 = 2048 patchs, soit 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 décompte final et l’estimation.

Tokenisation des images par tuiles

Les modèles du tableau suivant 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`	2 833	5 667
`o1`, `o1-pro`, `o3`*	75	150

Avec "detail": "low", le coût d’une image se limite aux tokens de base du modèle, quelles que soient ses dimensions. Avec "detail": "high" ou "detail": "auto", procédez comme suit :

Réduisez l’image pour qu’elle tienne dans un carré de 2 048 × 2 048 pixels en conservant ses proportions. N’agrandissez pas les images plus petites.
Si le côté le plus court dépasse 768 pixels, ramenez-le à 768 pixels et arrondissez l’autre dimension au pixel entier inférieur.
Comptez les carrés de 512 pixels de côté nécessaires pour couvrir l’image. Chaque carré consomme le nombre de tokens par tuile indiqué pour le modèle.
Ajoutez les tokens de base du modèle au total des tokens des tuiles.

Images en entrée des modèles GPT Image

Les modèles GPT Image appliquent une tarification distincte aux tokens d’image pour la génération et la modification d’images. Le calculateur des modèles de vision n’estime pas leurs coûts d’entrée ou de sortie. Pour connaître les tarifs en vigueur, 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

gpt-image-1 a été mis hors service le 23 octobre 2026. Les règles de calcul des tokens d’entrée ci-dessous permettent de comparer les coûts historiques. Consultez l’avis de retrait pour connaître les modèles de remplacement.

Pour les anciennes requêtes, utilisez les règles de redimensionnement par tuiles, en ramenant le côté le plus court à 512 pixels au lieu de 768. 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é de l’image en entrée est 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é est élevée, nous ajoutons aux tokens d’image décrits ci-dessus un nombre fixe de tokens qui dépend des proportions de l’image.

Si l’image est carrée, nous ajoutons 4 160 tokens d’image en entrée.
Si ses proportions se rapprochent d’un format portrait ou paysage, nous ajoutons 6 240 tokens.

Pour connaître les anciens tarifs des tokens d’image en entrée, consultez la page du modèle GPT Image 1.

Limites

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

Images médicales : le modèle ne convient pas à l’interprétation d’images médicales spécialisées, comme les images de scanner. Ne l’utilisez pas pour donner des conseils médicaux.
Langues autres que l’anglais : les performances du modèle peuvent diminuer lorsque les images contiennent du texte dans un système d’écriture non latin, comme le japonais ou le coréen.
Texte de petite taille : agrandissez le texte dans l’image pour le rendre plus lisible. Si le modèle prend en charge "detail": "original", ce réglage peut également améliorer les résultats.
Rotation : le modèle peut mal interpréter du texte ou des images présentés de travers ou à l’envers.
Éléments visuels : le modèle peut avoir du mal à interpréter des graphiques ou du texte qui utilisent des couleurs ou des styles différents, par exemple des lignes continues, en tirets ou en pointillés.
Raisonnement spatial : le modèle a du mal à effectuer des tâches qui nécessitent de localiser précisément des éléments, par exemple repérer la position des pièces sur un échiquier.
Exactitude : dans certains cas, le modèle peut produire des descriptions ou des légendes incorrectes.
Format de l’image : le modèle a du mal à interpréter 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 les règles de redimensionnement par modèle pour connaître les limites propres à chaque modèle.
Comptage : le modèle peut donner un nombre approximatif d’objets présents dans une image.
CAPTCHA : pour des raisons de sécurité, notre système bloque l’envoi de CAPTCHA.

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès