Visão

Este guia descreve como trabalhar com imagens no Claude, incluindo melhores práticas, exemplos de código e limitações a serem consideradas.

Como usar a visão

Use os recursos de visão do Claude via:

claude.ai. Faça upload de uma imagem como faria com um arquivo, ou arraste e solte uma imagem diretamente na janela de chat.
O Console Workbench. Se você selecionar um modelo que aceita imagens (apenas modelos Claude 3 e 4), um botão para adicionar imagens aparece no canto superior direito de cada bloco de mensagem do Usuário.
Requisição de API. Veja os exemplos neste guia.

Antes de fazer upload

Noções básicas e limites

Você pode incluir várias imagens em uma única requisição (até 20 para claude.ai e 100 para requisições de API). O Claude analisará todas as imagens fornecidas ao formular sua resposta. Isso pode ser útil para comparar ou contrastar imagens.

Se você enviar uma imagem maior que 8000x8000 px, ela será rejeitada. Se você enviar mais de 20 imagens em uma requisição de API, este limite é de 2000x2000 px.

Avalie o tamanho da imagem

Para um desempenho ideal, recomendamos redimensionar imagens antes do upload se forem muito grandes. Se a borda longa da sua imagem tiver mais de 1568 pixels, ou se sua imagem tiver mais de ~1.600 tokens, ela será primeiro redimensionada, preservando a proporção, até estar dentro dos limites de tamanho.

Se sua imagem de entrada for muito grande e precisar ser redimensionada, isso aumentará a latência do tempo até o primeiro token, sem lhe dar qualquer desempenho adicional do modelo. Imagens muito pequenas com menos de 200 pixels em qualquer borda podem degradar o desempenho.

Para melhorar o tempo até o primeiro token, recomendamos redimensionar imagens para não mais que 1,15 megapixels (e dentro de 1568 pixels em ambas as dimensões).

Aqui está uma tabela de tamanhos máximos de imagem aceitos por nossa API que não serão redimensionados para proporções comuns. Com o modelo Claude Sonnet 3.7, essas imagens usam aproximadamente 1.600 tokens e cerca de $4,80/1K imagens.

Proporção	Tamanho da imagem
1:1	1092x1092 px
3:4	951x1268 px
2:3	896x1344 px
9:16	819x1456 px
1:2	784x1568 px

Calcule os custos de imagem

Cada imagem que você inclui em uma requisição ao Claude conta para o seu uso de tokens. Para calcular o custo aproximado, multiplique o número aproximado de tokens de imagem pelo preço por token do modelo que você está usando.

Se sua imagem não precisar ser redimensionada, você pode estimar o número de tokens usados através deste algoritmo: tokens = (largura px * altura px)/750

Aqui estão exemplos de tokenização aproximada e custos para diferentes tamanhos de imagem dentro das restrições de tamanho da nossa API com base no preço por token do Claude Sonnet 3.7 de $3 por milhão de tokens de entrada:

Tamanho da imagem	# de Tokens	Custo / imagem	Custo / 1K imagens
200x200 px(0,04 megapixels)	~54	~$0,00016	~$0,16
1000x1000 px(1 megapixel)	~1334	~$0,004	~$4,00
1092x1092 px(1,19 megapixels)	~1590	~$0,0048	~$4,80

Garantindo a qualidade da imagem

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

Formato da imagem: Use um formato de imagem suportado: JPEG, PNG, GIF ou WebP.
Clareza da imagem: Certifique-se de que as imagens estejam claras e não muito borradas ou pixeladas.
Texto: Se a imagem contiver texto importante, certifique-se de que seja legível e não muito pequeno. Evite cortar contexto visual importante apenas para ampliar o texto.

Exemplos de prompts

Muitas das técnicas de prompt que funcionam bem para interações baseadas em texto com o Claude também podem ser aplicadas a prompts baseados em imagens.

Estes exemplos demonstram estruturas de prompt de melhores práticas envolvendo imagens.

Assim como com a colocação de consulta de documentos, o Claude funciona melhor quando as imagens vêm antes do texto. Imagens colocadas após o texto ou interpoladas com texto ainda terão bom desempenho, mas se seu caso de uso permitir, recomendamos uma estrutura de imagem-depois-texto.

Sobre os exemplos de prompt

Os exemplos a seguir demonstram como usar os recursos de visão do Claude usando várias linguagens de programação e abordagens. Você pode fornecer imagens ao Claude de três maneiras:

Como uma imagem codificada em base64 em blocos de conteúdo image
Como uma referência de URL para uma imagem hospedada online
Usando a API de Arquivos (upload uma vez, use várias vezes)

Os exemplos de prompt base64 usam estas variáveis:

    # Para imagens baseadas em URL, você pode usar o URL diretamente em sua requisição JSON
    
    # Para imagens codificadas em base64, você precisa primeiro codificar a imagem
    # Exemplo de como codificar uma imagem para base64 em bash:
    BASE64_IMAGE_DATA=$(curl -s "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg" | base64)
    
    # Os dados codificados agora podem ser usados em suas chamadas de API

Abaixo estão exemplos de como incluir imagens em uma requisição da API Messages usando imagens codificadas em base64 e referências de URL:

Exemplo de imagem codificada em base64

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-sonnet-4-20250514",
    "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."
          }
        ]
      }
    ]
  }'

Exemplo de imagem baseada em URL

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-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "url",
              "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
            }
          },
          {
            "type": "text",
            "text": "Describe this image."
          }
        ]
      }
    ]
  }'

Exemplo de imagem da API de Arquivos

Para imagens que você usará repetidamente ou quando quiser evitar sobrecarga de codificação, use a API de Arquivos:

# Primeiro, faça upload da sua imagem para a API de Arquivos
curl -X POST https://api.anthropic.com/v1/files \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: files-api-2025-04-14" \
  -F "file=@image.jpg"

# Depois use o file_id retornado em sua mensagem
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: files-api-2025-04-14" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "file",
              "file_id": "file_abc123"
            }
          },
          {
            "type": "text",
            "text": "Describe this image."
          }
        ]
      }
    ]
  }'

Veja exemplos da API Messages para mais exemplos de código e detalhes de parâmetros.

Exemplo: Uma imagem

É melhor colocar imagens mais cedo no prompt do que perguntas sobre elas ou instruções para tarefas que as usam.

Peça ao Claude para descrever uma imagem.

Função	Conteúdo
Usuário	[Imagem] Descreva esta imagem.

Aqui está a chamada de API correspondente usando o modelo Claude Sonnet 3.7.

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    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."
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    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."
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Describe this image."
                }
            ],
        }
    ],
)

Exemplo: Múltiplas imagens

Em situações onde há múltiplas imagens, introduza cada imagem com Imagem 1: e Imagem 2: e assim por diante. Você não precisa de novas linhas entre imagens ou entre imagens e o prompt.

Peça ao Claude para descrever as diferenças entre múltiplas imagens.

Função	Conteúdo
Usuário	Imagem 1: [Imagem 1] Imagem 2: [Imagem 2] Como essas imagens são diferentes?

Aqui está a chamada de API correspondente usando o modelo Claude Sonnet 3.7.

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Iridescent.green.sweat.bee1.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Exemplo: Múltiplas imagens com um prompt de sistema

Peça ao Claude para descrever as diferenças entre múltiplas imagens, enquanto dá a ele um prompt de sistema sobre como responder.

Conteúdo
Sistema	Responda apenas em espanhol.
Usuário	Imagem 1: [Imagem 1] Imagem 2: [Imagem 2] Como essas imagens são diferentes?

Aqui está a chamada de API correspondente usando o modelo Claude Sonnet 3.7.

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Respond only in Spanish.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Respond only in Spanish.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Respond only in Spanish.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagem 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Imagem 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Iridescent.green.sweat.bee1.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Como essas imagens são diferentes?"
                }
            ],
        }
    ],
)

Exemplo: Quatro imagens em dois turnos de conversa

As capacidades de visão do Claude brilham em conversas multimodais que misturam imagens e texto. Você pode ter trocas extensas de ida e volta com o Claude, adicionando novas imagens ou perguntas de acompanhamento a qualquer momento. Isso permite fluxos de trabalho poderosos para análise iterativa de imagens, comparação ou combinação de visuais com outros conhecimentos.

Peça ao Claude para contrastar duas imagens, depois faça uma pergunta de acompanhamento comparando as primeiras imagens com duas novas imagens.

Função	Conteúdo
Usuário	Imagem 1: [Imagem 1] Imagem 2: [Imagem 2] Como essas imagens são diferentes?
Assistente	[Resposta do Claude]
Usuário	Imagem 1: [Imagem 3] Imagem 2: [Imagem 4] Essas imagens são semelhantes às duas primeiras?
Assistente	[Resposta do Claude]

Ao usar a API, simplesmente insira novas imagens no array de Mensagens na função user como parte de qualquer estrutura padrão de conversa de múltiplos turnos.

Limitações

Embora as capacidades de compreensão de imagem do Claude sejam de ponta, existem algumas limitações a serem consideradas:

Identificação de pessoas: O Claude não pode ser usado para identificar (ou seja, nomear) pessoas em imagens e se recusará 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 habilidades de raciocínio espacial do Claude são limitadas. Ele pode ter dificuldades com tarefas que exigem localização precisa ou layouts, como ler um mostrador de relógio analógico ou descrever posições exatas de peças de xadrez.
Contagem: O Claude pode fornecer contagens aproximadas de objetos em uma imagem, mas pode nem sempre ser precisamente exato, especialmente com grandes números de objetos pequenos.
Imagens geradas por IA: O Claude não sabe se uma imagem é gerada por IA e pode estar incorreto se questionado. Não confie nele para detectar imagens falsas ou sintéticas.
Conteúdo inadequado: O Claude não processará imagens inadequadas ou explícitas que violem nossa Política de Uso Aceitável.
Aplicações de saúde: Embora o Claude possa analisar imagens médicas gerais, ele não foi projetado para interpretar exames diagnósticos complexos como TCs ou RMIs. As saídas do Claude não devem ser consideradas um substituto para aconselhamento médico profissional ou diagnóstico.

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

FAQ

Quais tipos de arquivo de imagem o Claude suporta?

O Claude pode ler URLs de imagens?

Sim, o Claude agora pode processar imagens a partir de URLs com nossos blocos de fonte de imagem de URL na API. Simplesmente use o tipo de fonte “url” em vez de “base64” em suas requisições de API. Exemplo:

{
  "type": "image",
  "source": {
    "type": "url",
    "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
  }
}

Existe um limite para o tamanho do arquivo de imagem que posso fazer upload?

Quantas imagens posso incluir em uma requisição?

O Claude lê metadados de imagem?

Posso excluir imagens que carreguei?

Onde posso encontrar detalhes sobre privacidade de dados para uploads de imagem?

E se a interpretação de imagem do Claude parecer errada?

O Claude pode gerar ou editar imagens?

Aprofunde-se na visão

Pronto para começar a construir com imagens usando o Claude? Aqui estão alguns recursos úteis:

Cookbook multimodal: Este cookbook tem dicas sobre como começar com imagens e técnicas de melhores práticas para garantir o desempenho de mais alta qualidade com imagens. Veja como você pode efetivamente fazer prompts para o Claude com imagens para realizar tarefas como interpretar e analisar gráficos ou extrair conteúdo de formulários.
Referência da API: Visite nossa documentação para a API Messages, incluindo exemplos de chamadas de API envolvendo imagens.

Se você tiver outras dúvidas, sinta-se à vontade para entrar em contato com nossa equipe de suporte. Você também pode participar da nossa comunidade de desenvolvedores para se conectar com outros criadores e obter ajuda de especialistas da Anthropic.

Embeddings Suporte a PDF

On this page

Como usar a visão
Antes de fazer upload
Noções básicas e limites
Avalie o tamanho da imagem
Calcule os custos de imagem
Garantindo a qualidade da imagem
Exemplos de prompts
Sobre os exemplos de prompt
Exemplo de imagem codificada em base64
Exemplo de imagem baseada em URL
Exemplo de imagem da API de Arquivos
Limitações
FAQ
Aprofunde-se na visão

Primeiros passos

Modelos e preços

Aprender sobre Claude

Capacidades

Ferramentas

Protocolo de contexto do modelo (MCP)

Casos de uso

Engenharia de prompts

Testar e avaliar

Fortalecer salvaguardas

Centro jurídico

Como usar a visão

Antes de fazer upload

Noções básicas e limites

Avalie o tamanho da imagem

Calcule os custos de imagem

Garantindo a qualidade da imagem

Exemplos de prompts

Sobre os exemplos de prompt

Exemplo de imagem codificada em base64

Exemplo de imagem baseada em URL

Exemplo de imagem da API de Arquivos

Limitações

FAQ

Aprofunde-se na visão

Primeiros passos

Modelos e preços

Aprender sobre Claude

Capacidades

Ferramentas

Protocolo de contexto do modelo (MCP)

Casos de uso

Engenharia de prompts

Testar e avaliar

Fortalecer salvaguardas

Centro jurídico

​Como usar a visão

​Antes de fazer upload

​Noções básicas e limites

​Avalie o tamanho da imagem

​Calcule os custos de imagem

​Garantindo a qualidade da imagem

​Exemplos de prompts

​Sobre os exemplos de prompt

​Exemplo de imagem codificada em base64

​Exemplo de imagem baseada em URL

​Exemplo de imagem da API de Arquivos

​Limitações

​FAQ

​Aprofunde-se na visão

Como usar a visão

Antes de fazer upload

Noções básicas e limites

Avalie o tamanho da imagem

Calcule os custos de imagem

Garantindo a qualidade da imagem

Exemplos de prompts

Sobre os exemplos de prompt

Exemplo de imagem codificada em base64

Exemplo de imagem baseada em URL

Exemplo de imagem da API de Arquivos

Limitações

FAQ

Aprofunde-se na visão