Visión

Esta guía describe cómo enviar imágenes a Claude, los límites y costos que aplican, y dónde encontrar orientación para los flujos de trabajo basados en coordenadas.

Enviar imágenes a Claude

Usa las capacidades de visión de Claude a través de:

• claude.ai. Sube una imagen como lo harías con un archivo, o arrastra y suelta una imagen directamente en la ventana del chat.
• Playground en la Claude Console. Agrega imágenes directamente a cualquier bloque de mensaje User.
• Solicitud a la API. Consulta los siguientes ejemplos.

En la API, proporciona imágenes a Claude como bloques de contenido image usando uno de tres tipos de fuente:

1. Una imagen codificada en base64 incrustada en el cuerpo de la solicitud
2. Una referencia URL a una imagen alojada en línea
3. Un file_id devuelto por la Files API (sube una vez, referencia muchas veces)

Ejemplo de imagen codificada en base64

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)

Ejemplo de imagen basada en URL

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)

Ejemplo de imagen con la Files API

Para imágenes que usarás repetidamente o cuando quieras evitar la sobrecarga de codificación, usa la Files API. Sube la imagen una vez y luego referencia el file_id devuelto en mensajes posteriores en lugar de volver a enviar los datos en base64.

client = anthropic.Anthropic()

# Sube el archivo de imagen
with open("vision-example.jpg", "rb") as f:
    file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

# Usa el archivo subido en un mensaje
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)

Consulta los ejemplos de la Messages APIVista previa disponible con enlaces a la referencia de la API — presiona Tab hasta que el foco entre a la tarjeta y Escape para volver. para ver más código de ejemplo y detalles de los parámetros.

Múltiples imágenes

Puedes incluir múltiples imágenes en una sola solicitud, y Claude las analiza en conjunto. Esto es útil para comparar imágenes, preguntar sobre diferencias o trabajar con una secuencia, como las páginas de un documento. Al enviar varias imágenes, introduce cada una con una etiqueta de texto corta (Image 1:, Image 2:, y así sucesivamente) para que puedas referirte a ellas por nombre en tu prompt y en turnos posteriores.

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)

En una conversación de múltiples turnos, agrega nuevas imágenes en turnos user posteriores de la misma manera. Claude tiene acceso a todas las imágenes de turnos anteriores, por lo que preguntas de seguimiento como “¿Son estas similares a las dos primeras?” funcionan sin volver a incluir las imágenes anteriores en el contenido del nuevo turno.

Límites y costos de las imágenes

Límites de solicitud

El número máximo de imágenes por mensaje o solicitud es:

• 20 por mensaje en claude.ai
• 100 por solicitud en la API, para modelos con una “context window” (ventana de contexto) de 200k tokens
• 600 por solicitud en la API, para todos los demás modelos

Las dimensiones máximas de cada imagen son 8000x8000 px.

Si una sola solicitud a la API contiene más de 20 imágenes, se aplica un límite de dimensiones por imagen más estricto a todas las imágenes de esa solicitud. Todos los bloques image de la solicitud cuentan para este umbral, incluidas las imágenes de turnos anteriores de la conversación que reenvías y las imágenes anidadas dentro del contenido de tool_result (por ejemplo, capturas de pantalla devueltas a la herramienta de uso de computadora). En Claude Models on Google Cloud (Google managed) y Amazon Bedrock, los bloques de documentos como los PDF también cuentan para este umbral. Las imágenes que exceden el límite más estricto se rechazan con un invalid_request_error cuyo mensaje hace referencia a “many-image requests” e indica el límite actual en píxeles. Para mantenerte por debajo del límite en todas las plataformas, redimensiona cada imagen de modo que ninguna dimensión supere los 3,000 px, o limita la solicitud a 20 bloques de imagen y documento o menos.

El tamaño máximo por imagen es:

• 10 MB (codificada en base64) en la API de Claude y en Claude Models on Google Cloud (Google managed).
• 5 MB (codificada en base64) en Amazon Bedrock.
• 10 MB en claude.ai.

Formatos admitidos

Claude admite imágenes JPEG, PNG, GIF y WebP (image/jpeg, image/png, image/gif, image/webp). Las animaciones no son compatibles y solo se usa el primer fotograma.

Resolución y costo en tokens

Claude procesa las imágenes en parches en lugar de píxeles. Cada parche es un bloque de 28×28 píxeles de la imagen, denominado token visual. Por lo tanto, una imagen cuesta ⌈width / 28⌉ × ⌈height / 28⌉ tokens visuales.

Cada modelo tiene una resolución de imagen nativa máxima, expresada como un límite del lado largo y un límite de tokens visuales. Las imágenes que superan cualquiera de los dos límites se reducen de escala antes de procesarse; consulta Cómo Claude redimensiona y rellena las imágenes para conocer la regla exacta. La excepción son las capturas de pantalla y las imágenes de zoom que devuelves a los conjuntos de herramientas de uso de computadora y uso de navegador: la API rechaza una imagen tool_result que excede los límites del modelo con un error de validación en lugar de reducirla de escala, así que redimensiona esas imágenes en tu aplicación antes de devolverlas. Para que cualquier otra imagen de tamaño excesivo sea rechazada con un error en lugar de reducida de escala, establece el campo transformations del bloque de imagen.

La compatibilidad con alta resolución es automática en los modelos indicados y no requiere ningún encabezado beta ni activación del lado del cliente.

La siguiente tabla muestra la resolución reducida y el costo en tokens visuales para varios tamaños de imagen en cada nivel:

Cuando una imagen se reduce, Claude la escala al tamaño más grande que se ajuste a los límites del nivel, preservando su relación de aspecto. Esto limita el costo en tokens. Para conocer la regla precisa y una implementación de referencia, consulta Cómo Claude redimensiona y rellena las imágenes.

Para estimar el costo, multiplica el conteo de tokens por el precio por token del modelo que estés usando. Por ejemplo, con el precio de Claude Haiku 4.5 de $1 USD por millón de tokens de entrada (nivel estándar), la imagen de 1000×1000 cuesta aproximadamente $1.30 USD por cada mil imágenes. Con el precio de Claude Opus 5.5 de $4 USD por millón (nivel de alta resolución), la misma imagen cuesta aproximadamente $5.18 USD por cada mil y la imagen 4K aproximadamente $19.14 USD por cada mil.

Las imágenes de alta resolución pueden usar hasta aproximadamente tres veces más tokens visuales que la misma imagen en un modelo de nivel estándar. Si no necesitas la fidelidad adicional que la alta resolución proporciona para el uso de computadora, la comprensión de capturas de pantalla y los documentos densos, submuestrea las imágenes antes de enviarlas para controlar los costos en tokens. Para minimizar la latencia y simplificar los flujos de trabajo basados en coordenadas, prefiere redimensionar las imágenes antes de subirlas.

Orientación sobre la calidad de imagen

Al proporcionar imágenes a Claude, ten en cuenta lo siguiente para obtener los mejores resultados:

• Claridad de la imagen: Asegúrate de que las imágenes sean claras y no estén demasiado borrosas o pixeladas.
• Texto: Si la imagen contiene texto importante, asegúrate de que sea legible y no demasiado pequeño. Evita recortar contexto visual clave únicamente para agrandar el texto.
• Redimensionamiento: Ten en cuenta que tu imagen podría redimensionarse si es demasiado grande (consulta Resolución y costo en tokens); esto podría, por ejemplo, hacer que el texto sea menos legible. Considera redimensionar previamente tus imágenes, recortarlas, o ambas cosas. Para que una imagen de tamaño excesivo sea rechazada con un error en lugar de redimensionada (importante para los flujos de trabajo de coordenadas), marca el bloque de imagen con "oversized_image": "error".
• Compresión de imagen: Comprimir las imágenes antes de enviarlas, usando un formato con pérdida como JPEG o WebP (modo con pérdida), puede reducir la latencia al reducir el tamaño de las solicitudes. Sin embargo, esto puede introducir artefactos perjudiciales para el rendimiento del modelo, especialmente cuando se aplican múltiples pasadas de compresión. Por ejemplo, una compresión JPEG intensa puede hacer que el texto sea difícil de leer. Confirma que tu configuración de compresión sea apropiada para la tarea inspeccionando las imágenes reales enviadas a la API.

Coordenadas y cuadros delimitadores

Para cuadros delimitadores, puntos y coordenadas en píxeles, consulta Coordenadas y cuadros delimitadores. Claude devuelve coordenadas absolutas en píxeles relativas a la imagen que procesa después del redimensionamiento; esa guía explica cómo Claude redimensiona y rellena las imágenes y cómo redimensionarlas previamente o reescalar para que las coordenadas coincidan con tu imagen original.

Limitaciones

Aunque las capacidades de comprensión de imágenes de Claude son avanzadas, hay algunas limitaciones que debes tener en cuenta:

• Identificación de personas: Claude no puede usarse para nombrar a personas en imágenes y se niega a hacerlo (consulta la Política de uso).
• Precisión: Claude podría alucinar o cometer errores al interpretar imágenes de baja calidad, rotadas o muy pequeñas, de menos de 200 píxeles.
• Razonamiento espacial: Las salidas de coordenadas y localización de Claude son aproximadas. Sigue la orientación en Coordenadas y cuadros delimitadores y verifica las salidas antes de confiar en ellas.
• Conteo: Claude puede dar conteos aproximados de objetos en una imagen, pero podría no ser siempre exactamente preciso, especialmente con grandes cantidades de objetos pequeños.
• Imágenes generadas por IA: Claude no puede determinar si una imagen fue generada por IA y podría equivocarse si se le pregunta. No confíes en él para detectar imágenes falsas o sintéticas.
• Contenido inapropiado: Claude no procesa imágenes inapropiadas o explícitas que infrinjan la Política de uso.
• Aplicaciones de salud: Aunque Claude puede analizar imágenes médicas generales, no está diseñado para interpretar estudios diagnósticos complejos como tomografías computarizadas o resonancias magnéticas. Las salidas de Claude no deben considerarse un sustituto del consejo o diagnóstico médico profesional.

Siempre revisa y verifica cuidadosamente las interpretaciones de imágenes de Claude, especialmente en casos de uso de alto riesgo. No uses Claude para tareas que requieran precisión perfecta o análisis de imágenes sensibles sin supervisión humana.

Preguntas frecuentes

Próximos pasos