Visión

Esta guía describe cómo trabajar con imágenes en Claude, incluyendo mejores prácticas, ejemplos de código y limitaciones a tener en cuenta.

Cómo usar la visión

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 de chat.
El Console Workbench. Si seleccionas un modelo que acepta imágenes (solo modelos Claude 3 y 4), aparece un botón para agregar imágenes en la parte superior derecha de cada bloque de mensaje de Usuario.
Solicitud API. Ve los ejemplos en esta guía.

Antes de subir

Conceptos básicos y límites

Puedes incluir múltiples imágenes en una sola solicitud (hasta 20 para claude.ai y 100 para solicitudes API). Claude analizará todas las imágenes proporcionadas al formular su respuesta. Esto puede ser útil para comparar o contrastar imágenes.

Si envías una imagen más grande que 8000x8000 px, será rechazada. Si envías más de 20 imágenes en una solicitud API, este límite es de 2000x2000 px.

Aunque la API soporta 100 imágenes por solicitud, hay un límite de tamaño de solicitud de 32MB para endpoints estándar.

Evaluar el tamaño de imagen

Para un rendimiento óptimo, recomendamos redimensionar las imágenes antes de subirlas si son demasiado grandes. Si el borde largo de tu imagen es más de 1568 píxeles, o tu imagen es más de ~1,600 tokens, primero será escalada hacia abajo, preservando la relación de aspecto, hasta que esté dentro de los límites de tamaño.

Si tu imagen de entrada es demasiado grande y necesita ser redimensionada, aumentará la latencia del tiempo hasta el primer token, sin darte ningún rendimiento adicional del modelo. Imágenes muy pequeñas de menos de 200 píxeles en cualquier borde dado pueden degradar el rendimiento.

Para mejorar el tiempo hasta el primer token, recomendamos redimensionar las imágenes a no más de 1.15 megapíxeles (y dentro de 1568 píxeles en ambas dimensiones).

Aquí hay una tabla de tamaños máximos de imagen aceptados por nuestra API que no serán redimensionados para relaciones de aspecto comunes. Con el modelo Claude Sonnet 3.7, estas imágenes usan aproximadamente 1,600 tokens y alrededor de $4.80/1K imágenes.

Relación de aspecto	Tamaño de imagen
1:1	1092x1092 px
3:4	951x1268 px
2:3	896x1344 px
9:16	819x1456 px
1:2	784x1568 px

Calcular costos de imagen

Cada imagen que incluyas en una solicitud a Claude cuenta hacia tu uso de tokens. Para calcular el costo aproximado, multiplica el número aproximado de tokens de imagen por el precio por token del modelo que estés usando.

Si tu imagen no necesita ser redimensionada, puedes estimar el número de tokens usados a través de este algoritmo: tokens = (ancho px * alto px)/750

Aquí hay ejemplos de tokenización aproximada y costos para diferentes tamaños de imagen dentro de las restricciones de tamaño de nuestra API basados en el precio por token de Claude Sonnet 3.7 de $3 por millón de tokens de entrada:

Tamaño de imagen	# de Tokens	Costo / imagen	Costo / 1K imágenes
200x200 px(0.04 megapíxeles)	~54	~$0.00016	~$0.16
1000x1000 px(1 megapíxel)	~1334	~$0.004	~$4.00
1092x1092 px(1.19 megapíxeles)	~1590	~$0.0048	~$4.80

Asegurar la calidad de imagen

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

Formato de imagen: Usa un formato de imagen soportado: JPEG, PNG, GIF, o WebP.
Claridad de imagen: Asegúrate de que las imágenes sean claras y no 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 solo para agrandar el texto.

Ejemplos de prompts

Muchas de las técnicas de prompting que funcionan bien para interacciones basadas en texto con Claude también se pueden aplicar a prompts basados en imágenes.

Estos ejemplos demuestran estructuras de prompt de mejores prácticas que involucran imágenes.

Así como con la colocación de consulta de documentos, Claude funciona mejor cuando las imágenes vienen antes del texto. Las imágenes colocadas después del texto o interpoladas con texto aún funcionarán bien, pero si tu caso de uso lo permite, recomendamos una estructura imagen-luego-texto.

Acerca de los ejemplos de prompts

Los siguientes ejemplos demuestran cómo usar las capacidades de visión de Claude usando varios lenguajes de programación y enfoques. Puedes proporcionar imágenes a Claude de tres maneras:

Como una imagen codificada en base64 en bloques de contenido image
Como una referencia URL a una imagen alojada en línea
Usando la API de Archivos (sube una vez, usa múltiples veces)

Los ejemplos de prompts base64 usan estas variables:

    # Para imágenes basadas en URL, puedes usar la URL directamente en tu solicitud JSON
    
    # Para imágenes codificadas en base64, necesitas primero codificar la imagen
    # Ejemplo de cómo codificar una imagen a base64 en bash:
    BASE64_IMAGE_DATA=$(curl -s "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg" | base64)
    
    # Los datos codificados ahora pueden ser usados en tus llamadas API

A continuación hay ejemplos de cómo incluir imágenes en una solicitud de la API de Mensajes usando imágenes codificadas en base64 y referencias URL:

Ejemplo de imagen codificada en 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 esta imagen."
          }
        ]
      }
    ]
  }'

Ejemplo de imagen basada en 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 esta imagen."
          }
        ]
      }
    ]
  }'

Ejemplo de imagen de la API de Archivos

Para imágenes que usarás repetidamente o cuando quieras evitar la sobrecarga de codificación, usa la API de Archivos:

# Primero, sube tu imagen a la API de Archivos
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"

# Luego usa el file_id devuelto en tu mensaje
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 esta imagen."
          }
        ]
      }
    ]
  }'

Ve ejemplos de la API de Mensajes para más código de ejemplo y detalles de parámetros.

Ejemplo: Una imagen

Es mejor colocar las imágenes antes en el prompt que las preguntas sobre ellas o instrucciones para tareas que las usen.

Pide a Claude que describa una imagen.

Rol	Contenido
Usuario	[Imagen] Describe esta imagen.

Aquí está la llamada API correspondiente usando el 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 esta imagen."
                }
            ],
        }
    ],
)

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 esta imagen."
                }
            ],
        }
    ],
)

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 esta imagen."
                }
            ],
        }
    ],
)

Ejemplo: Múltiples imágenes

En situaciones donde hay múltiples imágenes, introduce cada imagen con Imagen 1: e Imagen 2: y así sucesivamente. No necesitas saltos de línea entre imágenes o entre imágenes y el prompt.

Pide a Claude que describa las diferencias entre múltiples imágenes.

Rol	Contenido
Usuario	Imagen 1: [Imagen 1] Imagen 2: [Imagen 2] ¿En qué se diferencian estas imágenes?

Aquí está la llamada API correspondiente usando el 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": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Iridescent.green.sweat.bee1.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Ejemplo: Múltiples imágenes con un prompt del sistema

Pide a Claude que describa las diferencias entre múltiples imágenes, mientras le das un prompt del sistema sobre cómo responder.

Contenido
Sistema	Responde solo en español.
Usuario	Imagen 1: [Imagen 1] Imagen 2: [Imagen 2] ¿En qué se diferencian estas imágenes?

Aquí está la llamada API correspondiente usando el modelo Claude Sonnet 3.7.

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Responde solo en español.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Responde solo en español.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image1_media_type,
                        "data": image1_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image2_media_type,
                        "data": image2_data,
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Python
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Responde solo en español.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Imagen 1:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "Imagen 2:"
                },
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Iridescent.green.sweat.bee1.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "¿En qué se diferencian estas imágenes?"
                }
            ],
        }
    ],
)

Ejemplo: Cuatro imágenes a través de dos turnos de conversación

Las capacidades de visión de Claude brillan en conversaciones multimodales que mezclan imágenes y texto. Puedes tener intercambios extendidos de ida y vuelta con Claude, agregando nuevas imágenes o preguntas de seguimiento en cualquier momento. Esto permite flujos de trabajo poderosos para análisis iterativo de imágenes, comparación, o combinando visuales con otro conocimiento.

Pide a Claude que contraste dos imágenes, luego haz una pregunta de seguimiento comparando las primeras imágenes con dos nuevas imágenes.

Rol	Contenido
Usuario	Imagen 1: [Imagen 1] Imagen 2: [Imagen 2] ¿En qué se diferencian estas imágenes?
Asistente	[Respuesta de Claude]
Usuario	Imagen 1: [Imagen 3] Imagen 2: [Imagen 4] ¿Son estas imágenes similares a las dos primeras?
Asistente	[Respuesta de Claude]

Al usar la API, simplemente inserta nuevas imágenes en el array de Mensajes en el rol user como parte de cualquier estructura estándar de conversación multiturnos.

Limitaciones

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

Identificación de personas: Claude no puede ser usado para identificar (es decir, nombrar) personas en imágenes y se negará a hacerlo.
Precisión: Claude puede 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 habilidades de razonamiento espacial de Claude son limitadas. Puede tener dificultades con tareas que requieren localización precisa o diseños, como leer la cara de un reloj analógico o describir posiciones exactas de piezas de ajedrez.
Conteo: Claude puede dar conteos aproximados de objetos en una imagen pero puede no ser siempre precisamente exacto, especialmente con grandes números de objetos pequeños.
Imágenes generadas por IA: Claude no sabe si una imagen es generada por IA y puede ser incorrecto si se le pregunta. No confíes en él para detectar imágenes falsas o sintéticas.
Contenido inapropiado: Claude no procesará imágenes inapropiadas o explícitas que violen nuestra Política de Uso Aceptable.
Aplicaciones de salud: Aunque Claude puede analizar imágenes médicas generales, no está diseñado para interpretar escaneos diagnósticos complejos como TCs o RMs. Las salidas de Claude no deben considerarse un sustituto del consejo médico profesional o diagnóstico.

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

FAQ

¿Qué tipos de archivos de imagen soporta Claude?

¿Puede Claude leer URLs de imágenes?

Sí, Claude ahora puede procesar imágenes desde URLs con nuestros bloques de fuente de imagen URL en la API. Simplemente usa el tipo de fuente “url” en lugar de “base64” en tus solicitudes API. Ejemplo:

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

¿Hay un límite al tamaño de archivo de imagen que puedo subir?

¿Cuántas imágenes puedo incluir en una solicitud?

¿Claude lee metadatos de imagen?

¿Puedo eliminar imágenes que he subido?

¿Dónde puedo encontrar detalles sobre privacidad de datos para subidas de imágenes?

¿Qué pasa si la interpretación de imagen de Claude parece incorrecta?

¿Puede Claude generar o editar imágenes?

Profundiza en la visión

¿Listo para empezar a construir con imágenes usando Claude? Aquí hay algunos recursos útiles:

Cookbook multimodal: Este cookbook tiene consejos sobre empezar con imágenes y técnicas de mejores prácticas para asegurar el rendimiento de más alta calidad con imágenes. Ve cómo puedes efectivamente hacer prompts a Claude con imágenes para llevar a cabo tareas como interpretar y analizar gráficos o extraer contenido de formularios.
Referencia API: Visita nuestra documentación para la API de Mensajes, incluyendo llamadas API de ejemplo que involucran imágenes.

Si tienes cualquier otra pregunta, siéntete libre de contactar a nuestro equipo de soporte. También puedes unirte a nuestra comunidad de desarrolladores para conectar con otros creadores y obtener ayuda de expertos de Anthropic.

Embeddings Soporte para PDF

On this page

Cómo usar la visión
Antes de subir
Conceptos básicos y límites
Evaluar el tamaño de imagen
Calcular costos de imagen
Asegurar la calidad de imagen
Ejemplos de prompts
Acerca de los ejemplos de prompts
Ejemplo de imagen codificada en base64
Ejemplo de imagen basada en URL
Ejemplo de imagen de la API de Archivos
Limitaciones
FAQ
Profundiza en la visión

Primeros pasos

Modelos y precios

Aprende sobre Claude

Capacidades

Herramientas

Protocolo de Contexto del Modelo (MCP)

Casos de uso

Ingeniería de prompts

Probar y evaluar

Fortalecer las barreras de protección

Centro legal

Cómo usar la visión

Antes de subir

Conceptos básicos y límites

Evaluar el tamaño de imagen

Calcular costos de imagen

Asegurar la calidad de imagen

Ejemplos de prompts

Acerca de los ejemplos de prompts

Ejemplo de imagen codificada en base64

Ejemplo de imagen basada en URL

Ejemplo de imagen de la API de Archivos

Limitaciones

FAQ

Profundiza en la visión

Primeros pasos

Modelos y precios

Aprende sobre Claude

Capacidades

Herramientas

Protocolo de Contexto del Modelo (MCP)

Casos de uso

Ingeniería de prompts

Probar y evaluar

Fortalecer las barreras de protección

Centro legal

​Cómo usar la visión

​Antes de subir

​Conceptos básicos y límites

​Evaluar el tamaño de imagen

​Calcular costos de imagen

​Asegurar la calidad de imagen

​Ejemplos de prompts

​Acerca de los ejemplos de prompts

​Ejemplo de imagen codificada en base64

​Ejemplo de imagen basada en URL

​Ejemplo de imagen de la API de Archivos

​Limitaciones

​FAQ

​Profundiza en la visión

Cómo usar la visión

Antes de subir

Conceptos básicos y límites

Evaluar el tamaño de imagen

Calcular costos de imagen

Asegurar la calidad de imagen

Ejemplos de prompts

Acerca de los ejemplos de prompts

Ejemplo de imagen codificada en base64

Ejemplo de imagen basada en URL

Ejemplo de imagen de la API de Archivos

Limitaciones

FAQ

Profundiza en la visión