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

Utiliza 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), aparecerá un botón para añadir imágenes en la parte superior derecha de cada bloque de mensaje de Usuario.
Solicitud API. Consulta 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 mayor de 8000x8000 px, será rechazada. Si envías más de 20 imágenes en una solicitud API, este límite es de 2000x2000 px.

Evaluar el tamaño de la imagen

Para un rendimiento óptimo, recomendamos redimensionar las imágenes antes de subirlas si son demasiado grandes. Si el borde largo de tu imagen tiene más de 1568 píxeles, o tu imagen tiene más de ~1.600 tokens, primero se reducirá su escala, 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. Las imágenes muy pequeñas con menos de 200 píxeles en cualquier borde 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 utilizan 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 para 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 utilizando.

Si tu imagen no necesita ser redimensionada, puedes estimar el número de tokens utilizados a través de este algoritmo: tokens = (ancho px * altura 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 la imagen

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

Formato de imagen: Utiliza un formato de imagen compatible: 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 el contexto visual clave solo para ampliar 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 prompts de mejores prácticas que involucran imágenes.

Al igual que con la colocación de consultas en documentos, Claude funciona mejor cuando las imágenes vienen antes del texto. Las imágenes colocadas después del texto o interpoladas con texto seguirán funcionando bien, pero si tu caso de uso lo permite, recomendamos una estructura de imagen-luego-texto.

Acerca de los ejemplos de prompts

Los siguientes ejemplos demuestran cómo usar las capacidades de visión de Claude utilizando 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 (subir una vez, usar múltiples veces)

Los ejemplos de prompts base64 utilizan estas variables:

    # Para imágenes basadas en URL, puedes usar la URL directamente en tu solicitud JSON
    
    # Para imágenes codificadas en base64, primero necesitas 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 utilizados en tus llamadas API

A continuación se muestran ejemplos de cómo incluir imágenes en una solicitud de la API de Mensajes utilizando 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 this image."
          }
        ]
      }
    ]
  }'

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 this image."
          }
        ]
      }
    ]
  }'

Ejemplo de imagen con 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 this image."
          }
        ]
      }
    ]
  }'

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

Ejemplo: Una imagen

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

Pide a Claude que describa una imagen.

Rol	Contenido
Usuario	[Imagen] Describe esta imagen.

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

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 utilizando 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 de sistema

Pide a Claude que describa las diferencias entre múltiples imágenes, mientras le das un prompt de sistema para 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 utilizando 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 en 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 extensos de ida y vuelta con Claude, añadiendo nuevas imágenes o preguntas de seguimiento en cualquier momento. Esto permite flujos de trabajo potentes para análisis iterativo de imágenes, comparación o combinación de elementos 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]

Cuando uses 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

Si bien 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 utilizado 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 (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 esfera 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 cantidades de objetos pequeños.
Imágenes generadas por IA: Claude no sabe si una imagen es generada por IA y puede estar equivocado 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 TC o RM. 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 alta importancia. No uses Claude para tareas que requieran precisión perfecta o análisis de imágenes sensibles sin supervisión humana.

Preguntas frecuentes

¿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 para el tamaño de archivo de imagen que puedo subir?

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

¿Claude lee los metadatos de las imágenes?

¿Puedo eliminar imágenes que he subido?

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

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

¿Puede Claude generar o editar imágenes?

Profundiza más en la visión

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

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

Si tienes alguna otra pregunta, no dudes en 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 la imagen
Calcular costos de imagen
Asegurar la calidad de la 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 con API de Archivos
Limitaciones
Preguntas frecuentes
Profundiza más en la visión

Primeros pasos

Modelos y precios

Conoce Claude

Capacidades

Herramientas

Protocolo de Contexto del Modelo (MCP)

Casos de uso

Ingeniería de prompts

Probar y evaluar

Reforzar barreras de seguridad

Centro legal

Cómo usar la visión

Antes de subir

Conceptos básicos y límites

Evaluar el tamaño de la imagen

Calcular costos de imagen

Asegurar la calidad de la 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 con API de Archivos

Limitaciones

Preguntas frecuentes

Profundiza más en la visión

Primeros pasos

Modelos y precios

Conoce Claude

Capacidades

Herramientas

Protocolo de Contexto del Modelo (MCP)

Casos de uso

Ingeniería de prompts

Probar y evaluar

Reforzar barreras de seguridad

Centro legal

​Cómo usar la visión

​Antes de subir

​Conceptos básicos y límites

​Evaluar el tamaño de la imagen

​Calcular costos de imagen

​Asegurar la calidad de la 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 con API de Archivos

​Limitaciones

​Preguntas frecuentes

​Profundiza más en la visión

Cómo usar la visión

Antes de subir

Conceptos básicos y límites

Evaluar el tamaño de la imagen

Calcular costos de imagen

Asegurar la calidad de la 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 con API de Archivos

Limitaciones

Preguntas frecuentes

Profundiza más en la visión