# PDF en Claude Code: conversión, tokens y conservación de la estructura > MarkItDown, PyMuPDF4LLM, MCP, scripts completos de conversión, límites de PDF y casos en los que el análisis visual importa más que ahorrar tokens. Source: https://ailoot.ai/blog/es/pdf-claude-code-markdown/ Canonical: https://ailoot.ai/blog/es/pdf-claude-code-markdown/ Language: es Publisher: Ailoot (https://ailoot.ai/) Translation: guide-196 Revision: sha256-9928669b4134696a0b107edce4bc6b9bc4931fdc0c10465a0478495c68790657
Puntos clave Cada página de un PDF en Claude Code cuesta entre 1.500 y 3.000 tokens antes de la primera pregunta, y Anthropic lo dice claramente en su documentación. En el cálculo ilustrativo siguiente, un informe de 15 páginas en 4 chats usa 135.000 tokens PDF por unos 0,40 $, frente a 18.000 tokens Markdown por 0,054 $: aproximadamente un 87 % menos. Se suponen 2.250 tokens PDF o 300 Markdown por página con la tarifa de entrada del ejemplo; los documentos reales varían. Esta guía abarca tres métodos de conversión (MarkItDown, PyMuPDF4LLM y un servidor MCP) y un script de bash listo para usar con una carpeta de documentos.
Encontrarás instrucciones prácticas para usar Ailoot en la [documentación](https://ailoot.ai/docs/).
## ¿Qué ocurre con un PDF en Claude y por qué cuesta entre 1.500 y 3.000 tokens por página?
Puntos clave Cuando subes un PDF a Claude Code, Claude no lo lee como si fuera un archivo de texto. Primero, cada página se convierte en una imagen y después se extrae el texto. Ambas capas —la imagen y el texto— se añaden juntas al contexto. Por eso cada página ocupa entre 1.500 y 3.000 tokens, y un documento de 50 páginas puede consumir entre 75.000 y 150.000 tokens antes de que hagas tu primera pregunta.
La documentación oficial de Anthropic describe el proceso en tres pasos sencillos:

El sistema convierte cada página del documento en una imagen. El texto de cada página se extrae y se proporciona junto a la imagen de la página. Claude analiza tanto el texto como las imágenes para comprender mejor el documento.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Parece lógico, pero los costes de procesamiento aumentan de forma lineal con el número de páginas. Y esta cifra explica por qué se agota tu límite de uso con un solo PDF:

Cada página suele consumir entre 1.500 y 3.000 tokens, según la densidad del contenido. Como cada página se convierte en una imagen, se aplica el mismo coste que para las imágenes estándar.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Para hacerse una idea, Anthropic midió el mismo PDF de 3 páginas en Bedrock en dos modos. En modo de texto (Converse Document Chat), consumió unos 1.000 tokens. Con análisis visual (Claude PDF Chat), consumió unos 7.000. Incluir imágenes hace que el procesamiento sea **7 veces más caro**. Las capturas de pantalla de las páginas son aún peores. Una captura de pantalla de 1000×1000 píxeles cuesta unos 1.300 tokens. El mecanismo es sencillo: los PDF son caros porque Claude no confía en su OCR. Usa tanto el texto como la imagen para compararlos, y pagas por ambas capas a la vez. Con documentos grandes puedes hacerlo de otra manera: guarda el archivo como Markdown en la carpeta de tu proyecto y dile a Claude: «Aquí hay un documento con información; distribúyela». Claude repartirá el contenido entre sus propios archivos y seguirá trabajando con el texto organizado, en vez de consumirlo todo de una vez. ## ¿Cuántos tokens consume un PDF en una tarea habitual?
Puntos clave Considera un informe público de 15 páginas en 4 contextos: análisis, citas, traducción y resumen. Supón 2.250 tokens de entrada por página PDF, 300 por página Markdown convertida y la misma tarifa de entrada. Volver a subir el PDF produce 135.000 tokens, unos 0,40 $; Markdown, 18.000, o 0,054 $. El ahorro aproximado del 87 % deriva de esos supuestos, no de medir todos los PDF.
Estas son las cifras concretas (modelo Sonnet 4.x, entrada a 3 $ por millón de tokens): | Método | Tokens (15 páginas, 4 chats) | Coste | |------------------------------|-----------------------------|-------------| | PDF subido directamente 4 veces | 15 × 2250 × 4 = **135.000** | unos 0,40 $ | | PDF → Markdown + 4 chats | 15 × 300 × 4 = **18.000** | unos 0,054 $ | | Ahorro | **−87 %** | **−0,35 $** | Y eso es solo un ciclo de 4 solicitudes. Después entra en juego el almacenamiento en caché de prompts (TTL de 5 minutos por defecto, hasta 1 hora en un nivel ampliado y hasta un 90 % de descuento en llamadas repetidas dentro de ese intervalo); los ahorros se multiplican. Cada vez que subes el mismo PDF a un chat nuevo, Claude vuelve a leerlo; la caché no se conserva entre chats. Si conviertes ese PDF de 15 páginas a Markdown una vez y lo añades como `.md` en cada uno de cuatro chats nuevos, el ejemplo usa 15 × 300 × 4 = 18.000 tokens de entrada, frente a 135.000. Los 300 tokens por página convertida y 2.250 por página PDF son supuestos del cálculo, no constantes medidas para todos los PDF. Cuenta tu documento real y confirma la calidad de conversión antes de estimar el ahorro. El ahorro es aún más significativo con una suscripción a Claude Pro. Un informe de 100 páginas puede consumir todo el límite de 5 horas. Tras convertirlo a Markdown, caben más de 10 documentos de ese tipo en el mismo presupuesto. ## ¿Cuáles son los límites de la API de Anthropic para PDF en 2026?
Puntos clave Anthropic impone límites estrictos: un máximo de 32 MB por solicitud (incluido todo el contenido, no solo el PDF) y un máximo de 600 páginas por solicitud. Sin embargo, el límite es menor para los modelos actuales Sonnet 4.x y Opus 4.x con contexto de 200K: **100 páginas**. Puedes enviar un PDF de tres maneras: mediante una URL, en Base64 o a través de la Files API para reutilizarlo con `file_id`. La Files API y la división en partes se usan para documentos largos.
La documentación de Anthropic enumera los límites al principio (actualizados al 31 de mayo de 2026): | Requisito | Límite | |-----------------------------|--------------------------------------------| | Tamaño máximo de la solicitud | 32 MB (varía según la plataforma) | | Máximo de páginas por solicitud | 600 (100 para modelos con contexto de 200K tokens) | | Formato | PDF estándar sin contraseña ni cifrado |

Ambos límites se aplican al cuerpo entero de la solicitud, incluido el contenido que acompaña al PDF. Para archivos PDF grandes, usa la Files API y haz referencia a ellos con `file_id` para mantener pequeño el cuerpo de la solicitud.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Claude.ai (la aplicación web para consumidores) tiene límites distintos: un máximo de 500 MB por archivo y hasta 20 archivos en un chat. Sin embargo, el análisis visual solo funciona con PDF de hasta 100 páginas; por encima de ese límite, Claude ve solo el texto, sin gráficos ni diagramas. Hay tres formas de enviar un PDF a través de la API: 1. **Mediante URL** - `"source": {"type": "url", "url": "..."}` - la opción más sencilla cuando el documento está en línea. 2. **En Base64** - `"source": {"type": "base64", "media_type": "application/pdf", "data": "..."}` - para archivos locales. 3. **A través de la Files API** - `"source": {"type": "file", "file_id": "file_abc123"}` - para solicitudes repetidas; requiere el encabezado beta `anthropic-beta: files-api-2025-04-14`. La Files API es la principal forma de ahorrar cuando trabajas con el mismo PDF en distintos chats. Súbelo una vez, obtén un `file_id` y úsalo en todas las interacciones. Con `cache_control: ephemeral`, las llamadas repetidas cuestan el 10 % del precio habitual. Anthropic también ofrece consejos oficiales para reducir el uso:

Los PDF densos (con mucho texto pequeño, tablas complejas o muchos gráficos) pueden llenar la ventana de contexto antes de que alcances el límite de páginas. Prueba a dividir el documento en secciones; si son archivos grandes, reduce la resolución de las imágenes incrustadas antes de subirlos.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
## Método 1: ¿Cómo se configura MarkItDown en 5 minutos?
Puntos clave MarkItDown es una utilidad de Python del equipo Microsoft AutoGen que convierte PDF, DOCX, PPTX, XLSX, HTML, audio, imágenes e incluso vídeos de YouTube a Markdown limpio. Tiene 134 mil estrellas en GitHub, licencia MIT y se instala con un solo comando: `pip install 'markitdown[all]'`. Es igual de fácil de usar: `markitdown document.pdf > document.md`. Es la herramienta más versátil para convertir archivos antes de usar Claude Code.
MarkItDown es un proyecto oficial de Microsoft mantenido por el equipo AutoGen. En GitHub tiene 134 mil estrellas y 9,2 mil forks (a finales de mayo de 2026). Su propósito se explica directamente en el README:

Una utilidad ligera de Python para convertir archivos a Markdown y usarlos con LLM y procesos de análisis de texto.

— Microsoft, https://github.com/microsoft/markitdown
Formatos compatibles: - **Documentos:** PDF, DOCX, PPTX, XLSX - **Web:** HTML, JSON, XML, CSV - **Medios:** audio con transcripción, imágenes con EXIF y OCR, vídeos de YouTube (mediante subtítulos) - **Archivos:** ZIP, EPub - **Otros:** todos los adjuntos de archivos Outlook MSG ### Instalación Requisito: Python 3.10+ (normalmente ya está instalado en macOS; en Windows tendrás que instalarlo por separado). ```bash pip install 'markitdown[all]' ``` Si no necesitas todos los formatos, puedes instalar solo algunos: ```bash pip install 'markitdown[pdf, docx, pptx]' ``` ### Convertir un solo archivo El caso más sencillo: ```bash markitdown document.pdf > document.md ``` Después, `document.md` aparecerá en la carpeta actual. Añádelo a Claude Code con `@document.md` o simplemente colócalo junto a tu proyecto. ### API de Python Si quieres integrarlo en tu script: ```python from markitdown import MarkItDown md = MarkItDown() result = md.convert("research-paper.pdf") print(result.text_content) # You can save it straight away: with open("research-paper.md", "w") as f: f.write(result.text_content) ``` ### Lo que MarkItDown NO puede hacer - **OCR de PDF escaneados** - no devuelve nada. Para escaneos, necesitas PyMuPDF4LLM o Docling. - **Diseños complejos con varias columnas** - puede desordenar el orden de lectura. - **URL incrustadas en PDF** - no las conserva. Para los PDF sencillos (informes, artículos, documentación), MarkItDown es la mejor opción: una herramienta versátil que se instala en un minuto y no requiere conocimientos de Python. Las mediciones de su rendimiento con documentos en cirílico y escaneos se muestran en el análisis sobre cómo [convertir un PDF a texto para IA](https://ailoot.ai/blog/es/markitdown-pdf-word-to-text/). ## Método 2: ¿Qué ofrece PyMuPDF4LLM y cuándo es mejor?
Puntos clave PyMuPDF4LLM es un proyecto de Artifex Software basado en el motor nativo C de MuPDF. Es el convertidor de PDF más rápido (no necesita GPU); aplica OCR inteligente solo a las zonas ilegibles y reduce el tiempo de procesamiento un 50 %. Es la única herramienta popular que conserva las URL e imágenes incrustadas de los PDF. El inconveniente es su doble licencia AGPL v3 o comercial de Artifex: para proyectos SaaS, la AGPL significa que tienes que publicar tu código.
MarkItDown ofrece variedad de formatos; PyMuPDF4LLM ofrece un procesamiento más profundo de PDF.

Una extensión ligera de PyMuPDF que convierte PDF en datos limpios y estructurados con una configuración mínima.

— Artifex Software, https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/
La versión vigente al 31 de mayo de 2026 es la 1.27.2.3 (publicada el 24 de abril de 2026). ### Qué incluye - Páginas con varias columnas y el orden de lectura correcto - Conversión de tablas a Markdown con formato de GitHub - Eliminación automática de encabezados y pies de página - Extracción de imágenes con enlaces relativos a una carpeta aparte - OCR inteligente: solo se aplica a las zonas ilegibles y ahorra aproximadamente un 50 % del tiempo de procesamiento - Motor nativo C, **no necesita GPU** ### Instalación ```bash pip install pymupdf4llm ``` ### Uso ```python import pymupdf4llm # Uso básico - directamente a Markdown: md_text = pymupdf4llm.to_markdown("document.pdf") # Guardarlo: with open("document.md", "w") as f: f.write(md_text) ``` En una sola línea, como prometí: ```bash python3 -c "import pymupdf4llm; \ open('document.md','w').write(pymupdf4llm.to_markdown('document.pdf'))" ``` ### Cuándo elegir PyMuPDF4LLM en lugar de MarkItDown - Cuando el PDF contiene muchos enlaces que necesitas conservar (MarkItDown los pierde). - Cuando el documento está escaneado y necesitas OCR. - Cuando necesitas procesar rápidamente miles de archivos en local: el motor nativo C es más rápido que los wrappers de Python. - Cuando necesitas extraer imágenes del PDF a una carpeta aparte para procesarlas después. ### Detalle de la licencia (importante para empresas) PyMuPDF4LLM tiene doble licencia: AGPL v3 O una licencia comercial de Artifex. **AGPL significa que:** si usas la biblioteca en un SaaS público, debes publicar todo el código fuente de tu servicio bajo la misma AGPL. Para uso interno (tu script en tu portátil), no hay restricciones. Para desarrollar un producto comercial sin revelar el código, compra una licencia a Artifex (artifex.com). Los precios no están publicados; solicítalos al equipo de ventas. Si estás desarrollando un producto para clientes, comprueba la licencia desde el principio. MarkItDown (MIT) y Docling (MIT) son opciones más seguras para SaaS. ## Método 3: conectar MarkItDown al agente de inteligencia artificial Claude Code mediante MCP {#método-3-cómo-conectas-el-servidor-mcp-de-markitdown-a-claude-code}
Puntos clave El servidor MCP de MarkItDown es el mismo MarkItDown integrado en el protocolo MCP, para que Claude Code pueda convertir PDF sobre la marcha sin cargar el archivo original en el contexto. Se conecta con un solo comando usando uv; la versión está fijada: `markitdown-mcp@0.0.1a7`. La herramienta que recibe Claude es `convert_to_markdown(uri)`. En reposo, la descripción del skill cuesta unos 110 tokens, y cero cuando no se necesita.
El modo CLI de MarkItDown significa «Convierto los archivos manualmente por adelantado»; el servidor MCP significa «Claude Code decide cuándo convertirlos». ### Instalación Necesitas el gestor de paquetes uv. No hace falta instalar el servidor por separado; uv lo descarga la primera vez que se ejecuta. ### Configuración en Claude Code Un solo comando conecta el servidor a todos tus proyectos, con la versión fijada: ```bash claude mcp add --scope user --env 'ORT_DISABLE_TELEMETRY=1' --env 'UV_PYTHON=3.12' --transport stdio markitdown -- uvx markitdown-mcp@0.0.1a7 claude mcp list ``` La entrada `markitdown` debería indicar “Connected”. El primer inicio descarga unos setenta paquetes y puede tardar hasta un minuto; después, el servidor se inicia en uno o dos segundos. Estas son las razones por las que el comando necesita las dos variables. `ORT_DISABLE_TELEMETRY=1` desactiva las estadísticas que el motor onnxruntime del servidor envía a Microsoft de forma predeterminada en Mac y Linux. `UV_PYTHON=3.12` ejecuta el servidor con Python 3.12, para el que hay paquetes precompilados disponibles en Windows, Linux y Mac con Apple Silicon. En los Mac Intel y en macOS 13 y versiones anteriores, el servidor no se instala con Python 3.14. Hay una salvedad para Intel y la versión 3.12: uv compilará la biblioteca cryptography desde el código fuente porque no hay paquetes precompilados para Intel desde junio de 2026. La instalación tarda más y puede fallar. Si no tienes Python 3.12, uv lo descargará. El servidor se ejecuta directamente en tu ordenador y puede abrir cualquier archivo al que tengas acceso. Si Claude Code estaba abierto, reinícialo y `markitdown` aparecerá en la lista de servidores MCP. ### Cómo usarlo En Claude Code, solo tienes que decir: ``` Convierte /Users/your-user/Documents/report.pdf a Markdown y analiza los puntos principales. ``` Claude llama por su cuenta a `convert_to_markdown(uri)`, recibe el Markdown y trabaja con él; el PDF no se carga en el contexto. ### URI compatibles - `file://` - archivos locales - `http://`, `https://` - documentos en línea - `data:` - datos insertados (Base64) ### Seguridad Según el README oficial:

El servidor no admite autorización y se ejecuta con los permisos del usuario que lo haya iniciado.

— Microsoft, https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp
De forma predeterminada, está enlazado a localhost. Si lo ejecutas mediante HTTP/SSE (opción `--http --host 127.0.0.1 --port 3001`), no expongas el puerto al exterior sin un proxy inverso autenticado. ## ¿Qué método deberías elegir para tu tarea?
Puntos clave MarkItDown es la opción más versátil si trabajas con distintos formatos (PDF + DOCX + PPTX + YouTube) y necesitas un comando CLI rápido. PyMuPDF4LLM es el especialista en PDF: más rápido, con OCR y conservación de enlaces, pero una trampa de AGPL para SaaS. Docling está preparado para producción y gestiona mejor las tablas y fórmulas. Marker es para artículos científicos con matemáticas. El servidor MCP es para cuando no quieres preocuparte por la conversión y prefieres que Claude Code decida por su cuenta.
Tabla comparativa ampliada: | Herramienta | Estrellas en GitHub | Ideal para | Velocidad | Licencia | |----|----|----|----|----| | **MarkItDown** (Microsoft) | 134k | PDF + DOCX + PPTX + YouTube + audio | Media | MIT | | **PyMuPDF4LLM** (Artifex) | \- | PDF nativos, OCR, URL incrustadas | La más rápida (sin GPU) | AGPL v3 / comercial | | **Docling** (IBM Research) | 60,7k | RAG en producción, tablas, fórmulas | Media | MIT | | **Marker** (datalab.to) | 35,6k | PDF científicos, arXiv, fórmulas | Alta (con GPU) | GPL-3.0 + Open Rail-M | | **MinerU** | \- | Documentos CJK (chino/japonés) | Alta | Apache-2.0 | Marker publica cifras de precisión impresionantes en pruebas de referencia:

0,18 segundos por página en una GPU H100 (122 páginas por segundo). Precisión del 95,67 % frente al 84,24 % de Llamaparse y al 86,43 % de Mathpix. En artículos científicos, 96,67 %.

— datalab.to, https://github.com/datalab-to/marker
Sin embargo, Marker necesita una GPU para alcanzar una buena velocidad y utiliza modelos de aprendizaje automático. Para la mayoría de las tareas con PDF de texto normal, PyMuPDF4LLM o MarkItDown bastan y funcionan en segundos sin GPU. ### Una regla sencilla para elegir 1. **Uno o dos PDF, necesitas rapidez** - MarkItDown CLI. 2. **Decenas de PDF, necesitas automatización** - servidor MCP de MarkItDown o PyMuPDF4LLM en un script. 3. **PDF con enlaces e imágenes donde importa conservar la estructura** - PyMuPDF4LLM. 4. **RAG en producción para empresas donde importa la estabilidad de las tablas** - Docling. 5. **Artículos científicos con fórmulas** - Marker. 6. **No quieres preocuparte por ello y prefieres dejar que Claude convierta los archivos** - servidor MCP de MarkItDown. ## ¿Cómo se escribe un script listo para usar que convierta automáticamente una carpeta de documentos?
Puntos clave La solución más práctica es un script de bash que recorra una carpeta del proyecto, convierta todos los archivos PDF, DOCX y PPTX a Markdown y los guarde en una subcarpeta `_md/`. Configúralo una vez y cualquier carpeta nueva de documentos se volverá «legible para Claude» de una sola pasada. Después, añade `_md/` a Claude Code con `@_md/` y trabaja con el texto comprimido.
Un ejemplo práctico: imagina que tienes 40 informes PDF y PPTX de clientes en una carpeta: extractos de cuentas de corretaje, contratos y presentaciones. Subir toda la carpeta a Claude directamente no sirve de nada: la ventana de contexto se llenará antes de la primera respuesta. Procesa toda la carpeta de una vez con el script de abajo y luego trabaja con archivos `.md` ligeros en lugar de PDF voluminosos. Guarda este script como `scripts/docs-to-md.sh` en la raíz del proyecto: ```bash #!/bin/bash # docs-to-md.sh - convierte todos los documentos de una carpeta a Markdown con MarkItDown # Uso: bash docs-to-md.sh ./documents set -e INPUT_DIR="${1:-./documents}" OUTPUT_DIR="${INPUT_DIR}/_md" mkdir -p "$OUTPUT_DIR" echo "Scanning $INPUT_DIR..." for file in "$INPUT_DIR"/*.{pdf,docx,pptx,xlsx}; do [ -f "$file" ] || continue basename=$(basename "$file") name="${basename%.*}" output="$OUTPUT_DIR/${name}.md" if [ -f "$output" ] && [ "$output" -nt "$file" ]; then echo "Skipping $basename (already converted)" continue fi echo "Converting $basename..." markitdown "$file" > "$output" done echo "Done. Results are in $OUTPUT_DIR" ``` Dale permisos de ejecución: ```bash chmod +x scripts/docs-to-md.sh ``` Ejecútalo: ```bash bash scripts/docs-to-md.sh ./reports ``` Al terminar, `./reports/_md/` contendrá las versiones `.md` de todos los documentos. Añádelas a Claude Code con `@reports/_md/` y trabaja con el texto comprimido en lugar de con PDF. El script omite automáticamente los archivos ya convertidos (si el archivo `.md` es más reciente que el original); volver a ejecutarlo es rápido y no recalcula todo. ### Idempotencia y conversión incremental Si quieres que el script detecte los PDF modificados y guardados con el mismo nombre, añade una comprobación del hash del contenido: ```bash hash=$(shasum -a 256 "$file" | cut -d' ' -f1) hash_file="$OUTPUT_DIR/.${name}.sha256" if [ -f "$hash_file" ] && [ "$(cat "$hash_file")" = "$hash" ]; then echo "Skipping $basename (hash matches)" continue fi markitdown "$file" > "$output" echo "$hash" > "$hash_file" ``` Esta versión vuelve a convertir un archivo solo si su contenido ha cambiado. ## ¿Cuándo sigue siendo mejor usar un PDF en Claude que Markdown?
Puntos clave La conversión a Markdown pierde tres cosas: elementos visuales (diagramas, gráficos, planos), tablas complejas con celdas combinadas y pies de figura, y el formato completo del documento como pieza de referencia (por ejemplo, un contrato que debes citar por página). Si estas cosas importan para la tarea, conserva el PDF, activa el análisis visual y asume conscientemente ese coste.
Tres casos en los que la conversión a Markdown se queda corta: ### 1. Análisis visual de diagramas y gráficos Si Claude necesita «leer» un gráfico —una curva de precios, un diagrama de procesos o un esquema de arquitectura—, esa información no aparece en Markdown. Markdown conserva solo los pies de figura; la figura en sí se pierde. Solución: sube el PDF y activa explícitamente el modo visual. En la API de Claude, la opción funciona automáticamente; en AWS Bedrock necesitas la opción `citations`.

Claude analiza tanto el texto como las imágenes para comprender mejor el documento.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
### 2. Tablas complejas con celdas combinadas Las tablas Markdown son planas. Si el PDF contiene una tabla con celdas combinadas, encabezados de varios niveles o tablas anidadas, el convertidor la aplanará o perderá las relaciones entre sus elementos. Solución: usa directamente el PDF, usa Docling (que gestiona mejor las tablas complejas) o dale formato manualmente tras la conversión. ### 3. Documentos como piezas con referencias a páginas En documentos legales, contratos y actas, importa poder citar «página 7, párrafo 3». En Markdown se pierden los números de página. Solución: PDF + Files API + almacenamiento en caché de prompts. Sube el documento una vez y luego haz referencia a él mediante `file_id`; Claude ve la paginación y puede citar páginas concretas. ### Documentos breves Si un PDF tiene menos de 2 páginas y lo usas una sola vez, no vale la pena convertirlo. 5.000 tokens para un PDF frente a 800 para Markdown no supone un ahorro suficiente como para justificar la instalación de MarkItDown. El punto de equilibrio está en torno a 5 páginas o más, o 2 usos o más del mismo documento. Por debajo de eso, sube el PDF directamente; por encima, conviértelo. ## ¿Cuáles son los 5 errores más comunes que se cometen con los PDF en Claude?
Puntos clave Los principales errores: volver a subir el mismo PDF en distintos chats en lugar de convertirlo una vez, no usar el almacenamiento en caché de prompts para solicitudes repetidas, usar capturas de pantalla en vez de texto, no aplicar OCR a los PDF escaneados e ignorar el límite de 100 páginas de los modelos con contexto de 200K. Cada error desperdicia decenas de miles de tokens sin motivo.
### 1. Subir el mismo PDF a un chat nuevo cada vez Claude Pro tiene un límite de mensajes por cada periodo de 5 horas; un solo informe de 50 páginas puede agotarlo antes de que hagas una segunda pregunta. Hay un principio sencillo para evitarlo: **una tarea, un chat**. Cuando la IA empieza a consumir una cantidad absurda de tokens, significa que estás metiendo todo en un solo chat y añadiendo el PDF una y otra vez. Dedica cada ventana a una microtarea. Convierte el documento a Markdown una vez y luego añade el archivo `.md` a cada ventana nueva junto con el proyecto. El círculo de la ventana de contexto no se pondrá amarillo. Solución: conviértelo a Markdown una vez o usa la Files API con `file_id` y almacenamiento en caché de prompts. ### 2. Una captura de pantalla en vez de texto Un ejemplo habitual: alguien quiere mostrarle a Claude un fragmento de código o una tabla, hace una captura de toda la pantalla de 1920×1080 y se pregunta por qué se le agota el límite tras 5 solicitudes. Una captura de pantalla de 1000×1000 píxeles cuesta unos 1.300 tokens. El mismo texto copiado a mano cuesta entre 50 y 100 tokens. La diferencia es de 13 a 26 veces. Solución: recorta las capturas para dejar solo la parte importante o, mejor aún, copia el texto directamente. ### 3. Un PDF escaneado sin OCR MarkItDown no puede hacer OCR. Si conviertes un escaneo, obtendrás un archivo `.md` vacío (o 3 líneas de texto ilegible). Solución: para documentos escaneados, usa PyMuPDF4LLM (con su OCR inteligente integrada) o Docling. ### 4. Ignorar el límite de 100 páginas La documentación de Anthropic establece un límite de 600 páginas por solicitud, pero, en la práctica, el límite para los modelos con contexto de 200K (Sonnet 4.x, Opus 4.x) es de **100 páginas**. El límite de 600 páginas está pensado para modelos antiguos o niveles especiales. Si subes un informe de 150 páginas a Sonnet 4.6, recibirás un error o, peor aún, Claude procesará solo las primeras 100 páginas y actuará como si hubiera leído el documento entero. Solución: divide los PDF largos en partes antes de subirlos. O conviértelos a Markdown: no hay límite de páginas, solo de tokens. ### 5. No usar el almacenamiento en caché de prompts para solicitudes repetidas Si trabajas con el mismo documento mediante la API, inclúyelo en `cache_control: ephemeral`. Las solicitudes repetidas en un plazo de 5 minutos cuestan el 10 % del precio inicial. Una solicitud cuesta más; las demás tienen un descuento del 90 %. Solución: activa por defecto el almacenamiento en caché de prompts para cualquier documento que subas más de una vez. ## Qué sigue: ingeniería de contexto
Puntos clave Convertir PDF a Markdown es una técnica de ingeniería de contexto, una nueva competencia para trabajar con IA. Un prompt es una pregunta. El contexto es todo lo que Claude ve antes y alrededor de la pregunta: el prompt del sistema, CLAUDE.md, los archivos, los servidores MCP y el historial de la sesión. Cuanto más limpio sea el contexto, más precisa será la respuesta y menos costará. Lee el análisis completo en la guía «Ingeniería de contexto en 2026».
Convertir PDF a Markdown es una manera de ahorrar tokens. Por sí solo, no hace que las respuestas de Claude sean más precisas. La precisión proviene de la **ingeniería de contexto**: la disciplina de decidir qué incluir en el contexto del modelo antes de hacer una pregunta. Si tu `CLAUDE.md` tiene 800 líneas, tu proyecto cuenta con 10 servidores MCP innecesarios y añades un PDF de 100 páginas, la conversión a Markdown evitará una fuga, pero las otras tres seguirán ahí. Por eso estas guías tratan lo siguiente: - [Adónde van los tokens en Claude Code](https://ailoot.ai/blog/es/where-claude-code-tokens-go/) - 9 patrones de pérdida de contexto, no solo con los PDF. - [Ingeniería de contexto en 2026](https://ailoot.ai/blog/es/context-engineering/) - la gestión sistemática del contexto. - [Modo Plan en Claude Code](https://ailoot.ai/blog/es/claude-code-plan-mode/) - el modo de planificación antes de que Claude empiece a escribir código.
### Fuentes - [Anthropic - Compatibilidad con PDF (platform.claude.com)](https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support) - [Anthropic - Subir archivos a Claude (support.claude.com)](https://support.claude.com/en/articles/8241126-upload-files-to-claude) - [Microsoft MarkItDown en GitHub](https://github.com/microsoft/markitdown) - [Servidor MCP de MarkItDown](https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp) - [PyMuPDF4LLM - documentación oficial](https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/) - [Docling en GitHub (IBM Research)](https://github.com/DS4SD/docling) - [Marker en GitHub (datalab.to)](https://github.com/datalab-to/marker)
Sigue descubriendo Ailoot en [ailoot.ai](https://ailoot.ai/).
## Preguntas sobre Claude Code ### ¿Cuántos tokens Markdown usa el ejemplo de 15 páginas y cuatro chats? Con la suposición de 300 tokens por página convertida, son 15 × 300 × 4 = 18.000 tokens de entrada. Es una estimación ilustrativa; cuenta los tokens del documento convertido para tu archivo real. ### ¿Basta convertir a texto cualquier PDF? No. Compara el Markdown con el PDF, sobre todo tablas, orden de páginas y contenido que dependa de imágenes. Compara tokens solo después de confirmar que sobrevivió la información necesaria para la tarea. ## Ailoot · La empresa y su cartera de proyectos Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI. La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes. Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.