How to extract data from invoices

First, work out what you are actually dealing with

Two properties determine almost everything that follows, and both take ten minutes to check.

The first is whether your PDFs contain a real text layer or are images. Open one and try to select a word. If you can highlight text, the file has embedded text and a great many options open up, including free ones. If nothing selects, it is a scan or a photograph, and optical character recognition is unavoidable. Every approach below gets harder and less reliable.

The second is layout variety. Fifty invoices from one supplier, all identical, is a fundamentally different problem from fifty invoices from fifty suppliers. The first is a parsing exercise you solve once. The second is a recognition problem that never fully settles, because a new supplier layout arrives every month and the tenth one is not like the first nine.

Almost every bad tooling decision in this area comes from solving one of those problems with a method suited to the other.

Manual entry

It deserves to be listed honestly, because it is still the correct answer sometimes. Manual entry needs no setup, no software and no evaluation, and a competent person keys a simple invoice in one to three minutes.

At twenty invoices a month that is under an hour, and no automation project repays the effort of choosing it. The arithmetic turns somewhere in the low hundreds per month, and it turns faster than people expect because the cost is not only the typing. It is the checking, the corrections, the bills that get missed and the person who cannot do anything else while the pile is on their desk.

Manual entry's real weakness is not speed but consistency. Error rates on repetitive numeric transcription are non-trivial and they rise with fatigue and volume, which is precisely when nobody has time to check.

Excel and Power Query

If your invoices are digital PDFs with a consistent layout, Power Query in Excel can genuinely do this, and it is free with software you already have.

Power Query's PDF connector reads tables and pages out of a PDF into a table you can transform, and pointing it at a folder lets you process a batch. For a supplier who sends the same layout every month, you build the query once and refresh it thereafter. Similar approaches work in Google Sheets with a script, though less comfortably.

The limits arrive quickly. The PDF connector needs an actual text layer, scans return nothing useful. It reads what it identifies as tables, so header fields floating outside a table structure need separate handling. Multi-page invoices where the table continues across pages need careful appending. And crucially, a layout change from the supplier breaks the query silently, producing shifted columns rather than an error.

Verdict: good for a handful of suppliers with stable digital layouts and someone comfortable in Excel. It does not survive layout variety.

Python: pdfplumber, PyMuPDF and Tesseract

For developers this is the most flexible option and often the right one. It is also the option most consistently underestimated, so it is worth being specific about what each library does.

pdfplumber extracts text with position information from digital PDFs, and has genuinely useful table detection. Because you get word coordinates, you can write rules like "the value to the right of the label Invoice Number" or "the table bounded by these lines", which is far more robust than string searching. It is slower on large files and it cannot help with scans.

PyMuPDF (fitz) is fast, extracts text and coordinates, and renders pages to images. In practice it is often used as the front end to an OCR pipeline: render each page at a suitable resolution, then pass the image on. It is the pragmatic choice when performance matters.

Tesseract is the standard open-source OCR engine and is where scanned documents get handled. It works, and its output quality depends heavily on preprocessing, deskewing, thresholding, resolution. Two hundred DPI clean scans give reasonable results; a phone photograph taken at an angle in poor light gives output you would not want to post to a ledger. Tesseract returns text and bounding boxes, not fields, so all the logic that turns "a page of words" into "invoice number, date, total, lines" is still yours to write.

• Fifty invoices from one supplier, digital PDFs: write the script. An afternoon of work, and it runs forever.
• A few suppliers with stable layouts: still worth scripting, with one parser per layout.
• Thirty suppliers, layouts change occasionally: the maintenance starts to exceed the value.
• Hundreds of suppliers, unpredictable layouts, scans mixed with digital: position-based rules do not converge. This is where scripting stops being the economical answer.

The line-items problem

Header fields are the easy part. Invoice number, date and total sit in predictable places and can be found by label proximity in most approaches above. Line items are where every method is tested.

The difficulties are structural rather than cosmetic. Tables run across page breaks, sometimes repeating headers and sometimes not. Descriptions wrap onto two or three lines, so a row is not a line of text. Columns are separated by whitespace rather than rules, so the boundaries have to be inferred. Discounts, subtotals and section headings appear inside the table and look like line items. Some suppliers put quantity before description, others after.

If you are evaluating any option, test it on line items rather than on totals. A tool that reads headers perfectly and mangles lines is only useful if you never needed to code spend per item. And most people who think that eventually find out otherwise.

Template-based tools

The traditional commercial approach: define a template per supplier layout by drawing zones on a sample document, then apply that template to matching invoices. Older document-capture products are built entirely this way.

Where layouts are stable and few, they are precise and predictable, and predictability has real value in finance. You know exactly what will be read and from where.

The failure mode is maintenance. Every new supplier needs a template before their first invoice can be processed, which means the first invoice is always manual. Every layout change breaks the template, and suppliers change layouts without announcing it. Organizations that adopted this approach commonly find someone spends a day a week maintaining templates, which is a cost that grows with supplier count rather than volume.

AI extraction services

The current generation of extraction services uses machine-learning models that read a document the way a person does. Locating fields by context and layout understanding rather than by fixed coordinates. The practical difference is that an unfamiliar supplier layout works on the first invoice, without a template.

This is the approach our own product, InvoiceExtraction, takes: documents go in, structured fields and line items come out through an interface or an API, with low-confidence values flagged for review rather than silently guessed. We mention it here because it is the category this page belongs to, not because it is the right answer for every reader on this page.

The honest limitations apply to the whole category. Output is probabilistic, so validation matters. Line items should sum to the subtotal, subtotal plus tax should equal the total, and anything failing those checks should be reviewed regardless of how confident a model claims to be. Poor-quality scans remain difficult for any system, because information genuinely absent from an image cannot be recovered. And there is a per-document cost, which is irrelevant at eight hundred invoices a month and material at eight hundred thousand.

Where it clearly wins is many suppliers, varied layouts, mixed digital and scanned documents, and no appetite to maintain code or templates. Where it is overkill is one supplier, fifty identical digital invoices, and a developer on the team.

Choosing, in one paragraph

Under about fifty invoices a month, keep entering them by hand and spend the effort elsewhere. Digital PDFs from a small number of stable suppliers, and someone who knows Excel: Power Query. A developer, digital PDFs, few layouts: Python with pdfplumber, and PyMuPDF plus Tesseract if scans are involved. Many suppliers, changing layouts, scans in the mix, no maintenance appetite: a service that does not need templates. The most expensive mistake is not picking the wrong option. It is picking one suited to fifty identical invoices and applying it to three hundred different ones.