Are LLMs Good Enough for Document Extraction in 2026?

Log inBook a demo

← Back to Blog<br>Every frontier large language model (LLM) can now read a scanned PDF receipt or invoice, or a hastily snapped photo of one, and give you structured data with its context intact. So are dedicated document extraction models dead?

Not yet. The AI document layer — the specialized models that sit between raw files and your application, with Unsiloed as one example — is a growing category, because "can read a PDF" and "can be trusted with the PDF" turn out to be very different claims.

This guide covers when an LLM is good enough on its own, and when a specialized model earns its place. The examples throughout compare Claude Opus 4.8 with Unsiloed.

TLDR:

For clean, one-off documents, a frontier LLM is good enough. Snap a photo, ask in plain language, get the answer.

On dense, degraded, or handwritten documents, LLMs fail quietly, inventing values and dropping rows, because the model only ever sees a downscaled image of the page.

To trust the output, stack cheap checks: per-value confidence scores and citations, internal reconciliation, and reading each page more than once. It never hits 100%, but it beats manual review on accuracy, speed, and cost.

Ingesting many documents into search or RAG is a pipeline, not a prompt. A dedicated model ships that pipeline as API calls, while raw Claude leaves you to build it yourself.

Cost is roughly a cent a page either way, and free tiers win at low volume.

Bottom line: use the LLM as the brain and a dedicated document model as the eyes.

When LLMs Are Enough

You might expect a post at this URL to argue LLMs are never good enough. Often they are. For everyday, one-off tasks, with a little prompting, a frontier model does the job.

Take splitting a restaurant bill. You snap a photo, ask in plain English, and the model reads the receipt, does the math, and hands back the answer in one shot.

This is the sweet spot for an LLM: a clean document, a one-off task, and a question in plain language. The model handles the reading and the reasoning in one step.

The trouble starts when any of those conditions break.

LLMs Fall Apart When 'Pretty Good' Isn't Enough

When documents get more complex, LLMs begin to struggle. A vision model downscales every page to a fixed resolution, so on a dense, small-print, or large-format page much of the detail is gone before it even starts reading. Handwriting and faint scans push the gap widest of all. The failures that follow are the dangerous kind: not blanks or refusals, but plausible-looking wrong values, with nothing to flag which ones to distrust.

The example below shows all of this at once with a real 277-row government procurement register. Same simple prompt as the receipt, a far harder document:

The model invented a project description, misread a date and repeated it down the column, changed a supplier's name, and quietly stopped a quarter of the way through the table. None of these errors announce themselves, so you only catch them by checking the output against the source, which defeats the point of automating the extraction in the first place.

When Accuracy Matters

For a lot of work, "mostly right" is fine. For an invoice total, a dosage, or a financial filing, it isn't. You can't blindly trust the output, but you can't check every field by hand either. The way through is to stack a few checks, starting with the one a specialized model gives you out of the box.

Start With Confidence Scores and Citations

This is the check that comes built in. A specialized model returns every value with a confidence score and a citation box on the page. Sort by confidence, accept the high-confidence values, and a reviewer opens only the flagged ones, where the box drops them onto the exact cell to confirm or fix. An LLM hands back a bare string, so with raw Claude you'd be building this layer yourself.

But confidence scores and a reviewer aren't enough on their own. A 0.97 score sounds reassuring until you run it across thousands of documents, where even a small error rate adds up to hundreds of wrong values. And the score isn't a guarantee: a model is sometimes confidently wrong, so those mistakes score high and never reach the review queue. Confidence tells you where to look first, not everywhere the errors are. So you layer more checks on top.

Let the Data Check Itself

Most documents have numbers that must agree: line items sum to a total, columns add up, a tax is a fixed percentage. Check those relationships and the data catches its own errors, no human needed.

Read It More Than Once

Read the same page twice, by a different model or from a cleaned-up image. Where the two reads agree, the value is almost certainly right. Where they disagree, you have found a cell to check.

It's never 100%, and that's fine. Stack these and confidence climbs, though never to certainty, and some errors will slip through. The goal is to be more accurate, faster,...