---
title: Visão
url: https://platform.claude.com/docs/pt-BR/build-with-claude/vision
description: Os recursos de visão do Claude permitem que ele compreenda e analise imagens, abrindo possibilidades empolgantes para interação multimodal.
---

Este guia descreve como enviar imagens ao Claude, os limites e custos aplicáveis e onde encontrar orientações para [fluxos de trabalho baseados em coordenadas](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates).

***

## Enviar imagens ao Claude

Use os recursos de visão do Claude por meio de:

* [claude.ai](https://claude.ai/). Faça upload de uma imagem como faria com um arquivo, ou arraste e solte uma imagem diretamente na janela de chat.
* [Playground](https://platform.claude.com/playground) no Claude Console. Adicione imagens diretamente a qualquer bloco de mensagem User.
* Requisição de API. Veja os exemplos a seguir.

Na API, forneça imagens ao Claude como blocos de conteúdo `image` usando um de três tipos de origem:

1. Uma imagem codificada em base64 incorporada no corpo da requisição
2. Uma referência de URL para uma imagem hospedada online
3. Um `file_id` retornado pela [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files) (faça upload uma vez, referencie muitas vezes)

<Note>
  No Amazon Bedrock e no Google Cloud, apenas origens codificadas em base64 estão disponíveis atualmente.
</Note>

<Tip>
  Assim como [colocar documentos longos antes da sua consulta](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting) melhora os resultados em prompts de texto, o Claude funciona melhor quando as imagens vêm antes do texto. Imagens colocadas após o texto ou intercaladas com o texto ainda têm bom desempenho, mas, se o seu caso de uso permitir, prefira uma estrutura de imagem seguida de texto.
</Tip>

### Exemplo de imagem codificada em 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>

### Exemplo de imagem baseada em 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>

### Exemplo de imagem com a Files API

Para imagens que você usará repetidamente ou quando quiser evitar a sobrecarga de codificação, use a [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files). Faça upload da imagem uma vez e, em seguida, referencie o `file_id` retornado nas mensagens subsequentes em vez de reenviar dados em base64.

<Tip>
  Em conversas com múltiplos turnos e fluxos de trabalho agênticos, cada requisição reenvia o histórico completo da conversa. Se as imagens estiverem codificadas em base64, todos os bytes da imagem são incluídos no payload a cada turno, o que pode aumentar significativamente o tamanho da requisição e a latência à medida que a conversa cresce. Fazer upload das imagens para a Files API e referenciá-las por `file_id` mantém os payloads das requisições pequenos, independentemente de quantas imagens se acumulem no histórico da conversa.
</Tip>

<CodeGroup>
  ```bash cURL
  # Primeiro, faça upload da sua imagem para a 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')

  # Em seguida, use o file_id retornado na sua mensagem
  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

  # Primeiro, faça upload da sua imagem para a Files API
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # Em seguida, use o file_id retornado na sua mensagem
  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()

  # Faça o upload do arquivo de imagem
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # Use o arquivo enviado em uma mensagem
  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();

  // Faça upload do arquivo de imagem
  const fileUpload = await anthropic.files.upload({
    file: await toFile(fs.createReadStream("vision-example.jpg"), undefined, {
      type: "image/jpeg"
    })
  });

  // Use o arquivo enviado em uma mensagem
  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();

  // Faz o upload do arquivo de imagem
  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"),
      },
  });

  // Usa o arquivo enviado em uma mensagem
  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()

  // Faça upload do arquivo de imagem
  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)
  }

  // Use o arquivo enviado em uma mensagem
  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();

      // Faça upload do arquivo de imagem
      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()
      );

      // Use o arquivo enviado em uma mensagem
      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();

  // Faça upload do arquivo de imagem
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // Use o arquivo enviado em uma mensagem
  $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

  # Faça upload do arquivo de imagem
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # Use o arquivo enviado em uma mensagem
  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>

Consulte os [exemplos da Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create) para mais códigos de exemplo e detalhes de parâmetros.

### Múltiplas imagens

Você pode incluir múltiplas imagens em uma única requisição, e o Claude as analisa em conjunto. Isso é útil para comparar imagens, perguntar sobre diferenças ou trabalhar com uma sequência, como as páginas de um documento. Ao enviar várias imagens, introduza cada uma com um rótulo de texto curto (`Image 1:`, `Image 2:` e assim por diante) para que você possa se referir a elas pelo nome no seu prompt e nos turnos seguintes.

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

Em uma conversa com múltiplos turnos, adicione novas imagens em turnos `user` posteriores da mesma forma. O Claude tem acesso a todas as imagens dos turnos anteriores, então perguntas de acompanhamento como "Estas são semelhantes às duas primeiras?" funcionam sem incluir novamente as imagens anteriores no conteúdo do novo turno.

***

## Limites e custos de imagens

### Limites de requisição

O número máximo de imagens por mensagem ou requisição é:

* 20 por mensagem no [claude.ai](https://claude.ai/).
* 100 por requisição na API, para modelos com uma "context window" (janela de contexto) de 200k tokens.
* 600 por requisição na API, para todos os outros modelos.

As dimensões máximas por imagem são 8000x8000 px.

Se uma única requisição de API contiver mais de 20 imagens, um limite de dimensão por imagem mais rigoroso se aplica a todas as imagens dessa requisição. Todos os blocos `image` na requisição contam para esse limite, incluindo imagens de turnos anteriores da conversa que você reenvia e imagens aninhadas dentro do conteúdo de `tool_result` (por exemplo, capturas de tela retornadas à ferramenta de uso do computador). No Amazon Bedrock e no Google Cloud, blocos de documento, como PDFs, também contam para esse limite. Imagens que excedem o limite mais rigoroso são rejeitadas com um `invalid_request_error` cuja mensagem faz referência a "many-image requests" e informa o limite atual em pixels. Para ficar abaixo do limite em todas as plataformas, redimensione cada imagem para que nenhuma dimensão exceda 2000 px, ou mantenha a requisição com 20 ou menos blocos de imagem e documento.

O tamanho máximo por imagem é:

* 10 MB (codificado em base64) ao usar a Claude API diretamente.
* 5 MB (codificado em base64) no Amazon Bedrock e no Google Cloud.
* 10 MB no [claude.ai](https://claude.ai/).

<Note>
  Embora a API suporte até 600 imagens por requisição, os [limites de tamanho de requisição](https://platform.claude.com/docs/pt-BR/api/overview#request-size-limits) (32 MB para endpoints padrão; menores em algumas plataformas operadas por parceiros, por exemplo, Amazon Bedrock e Google Cloud) podem ser atingidos primeiro. Para muitas imagens, considere fazer upload com a [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#files-api-image-example) e referenciá-las por `file_id` para manter os payloads das requisições pequenos.

  Mesmo ao usar a Files API, requisições com muitas imagens grandes podem falhar antes de atingir a contagem de 600 imagens. Reduza as dimensões ou os tamanhos de arquivo das imagens (por exemplo, por meio de "downsampling" (redução de amostragem)) antes de fazer o upload (consulte [Resolução e custo em tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#evaluate-image-size)).
</Note>

### Formatos suportados

O Claude suporta imagens JPEG, PNG, GIF e WebP (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Animações não são suportadas, e apenas o primeiro quadro é usado.

### Resolução e custo em tokens

O Claude visualiza imagens em "patches" (blocos) em vez de pixels. Cada patch é um bloco de 28×28 pixels da imagem, chamado de "visual token" (token visual). Uma imagem, portanto, custa `⌈width / 28⌉ × ⌈height / 28⌉` tokens visuais.

Cada modelo tem uma resolução de imagem nativa máxima, expressa como um limite de borda longa e um limite de tokens visuais. Imagens maiores que qualquer um desses limites são reduzidas antes do processamento; consulte [Como o Claude redimensiona e preenche imagens](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images) para a regra exata. A exceção são as capturas de tela e imagens de zoom que você retorna aos conjuntos de ferramentas de [uso do computador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) e [uso do navegador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates): a API rejeita uma imagem de `tool_result` que excede os limites do modelo com um erro de validação em vez de reduzi-la, então redimensione essas imagens na sua aplicação antes de retorná-las. Para que qualquer outra imagem grande demais seja rejeitada com um erro em vez de reduzida, defina o [campo `transformations`](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates#oversized-image-error) do bloco de imagem.

| Nível de resolução | Modelos                          | Borda longa máxima | Máximo de tokens visuais |
| ------------------ | -------------------------------- | ------------------ | ------------------------ |
| Alta resolução     | Claude 4.7 e modelos posteriores | 2576 px            | 4784                     |
| Padrão             | Todos os outros modelos          | 1568 px            | 1568                     |

O suporte a alta resolução é automático nos modelos listados e não requer cabeçalho beta nem ativação no lado do cliente.

A tabela a seguir mostra a resolução reduzida e o custo em tokens visuais para vários tamanhos de imagem em cada nível:

| Tamanho da imagem              | Nível padrão: reduzida para | Nível padrão: tokens | Nível de alta resolução: reduzida para | Nível de alta resolução: tokens |
| ------------------------------ | --------------------------- | -------------------- | -------------------------------------- | ------------------------------- |
| 200x200 px (0,04 megapixels)   | Não redimensionada          | 64                   | Não redimensionada                     | 64                              |
| 1000x1000 px (1 megapixel)     | Não redimensionada          | 1296                 | Não redimensionada                     | 1296                            |
| 1092x1092 px (1,19 megapixels) | Não redimensionada          | 1521                 | Não redimensionada                     | 1521                            |
| 1920x1080 px (2,07 megapixels) | 1456x819 px                 | 1560                 | Não redimensionada                     | 2691                            |
| 2000x1500 px (3 megapixels)    | 1269x952 px                 | 1564                 | Não redimensionada                     | 3888                            |
| 3840x2160 px (8,29 megapixels) | 1456x819 px                 | 1560                 | 2576x1449 px                           | 4784                            |

Quando uma imagem é reduzida, o Claude a dimensiona para o maior tamanho que caiba nos limites do nível, preservando sua proporção. Isso limita o custo em tokens. Para a regra precisa e uma implementação de referência, consulte [Como o Claude redimensiona e preenche imagens](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Para estimar o custo, multiplique a contagem de tokens pelo [preço por token do modelo](https://claude.com/pricing) que você está usando. Por exemplo, com o preço de $1 USD por milhão de tokens de entrada do Claude Haiku 4.5 (nível padrão), a imagem de 1000×1000 custa cerca de $1,30 USD por mil imagens. Com o preço de $4 USD por milhão do Claude Opus 5.5 (nível de alta resolução), a mesma imagem custa cerca de $5,18 USD por mil e a imagem 4K cerca de $19,14 USD por mil.

Imagens de alta resolução podem usar até aproximadamente três vezes mais tokens visuais do que a mesma imagem em um modelo de nível padrão. Se você não precisa da fidelidade adicional que a alta resolução oferece para uso do computador, compreensão de capturas de tela e documentos densos, reduza a amostragem das imagens antes de enviá-las para controlar os custos em tokens. Para minimizar a latência e simplificar [fluxos de trabalho baseados em coordenadas](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates), prefira redimensionar as imagens antes de fazer o upload.

### Orientações sobre qualidade de imagem

Ao fornecer imagens ao Claude, tenha em mente o seguinte para obter os melhores resultados:

* **Nitidez da imagem:** Certifique-se de que as imagens estejam nítidas e não muito borradas ou pixeladas.
* **Texto:** Se a imagem contiver texto importante, certifique-se de que ele esteja legível e não seja muito pequeno. Evite recortar contexto visual importante apenas para ampliar o texto.
* **Redimensionamento:** Leve em conta que sua imagem pode ser redimensionada se for muito grande (consulte [Resolução e custo em tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#evaluate-image-size)); isso pode, por exemplo, tornar o texto menos legível. Considere redimensionar previamente suas imagens, recortá-las ou ambos. Para que uma imagem grande demais seja rejeitada com um erro em vez de redimensionada (importante para [fluxos de trabalho com coordenadas](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates)), marque o bloco de imagem com [`"oversized_image": "error"`](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates#oversized-image-error).
* **Compressão de imagem:** Comprimir imagens antes de enviá-las, usando um formato com perdas como JPEG ou WebP (modo com perdas), pode reduzir a latência ao diminuir o tamanho das requisições. No entanto, isso pode introduzir artefatos prejudiciais ao desempenho do modelo, especialmente quando múltiplas passagens de compressão são aplicadas. Por exemplo, uma compressão JPEG intensa pode dificultar a leitura do texto. Confirme se suas configurações de compressão são adequadas para a tarefa inspecionando as imagens reais enviadas à API.

***

## Coordenadas e caixas delimitadoras

Para "bounding boxes" (caixas delimitadoras), pontos e coordenadas de pixel, consulte [Coordenadas e caixas delimitadoras](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates). O Claude retorna coordenadas absolutas em pixels relativas à imagem que ele vê após o redimensionamento; esse guia aborda como o Claude redimensiona e preenche imagens e como redimensionar previamente ou reescalar para que as coordenadas se alinhem com sua imagem original.

***

## Limitações

Embora os recursos de compreensão de imagens do Claude sejam de ponta, há algumas limitações a serem consideradas:

* **Identificação de pessoas:** O Claude [não pode ser usado](https://www.anthropic.com/legal/aup) para nomear pessoas em imagens e se recusa a fazê-lo.
* **Precisão:** O Claude pode alucinar ou cometer erros ao interpretar imagens de baixa qualidade, rotacionadas ou muito pequenas, com menos de 200 pixels.
* **Raciocínio espacial:** As saídas de coordenadas e localização do Claude são aproximadas. Siga as orientações em [Coordenadas e caixas delimitadoras](https://platform.claude.com/docs/pt-BR/build-with-claude/vision-coordinates) e verifique as saídas antes de confiar nelas.
* **Contagem:** O Claude pode fornecer contagens aproximadas de objetos em uma imagem, mas nem sempre com precisão exata, especialmente com grandes quantidades de objetos pequenos.
* **Imagens geradas por IA:** O Claude não consegue determinar se uma imagem foi gerada por IA e pode estar incorreto se perguntado. Não confie nele para detectar imagens falsas ou sintéticas.
* **Conteúdo inadequado:** O Claude não processa imagens inadequadas ou explícitas que violem a [Política de Uso Aceitável](https://www.anthropic.com/legal/aup).
* **Aplicações em saúde:** Embora o Claude possa analisar imagens médicas gerais, ele não foi projetado para interpretar exames diagnósticos complexos, como tomografias computadorizadas ou ressonâncias magnéticas. As saídas do Claude não devem ser consideradas um substituto para aconselhamento ou diagnóstico médico profissional.

Sempre revise e verifique cuidadosamente as interpretações de imagens do Claude, especialmente para casos de uso de alto risco. Não use o Claude para tarefas que exijam precisão perfeita ou análise de imagens sensíveis sem supervisão humana.

***

## Perguntas frequentes

<AccordionGroup>
  <Accordion title="Quais tipos de arquivo de imagem o Claude suporta?">
    JPEG, PNG, GIF e WebP. Consulte [Formatos suportados](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="O Claude consegue ler URLs de imagens?">
    Sim. Use o tipo de origem `url` em vez de `base64` no bloco de conteúdo `image`. Consulte o [exemplo de imagem baseada em URL](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="Existe um limite para o tamanho do arquivo de imagem que posso enviar?">
    Sim. Consulte [Limites de requisição](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#request-limits) para os limites de tamanho por imagem e da requisição como um todo na Claude API, no Amazon Bedrock, no Google Cloud e no claude.ai.
  </Accordion>

  <Accordion title="Quantas imagens posso incluir em uma requisição?">
    Até 600 por requisição de API (100 para modelos com uma janela de contexto de 200k tokens) e 20 por turno no claude.ai. Consulte [Limites de requisição](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#request-limits) para detalhes e para o limite menor de dimensão por imagem que se aplica acima de 20 imagens.
  </Accordion>

  <Accordion title="O Claude lê metadados de imagens?">
    Não, o Claude não analisa nem recebe nenhum metadado das imagens enviadas a ele.
  </Accordion>

  <Accordion title="Posso excluir imagens que enviei?">
    Não. Os uploads de imagens são efêmeros e não são armazenados além da duração da requisição de API. As imagens enviadas são excluídas automaticamente após serem processadas.
  </Accordion>

  <Accordion title="Onde posso encontrar detalhes sobre privacidade de dados para uploads de imagens?">
    Consulte a página da política de privacidade da Anthropic para obter informações sobre como as imagens enviadas e outros dados são tratados. A Anthropic não usa imagens enviadas para treinar modelos.
  </Accordion>

  <Accordion title="E se a interpretação de imagem do Claude parecer errada?">
    Se a interpretação de imagem do Claude parecer incorreta:

    1. Certifique-se de que a imagem esteja nítida, em alta qualidade e orientada corretamente.
    2. Experimente técnicas de engenharia de prompt para melhorar os resultados.
    3. Se o problema persistir, sinalize a saída no claude.ai (polegar para cima/para baixo) ou entre em contato com a [equipe de suporte](https://support.claude.com/).

    Seu feedback ajuda a melhorar o Claude!
  </Accordion>

  <Accordion title="O Claude pode gerar ou editar imagens?">
    Não, o Claude é apenas um modelo de compreensão de imagens. Ele pode interpretar e analisar imagens, mas não pode gerar, produzir, editar, manipular ou criar imagens.
  </Accordion>
</AccordionGroup>

***

## Próximos passos

<CardGroup cols={2}>
  <Card title="Cookbook multimodal" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    Obtenha dicas e técnicas de boas práticas para tarefas como interpretar gráficos e extrair conteúdo de formulários.
  </Card>

  <Card title="Referência da API" icon="code" href="https://platform.claude.com/docs/pt-BR/api/messages/create">
    Consulte a documentação da Messages API, incluindo exemplos de chamadas de API envolvendo imagens.
  </Card>
</CardGroup>