Uploading Files to Claude: Projects, Vision, and 200K Context

The short version

Claude approaches uploaded files differently than ChatGPT in one important way: it tends to read the whole thing. Where ChatGPT chunks your file and retrieves the relevant bits for each question, Claude loads the full document into its context window (currently 200K tokens on standard plans, up to 1M on Enterprise) and reasons across all of it at once. That changes what workflows are practical.

Claude also handles PDFs more gracefully than most tools. It processes them as text plus rendered page images — so when the text extraction is messy, it can fall back on actually looking at the page. This is why Claude often does better on scanned or image-heavy PDFs than you would expect. It is not a substitute for a proper OCR pipeline on documents that matter, but it fails less silently.

What Claude does with an uploaded file

When you attach a file in the Claude web app or an API call with the Files or PDF beta:

• PDFs are processed in two passes — Claude extracts the text layer and also renders each page as an image that the vision model can read. Both go into the context window. This is why layout, figures, and even handwriting can sometimes come through even when the text layer is garbage.
• Word, PowerPoint, Excel, CSV, text, markdown are converted to text internally and put into context. There is no retrieval step — the whole document is there, token budget permitting.
• Images go to the vision model directly. The current flagship Claude model handles screenshots, diagrams, charts, and photos of text quite well.
• Code files are treated as text with syntax context. Useful for reviewing pull requests or asking Claude to trace a bug across multiple files.

Everything sharing the context window means three things: you have a hard ceiling (roughly 150,000 words of document plus conversation before things start to get crowded), Claude can reason across the entire document for every question, and the more stuff you upload, the less room is left for the back-and-forth.

When the 200K context actually matters

The standard 200,000-token window is roughly 150,000 words, or about a 500-page novel. In practice, the useful threshold is lower because you also need room for the system prompt, your questions, and Claude's answers. Plan for around 180K of document content if you want a real conversation on top. Enterprise plans currently push this ceiling much higher.

Here is where that matters and where it does not:

A corporate lawyer uploading a 300-page merger agreement to Claude is the scenario that shows off what the 200K window is good for. With ChatGPT's retrieval approach, the model sees five or six chunks at a time. With Claude, it sees the whole agreement, which means you can ask "does the change of control clause in section 7 conflict with the indemnification language in section 14?" and get a coherent answer that actually compares the two. Retrieval-based tools often miss cross-document connections like that because the chunks for the two sections never land in the same retrieval call.

Projects: the feature most people underuse

Projects are a paid feature (Pro, Team, and Enterprise plans). A Project is a workspace you create that holds a custom system prompt and a large pool of "Project knowledge" — reference files that are available to every conversation inside that Project. Upload a file there once and Claude knows about it for every chat you start.

The workflows where Projects shine:

• Reviewing the same contract across weeks. Upload the current draft once. Each negotiation round, start a new conversation in the Project and ask Claude about the latest changes. You don't re-upload every time.
• Coaching assistants trained on your methodology. Coaches put their frameworks, past notes, and tone-of-voice documents in a Project, then use new conversations to draft session prep for individual clients.
• Legal research with a running case file. Load statutes, briefs, and research memos into a Project. Every new conversation starts with all of that context already in play.
• Technical docs for a codebase. Project knowledge holds the architecture overview and style guide; individual chats debug specific problems.

The trap: Project knowledge still has to fit in the context window on every turn. More reference material means less room for conversation and for the code or documents you drop into a specific chat. Curate aggressively — high-signal reference files, not a dumping ground.

How Claude reads PDFs: text plus vision

This is the feature that most clearly distinguishes Claude from ChatGPT on document uploads. When you send a PDF, Claude's backend does two things:

1. Extracts the text layer using a native parser.
2. Renders each page as an image and sends those to the vision model.

Both get stitched into the model's context. For a clean born-digital PDF, this is redundant but harmless. For a tricky PDF — scanned, multi-column, heavy with figures or tables — the second pass rescues content that the first pass mangled. Claude can literally look at the page and describe what it sees.

Practical implication: Claude is usually more forgiving than ChatGPT on messy PDFs. But "more forgiving" is not "reliable." On a scanned 200-page deposition, the token cost of rendering every page as an image is high, and the vision model can still miss things or hallucinate cleanly-formatted text that isn't there. Convert and verify for anything that will end up in a decision, filing, or deliverable.

Decision tree: upload or convert first?

Artifacts: extract, render, iterate

Artifacts are not strictly about file uploads, but they are how you get structured output back from Claude after you upload something. The pattern:

1. Upload a PDF (contract, research paper, report).
2. Ask Claude to produce a structured summary, a comparison table, or a timeline — as an Artifact.
3. Claude renders it in the side panel. You can edit it, copy it, or ask Claude to revise it inline.

A pattern we see work well for lawyers reviewing contracts: upload the draft, ask Claude for a "redline summary table" Artifact with one row per material change, categorized by risk level. You get an editable markdown table you can drop into an email or a memo. The contract stays in context for follow-up questions.

A real before-and-after

Same quarterly report table, same scenario as the ChatGPT guide. Claude's vision fallback means it handles the raw PDF a bit better, but the markdown version is still dramatically more reliable for specific numeric questions.

Segment Q1 Q2 Q3
Cloud 4.2 4.6 5.1
Services
Hardware 2.1 2.0 1.9
Licensing 1.3 1.4 1.5
Total 7.6 8.0 8.5

| Segment       | Q1  | Q2  | Q3  |
|---------------|-----|-----|-----|
| Cloud Services| 4.2 | 4.6 | 5.1 |
| Hardware      | 2.1 | 2.0 | 1.9 |
| Licensing     | 1.3 | 1.4 | 1.5 |
| Total         | 7.6 | 8.0 | 8.5 |

Things people get wrong about Claude

"Claude's big context means I can dump everything in"

You can, but signal-to-noise matters. Claude pays attention to everything in context, which means irrelevant documents dilute its focus on the relevant ones. A 150K-token working set you chose carefully beats a 180K-token kitchen sink.

"Claude reads PDFs perfectly because of vision"

The vision pass helps, but it is not magic. Small text, tables with many columns, handwriting, and non-English scripts still fail. And because the failure is hidden inside the model's reasoning rather than shown to you, you can't audit what it missed. Convert beforehand and you get a reviewable artifact.

"Projects replace conversion"

Projects store files; they don't clean them. A messy PDF in Project knowledge is still a messy PDF every time a conversation loads it. Convert once, drop the markdown in the Project, and every future conversation benefits.

Practical Claude workflows worth copying

• Contract review. Convert the contract to markdown, upload to a Project with a system prompt describing your firm's standard redline checklist, and start a new conversation per round of edits.
• Research synthesis. Convert 10–20 papers to markdown, load into a conversation, ask Claude to produce a comparison table as an Artifact, iterate on the dimensions that matter to you.
• Book-to-knowledge-base. Convert an EPUB to markdown (our EPUB converter handles this), split by chapter, and load chapters into a Project. See our deep dive on building a knowledge base from books.
• Policy analysis. Convert the full text of a bill or regulation, upload, and ask Claude to highlight changes from a previous version you also upload. The 200K window lets it diff them in one go.

Where to go next

If you are choosing between tools for a specific job, our ChatGPT guide covers how retrieval-based file upload differs from Claude's full-context approach: uploading files to ChatGPT. For documents too big even for Claude's 200K window, Gemini's million-token context becomes relevant — see uploading files to Gemini.

And if you want to stop converting one file at a time, the batch converter handles whole folders at once, which is what most real Claude Project workflows end up needing.