# PDF-filer i Claude Code: konvertering, tokens og bevarelse af struktur > MarkItDown, PyMuPDF4LLM, MCP, komplette konverteringsscripts, PDF-begrænsninger og tilfælde, hvor visuel analyse er vigtigere end tokenbesparelser. Source: https://ailoot.ai/blog/da/pdf-claude-code-markdown/ Canonical: https://ailoot.ai/blog/da/pdf-claude-code-markdown/ Language: da Publisher: Ailoot (https://ailoot.ai/) Translation: guide-196 Revision: sha256-262d465ca9e5c2b3535732635d5f0d6a7c673ff8082333c61aa6cef2465d12d2
Vigtigste pointe Hver PDF-side i Claude Code koster 1.500–3.000 tokens, før du stiller det første spørgsmål – og Anthropic siger det helt tydeligt i sin dokumentation. I den illustrative beregning nedenfor bruger en rapport på 15 sider i 4 forskellige chats 135.000 PDF-inputtokens til cirka 0,40 $ mod 18.000 Markdown-inputtokens til 0,054 $, cirka 87% mindre. Det antager 2.250 PDF-tokens eller 300 Markdown-tokens pr. side til eksemplets inputpris; faktiske dokumenter varierer. Denne guide gennemgår tre konverteringsmetoder (MarkItDown, PyMuPDF4LLM og en MCP-server) samt et bash-script, der er klar til brug på en mappe med dokumenter.
Praktiske instruktioner til brug af Ailoot findes i [dokumentationen](https://ailoot.ai/docs/).
## Hvad sker der med en PDF i Claude, og hvorfor koster hver side 1.500–3.000 tokens?
Vigtigste pointe Når du uploader en PDF til Claude Code, læser det den ikke som en tekstfil. Først konverteres hver side til et billede, derefter udtrækkes teksten fra den, og begge lag – billedet og teksten – føjes til konteksten samtidig. Derfor fylder én side 1.500–3.000 tokens, og et dokument på 50 sider kan bruge 75.000–150.000 tokens, før du stiller dit første spørgsmål.
Anthropics officielle dokumentation beskriver processen i tre enkle trin:

Systemet konverterer hver dokumentside til et billede. Tekst fra hver side udtrækkes og leveres sammen med sidebilledet. Claude analyserer både teksten og billederne for bedre at forstå dokumentet.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Det lyder logisk, men behandlingsomkostningerne vokser lineært med antallet af sider. Og her er tallet, der forklarer, hvorfor din abonnementsgrænse opbruges af én enkelt PDF:

Hver side bruger typisk 1.500–3.000 tokens afhængigt af indholdstætheden. Da hver side konverteres til et billede, gælder samme omkostning som for almindelige billeder.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
For at vise, hvor meget det er, målte Anthropic den samme PDF på 3 sider på Bedrock i to tilstande. I teksttilstand (Converse Document Chat) brugte den ~1.000 tokens. Med visuel analyse (Claude PDF Chat) brugte den ~7.000 tokens. Når billeder medtages, bliver behandlingen **7 gange dyrere**. Skærmbilleder af sider er endnu værre. Et skærmbillede på 1000×1000 pixels koster omkring 1.300 tokens. Mekanismen er enkel: PDF-filer er dyre, fordi Claude ikke stoler på sin OCR. Den bruger både tekst og billede, så den kan sammenligne dem – og du betaler for begge lag på én gang. Med store dokumenter kan du gøre det anderledes: Gem filen som Markdown i projektmappen, og sig til Claude: »her er et dokument med information i – fordel det«. Den fordeler indholdet mellem sine egne filer og fortsætter arbejdet med den organiserede tekst i stedet for at bruge det hele på én gang. ## Hvor meget bruger en PDF i en typisk opgave?
Vigtigste pointe Betragt en offentlig rapport på 15 sider brugt i 4 sammenhænge: analyse, citater, oversættelse og resumé. Antag 2.250 inputtokens pr. PDF-side, 300 pr. konverteret Markdown-side og samme inputpris for begge. Gentagen PDF-upload giver 135.000 inputtokens til cirka 0,40 $; Markdown giver 18.000 til 0,054 $. Besparelsen på cirka 87% følger af disse antagelser, ikke af en måling af enhver PDF.
De konkrete tal (Sonnet 4.x-model, input til 3 $ pr. million tokens): | Fremgangsmåde | Tokens (15 sider, 4 chats) | Omkostning | |------------------------------|-----------------------------|-------------| | PDF uploadet direkte 4 gange | 15 × 2250 × 4 = **135.000** | ~0,40 $ | | PDF → Markdown + 4 chats | 15 × 300 × 4 = **18.000** | ~0,054 $ | | Besparelse | **−87 %** | **−0,35 $** | Og det er kun for én cyklus med 4 forespørgsler. Derefter kommer promptcaching i spil (5 minutters TTL som standard, op til 1 time på et udvidet niveau, med op til 90 % rabat på gentagne kald inden for tidsvinduet) – besparelsen bliver endnu større. Hver gang du uploader den samme PDF i en ny chat, læser Claude den igen; cachen følger ikke med mellem chats. Hvis du konverterer samme PDF på 15 sider til Markdown én gang og derefter medtager den som `.md`-fil i hver af fire nye chats, bruger eksemplet 15 × 300 × 4 = 18.000 inputtokens frem for 135.000. De 300 tokens pr. konverteret side og 2.250 tokens pr. PDF-side er antagelser i beregningen, ikke målte konstanter for enhver PDF. Tæl dit faktiske dokument, og bekræft konverteringskvaliteten før beregning af besparelser. Regnestykket bliver endnu vigtigere med et Claude Pro-abonnement. Én rapport på 100 sider kan opbruge hele grænsen på 5 timer. Efter konvertering til Markdown kan 10+ sådanne dokumenter være inden for samme budget. ## Hvilke API-grænser har Anthropic for PDF-filer i 2026?
Vigtigste pointe Anthropic har strenge grænser: højst 32 MB pr. forespørgsel (inklusive alt indhold, ikke kun PDF-filen) og højst 600 sider pr. forespørgsel. Men grænsen er lavere for de aktuelle Sonnet 4.x- og Opus 4.x-modeller med 200K kontekst: **100 sider**. Du kan sende en PDF på tre måder: via URL, i Base64 eller via Files API til genbrug med `file_id`. Files API sammen med opdeling i dele bruges til lange dokumenter.
Anthropics dokumentation angiver grænserne øverst (aktuelle pr. 31. maj 2026): | Krav | Grænse | |-----------------------------|--------------------------------------------| | Maksimal størrelse på forespørgsel | 32 MB (varierer efter platform) | | Maksimalt antal sider pr. forespørgsel | 600 (100 for modeller med 200K-tokenkontekst) | | Format | Standard-PDF uden adgangskode eller kryptering |

Begge grænser gælder hele forespørgslens indhold, også indhold ved siden af PDF-filen. Brug Files API til store PDF-filer, og henvis til dem med `file_id` for at holde forespørgslens indhold lille.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
Claude.ai (forbrugernes webapp) har andre grænser: højst 500 MB pr. fil og op til 20 filer i en chat. Visuel analyse fungerer dog kun for PDF-filer på op til 100 sider – ud over det ser Claude kun tekst, uden diagrammer og illustrationer. Tre måder at sende en PDF gennem API'et på: 1. **Via URL** - `"source": {"type": "url", "url": "..."}` - enklest, når dokumentet er online. 2. **I Base64** - `"source": {"type": "base64", "media_type": "application/pdf", "data": "..."}` - til lokale filer. 3. **Via Files API** - `"source": {"type": "file", "file_id": "file_abc123"}` - til gentagne forespørgsler; kræver beta-headeren `anthropic-beta: files-api-2025-04-14`. Files API er den vigtigste måde at spare på, når du arbejder med den samme PDF i forskellige chats. Upload den én gang, få et `file_id`, og brug det derefter til alle interaktioner. Med `cache_control: ephemeral` koster gentagne kald 10 % af den normale pris. Anthropic giver også officielle råd om at minimere forbruget:

Tætte PDF-filer (med meget lille tekst, komplekse tabeller eller mange grafikker) kan fylde kontekstvinduet, før du når sidegrænsen. Prøv at dele dokumentet op i afsnit; for store filer kan du reducere opløsningen på indlejrede billeder, før du uploader dem.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
## Metode 1: Sådan konfigurerer du MarkItDown på 5 minutter
Vigtigste pointe MarkItDown er et Python-værktøj fra Microsoft AutoGen-teamet, der konverterer PDF, DOCX, PPTX, XLSX, HTML, lyd, billeder og endda YouTube-videoer til ren Markdown. Det har 134 tusind stjerner på GitHub, en MIT-licens og installeres med én kommando: `pip install 'markitdown[all]'`. Det er lige så nemt at bruge: `markitdown document.pdf > document.md`. Det mest alsidige værktøj til at konvertere filer, før du bruger Claude Code.
MarkItDown er et officielt Microsoft-projekt, som vedligeholdes af AutoGen-teamet. På GitHub har det 134 tusind stjerner og 9,2 tusind forks (ved udgangen af maj 2026). Formålet står direkte i README-filen:

Et letvægtsværktøj i Python til at konvertere filer til Markdown til brug med LLM'er og tekstanalysescripts.

— Microsoft, https://github.com/microsoft/markitdown
Understøttede formater: - **Dokumenter:** PDF, DOCX, PPTX, XLSX - **Web:** HTML, JSON, XML, CSV - **Medier:** lyd med transskription, billeder med EXIF og OCR, YouTube-videoer (via undertekster) - **Arkiver:** ZIP, EPub - **Andet:** alle vedhæftede filer i Outlook MSG-filer ### Installation Krav: Python 3.10+ (normalt allerede installeret på macOS; på Windows skal du installere det separat). ```bash pip install 'markitdown[all]' ``` Hvis du ikke har brug for alle formater, kan du installere udvalgte formater: ```bash pip install 'markitdown[pdf, docx, pptx]' ``` ### Konvertering af en enkelt fil Det enkleste tilfælde: ```bash markitdown document.pdf > document.md ``` Derefter vises `document.md` i den aktuelle mappe. Tag den med i Claude Code med `@document.md`, eller læg den ved siden af projektet. ### Python-API Hvis du vil integrere det i dit script: ```python from markitdown import MarkItDown md = MarkItDown() result = md.convert("research-paper.pdf") print(result.text_content) # Du kan gemme den med det samme: with open("research-paper.md", "w") as f: f.write(result.text_content) ``` ### Hvad MarkItDown IKKE kan - **OCR af scannede PDF-filer** - det returnerer ingenting. Scanninger kræver PyMuPDF4LLM eller Docling. - **Komplekse layouts med flere kolonner** - det kan forvrænge læserækkefølgen. - **Indlejrede URL'er fra PDF-filer** - det bevarer dem ikke. Til enkle PDF-filer (rapporter, artikler, dokumentation) er MarkItDown det bedste valg: et alsidigt værktøj, der installeres på et minut og ikke kræver kendskab til Python. Dets ydeevne med kyrillisk tekst og scanninger vises i målingerne i analysen af, hvordan du kan [konvertere en PDF til tekst til AI](https://ailoot.ai/blog/da/markitdown-pdf-word-to-text/). ## Metode 2: Hvad tilbyder PyMuPDF4LLM, og hvornår er det bedre?
Vigtigste pointe PyMuPDF4LLM er et Artifex Software-projekt baseret på den indbyggede C-motor MuPDF. Det er den hurtigste PDF-konverter (GPU er ikke nødvendig); smart OCR anvendes kun på ulæselige områder og reducerer behandlingstiden med 50 %. Det er det eneste populære værktøj, der bevarer indlejrede URL'er og billeder fra PDF-filer. Ulempen er den dobbelte AGPL v3-/Artifex-kommercielle licens: For SaaS-projekter betyder AGPL, at du skal offentliggøre din kode.
MarkItDown tilbyder bredde i formater; PyMuPDF4LLM tilbyder dybde i PDF-behandling.

En letvægtsudvidelse til PyMuPDF, der gør PDF-filer til rene, strukturerede data med minimal opsætning.

— Artifex Software, https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/
Versionen pr. 31. maj 2026 er 1.27.2.3 (udgivet 24. april 2026). ### Hvad følger med - Sider med flere kolonner i korrekt læserækkefølge - Tabeller konverteret til GitHub-flavored Markdown - Sidehoveder og sidefødder fjernes automatisk - Billeder udtrækkes med relative links til en separat mappe - Smart OCR: bruges kun på ulæselige områder og sparer ~50 % af behandlingstiden - Indbygget C-motor, **GPU er ikke nødvendig** ### Installation ```bash pip install pymupdf4llm ``` ### Brug ```python import pymupdf4llm # Grundlæggende brug - direkte til Markdown: md_text = pymupdf4llm.to_markdown("document.pdf") # Gem den: with open("document.md", "w") as f: f.write(md_text) ``` På én linje, som lovet: ```bash python3 -c "import pymupdf4llm; \ open('document.md','w').write(pymupdf4llm.to_markdown('document.pdf'))" ``` ### Hvornår skal du vælge PyMuPDF4LLM frem for MarkItDown? - Når PDF-filen har mange links, du skal bevare (MarkItDown mister dem). - Når dokumentet er scannet, og du har brug for OCR. - Når du har brug for hurtig behandling af tusindvis af filer lokalt – den indbyggede C-motor er hurtigere end Python-wrappere. - Når du har brug for billeder fra PDF-filen i en separat mappe til videre behandling. ### Licensdetaljer (vigtigt for virksomheder) PyMuPDF4LLM har dobbeltlicens: AGPL v3 ELLER Artifex kommerciel licens. **AGPL betyder:** Hvis du bruger biblioteket i en offentlig SaaS-tjeneste, skal du offentliggøre hele tjenestens kildekode under samme AGPL. Til intern brug (dit script på din bærbare computer) er der ingen begrænsninger. Hvis du udvikler kommercielt uden at offentliggøre koden, skal du købe en licens fra Artifex (artifex.com). Priserne offentliggøres ikke; spørg salgsafdelingen. Hvis du bygger et produkt til kunder, skal du tjekke licensen fra starten. MarkItDown (MIT) og Docling (MIT) er sikrere til SaaS. ## Metode 3: Sådan forbinder du MarkItDown MCP-serveren med Claude Code
Vigtigste pointe MarkItDown MCP-serveren er det samme MarkItDown pakket ind i MCP-protokollen, så Claude Code kan konvertere PDF-filer løbende uden at indlæse originalfilen i konteksten. Forbind den med én kommando via uv; versionen er fastlåst: `markitdown-mcp@0.0.1a7`. Det værktøj, Claude får, er `convert_to_markdown(uri)`. Tomgangsomkostningen er ~110 tokens for færdighedsbeskrivelsen og nul, når den ikke er nødvendig.
MarkItDown i CLI-tilstand betyder »jeg konverterer filer manuelt på forhånd«; MCP-serveren betyder »Claude Code beslutter, hvornår det skal konverteres«. ### Installation Du skal bruge pakkehåndteringen uv. Det er ikke nødvendigt at installere serveren separat; uv downloader den første gang, den køres. ### Konfiguration i Claude Code Én kommando forbinder serveren med alle dine projekter, og versionen er fastlåst: ```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 ``` Posten `markitdown` bør vise »Connected«. Første opstart downloader omkring halvfjerds pakker og tager op til et minut; derefter starter serveren på et sekund eller to. Her er grunden til, at kommandoen har brug for de to variabler. `ORT_DISABLE_TELEMETRY=1` deaktiverer statistik, som onnxruntime-motoren i serveren som standard sender til Microsoft på Mac og Linux. `UV_PYTHON=3.12` kører serveren med Python 3.12, som har forbyggede pakker til Windows, Linux og Mac-computere med Apple Silicon. På Intel-Mac-computere og macOS 13 og tidligere installeres serveren ikke med Python 3.14. Der er et forbehold ved Intel og 3.12: uv bygger kryptografibiblioteket fra kildekoden, fordi der ikke har været en forbygget Intel-pakke til rådighed siden juni 2026. Installationen tager længere tid og kan mislykkes. Hvis du ikke har Python 3.12, downloader uv det for dig. Serveren kører direkte på din computer og kan åbne alle filer, du har adgang til. Hvis Claude Code var åbent, skal du genstarte det, hvorefter `markitdown` vises på listen over MCP-servere. ### Sådan bruger du den Sig blot følgende i Claude Code: ``` Konvertér /Users/your-user/Documents/report.pdf til Markdown, og analysér hovedpunkterne. ``` Claude kalder selv `convert_to_markdown(uri)`, henter Markdown og arbejder med den – PDF-filen indlæses slet ikke i konteksten. ### Understøttede URI'er - `file://` - lokale filer - `http://`, `https://` - dokumenter online - `data:` - indlejrede data (Base64) ### Sikkerhed Fra den officielle README:

Serveren understøtter ikke autorisation og kører med de tilladelser, som brugeren, der startede den, har.

— Microsoft, https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp
Som standard er den bundet til localhost. Hvis du kører den over HTTP/SSE (indstillingen `--http --host 127.0.0.1 --port 3001`), må du ikke eksponere porten eksternt uden en autentificeret reverse proxy. ## Hvilken metode skal du vælge til din opgave?
Vigtigste pointe MarkItDown er et allroundværktøj, hvis du arbejder med forskellige formater (PDF + DOCX + PPTX + YouTube) og har brug for en hurtig CLI-kommando. PyMuPDF4LLM er PDF-specialisten: hurtigere, med OCR og bevarelse af links, men en AGPL-fælde for SaaS. Docling er produktionsklar og håndterer tabeller og formler bedst. Marker er til videnskabelige artikler med matematik. MCP-serveren er til dig, der ikke vil tænke på konvertering og vil lade Claude Code beslutte selv.
Udvidet sammenligningstabel: | Værktøj | GitHub-stjerner | Bedst til | Hastighed | Licens | |----|----|----|----|----| | **MarkItDown** (Microsoft) | 134k | PDF + DOCX + PPTX + YouTube + lyd | Middel | MIT | | **PyMuPDF4LLM** (Artifex) | \- | Native PDF, OCR, indlejrede URL'er | Hurtigst (ingen GPU) | AGPL v3 / kommerciel | | **Docling** (IBM Research) | 60.7k | Produktions-RAG, tabeller, formler | Middel | MIT | | **Marker** (datalab.to) | 35.6k | Videnskabelige PDF-filer, arXiv, formler | Høj (med GPU) | GPL-3.0 + Open Rail-M | | **MinerU** | \- | CJK-dokumenter (kinesisk/japansk) | Høj | Apache-2.0 | Marker viser imponerende nøjagtighedstal i benchmarks:

0,18 sekunder pr. side på en H100-GPU (122 sider pr. sekund). Nøjagtighed på 95,67 % sammenlignet med Llamaparse (84,24 %) og Mathpix (86,43 %). For videnskabelige artikler: 96,67 %.

— datalab.to, https://github.com/datalab-to/marker
Men Marker kræver en GPU for at være hurtig og medfører maskinlæringsmodeller. Til de fleste opgaver (almindelige PDF-filer med tekst) klarer PyMuPDF4LLM eller MarkItDown opgaven på få sekunder uden GPU. ### En enkel tommelfingerregel 1. **En eller to PDF-filer, skal gå hurtigt** - MarkItDown CLI. 2. **Dusinvis af PDF-filer, brug for automatisering** - MarkItDown MCP-server eller PyMuPDF4LLM i et script. 3. **PDF-filer med links og billeder, hvor det er vigtigt at bevare strukturen** - PyMuPDF4LLM. 4. **Produktions-RAG til virksomheder, hvor stabile tabeller er vigtige** - Docling. 5. **Videnskabelige artikler med formler** - Marker. 6. **Vil ikke tænke over det; lad Claude konvertere** - MarkItDown MCP-server. ## Sådan skriver du et script, der automatisk konverterer en mappe med dokumenter
Vigtigste pointe Den mest praktiske løsning er et bash-script, der gennemgår en projektmappe, konverterer alle PDF-, DOCX- og PPTX-filer til Markdown og lægger dem i en undermappe `_md/`. Sæt det op én gang, så bliver enhver ny mappe med dokumenter »Claude-læsbar« i én omgang. Tag derefter `_md/` med i Claude Code via `@_md/`, og arbejd med den komprimerede tekst.
Et praktisk eksempel: Forestil dig, at du har 40 PDF- og PPTX-rapporter fra kunder i én mappe – mæglerkontoudtog, kontrakter og præsentationer. Det nytter ikke at uploade hele mappen direkte til Claude: kontekstvinduet fyldes med information, før du får det første svar. Kør hele mappen gennem scriptet nedenfor i én omgang, og fortsæt derefter med lette `.md`-filer i stedet for tunge PDF-filer. Gem dette script som `scripts/docs-to-md.sh` i projektroden: ```bash #!/bin/bash # docs-to-md.sh - konverterer alle dokumenter i en mappe til Markdown med MarkItDown # Brug: 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" ``` Gør det eksekverbart: ```bash chmod +x scripts/docs-to-md.sh ``` Kør det: ```bash bash scripts/docs-to-md.sh ./reports ``` Efter kørslen indeholder `./reports/_md/` `.md`-versioner af alle dokumenterne. Tag dem med i Claude Code via `@reports/_md/`, og arbejd med den komprimerede tekst i stedet for PDF-filer. Scriptet springer automatisk filer over, der allerede er konverteret (hvis `.md`-filen er nyere end kildefilen) – det er hurtigt at køre igen, og alt skal ikke beregnes på ny. ### Idempotens og inkrementel konvertering Hvis du vil have scriptet til at opdage PDF-filer, der er blevet ændret (gemt igen under samme navn), skal du tilføje et tjek af indholdets hash: ```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" ``` Denne version konverterer kun en fil igen, hvis dens indhold er ændret. ## Hvornår er en PDF i Claude stadig bedre end Markdown?
Vigtigste pointe Markdown-konvertering mister tre ting: visuelle elementer (diagrammer, grafer, tegninger), komplekse tabeller med sammenflettede celler og billedtekster samt dokumentets fulde formatering som artefakt (for eksempel en kontrakt, du skal henvise til efter sidetal). Hvis disse ting er vigtige for opgaven, skal du beholde PDF-filen, aktivere visuel analyse og betale den visuelle omkostning med åbne øjne.
Tre tilfælde, hvor Markdown-konvertering ikke slår til: ### 1. Visuel analyse af diagrammer og grafer Hvis Claude skal »læse« en graf – en priskurve, et procesdiagram eller et arkitekturdiagram – findes oplysningerne ikke i Markdown. Markdown bevarer kun figurtekster; selve figuren går tabt. Løsning: Upload PDF-filen, og aktivér udtrykkeligt visuel tilstand. I Claude API virker flaget automatisk; på AWS Bedrock skal du bruge flaget `citations`.

Claude analyserer både teksten og billederne for bedre at forstå dokumentet.

— Anthropic, https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support
### 2. Komplekse tabeller med sammenflettede celler Markdown-tabeller er flade. Hvis PDF-filen har en tabel med sammenflettede celler, overskrifter på flere niveauer eller indlejrede undertabeller, flader konverteringsværktøjet den enten ud eller mister relationerne. Løsning: Brug PDF-filen direkte, brug Docling (det håndterer komplekse tabeller bedst), eller formatér den manuelt efter konverteringen. ### 3. Dokumenter som artefakter med sidehenvisninger For juridiske dokumenter, kontrakter og referater er det vigtigt at kunne citere »side 7, afsnit 3«. Sidetal går tabt i Markdown. Løsning: PDF + Files API + promptcaching. Upload filen én gang, og henvis derefter til den med `file_id`; Claude kan se sidetallene og henvise til bestemte sider. ### Korte dokumenter Hvis en PDF er kortere end 2 sider, og du kun bruger den én gang, kan konvertering ikke betale sig. 5.000 tokens for en PDF sammenlignet med 800 for Markdown er ikke nok besparelse til at retfærdiggøre installation af MarkItDown. Balancepunktet er omkring 5+ sider eller 2+ anvendelser af det samme dokument. Under det skal du uploade PDF-filen direkte; over det skal du konvertere den. ## Hvad er de 5 mest almindelige fejl, folk begår med PDF-filer i Claude?
Vigtigste pointe De største faldgruber: at uploade den samme PDF igen i forskellige chats i stedet for at konvertere den én gang, at undlade promptcaching til gentagne forespørgsler, at bruge skærmbilleder i stedet for tekst, at undlade OCR på scannede PDF-filer og at ignorere grænsen på 100 sider for modeller med 200K kontekst. Hver fejl spilder titusindvis af tokens uden nogen god grund.
### 1. Uploade den samme PDF i en ny chat hver gang Claude Pro har en beskedgrænse over 5 timer – én rapport på 50 sider kan opbruge den, før du når at stille et andet spørgsmål. Der er et enkelt princip for dette: **én opgave – én chat**. Når AI begynder at bruge et absurd antal tokens, betyder det, at du propper alt ind i én chat og uploader PDF-filen igen og igen. Hold én mikropgave i hvert vindue. Konvertér dokumentet til Markdown én gang, og føj derefter `.md`-filen til hvert nyt vindue sammen med projektet. Cirklen for kontekstvinduet bliver ikke gul. Løsning: Konvertér den til Markdown én gang, eller brug Files API med `file_id` og promptcaching. ### 2. Et skærmbillede i stedet for tekst Et typisk eksempel: Nogen vil vise Claude et kodestykke eller en tabel, tager et skærmbillede af hele skærmen på 1920×1080 og undrer sig over, at grænsen er nået efter 5 forespørgsler. Et skærmbillede på 1000×1000 pixels koster ~1.300 tokens. Den samme tekst, kopieret manuelt, koster 50–100 tokens. Det er en forskel på 13–26 gange. Løsning: Beskær skærmbilleder tæt (så kun det vigtige er med), eller endnu bedre, kopiér teksten direkte. ### 3. En scannet PDF uden OCR MarkItDown kan ikke udføre OCR. Hvis du konverterer en scanning, bliver resultatet en tom `.md`-fil (eller 3 linjer støj). Løsning: Brug PyMuPDF4LLM (med den indbyggede smarte OCR) eller Docling til scanninger. ### 4. At ignorere grænsen på 100 sider Anthropics dokumentation angiver en grænse på 600 sider pr. forespørgsel – men i praksis er grænsen for modeller med 200K kontekst (Sonnet 4.x, Opus 4.x) **100 sider**. Grænsen på 600 sider er beregnet til ældre modeller eller særlige niveauer. Hvis du uploader en rapport på 150 sider til Sonnet 4.6, får du en fejl, eller endnu værre: Claude behandler kun de første 100 sider og opfører sig, som om den har læst hele dokumentet. Løsning: Del lange PDF-filer op i dele, før du uploader dem. Eller konvertér dem til Markdown – der er ingen sidegrænse, kun en tokengrænse. ### 5. Ikke at bruge promptcaching til gentagne forespørgsler Hvis du arbejder med det samme dokument via API'et, skal du pakke det ind i `cache_control: ephemeral`. Gentagne kald inden for 5 minutter koster 10 % af den oprindelige pris. Ét kald koster mere; resten får 90 % rabat. Løsning: Aktivér promptcaching som standard for alt, du uploader mere end én gang. ## Hvad nu: kontekstteknik
Vigtigste pointe At konvertere PDF-filer til Markdown er én kontekstteknik, en ny færdighed i arbejdet med AI. En prompt er et spørgsmål. Kontekst er alt det, Claude ser før og omkring spørgsmålet: systemprompten, CLAUDE.md, filer, MCP-servere og sessionshistorik. Jo renere konteksten er, desto mere præcist bliver svaret, og desto mindre koster det. Læs hele analysen i guiden »Kontekstteknik i 2026«.
PDF-til-Markdown er én måde at spare tokens på. I sig selv gør det ikke Claudes svar mere præcise. Præcisionen kommer fra **kontekstteknik** – disciplinen i at vælge, hvad du lægger i modellens kontekst, før du stiller et spørgsmål. Hvis din `CLAUDE.md` har 800 linjer, dit projekt har 10 unødvendige MCP-servere, og du tager en PDF på 100 sider med, forhindrer Markdown-konverteringen ét læk, men de tre andre bliver. Derfor handler disse guides om: - [Hvor tokens går hen i Claude Code](https://ailoot.ai/blog/da/where-claude-code-tokens-go/) - 9 mønstre for kontekstlækager, ikke kun PDF-filer. - [Kontekstteknik i 2026](https://ailoot.ai/blog/da/context-engineering/) - systematisk konteksthåndtering. - [Plan Mode i Claude Code](https://ailoot.ai/blog/da/claude-code-plan-mode/) - planlægningstilstand, før Claude begynder at skrive kode.
### Kilder - [Anthropic - PDF-understøttelse (platform.claude.com)](https://platform.claude.com/docs/en/docs/build-with-claude/pdf-support) - [Anthropic - Upload filer til Claude (support.claude.com)](https://support.claude.com/en/articles/8241126-upload-files-to-claude) - [Microsoft MarkItDown på GitHub](https://github.com/microsoft/markitdown) - [MarkItDown MCP-server](https://github.com/microsoft/markitdown/tree/main/packages/markitdown-mcp) - [PyMuPDF4LLM - officiel dokumentation](https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/) - [Docling på GitHub (IBM Research)](https://github.com/DS4SD/docling) - [Marker på GitHub (datalab.to)](https://github.com/datalab-to/marker)
Fortsæt med at udforske Ailoot på [ailoot.ai](https://ailoot.ai/).
## Spørgsmål og svar ### Hvor mange Markdown-tokens bruger eksemplet med 15 sider og fire chats? Med artiklens antagelse om 300 tokens pr. konverteret side er totalen 15 × 300 × 4 = 18.000 inputtokens. Det er et illustrativt estimat; tæl det konverterede dokuments tokens for din egen fil. ### Er tekstkonvertering nok til enhver PDF? Nej. Sammenlign konverteret Markdown med PDF’en, især tabeller, siderækkefølge og indhold, der afhænger af billeder. Sammenlign først tokenforbrug efter bekræftelse af, at informationen til din opgave overlevede konverteringen. ## Ailoot · Virksomheden og dens projektportefølje Ailoot bygger på solid driftserfaring, en stor kundebase, stabil service og løbende kontrol af KPI. Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder. Ailoot bruger denne driftserfaring til API-adgang til AI-funktioner i kundernes produkter, agenter, applikationer og automatiseringer.