Claude Platform Docs
MensajesTrabajar con archivos

Compatibilidad con PDF

Procesa PDFs con Claude: extrae texto, analiza gráficos y comprende el contenido visual de tus documentos.

Puedes preguntarle a Claude sobre cualquier texto, imagen, gráfico y tabla en los PDFs que proporciones. Algunos casos de uso de ejemplo:

  • Analizar informes financieros y comprender gráficos/tablas
  • Extraer información clave de documentos legales
  • Ayudar con la traducción de documentos
  • Convertir información de documentos a formatos estructurados

Antes de comenzar

Verifica los requisitos de PDF

Claude funciona con cualquier PDF estándar. Asegúrate de que el tamaño de tu solicitud cumpla con estos requisitos:

RequisitoLímite
Tamaño máximo de solicitud128 MB en la Claude API de primera parte (varía según la plataforma; consulta los límites de tamaño de solicitud)
Máximo de páginas por solicitud600 (100 cuando la ventana de contexto de la solicitud es inferior a 1M de tokens)
FormatoPDF estándar (sin contraseñas/cifrado)

Ambos límites se aplican a la carga útil completa de la solicitud, incluido cualquier otro contenido enviado junto con los PDFs. Para PDFs grandes, considera subirlos con la Files API y referenciarlos mediante file_id para mantener pequeñas las cargas útiles de las solicitudes.

Dado que la compatibilidad con PDF depende de las capacidades de visión de Claude, está sujeta a las mismas limitaciones y consideraciones que otras tareas de visión.

Plataformas y modelos compatibles

Todos los modelos activos admiten el procesamiento de PDF.

Procesa PDFs con Claude

Envía tu primera solicitud con PDF

Comienza con un ejemplo sencillo usando la Messages API. Puedes proporcionar PDFs a Claude de tres maneras:

  1. Como una referencia URL a un PDF alojado en línea
  2. Como un PDF codificado en base64 en bloques de contenido document
  3. Mediante un file_id de la Files API

Opción 1: Documento PDF basado en URL

El enfoque más sencillo es referenciar un PDF directamente desde una URL:

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "url",
                        "url": "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf",
                    },
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

La respuesta devuelve el análisis de Claude como bloques de texto en content, con el consumo de tokens en usage:

Output
{
  "id": "msg_01Hfp8YuFjQ55VgWbpdHDehB",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "This document is an addendum to the Claude 3 model card, reporting updated evaluation results. The key findings include..."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 300
  }
}

Opción 2: Documento PDF codificado en base64

Si necesitas enviar PDFs desde tu sistema local o cuando no hay una URL disponible:

import base64
import httpx2

# Primero, carga y codifica el PDF
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Alternativa: carga desde un archivo local
# with open("document.pdf", "rb") as f:
#     pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

# Envía a Claude usando codificación base64
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data,
                    },
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

Opción 3: Files API

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

client = anthropic.Anthropic()

# Sube el archivo PDF
with open("/path/to/document.pdf", "rb") as f:
    file_upload = client.files.upload(file=("document.pdf", f, "application/pdf"))

# Usa el archivo subido en un mensaje
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {"type": "file", "file_id": file_upload.id},
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

Cómo funciona la compatibilidad con PDF

Cuando envías un PDF a Claude, ocurren los siguientes pasos:

  1. El sistema extrae el contenido del documento.

    • El sistema convierte cada página del documento en una imagen.
    • El texto de cada página se extrae y se proporciona junto con la imagen de cada página.

  2. Claude analiza tanto el texto como las imágenes.

    • Los documentos se proporcionan como una combinación de texto e imágenes para su análisis.
    • Esto permite a los usuarios solicitar información sobre los elementos visuales de un PDF, como gráficos, diagramas y otro contenido no textual.

  3. Claude responde, haciendo referencia al contenido del PDF si es relevante.

    Claude puede hacer referencia tanto al contenido textual como al visual cuando responde. Puedes mejorar aún más el rendimiento integrando la compatibilidad con PDF con:

Estima tus costos

El recuento de tokens de un archivo PDF depende del texto total extraído del documento y del número de páginas:

  • Costos de tokens de texto: Cada página suele usar entre 1,500 y 3,000 tokens según la densidad del contenido. Se aplican los precios estándar de la API sin tarifas adicionales por PDF.
  • Costos de tokens de imagen: Dado que cada página se convierte en una imagen, se aplican los mismos cálculos de costo basados en imágenes.

Puedes usar el conteo de tokens para estimar los costos de tus PDFs específicos.

Optimiza el procesamiento de PDF

Mejora el rendimiento

Sigue estas mejores prácticas para obtener resultados óptimos:

  • Coloca los PDFs antes del texto en tus solicitudes
  • Usa fuentes estándar
  • Asegúrate de que el texto sea claro y legible
  • Rota las páginas a la orientación vertical correcta
  • Usa números de página lógicos (del visor de PDF) en los prompts
  • Divide los PDFs grandes en fragmentos cuando sea necesario
  • Habilita el almacenamiento en caché de prompts para análisis repetidos

Escala tu implementación

Para el procesamiento de alto volumen, considera estos enfoques:

Usa el almacenamiento en caché de prompts

Almacena en caché los PDFs con “prompt caching” (almacenamiento en caché de prompts) para mejorar el rendimiento en consultas repetidas:

import base64
import httpx2

# Primero, carga y codifica el PDF
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Crea un mensaje con el documento almacenado en caché
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data,
                    },
                    "cache_control": {"type": "ephemeral"},
                },
                {
                    "type": "text",
                    "text": "Which model has the highest human preference win rates across each use-case?",
                },
            ],
        }
    ],
)

print(message.content)

Procesa lotes de documentos

Usa la Message Batches API para procesar muchos PDFs en una sola solicitud:

import base64
import httpx2

# Primero, carga y codifica el PDF
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Crea un lote de solicitudes que usen el documento
client = anthropic.Anthropic()
message_batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "my-first-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "document",
                                "source": {
                                    "type": "base64",
                                    "media_type": "application/pdf",
                                    "data": pdf_data,
                                },
                            },
                            {
                                "type": "text",
                                "text": "Which model has the highest human preference win rates across each use-case?",
                            },
                        ],
                    }
                ],
            },
        },
        {
            "custom_id": "my-second-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "document",
                                "source": {
                                    "type": "base64",
                                    "media_type": "application/pdf",
                                    "data": pdf_data,
                                },
                            },
                            {
                                "type": "text",
                                "text": "Extract 5 key insights from this document.",
                            },
                        ],
                    }
                ],
            },
        },
    ]
)

print(message_batch)

Los lotes se procesan de forma asíncrona. Para verificar el progreso y recuperar los resultados una vez que finalice el procesamiento, consulta Procesamiento por lotes.

Próximos pasos

Visión

Las capacidades de visión de Claude le permiten procesar y analizar imágenes, lo que abre posibilidades emocionantes para la interacción multimodal.

Prueba ejemplos de PDF

Explora ejemplos prácticos de procesamiento de PDF en la receta del Claude Cookbook.

Ver la referencia de la API

Consulta la documentación completa de la API para la compatibilidad con PDF.

Disponibilidad

Compatibilidad con PDF
API
  • Messages API
  • Managed Agents
Modelos
  • Todos los modelos

Manejo de datos

Descripción general del manejo de datos

Endpoints aplicables

  • /v1/messages
Retención de datos ceroElegible

Excluye Modelos cubiertos

HIPAAElegible

La elegibilidad para HIPAA se aplica a los PDF enviados en línea a través de la Messages API, no a través de la Files API.

¿Te resultó útil esta página?