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 de usuario (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 API 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 por 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 cada imagen 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 vuelves a enviar y las imágenes anidadas dentro del contenido tool_result (por ejemplo, capturas de pantalla devueltas a la herramienta de uso de computadora). En Amazon Bedrock y Google Cloud, los bloques de documento 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 exceda los 2000 px, o mantén la solicitud en 20 o menos bloques de imagen y documento.

El tamaño máximo por imagen es:

• 10 MB (codificada en base64) al usar la Claude API directamente.
• 5 MB (codificada en base64) en Amazon Bedrock y Google Cloud.
• 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 ve 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 de $5 USD por millón (nivel de alta resolución), la misma imagen cuesta aproximadamente $6.48 USD por cada mil y la imagen 4K aproximadamente $23.92 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 ve después del redimensionamiento; esa guía cubre cómo Claude redimensiona y rellena las imágenes y cómo redimensionar 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 de vanguardia, hay algunas limitaciones que debes tener en cuenta:

• Identificación de personas: Claude no puede usarse para nombrar personas en imágenes y se niega a hacerlo.
• 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 violen la Política de uso aceptable.
• 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