---
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 processe e analise imagens, abrindo possibilidades empolgantes para interação multimodal.
featureMetadata:
  status: stable
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: stable
    Amazon Bedrock:
      availability: stable
      note: Somente fontes de imagem base64; limite por imagem de 5 MB (codificado em base64) e um tamanho total de requisição menor.
    Amazon Bedrock (bedrock-runtime):
      availability: stable
      note: Somente fontes de imagem base64; limite por imagem de 5 MB (codificado em base64) e um tamanho total de requisição menor.
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed):
      availability: stable
      note: Somente fontes de imagem base64; limite por imagem de 5 MB (codificado em base64) e um tamanho total de requisição menor.
    Microsoft Foundry: stable
---

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 Claude Models on Google Cloud (Google managed) e no Amazon Bedrock, apenas origens codificadas em base64 estão disponíveis.
</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: 2026-10-21" \
    -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 UserMessageParam
          {
              Content = 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)
              .addUserMessageOfContentBlockParams(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: 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: Anthropic::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: 2026-10-21" \
    -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 UserMessageParam
          {
              Content = 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)
              .addUserMessageOfContentBlockParams(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: 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: Anthropic::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
  curl -sS -X POST https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -F "file=@vision-example.jpg"

  # Em seguida, use o file_id da resposta do upload na sua mensagem
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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
  ant files upload --file ./vision-example.jpg

  # Em seguida, use o file_id da resposta do upload na sua mensagem
  ant messages create <<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 UserMessageParam
          {
              Content = 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 o 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)
              .addUserMessageOfContentBlockParams(
                  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;
  use Anthropic\Messages\Model;

  $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: 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: Anthropic::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: 2026-10-21" \
    -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 UserMessageParam
          {
              Content = 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)
              .addUserMessageOfContentBlockParams(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: 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: Anthropic::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 para cada mensagem ou requisição é:

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

As dimensões máximas para cada 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 de conteúdo `tool_result` (por exemplo, capturas de tela retornadas para a ferramenta de uso do computador). No Claude Models on Google Cloud (Google managed) e no Amazon Bedrock, 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 permanecer abaixo do limite em todas as plataformas, redimensione cada imagem para que nenhuma dimensão exceda 3.000 px, ou mantenha a requisição com 20 ou menos blocos de imagem e documento.

O tamanho máximo por imagem é:

* 10 MB (codificada em base64) na Claude API e no Claude Models on Google Cloud (Google managed).
* 5 MB (codificada em base64) no Amazon Bedrock.
* 10 MB no [claude.ai](https://claude.ai/).

<Note>
  Embora a API suporte até 600 imagens para cada requisição, os [limites de tamanho de requisição](https://platform.claude.com/docs/pt-BR/api/overview#request-size-limits) podem ser atingidos primeiro. O limite é de 128 MB na Claude API primária, e outras plataformas têm seus próprios limites. 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 referenciar 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 processa imagens em patches em vez de pixels. Cada patch é um bloco de 28×28 pixels da imagem, chamado de “visual token” (token visual). Portanto, uma imagem 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 | 2.576 px           | 4.784                    |
| Padrão             | Todos os outros modelos          | 1.568 px           | 1.568                    |

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          | 1.296                | Não redimensionada                     | 1.296                           |
| 1092x1092 px (1,19 megapixels) | Não redimensionada          | 1.521                | Não redimensionada                     | 1.521                           |
| 1920x1080 px (2,07 megapixels) | 1456x819 px                 | 1.560                | Não redimensionada                     | 2.691                           |
| 2000x1500 px (3 megapixels)    | 1269x952 px                 | 1.564                | Não redimensionada                     | 3.888                           |
| 3840x2160 px (8,29 megapixels) | 1456x819 px                 | 1.560                | 2576x1449 px                           | 4.784                           |

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 caixas delimitadoras, pontos e coordenadas em pixels, veja [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 processa 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 avançados, há algumas limitações a serem consideradas:

* **Identificação de pessoas:** O Claude não pode ser usado para nomear pessoas em imagens e se recusa a fazê-lo (veja a [Política de Uso](https://www.anthropic.com/legal/aup)).
* **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](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. Veja [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 total na Claude API, no Amazon Bedrock, no Claude Models on Google Cloud (Google managed) e no claude.ai.
  </Accordion>

  <Accordion title="Quantas imagens posso incluir em uma requisição?">
    Até 600 para cada requisição de API (100 para modelos com uma janela de contexto de 200k tokens) e 20 para cada turno no claude.ai. Veja [Limites de requisição](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#request-limits) para detalhes e para o limite de dimensão por imagem mais baixo 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. Consulte [API e retenção de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention) para saber por quanto tempo as imagens são mantidas. Se você enviar imagens com a [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files), poderá excluí-las por lá.
  </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="Receita 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>

## Disponibilidade

Visão (imagens) está disponível em todos os modelos.

### Suporte da API

#### [Messages API](https://platform.claude.com/docs/pt-BR/build-with-claude/working-with-messages)

* Disponibilidade: Sempre ativo

| Status                 | Plataformas de nuvem                                                                                                                                                                                                                                                                                                                                                                            |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Disponível             | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Microsoft Foundry](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry) |
| Disponível<sup>1</sup> | [Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock), [Amazon Bedrock (bedrock-runtime)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed)      |

1. Somente fontes de imagem base64; limite por imagem de 5 MB (codificado em base64) e um tamanho total de requisição menor.

#### [Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview)

* Disponibilidade: Sempre ativo

| Status     | Plataformas de nuvem             |
| ---------- | -------------------------------- |
| Disponível | Todas as plataformas compatíveis |
