# PDFs in Claude Code: Tokens sparen und Struktur erhalten > MarkItDown, PyMuPDF4LLM, MCP, vollständige Konvertierungsskripte, PDF-Limits und Fälle, in denen die visuelle Analyse wichtiger ist als Token-Einsparungen. Source: https://ailoot.ai/blog/de/pdf-claude-code-markdown/ Canonical: https://ailoot.ai/blog/de/pdf-claude-code-markdown/ Language: de Publisher: Ailoot (https://ailoot.ai/) Translation: guide-196 Revision: sha256-8fddddeddbb946d931e8bbf8fd9bcee18676d49333c78aedf3c73e92fae85ade
Das Wichtigste Jede PDF-Seite kostet in Claude Code 1.500–3.000 Tokens, noch bevor du die erste Frage stellst – und Anthropic sagt das in seiner Dokumentation ganz klar. In der folgenden Beispielrechnung verwendet ein 15-seitiger Bericht in vier Chats 135.000 PDF-Eingabetokens für etwa 0,40 $ gegenüber 18.000 Markdown-Eingabetokens für 0,054 $, rund 87 % weniger. Angenommen werden 2.250 PDF- beziehungsweise 300 Markdown-Tokens pro Seite zum Eingabepreis des Beispiels; tatsächliche Dokumente unterscheiden sich. Dieser Leitfaden behandelt drei Konvertierungsmethoden (MarkItDown, PyMuPDF4LLM und einen MCP-Server) sowie ein sofort einsetzbares Bash-Skript für einen Dokumentenordner.
Praktische Anleitungen zur Verwendung von Ailoot findest du in der [Dokumentation](https://ailoot.ai/docs/).
## Was passiert mit einer PDF in Claude, und warum kostet jede Seite 1.500–3.000 Tokens?
Das Wichtigste Wenn du eine PDF in Claude Code hochlädst, liest Claude sie nicht wie eine Textdatei. Zuerst wird jede Seite in ein Bild umgewandelt, anschließend wird der Text daraus extrahiert. Beide Ebenen – Bild und Text – werden gemeinsam zum Kontext hinzugefügt. Deshalb beansprucht eine Seite 1.500–3.000 Tokens, und ein 50-seitiges Dokument kann 75.000–150.000 Tokens verbrauchen, bevor du deine erste Frage stellst.
Anthropics offizielle Dokumentation beschreibt den Ablauf in drei einfachen Schritten:

Das System wandelt jede Dokumentseite in ein Bild um. Der Text jeder Seite wird extrahiert und zusammen mit dem Seitenbild bereitgestellt. Claude analysiert sowohl den Text als auch die Bilder, um das Dokument besser zu verstehen.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Das klingt logisch, doch die Verarbeitungskosten steigen linear mit der Seitenzahl. Und diese Zahl erklärt, warum dein Nutzungslimit schon bei einer einzigen PDF aufgebraucht ist:

Je nach Inhaltsdichte werden pro Seite üblicherweise 1.500–3.000 Tokens verbraucht. Da jede Seite in ein Bild umgewandelt wird, gelten dieselben Kosten wie für normale Bilder.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Um die Größenordnung einzuordnen: Anthropic hat dieselbe 3-seitige PDF auf Bedrock in zwei Modi gemessen. Im Textmodus (Converse Document Chat) verbrauchte sie etwa 1.000 Tokens. Bei visueller Analyse (Claude PDF Chat) waren es etwa 7.000 Tokens. Die Einbeziehung von Bildern macht die Verarbeitung **7-mal teurer**. Screenshots von Seiten sind noch ungünstiger. Ein Screenshot mit 1000×1000 Pixeln kostet etwa 1.300 Tokens. Der Grund ist einfach: PDFs sind teuer, weil Claude seiner OCR nicht vertraut. Claude nutzt sowohl Text als auch Bild, um beides abzugleichen – und du zahlst gleichzeitig für beide Ebenen. Bei großen Dokumenten kannst du anders vorgehen: Speichere die Datei als Markdown in deinem Projektordner und sage Claude: „Hier ist ein Dokument mit Informationen – verteile sie.“ Claude verteilt die Inhalte auf seine eigenen Dateien und arbeitet dann mit dem geordneten Text, statt alles auf einmal zu verbrauchen. ## Wie viele Tokens verbraucht eine PDF bei einer typischen Aufgabe?
Das Wichtigste Betrachte einen 15-seitigen öffentlichen Bericht in vier Zusammenhängen: Analyse, Zitate, Übersetzung und Zusammenfassung. Nimm 2.250 Eingabetokens je PDF-Seite, 300 je konvertierter Markdown-Seite und denselben Eingabepreis an. Wiederholtes Hochladen des PDFs ergibt 135.000 Eingabetokens für etwa 0,40 $, Markdown 18.000 für 0,054 $. Die rund 87 % Ersparnis folgen aus diesen Annahmen, nicht aus einer Messung jedes PDFs.
Die konkreten Zahlen (Sonnet-Modell der Reihe 4.x, Eingabe zu 3 $ pro Million Tokens): | Ansatz | Tokens (15 Seiten, 4 Chats) | Kosten | |------------------------------|-----------------------------|-------------| | PDF 4-mal direkt hochgeladen | 15 × 2250 × 4 = **135.000** | etwa 0,40 $ | | PDF → Markdown + 4 Chats | 15 × 300 × 4 = **18.000** | etwa 0,054 $ | | Einsparung | **−87 %** | **−0,35 $** | Und das gilt nur für einen Durchlauf mit 4 Anfragen. Danach kommt Prompt-Caching ins Spiel (standardmäßig 5 Minuten TTL, in einer erweiterten Stufe bis zu 1 Stunde und bis zu 90 % Rabatt auf wiederholte Anfragen innerhalb des Zeitfensters) – die Einsparungen vervielfachen sich. Jedes Mal, wenn du dieselbe PDF in einem neuen Chat hochlädst, liest Claude sie erneut. Der Cache wird nicht zwischen Chats übernommen. Wenn du dieselbe 15-seitige PDF einmal in Markdown konvertierst und in vier neuen Chats als `.md` einfügst, ergibt dieses Beispiel 15 × 300 × 4 = 18.000 Eingabetokens statt 135.000. Die 300 Tokens je konvertierter Seite und 2.250 je PDF-Seite sind Rechenannahmen, keine gemessenen Konstanten für jedes PDF. Zähle dein tatsächliches Dokument und prüfe die Konvertierungsqualität vor einer Ersparnisschätzung. Mit einem Claude-Pro-Abonnement fällt dieser Unterschied noch stärker ins Gewicht. Ein einziger 100-seitiger Bericht kann das gesamte 5-Stunden-Limit aufbrauchen. Nach der Konvertierung in Markdown passen 10 oder mehr solcher Dokumente in dasselbe Budget. ## Welche Anthropic-API-Limits gelten für PDFs im Jahr 2026?
Das Wichtigste Anthropic setzt strenge Limits: maximal 32 MB pro Anfrage (einschließlich aller Inhalte, nicht nur der PDF) und maximal 600 Seiten pro Anfrage. Für aktuelle Sonnet-4.x- und Opus-4.x-Modelle mit 200K Kontext gilt jedoch ein niedrigeres Limit: **100 Seiten**. Du kannst eine PDF auf drei Arten senden: per URL, als Base64 oder über die Files API zur Wiederverwendung mit `file_id`. Für lange Dokumente wird die Files API zusammen mit einer Aufteilung in Teile verwendet.
Anthropics Dokumentation nennt die Limits gleich am Anfang (Stand: 31. Mai 2026): | Voraussetzung | Limit | |-----------------------------|--------------------------------------------| | Maximale Anfragegröße | 32 MB (variiert je nach Plattform) | | Maximale Seitenzahl pro Anfrage | 600 (100 bei Modellen mit 200K Token Kontext) | | Format | Standard-PDF ohne Passwort oder Verschlüsselung |

Beide Limits gelten für den gesamten Anfragetext, einschließlich der Inhalte neben der PDF. Bei großen PDFs solltest du die Files API verwenden und sie mit `file_id` referenzieren, damit der Anfragetext klein bleibt.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Claude.ai (die Web-App für Verbraucher) hat andere Limits: maximal 500 MB pro Datei und bis zu 20 Dateien in einem Chat. Die visuelle Analyse funktioniert jedoch nur bei PDFs mit bis zu 100 Seiten – bei längeren Dokumenten sieht Claude nur den Text, keine Diagramme oder Grafiken. Drei Möglichkeiten, eine PDF über die API zu senden: 1. **Per URL** – `"source": {"type": "url", "url": "..."}` – am einfachsten, wenn das Dokument online verfügbar ist. 2. **Als Base64** – `"source": {"type": "base64", "media_type": "application/pdf", "data": "..."}` – für lokale Dateien. 3. **Über die Files API** – `"source": {"type": "file", "file_id": "file_abc123"}` – für wiederholte Anfragen; erfordert den Beta-Header `anthropic-beta: files-api-2025-04-14`. Die Files API ist die wichtigste Möglichkeit, bei der Arbeit mit derselben PDF in verschiedenen Chats zu sparen. Lade die Datei einmal hoch, erhalte eine `file_id`, und verwende sie dann für alle Interaktionen. Mit `cache_control: ephemeral` kosten wiederholte Anfragen 10 % des regulären Preises. Anthropic gibt außerdem offizielle Hinweise, wie du die Nutzung minimieren kannst:

Dichte PDFs (mit viel kleinem Text, komplexen Tabellen oder vielen Grafiken) können das Kontextfenster füllen, bevor du das Seitenlimit erreichst. Teile das Dokument in Abschnitte auf. Bei großen Dateien kannst du vor dem Hochladen die Auflösung eingebetteter Bilder verringern.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
## Methode 1: Wie richtest du MarkItDown in 5 Minuten ein?
Das Wichtigste MarkItDown ist ein Python-Werkzeug des Microsoft-AutoGen-Teams, das PDFs, DOCX-, PPTX- und XLSX-Dateien, HTML, Audio, Bilder und sogar YouTube-Videos in sauberes Markdown umwandelt. Auf GitHub hat es 134 Tausend Sterne, steht unter MIT-Lizenz und lässt sich mit einem Befehl installieren: `pip install 'markitdown[all]'`. Die Bedienung ist ebenso einfach: `markitdown document.pdf > document.md`. Das vielseitigste Werkzeug, um Dateien vor der Verwendung mit Claude Code zu konvertieren.
MarkItDown ist ein offizielles Microsoft-Projekt, das vom AutoGen-Team betreut wird. Auf GitHub hat es 134 Tausend Sterne und 9,2 Tausend Forks (Stand: Ende Mai 2026). Sein Zweck wird direkt in der README beschrieben:

Ein leichtgewichtiges Python-Werkzeug, das Dateien für die Verwendung mit LLMs und Textanalyse-Pipelines in Markdown umwandelt.

— Microsoft, https://github.com/microsoft/markitdown
Unterstützte Formate: - **Dokumente:** PDF, DOCX, PPTX, XLSX - **Web:** HTML, JSON, XML, CSV - **Medien:** Audio mit Transkription, Bilder mit EXIF und OCR, YouTube-Videos (über Untertitel) - **Archive:** ZIP, EPub - **Sonstiges:** alle Anhänge in Outlook-MSG-Dateien ### Installation Voraussetzung: Python 3.10+ (unter macOS meist bereits installiert; unter Windows musst du es separat installieren). ```bash pip install 'markitdown[all]' ``` Wenn du nicht alle Formate benötigst, kannst du ausgewählte installieren: ```bash pip install 'markitdown[pdf, docx, pptx]' ``` ### Eine einzelne Datei konvertieren Der einfachste Fall: ```bash markitdown document.pdf > document.md ``` Danach erscheint `document.md` im aktuellen Ordner. Füge die Datei mit `@document.md` in Claude Code ein oder lege sie einfach neben dein Projekt. ### Python-API Wenn du das Werkzeug in dein Skript integrieren möchtest: ```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) ``` ### Was MarkItDown NICHT kann - **OCR für gescannte PDFs** – es gibt nichts zurück. Für Scans brauchst du PyMuPDF4LLM oder Docling. - **Komplexe Layouts mit mehreren Spalten** – die Lesereihenfolge kann durcheinandergeraten. - **Eingebettete URLs aus PDFs** – sie bleiben nicht erhalten. Für einfache PDFs (Berichte, Artikel, Dokumentation) ist MarkItDown die beste Wahl: ein vielseitiges Werkzeug, das in einer Minute installiert ist und keine Python-Kenntnisse erfordert. Wie es mit kyrillischem Text und Scans funktioniert, zeigen die Messungen in der Analyse zum [Konvertieren einer PDF in Text für KI](https://ailoot.ai/blog/de/markitdown-pdf-word-to-text/). ## Methode 2: Was bietet PyMuPDF4LLM, und wann ist es die bessere Wahl?
Das Wichtigste PyMuPDF4LLM ist ein Artifex-Software-Projekt, das auf der nativen C-Engine MuPDF basiert. Es ist der schnellste PDF-Konverter (keine GPU erforderlich); intelligente OCR wird nur auf unlesbare Bereiche angewendet und verkürzt die Verarbeitungszeit um 50 %. Es ist das einzige beliebte Werkzeug, das eingebettete URLs und Bilder aus PDFs erhält. Der Nachteil ist die duale Lizenzierung unter AGPL v3 oder einer kommerziellen Artifex-Lizenz: Bei SaaS-Projekten bedeutet AGPL, dass du deinen Code veröffentlichen musst.
MarkItDown bietet eine breite Formatunterstützung; PyMuPDF4LLM bietet eine tiefgehende PDF-Verarbeitung.

Eine leichtgewichtige PyMuPDF-Erweiterung, die PDFs mit minimalem Einrichtungsaufwand in saubere, strukturierte Daten umwandelt.

— Artifex Software, https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/
Die aktuelle Version vom 31. Mai 2026 ist 1.27.2.3 (veröffentlicht am 24. April 2026). ### Was ist enthalten? - Mehrspaltige Seiten mit korrekter Lesereihenfolge - Tabellen werden in GitHub-flavored Markdown umgewandelt - Kopf- und Fußzeilen werden automatisch entfernt - Bilder werden extrahiert und mit relativen Links in einem separaten Ordner abgelegt - Intelligente OCR: nur auf unlesbare Bereiche angewendet; spart etwa 50 % der Verarbeitungszeit - Native C-Engine, **keine GPU erforderlich** ### Installation ```bash pip install pymupdf4llm ``` ### Verwendung ```python import pymupdf4llm # Basic use - straight to Markdown: md_text = pymupdf4llm.to_markdown("document.pdf") # Save it: with open("document.md", "w") as f: f.write(md_text) ``` In einer Zeile, wie versprochen: ```bash python3 -c "import pymupdf4llm; \ open('document.md','w').write(pymupdf4llm.to_markdown('document.pdf'))" ``` ### Wann solltest du PyMuPDF4LLM statt MarkItDown wählen? - Wenn die PDF viele Links enthält, die du erhalten möchtest (MarkItDown verliert sie). - Wenn das Dokument gescannt ist und du OCR benötigst. - Wenn du lokal Tausende von Dateien schnell verarbeiten möchtest – die native C-Engine ist schneller als Python-Wrapper. - Wenn du Bilder aus der PDF in einem separaten Ordner zur Weiterverarbeitung benötigst. ### Lizenzdetails (wichtig für Unternehmen) PyMuPDF4LLM ist doppelt lizenziert: AGPL v3 ODER kommerzielle Artifex-Lizenz. **AGPL bedeutet:** Wenn du die Bibliothek in einem öffentlichen SaaS verwendest, musst du den gesamten Quellcode deines Dienstes unter derselben AGPL veröffentlichen. Für die interne Nutzung (dein Skript auf deinem Laptop) gibt es keine Einschränkungen. Für die kommerzielle Entwicklung ohne Offenlegung des Codes kannst du eine Lizenz von Artifex (artifex.com) erwerben. Preise sind nicht veröffentlicht; du kannst sie beim Vertrieb anfragen. Wenn du ein Produkt für Kunden entwickelst, prüfe die Lizenz zu Beginn. MarkItDown (MIT) und Docling (MIT) sind für SaaS sicherer. ## Methode 3: Claude Code MCP einrichten und MarkItDown verbinden {#methode-3-wie-verbindest-du-den-markitdown-mcp-server-mit-claude-code}
Das Wichtigste Der MarkItDown-MCP-Server ist dasselbe MarkItDown, verpackt im MCP-Protokoll. Dadurch kann Claude Code PDFs bei Bedarf konvertieren, ohne die Originaldatei in den Kontext zu laden. Die Verbindung wird mit einem einzigen Befehl über uv hergestellt; die Version ist festgelegt: `markitdown-mcp@0.0.1a7`. Das Werkzeug für Claude heißt `convert_to_markdown(uri)`. Im Leerlauf kostet die Beschreibung des Skills etwa 110 Tokens; wenn sie nicht benötigt wird, kostet sie nichts.
MarkItDown im CLI-Modus bedeutet: „Ich konvertiere Dateien vorher manuell.“ Der MCP-Server bedeutet: „Claude Code entscheidet, wann konvertiert wird.“ ### Installation Du brauchst den Paketmanager uv. Der Server muss nicht separat installiert werden; uv lädt ihn beim ersten Start herunter. ### Konfiguration in Claude Code Ein Befehl verbindet den Server mit all deinen Projekten; die Version ist festgelegt: ```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 ``` Beim Eintrag `markitdown` sollte „Connected“ stehen. Beim ersten Start werden etwa siebzig Pakete heruntergeladen; das dauert bis zu einer Minute. Danach startet der Server in ein bis zwei Sekunden. Die beiden Variablen im Befehl haben folgenden Grund: `ORT_DISABLE_TELEMETRY=1` deaktiviert Statistiken, die die im Server enthaltene onnxruntime-Engine unter Mac und Linux standardmäßig an Microsoft sendet. `UV_PYTHON=3.12` führt den Server mit Python 3.12 aus, für das unter Windows, Linux und auf Macs mit Apple Silicon vorgefertigte Pakete verfügbar sind. Auf Intel-Macs sowie unter macOS 13 und früher lässt sich der Server mit Python 3.14 nicht installieren. Für Intel und Python 3.12 gilt eine Einschränkung: uv erstellt die Kryptografiebibliothek aus dem Quellcode, da seit Juni 2026 kein vorgefertigtes Intel-Paket verfügbar ist. Die Installation dauert länger und kann fehlschlagen. Wenn Python 3.12 nicht installiert ist, lädt uv es herunter. Der Server läuft direkt auf deinem Computer und kann jede Datei öffnen, auf die du Zugriff hast. Wenn Claude Code bereits geöffnet war, starte es neu; danach erscheint `markitdown` in der Liste der MCP-Server. ### Verwendung Sag in Claude Code einfach: ``` Convert /Users/your-user/Documents/report.pdf to Markdown and analyze the main points. ``` Claude ruft selbst `convert_to_markdown(uri)` auf, erhält das Markdown und verarbeitet es – die PDF wird überhaupt nicht in den Kontext geladen. ### Unterstützte URIs - `file://` – lokale Dateien - `http://`, `https://` – Online-Dokumente - `data:` – Inline-Daten (Base64) ### Sicherheit Aus der offiziellen README:

Der Server unterstützt keine Autorisierung und läuft mit den Berechtigungen des Benutzers, der ihn gestartet hat.

— Microsoft, https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp
Standardmäßig ist der Server an localhost gebunden. Wenn du ihn über HTTP/SSE ausführst (Option `--http --host 127.0.0.1 --port 3001`), solltest du den Port nicht ohne authentifizierten Reverse-Proxy nach außen öffnen. ## Welche Methode solltest du für deine Aufgabe wählen?
Das Wichtigste MarkItDown ist der Allrounder, wenn du mit unterschiedlichen Formaten arbeitest (PDF + DOCX + PPTX + YouTube) und einen schnellen CLI-Befehl brauchst. PyMuPDF4LLM ist der PDF-Spezialist: schneller, mit OCR und Linkerhalt, aber eine AGPL-Falle für SaaS. Docling ist für den Produktionseinsatz ausgelegt und verarbeitet Tabellen und Formeln am besten. Marker eignet sich für wissenschaftliche Arbeiten mit Mathematik. Der MCP-Server ist richtig, wenn du dich nicht mit der Konvertierung befassen möchtest und Claude Code selbst entscheiden soll.
Ausführliche Vergleichstabelle: | Tool | GitHub-Sterne | Am besten für | Geschwindigkeit | Lizenz | |----|----|----|----|----| | **MarkItDown** (Microsoft) | 134k | PDF + DOCX + PPTX + YouTube + Audio | Mittel | MIT | | **PyMuPDF4LLM** (Artifex) | \- | Native PDF-Verarbeitung, OCR, eingebettete URLs | Am schnellsten (keine GPU) | AGPL v3 / kommerziell | | **Docling** (IBM Research) | 60,7k | Produktionseinsatz von RAG, Tabellen, Formeln | Mittel | MIT | | **Marker** (datalab.to) | 35,6k | Wissenschaftliche PDFs, arXiv, Formeln | Hoch (mit GPU) | GPL-3.0 + Open Rail-M | | **MinerU** | \- | CJK-Dokumente (Chinesisch/Japanisch) | Hoch | Apache-2.0 | Marker nennt beeindruckende Genauigkeitswerte aus Benchmarks:

0,18 Sekunden pro Seite auf einer H100-GPU (122 Seiten pro Sekunde). Genauigkeit von 95,67 % gegenüber Llamaparse (84,24 %) und Mathpix (86,43 %). Bei wissenschaftlichen Arbeiten sind es 96,67 %.

— datalab.to, https://github.com/datalab-to/marker
Marker braucht jedoch eine GPU, um schnell zu arbeiten, und bringt Machine-Learning-Modelle mit. Für die meisten Aufgaben mit gewöhnlichen Text-PDFs reichen PyMuPDF4LLM oder MarkItDown aus; beide erledigen die Arbeit in Sekunden und ohne GPU. ### Eine einfache Entscheidungsregel 1. **Eine oder zwei PDFs, schnell erledigt** – MarkItDown CLI. 2. **Dutzende PDFs, Automatisierung erforderlich** – MarkItDown MCP-Server oder PyMuPDF4LLM in einem Skript. 3. **PDFs mit Links und Bildern, bei denen der Erhalt der Struktur wichtig ist** – PyMuPDF4LLM. 4. **Produktionseinsatz von RAG für Unternehmen, bei dem stabile Tabellen wichtig sind** – Docling. 5. **Wissenschaftliche Arbeiten mit Formeln** – Marker. 6. **Du möchtest dich nicht damit befassen und Claude soll die Konvertierung übernehmen** – MarkItDown MCP-Server. ## Wie schreibst du ein sofort nutzbares Skript, das einen Dokumentenordner automatisch konvertiert?
Das Wichtigste Am praktischsten ist ein Bash-Skript, das einen Projektordner durchgeht, alle PDF-, DOCX- und PPTX-Dateien in Markdown umwandelt und sie in einem Unterordner `_md/` ablegt. Richte es einmal ein, und jeder neue Dokumentenordner wird in einem Durchgang „Claude-lesbar“. Füge anschließend `_md/` mit `@_md/` in Claude Code ein und arbeite mit dem komprimierten Text.
Ein praktisches Beispiel: Angenommen, du hast in einem Ordner 40 PDF- und PPTX-Berichte von Kunden – Kontoauszüge, Verträge und Präsentationen. Den ganzen Ordner direkt in Claude hochzuladen, ist nutzlos: Das Kontextfenster ist voll, bevor du die erste Antwort erhältst. Lass den ganzen Ordner in einem Durchgang durch das folgende Skript laufen und arbeite dann mit schlanken `.md`-Dateien statt mit großen PDFs weiter. Speichere dieses Skript im Projektstamm unter `scripts/docs-to-md.sh`: ```bash #!/bin/bash # docs-to-md.sh - converts all documents in a folder to Markdown using MarkItDown # Usage: 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" ``` Mach es ausführbar: ```bash chmod +x scripts/docs-to-md.sh ``` Führe es aus: ```bash bash scripts/docs-to-md.sh ./reports ``` Nach dem Lauf enthält `./reports/_md/` Markdown-Versionen aller Dokumente. Füge sie mit `@reports/_md/` in Claude Code ein und arbeite statt mit PDFs mit dem komprimierten Text weiter. Das Skript überspringt automatisch bereits konvertierte Dateien (wenn die `.md`-Datei neuer ist als die Quelldatei). Ein erneuter Lauf ist günstig und berechnet nicht alles neu. ### Idempotenz und inkrementelle Konvertierung Wenn das Skript Änderungen an PDFs erkennen soll, die unter demselben Namen erneut gespeichert wurden, ergänze eine Prüfung des Inhaltshashs: ```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" ``` Diese Version konvertiert eine Datei nur dann erneut, wenn sich ihr Inhalt geändert hat. ## Wann ist eine PDF in Claude trotzdem besser als Markdown?
Das Wichtigste Bei der Markdown-Konvertierung gehen drei Dinge verloren: visuelle Elemente (Diagramme, Grafiken, Baupläne), komplexe Tabellen mit verbundenen Zellen und Bildunterschriften sowie die vollständige Formatierung des Dokuments als Beleg (etwa ein Vertrag, den du mit Seitenangabe zitieren musst). Wenn diese Aspekte für die Aufgabe wichtig sind, behalte die PDF, aktiviere die visuelle Analyse und nimm die visuellen Kosten bewusst in Kauf.
Drei Fälle, in denen die Markdown-Konvertierung an ihre Grenzen stößt: ### 1. Visuelle Analyse von Diagrammen und Grafiken Wenn Claude ein Diagramm „lesen“ muss – etwa eine Preiskurve, ein Ablauf- oder Architekturdiagramm –, stehen diese Informationen nicht im Markdown. Markdown bewahrt nur Bildunterschriften; die Abbildung selbst geht verloren. Lösung: Lade die PDF hoch und aktiviere ausdrücklich den visuellen Modus. In der Claude-API funktioniert die Einstellung automatisch; bei AWS Bedrock brauchst du die Einstellung `citations`.

Claude analysiert sowohl Text als auch Bilder, um das Dokument besser zu verstehen.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
### 2. Komplexe Tabellen mit verbundenen Zellen Markdown-Tabellen sind flach. Wenn die PDF eine Tabelle mit verbundenen Zellen, mehrstufigen Kopfzeilen oder verschachtelten Untertabellen enthält, wird der Konverter sie entweder abflachen oder die Beziehungen zwischen den Elementen verlieren. Lösung: Verwende die PDF direkt, nutze Docling (am besten für komplexe Tabellen geeignet) oder formatiere die Tabelle nach der Konvertierung manuell. ### 3. Dokumente als Belege mit Seitenangaben Bei Rechtsdokumenten, Verträgen und Sitzungsprotokollen ist es wichtig, „Seite 7, Absatz 3“ zitieren zu können. Seitenzahlen gehen in Markdown verloren. Lösung: PDF + Files API + Prompt-Caching. Lade die Datei einmal hoch und verweise anschließend mit `file_id` darauf. Claude sieht die Seitennummerierung und kann konkrete Seiten zitieren. ### Kurze Dokumente Wenn eine PDF weniger als 2 Seiten hat und du sie nur einmal verwendest, lohnt sich die Konvertierung nicht. 5.000 Tokens für eine PDF gegenüber 800 für Markdown bedeuten keine ausreichende Einsparung, um die Installation von MarkItDown zu rechtfertigen. Der Punkt, ab dem es sich rechnet, liegt bei etwa 5 oder mehr Seiten beziehungsweise 2 oder mehr Verwendungen desselben Dokuments. Darunter kannst du die PDF direkt hochladen; darüber solltest du sie konvertieren. ## Was sind die 5 häufigsten Fehler im Umgang mit PDFs in Claude?
Das Wichtigste Die häufigsten Fehler: dieselbe PDF in verschiedenen Chats erneut hochladen, statt sie einmal zu konvertieren; Prompt-Caching bei wiederholten Anfragen nicht verwenden; Screenshots statt Text nutzen; gescannte PDFs nicht per OCR verarbeiten; und das 100-Seiten-Limit für Modelle mit 200K Kontext ignorieren. Jeder dieser Fehler verschwendet ohne guten Grund Zehntausende Tokens.
### 1. Dieselbe PDF bei jedem neuen Chat erneut hochladen Claude Pro hat ein Nachrichtenlimit für einen Zeitraum von 5 Stunden – ein einziger 50-seitiger Bericht kann es aufbrauchen, bevor du eine zweite Frage stellst. Dafür gibt es ein einfaches Prinzip: **eine Aufgabe – ein Chat**. Wenn die KI absurd viele Tokens verbraucht, stopfst du vermutlich alles in einen Chat und fügst die PDF immer wieder hinzu. Erledige in jedem Fenster nur eine kleine Aufgabe. Konvertiere das Dokument einmal in Markdown und füge die `.md`-Datei zusammen mit dem Projekt in jedes neue Fenster ein. Der Kreis für das Kontextfenster wird nicht gelb. Lösung: Konvertiere sie einmal in Markdown oder verwende die Files API mit `file_id` und Prompt-Caching. ### 2. Screenshot statt Text Ein typisches Beispiel: Jemand möchte Claude einen Codeabschnitt oder eine Tabelle zeigen, macht einen Screenshot des gesamten 1920×1080-Bildschirms und wundert sich, warum das Limit nach 5 Anfragen aufgebraucht ist. Ein Screenshot mit 1000×1000 Pixeln kostet etwa 1.300 Tokens. Derselbe Text kostet beim manuellen Kopieren 50–100 Tokens. Das ist ein 13- bis 26-facher Unterschied. Lösung: Schneide Screenshots eng auf den wichtigen Bereich zu oder kopiere noch besser den Text direkt. ### 3. Eine gescannte PDF ohne OCR MarkItDown kann keine OCR. Wenn du einen Scan konvertierst, ist das Ergebnis eine leere `.md`-Datei (oder 3 Zeilen unleserlicher Text). Lösung: Verwende für Scans PyMuPDF4LLM mit seiner integrierten intelligenten OCR oder Docling. ### 4. Das 100-Seiten-Limit ignorieren Anthropics Dokumentation nennt ein Limit von 600 Seiten pro Anfrage. In der Praxis gilt für Modelle mit 200K Kontext (Sonnet 4.x, Opus 4.x) jedoch ein Limit von **100 Seiten**. Das Limit von 600 Seiten ist für ältere Modelle oder spezielle Stufen vorgesehen. Wenn du einen 150-seitigen Bericht in Sonnet 4.6 hochlädst, erhältst du eine Fehlermeldung oder – schlimmer noch – Claude verarbeitet nur die ersten 100 Seiten und tut so, als hätte es das gesamte Dokument gelesen. Lösung: Teile lange PDFs vor dem Hochladen in Abschnitte auf. Oder konvertiere sie in Markdown – dort gibt es kein Seitenlimit, sondern nur ein Tokenlimit. ### 5. Prompt-Caching bei wiederholten Anfragen nicht verwenden Wenn du über die API mit demselben Dokument arbeitest, umschließe es mit `cache_control: ephemeral`. Wiederholte Anfragen innerhalb von 5 Minuten kosten 10 % des ursprünglichen Preises. Eine Anfrage kostet mehr; die übrigen erhalten 90 % Rabatt. Lösung: Aktiviere Prompt-Caching standardmäßig für alles, was du mehr als einmal hochlädst. ## Wie geht es weiter: Context Engineering
Das Wichtigste PDFs in Markdown umzuwandeln ist eine Context-Engineering-Technik und eine neue Kompetenz im Umgang mit KI. Ein Prompt ist eine Frage. Kontext ist alles, was Claude vor und rund um die Frage sieht: der System-Prompt, CLAUDE.md, Dateien, MCP-Server und der Sitzungsverlauf. Je sauberer der Kontext, desto genauer die Antwort und desto geringer die Kosten. Die vollständige Analyse findest du im Leitfaden „Context Engineering im Jahr 2026“.
PDFs in Markdown umzuwandeln ist eine Möglichkeit, Tokens zu sparen. Für sich genommen macht das Claudes Antworten nicht genauer. Genauigkeit entsteht durch **Context Engineering** – die bewusste Gestaltung dessen, was du in den Kontext des Modells einfügst, bevor du eine Frage stellst. Wenn deine `CLAUDE.md` 800 Zeilen hat, dein Projekt 10 unnötige MCP-Server enthält und du eine 100-seitige PDF hinzufügst, verhindert die Markdown-Konvertierung zwar einen dieser Verluste, aber die anderen drei bleiben. Deshalb behandeln diese Leitfäden folgende Themen: - [Wohin die Tokens in Claude Code gehen](https://ailoot.ai/blog/de/where-claude-code-tokens-go/) – 9 Muster für Kontextverluste, nicht nur bei PDFs. - [Context Engineering im Jahr 2026](https://ailoot.ai/blog/de/context-engineering/) – systematische Verwaltung von Kontext. - [Planmodus in Claude Code](https://ailoot.ai/blog/de/claude-code-plan-mode/) – der Planmodus, bevor Claude mit dem Schreiben von Code beginnt.
### Quellen - [Anthropic – PDF-Unterstützung (platform.claude.com)](https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support) - [Anthropic – Dateien in Claude hochladen (support.claude.com)](https://support.claude.com/en/articles/8241126-upload-files-to-claude) - [Microsoft MarkItDown auf GitHub](https://github.com/microsoft/markitdown) - [MarkItDown-MCP-Server](https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp) - [PyMuPDF4LLM – offizielle Dokumentation](https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/) - [Docling auf GitHub (IBM Research)](https://github.com/DS4SD/docling) - [Marker auf GitHub (datalab.to)](https://github.com/datalab-to/marker)
Entdecke Ailoot weiter auf [ailoot.ai](https://ailoot.ai/).
## Fragen und Antworten ### Wie viele Markdown-Tokens braucht das Beispiel mit 15 Seiten und vier Chats? Mit der Annahme von 300 Tokens je konvertierter Seite sind es 15 × 300 × 4 = 18.000 Eingabetokens. Das ist eine Beispielschätzung. Zähle für deine Datei die Tokens des tatsächlich konvertierten Dokuments. ### Reicht eine Textkonvertierung für jedes PDF? Nein. Vergleiche Markdown und PDF, besonders Tabellen, Seitenfolge und bildabhängige Inhalte. Vergleiche Tokenverbrauch erst, nachdem die für deine Aufgabe nötigen Informationen die Konvertierung nachweislich überstanden haben. ## Ailoot · Das Unternehmen und sein Projektportfolio Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle. Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe. Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.