---
title: Vision
url: https://platform.claude.com/docs/fr/build-with-claude/vision
description: Les capacités de vision de Claude lui permettent de comprendre et d'analyser des images, ouvrant des possibilités passionnantes d'interaction multimodale.
---

Ce guide décrit comment envoyer des images à Claude, les limites et les coûts qui s'appliquent, et où trouver des conseils pour les [flux de travail basés sur les coordonnées](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates).

***

## Envoyer des images à Claude

Utilisez les capacités de vision de Claude via :

* [claude.ai](https://claude.ai/). Téléversez une image comme vous le feriez pour un fichier, ou glissez-déposez une image directement dans la fenêtre de discussion.
* Le [Playground](https://platform.claude.com/playground) dans la Claude Console. Ajoutez des images directement à n'importe quel bloc de message User.
* Une requête API. Consultez les exemples suivants.

Sur l'API, fournissez les images à Claude sous forme de blocs de contenu `image` en utilisant l'un des trois types de source :

1. Une image encodée en base64 intégrée dans le corps de la requête
2. Une référence URL vers une image hébergée en ligne
3. Un `file_id` renvoyé par l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files) (téléversez une fois, référencez plusieurs fois)

<Note>
  Sur Amazon Bedrock et Google Cloud, seules les sources encodées en base64 sont actuellement disponibles.
</Note>

<Tip>
  Tout comme [placer les longs documents avant votre requête](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting) améliore les résultats dans les prompts textuels, Claude fonctionne mieux lorsque les images précèdent le texte. Les images placées après le texte ou intercalées avec du texte donnent toujours de bons résultats, mais si votre cas d'usage le permet, privilégiez une structure image puis texte.
</Tip>

### Exemple d'image encodée en base64

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d @- <<EOF
  {
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "base64",
              "media_type": "image/jpeg",
              "data": "$BASE64_IMAGE_DATA"
            }
          },
          {
            "type": "text",
            "text": "Describe this image."
          }
        ]
      }
    ]
  }
  EOF
  ```

  ```bash CLI
  curl -sSo ./vision-example.jpg \
    https://platform.claude.com/docs/images/vision-example.jpg

  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: base64
            media_type: image/jpeg
            data: "@./vision-example.jpg"
        - type: text
          text: Describe this image.
  YAML
  ```

  ```python Python
  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image1_media_type = "image/png"

  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": image1_media_type,
                          "data": image1_data,
                      },
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic();

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/jpeg",
              data: imageData // Base64-encoded image data as string
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  string imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = imageData,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  imageData := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewImageBlockBase64("image/png", imageData),
  			anthropic.NewTextBlock("Describe this image."),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
  String imageData =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  List<ContentBlockParam> contentBlockParams = List.of(
    ContentBlockParam.ofImage(
      ImageBlockParam.builder()
        .source(
          Base64ImageSource.builder()
            .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
            .data(imageData)
            .build()
        )
        .build()
    ),
    ContentBlockParam.ofText(TextBlockParam.builder().text("Describe this image.").build())
  );
  Message message = client
    .messages()
    .create(
      MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(contentBlockParams)
        .build()
    );

  IO.println(message);
  ```

  ```php PHP
  $client = new Client();

  $imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $imageData,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  image_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image_data
            }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

### Exemple d'image basée sur une URL

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "image",
              "source": {
                "type": "url",
                "url": "https://platform.claude.com/docs/images/vision-example.jpg"
              }
            },
            {
              "type": "text",
              "text": "Describe this image."
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: url
            url: https://platform.claude.com/docs/images/vision-example.jpg
        - type: text
          text: Describe this image.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "url",
                          "url": "https://platform.claude.com/docs/images/vision-example.jpg",
                      },
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic();

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "url",
              url: "https://platform.claude.com/docs/images/vision-example.jpg"
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new UrlImageSource()
                      {
                          Url = "https://platform.claude.com/docs/images/vision-example.jpg",
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewImageBlock(anthropic.URLImageSourceParam{
  				URL: "https://platform.claude.com/docs/images/vision-example.jpg",
  			}),
  			anthropic.NewTextBlock("Describe this image."),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  List<ContentBlockParam> contentBlockParams = List.of(
    ContentBlockParam.ofImage(
      ImageBlockParam.builder()
        .source(
          UrlImageSource.builder()
            .url("https://platform.claude.com/docs/images/vision-example.jpg")
            .build()
        )
        .build()
    ),
    ContentBlockParam.ofText(TextBlockParam.builder().text("Describe this image.").build())
  );
  Message message = client
    .messages()
    .create(
      MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(contentBlockParams)
        .build()
    );
  System.out.println(message);
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'url',
                          'url' => 'https://platform.claude.com/docs/images/vision-example.jpg',
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "url",
              url: "https://platform.claude.com/docs/images/vision-example.jpg"
            }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

### Exemple d'image avec l'API Files

Pour les images que vous utiliserez de manière répétée ou lorsque vous souhaitez éviter la surcharge liée à l'encodage, utilisez l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files). Téléversez l'image une fois, puis référencez le `file_id` renvoyé dans les messages suivants au lieu de renvoyer les données base64.

<Tip>
  Dans les conversations à plusieurs tours et les flux de travail agentiques, chaque requête renvoie l'historique complet de la conversation. Si les images sont encodées en base64, l'intégralité des octets de l'image est incluse dans la charge utile à chaque tour, ce qui peut augmenter considérablement la taille des requêtes et la « latency » (latence) à mesure que la conversation s'allonge. Téléverser les images vers l'API Files et les référencer par `file_id` permet de garder des charges utiles de requête réduites, quel que soit le nombre d'images accumulées dans l'historique de la conversation.
</Tip>

<CodeGroup>
  ```bash cURL
  # Tout d'abord, téléversez votre image vers la Files API.
  FILE_ID=$(curl -sS -X POST https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -F "file=@vision-example.jpg" | jq -r '.id')

  # Utilisez ensuite le file_id renvoyé dans votre message.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "image",
              "source": {
                "type": "file",
                "file_id": "'"$FILE_ID"'"
              }
            },
            {
              "type": "text",
              "text": "Describe this image."
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  curl -sSo vision-example.jpg \
    https://platform.claude.com/docs/images/vision-example.jpg

  # Tout d'abord, téléversez votre image vers la Files API.
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # Utilisez ensuite le file_id renvoyé dans votre message.
  ant messages create \
    --transform content --format yaml <<YAML
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: file
            file_id: $FILE_ID
        - type: text
          text: Describe this image.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  # Téléverser le fichier image
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # Utiliser le fichier téléversé dans un message
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {"type": "file", "file_id": file_upload.id},
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )

  print(message.content)
  ```

  ```typescript TypeScript
  import Anthropic, { toFile } from "@anthropic-ai/sdk";
  import fs from "node:fs";

  const anthropic = new Anthropic();

  // Téléverser le fichier image
  const fileUpload = await anthropic.files.upload({
    file: await toFile(fs.createReadStream("vision-example.jpg"), undefined, {
      type: "image/jpeg"
    })
  });

  // Utiliser le fichier téléversé dans un message
  const response = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "file",
              file_id: fileUpload.id
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(response);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Core;
  using Anthropic.Models.Files;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  // Téléverser le fichier image
  var fileUpload = await client.Files.Upload(new FileUploadParams
  {
      File = new BinaryContent
      {
          Stream = File.OpenRead("vision-example.jpg"),
          FileName = "vision-example.jpg",
          ContentType = new("image/jpeg"),
      },
  });

  // Utiliser le fichier téléversé dans un message
  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new FileImageSource(fileUpload.ID))
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  // Téléverser le fichier image
  file, err := os.Open("vision-example.jpg")
  if err != nil {
  	log.Fatal(err)
  }
  defer file.Close()

  fileUpload, err := client.Files.Upload(context.Background(),
  	anthropic.FileUploadParams{
  		File: anthropic.File(file, "vision-example.jpg", "image/jpeg"),
  	})
  if err != nil {
  	log.Fatal(err)
  }

  // Utiliser le fichier téléversé dans un message
  message, err := client.Messages.New(context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(
  				anthropic.NewImageBlock(anthropic.FileImageSourceParam{
  					FileID: fileUpload.ID,
  				}),
  				anthropic.NewTextBlock("Describe this image."),
  			),
  		},
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message.Content)
  ```

  ```java Java
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.files.FileMetadata;
  import com.anthropic.models.files.FileUploadParams;
  // ...
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      // Téléverser le fichier image
      FileMetadata file = client.files().upload(
        FileUploadParams.builder()
          .file(
            MultipartField.<InputStream>builder()
              .value(Files.newInputStream(Path.of("vision-example.jpg")))
              .filename("vision-example.jpg")
              .contentType("image/jpeg")
              .build()
          )
          .build()
      );

      // Utiliser le fichier téléversé dans un message
      ImageBlockParam imageParam = ImageBlockParam.builder().fileSource(file.id()).build();

      MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(
          List.of(
            ContentBlockParam.ofImage(imageParam),
            ContentBlockParam.ofText(
              TextBlockParam.builder().text("Describe this image.").build()
            )
          )
        )
        .build();

      Message message = client.messages().create(params);
      System.out.println(message.content());
  ```

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  // Téléverser le fichier image
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // Utiliser le fichier téléversé dans un message
  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => ['type' => 'file', 'fileID' => $fileUpload->id],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Téléverser le fichier image
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # Utiliser le fichier téléversé dans un message
  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: { type: "file", file_id: file_upload.id }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message.content
  ```
</CodeGroup>

Consultez les [exemples de l'API Messages](https://platform.claude.com/docs/fr/api/messages/create) pour davantage d'exemples de code et de détails sur les paramètres.

### Images multiples

Vous pouvez inclure plusieurs images dans une seule requête, et Claude les analyse conjointement. Cela est utile pour comparer des images, poser des questions sur leurs différences ou travailler avec une séquence telle que les pages d'un document. Lorsque vous envoyez plusieurs images, introduisez chacune d'elles par une courte étiquette textuelle (`Image 1:`, `Image 2:`, etc.) afin de pouvoir y faire référence par leur nom dans votre prompt et dans les tours suivants.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": "Image 1:"
            },
            {
              "type": "image",
              "source": {
                "type": "base64",
                "media_type": "image/png",
                "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
              }
            },
            {
              "type": "text",
              "text": "Image 2:"
            },
            {
              "type": "image",
              "source": {
                "type": "base64",
                "media_type": "image/png",
                "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"
              }
            },
            {
              "type": "text",
              "text": "How are these images different?"
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: text
          text: "Image 1:"
        - type: image
          source:
            type: base64
            media_type: image/png
            data: iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC
        - type: text
          text: "Image 2:"
        - type: image
          source:
            type: base64
            media_type: image/png
            data: iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC
        - type: text
          text: How are these images different?
  YAML
  ```

  ```python Python
  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Image 1:"},
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": "image/png",
                          "data": image1_data,
                      },
                  },
                  {"type": "text", "text": "Image 2:"},
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": "image/png",
                          "data": image2_data,
                      },
                  },
                  {"type": "text", "text": "How are these images different?"},
              ],
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic();

  const image1Data =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  const image2Data =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Image 1:"
          },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image1Data
            }
          },
          {
            type: "text",
            text: "Image 2:"
          },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image2Data
            }
          },
          {
            type: "text",
            text: "How are these images different?"
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

  ```csharp C#
  AnthropicClient client = new();

  string image1Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  string image2Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new TextBlockParam("Image 1:")),
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = image1Data,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Image 2:")),
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = image2Data,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("How are these images different?")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  image1Data := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2Data := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("Image 1:"),
  			anthropic.NewImageBlockBase64("image/png", image1Data),
  			anthropic.NewTextBlock("Image 2:"),
  			anthropic.NewImageBlockBase64("image/png", image2Data),
  			anthropic.NewTextBlock("How are these images different?"),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  String image1Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  String image2Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  List<ContentBlockParam> contentBlockParams = List.of(
      ContentBlockParam.ofText(TextBlockParam.builder().text("Image 1:").build()),
      ContentBlockParam.ofImage(
          ImageBlockParam.builder()
              .source(
                  Base64ImageSource.builder()
                      .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                      .data(image1Data)
                      .build()
              )
              .build()
      ),
      ContentBlockParam.ofText(TextBlockParam.builder().text("Image 2:").build()),
      ContentBlockParam.ofImage(
          ImageBlockParam.builder()
              .source(
                  Base64ImageSource.builder()
                      .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                      .data(image2Data)
                      .build()
              )
              .build()
      ),
      ContentBlockParam.ofText(
          TextBlockParam.builder().text("How are these images different?").build()
      )
  );

  Message message = client
      .messages()
      .create(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024)
              .addUserMessageOfBlockParams(contentBlockParams)
              .build()
      );

  IO.println(message);
  ```

  ```php PHP
  $client = new Client();

  $image1Data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
  $image2Data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC';

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  ['type' => 'text', 'text' => 'Image 1:'],
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $image1Data,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Image 2:'],
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $image2Data,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'How are these images different?'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo $message;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Image 1:" },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image1_data
            }
          },
          { type: "text", text: "Image 2:" },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image2_data
            }
          },
          { type: "text", text: "How are these images different?" }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

Dans une conversation à plusieurs tours, ajoutez de nouvelles images dans les tours `user` ultérieurs de la même manière. Claude a accès à toutes les images des tours précédents, de sorte que les questions de suivi telles que « Celles-ci sont-elles similaires aux deux premières ? » fonctionnent sans qu'il soit nécessaire d'inclure à nouveau les images précédentes dans le contenu du nouveau tour.

***

## Limites et coûts des images

### Limites des requêtes

Le nombre maximal d'images par message ou par requête est de :

* 20 par message sur [claude.ai](https://claude.ai/).
* 100 par requête sur l'API, pour les modèles dotés d'une « context window » (fenêtre de contexte) de 200 000 tokens.
* 600 par requête sur l'API, pour tous les autres modèles.

Les dimensions maximales par image sont de 8000x8000 px.

Si une seule requête API contient plus de 20 images, une limite de dimensions par image plus stricte s'applique à chaque image de cette requête. Tous les blocs `image` de la requête sont comptabilisés dans ce seuil, y compris les images des tours de conversation précédents que vous renvoyez et les images imbriquées dans le contenu `tool_result` (par exemple, les captures d'écran renvoyées à l'outil d'utilisation de l'ordinateur). Sur Amazon Bedrock et Google Cloud, les blocs de documents tels que les PDF sont également comptabilisés dans ce seuil. Les images dépassant la limite plus stricte sont rejetées avec une erreur `invalid_request_error` dont le message fait référence aux « many-image requests » et indique la limite actuelle en pixels. Pour rester sous la limite sur toutes les plateformes, redimensionnez chaque image de sorte qu'aucune dimension ne dépasse 2000 px, ou limitez la requête à 20 blocs d'images et de documents ou moins.

La taille maximale par image est de :

* 10 Mo (encodée en base64) lors de l'utilisation directe de l'API Claude.
* 5 Mo (encodée en base64) sur Amazon Bedrock et Google Cloud.
* 10 Mo sur [claude.ai](https://claude.ai/).

<Note>
  Bien que l'API prenne en charge jusqu'à 600 images par requête, les [limites de taille des requêtes](https://platform.claude.com/docs/fr/api/overview#request-size-limits) (32 Mo pour les points de terminaison standard ; moins sur certaines plateformes exploitées par des partenaires, par exemple Amazon Bedrock et Google Cloud) peuvent être atteintes en premier. Pour un grand nombre d'images, envisagez de les téléverser avec l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/vision#files-api-image-example) et de les référencer par `file_id` afin de garder des charges utiles de requête réduites.

  Même en utilisant l'API Files, les requêtes contenant de nombreuses images volumineuses peuvent échouer avant d'atteindre le nombre de 600 images. Réduisez les dimensions ou la taille des fichiers des images (par exemple, par sous-échantillonnage) avant de les téléverser (voir [Résolution et coût en tokens](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size)).
</Note>

### Formats pris en charge

Claude prend en charge les images JPEG, PNG, GIF et WebP (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Les animations ne sont pas prises en charge, et seule la première image est utilisée.

### Résolution et coût en tokens

Claude voit les images sous forme de patchs plutôt que de pixels. Chaque patch est un bloc de 28×28 pixels de l'image, appelé token visuel. Une image coûte donc `⌈width / 28⌉ × ⌈height / 28⌉` tokens visuels.

Chaque modèle possède une résolution d'image native maximale, exprimée sous forme d'une limite de bord long et d'une limite de tokens visuels. Les images dépassant l'une ou l'autre de ces limites sont réduites avant traitement ; consultez [Comment Claude redimensionne et complète les images](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images) pour connaître la règle exacte. L'exception concerne les captures d'écran et les images de zoom que vous renvoyez aux ensembles d'outils d'[utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) et d'[utilisation du navigateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates) : l'API rejette une image `tool_result` qui dépasse les limites du modèle avec une erreur de validation au lieu de la réduire ; redimensionnez donc ces images dans votre application avant de les renvoyer. Pour que toute autre image surdimensionnée soit rejetée avec une erreur au lieu d'être réduite, définissez le [champ `transformations`](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#oversized-image-error) du bloc image.

| Niveau de résolution | Modèles                          | Bord long max. | Tokens visuels max. |
| -------------------- | -------------------------------- | -------------- | ------------------- |
| Haute résolution     | Claude 4.7 et modèles ultérieurs | 2576 px        | 4784                |
| Standard             | Tous les autres modèles          | 1568 px        | 1568                |

La prise en charge de la haute résolution est automatique sur les modèles indiqués et ne nécessite aucun en-tête bêta ni activation côté client.

Le tableau suivant indique la résolution réduite et le coût en tokens visuels pour plusieurs tailles d'image à chaque niveau :

| Taille de l'image              | Niveau standard : réduite à | Niveau standard : tokens | Niveau haute résolution : réduite à | Niveau haute résolution : tokens |
| ------------------------------ | --------------------------- | ------------------------ | ----------------------------------- | -------------------------------- |
| 200x200 px (0,04 mégapixel)    | Non redimensionnée          | 64                       | Non redimensionnée                  | 64                               |
| 1000x1000 px (1 mégapixel)     | Non redimensionnée          | 1296                     | Non redimensionnée                  | 1296                             |
| 1092x1092 px (1,19 mégapixel)  | Non redimensionnée          | 1521                     | Non redimensionnée                  | 1521                             |
| 1920x1080 px (2,07 mégapixels) | 1456x819 px                 | 1560                     | Non redimensionnée                  | 2691                             |
| 2000x1500 px (3 mégapixels)    | 1269x952 px                 | 1564                     | Non redimensionnée                  | 3888                             |
| 3840x2160 px (8,29 mégapixels) | 1456x819 px                 | 1560                     | 2576x1449 px                        | 4784                             |

Lorsqu'une image est réduite, Claude la met à l'échelle à la plus grande taille compatible avec les limites du niveau tout en préservant son rapport d'aspect. Cela plafonne le coût en tokens. Pour la règle précise et une implémentation de référence, consultez [Comment Claude redimensionne et complète les images](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Pour estimer le coût, multipliez le nombre de tokens par le [prix par token du modèle](https://claude.com/pricing) que vous utilisez. Par exemple, au tarif de Claude Haiku 4.5 de 1 $ USD par million de tokens d'entrée (niveau standard), l'image de 1000×1000 coûte environ 1,30 $ USD pour mille images. Au tarif de Claude Opus 5.5 de 4 $ USD par million (niveau haute résolution), la même image coûte environ 5,18 $ USD pour mille images et l'image 4K environ 19,14 $ USD pour mille images.

Les images haute résolution peuvent utiliser jusqu'à environ trois fois plus de tokens visuels que la même image sur un modèle de niveau standard. Si vous n'avez pas besoin de la fidélité supplémentaire qu'apporte la haute résolution pour l'utilisation de l'ordinateur, la compréhension de captures d'écran et les documents denses, sous-échantillonnez les images avant de les envoyer afin de maîtriser les coûts en tokens. Pour minimiser la latence et simplifier les [flux de travail basés sur les coordonnées](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates), privilégiez le redimensionnement des images avant de les téléverser.

### Conseils sur la qualité des images

Lorsque vous fournissez des images à Claude, gardez à l'esprit les points suivants pour obtenir les meilleurs résultats :

* **Clarté de l'image :** assurez-vous que les images sont nettes et pas trop floues ou pixelisées.
* **Texte :** si l'image contient du texte important, assurez-vous qu'il est lisible et pas trop petit. Évitez de rogner un contexte visuel essentiel uniquement pour agrandir le texte.
* **Redimensionnement :** tenez compte du fait que votre image peut être redimensionnée si elle est trop grande (voir [Résolution et coût en tokens](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size)) ; cela peut, par exemple, rendre le texte moins lisible. Envisagez de redimensionner vos images au préalable, de les rogner, ou les deux. Pour qu'une image surdimensionnée soit rejetée avec une erreur au lieu d'être redimensionnée (important pour les [flux de travail basés sur les coordonnées](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates)), marquez le bloc image avec [`"oversized_image": "error"`](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#oversized-image-error).
* **Compression d'image :** compresser les images avant de les envoyer, à l'aide d'un format avec perte tel que JPEG ou WebP (mode avec perte), peut réduire la latence en diminuant la taille des requêtes. Cependant, cela peut introduire des artefacts préjudiciables aux performances du modèle, en particulier lorsque plusieurs passes de compression sont appliquées. Par exemple, une forte compression JPEG peut rendre le texte difficile à lire. Vérifiez que vos paramètres de compression sont adaptés à la tâche en inspectant les images réellement envoyées à l'API.

***

## Coordonnées et boîtes englobantes

Pour les boîtes englobantes, les points et les coordonnées en pixels, consultez [Coordonnées et boîtes englobantes](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates). Claude renvoie des coordonnées absolues en pixels relatives à l'image qu'il voit après redimensionnement ; ce guide explique comment Claude redimensionne et complète les images et comment les redimensionner au préalable ou les remettre à l'échelle afin que les coordonnées correspondent à votre image d'origine.

***

## Limitations

Bien que les capacités de compréhension d'images de Claude soient à la pointe de la technologie, il existe certaines limitations à connaître :

* **Identification de personnes :** Claude [ne peut pas être utilisé](https://www.anthropic.com/legal/aup) pour nommer des personnes dans des images et refuse de le faire.
* **Précision :** Claude peut halluciner ou commettre des erreurs lors de l'interprétation d'images de faible qualité, pivotées ou très petites (moins de 200 pixels).
* **Raisonnement spatial :** les sorties de coordonnées et de localisation de Claude sont approximatives. Suivez les conseils de [Coordonnées et boîtes englobantes](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates) et vérifiez les sorties avant de vous y fier.
* **Comptage :** Claude peut fournir des décomptes approximatifs d'objets dans une image, mais peut ne pas toujours être parfaitement exact, en particulier avec un grand nombre de petits objets.
* **Images générées par IA :** Claude ne peut pas déterminer si une image a été générée par IA et peut se tromper si on lui pose la question. Ne comptez pas sur lui pour détecter des images fausses ou synthétiques.
* **Contenu inapproprié :** Claude ne traite pas les images inappropriées ou explicites qui enfreignent la [Politique d'utilisation acceptable](https://www.anthropic.com/legal/aup).
* **Applications de santé :** bien que Claude puisse analyser des images médicales générales, il n'est pas conçu pour interpréter des examens diagnostiques complexes tels que des scanners ou des IRM. Les sorties de Claude ne doivent pas être considérées comme un substitut à un avis médical ou à un diagnostic professionnel.

Examinez et vérifiez toujours attentivement les interprétations d'images de Claude, en particulier pour les cas d'usage à enjeux élevés. N'utilisez pas Claude pour des tâches nécessitant une précision parfaite ou une analyse d'images sensible sans supervision humaine.

***

## FAQ

<AccordionGroup>
  <Accordion title="Quels types de fichiers image Claude prend-il en charge ?">
    JPEG, PNG, GIF et WebP. Consultez [Formats pris en charge](https://platform.claude.com/docs/fr/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="Claude peut-il lire des URL d'images ?">
    Oui. Utilisez le type de source `url` au lieu de `base64` dans le bloc de contenu `image`. Consultez l'[exemple d'image basée sur une URL](https://platform.claude.com/docs/fr/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="Existe-t-il une limite à la taille des fichiers image que je peux téléverser ?">
    Oui. Consultez [Limites des requêtes](https://platform.claude.com/docs/fr/build-with-claude/vision#request-limits) pour connaître les limites de taille par image et par requête globale sur l'API Claude, Amazon Bedrock, Google Cloud et claude.ai.
  </Accordion>

  <Accordion title="Combien d'images puis-je inclure dans une seule requête ?">
    Jusqu'à 600 par requête API (100 pour les modèles dotés d'une fenêtre de contexte de 200 000 tokens) et 20 par tour sur claude.ai. Consultez [Limites des requêtes](https://platform.claude.com/docs/fr/build-with-claude/vision#request-limits) pour plus de détails et pour connaître la limite de dimensions par image plus basse qui s'applique au-delà de 20 images.
  </Accordion>

  <Accordion title="Claude lit-il les métadonnées des images ?">
    Non, Claude n'analyse ni ne reçoit aucune métadonnée des images qui lui sont transmises.
  </Accordion>

  <Accordion title="Puis-je supprimer les images que j'ai téléversées ?">
    Non. Les téléversements d'images sont éphémères et ne sont pas conservés au-delà de la durée de la requête API. Les images téléversées sont automatiquement supprimées après avoir été traitées.
  </Accordion>

  <Accordion title="Où puis-je trouver des informations sur la confidentialité des données pour les téléversements d'images ?">
    Reportez-vous à la page de la politique de confidentialité d'Anthropic pour savoir comment les images téléversées et les autres données sont traitées. Anthropic n'utilise pas les images téléversées pour entraîner ses modèles.
  </Accordion>

  <Accordion title="Que faire si l'interprétation d'une image par Claude semble erronée ?">
    Si l'interprétation d'une image par Claude semble incorrecte :

    1. Assurez-vous que l'image est nette, de haute qualité et correctement orientée.
    2. Essayez des techniques de prompt engineering pour améliorer les résultats.
    3. Si le problème persiste, signalez la sortie dans claude.ai (pouce levé/baissé) ou contactez l'[équipe d'assistance](https://support.claude.com/).

    Vos commentaires contribuent à améliorer Claude !
  </Accordion>

  <Accordion title="Claude peut-il générer ou modifier des images ?">
    Non, Claude est uniquement un modèle de compréhension d'images. Il peut interpréter et analyser des images, mais il ne peut pas générer, produire, modifier, manipuler ou créer des images.
  </Accordion>
</AccordionGroup>

***

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Cookbook multimodal" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    Obtenez des conseils et des techniques de bonnes pratiques pour des tâches telles que l'interprétation de graphiques et l'extraction de contenu à partir de formulaires.
  </Card>

  <Card title="Référence de l'API" icon="code" href="https://platform.claude.com/docs/fr/api/messages/create">
    Consultez la documentation de l'API Messages, y compris des exemples d'appels API impliquant des images.
  </Card>
</CardGroup>