I Have Invoices to Process. What Do I Use?

Quick Answer Based on Your Constraints

Never use EasyOCR for invoices. It confuses $ with 8. Turns $150 into 8150. Every single dollar amount will be wrong.

Why These Recommendations

I tested four OCR engines on the same invoice. The differences matter: get the total wrong and you have an accounting problem. Get line items wrong and you have a reconciliation nightmare.

The Test

This invoice has everything that breaks OCR: dollar signs, decimal points, commas in numbers, a table with aligned columns. If an engine can't handle this clean, computer-generated invoice, it won't handle real-world scans.

The Results

EasyOCR: Do Not Use for Invoices

EasyOCR confused $ with 8. Systematically. Every dollar amount was wrong:

An invoice total of $9,743.30 becomes $89,743.30. That's not a rounding error - it's a 9x multiplier that would break any accounting system. EasyOCR is fast (0.59s) but unusable for financial documents.

Tesseract: Fast, Minor Issues

Tesseract got all the numbers right but made text errors:

• "Qty" became "ay"
• "UI/UX Design" became "UWUX Design"

For invoice processing, these errors don't matter - the dollar amounts are correct. Tesseract also partially preserved the table structure, keeping line items together. At 0.77 seconds, it's a viable choice for bulk processing where you write regex to extract totals.

PaddleOCR: Perfect Text, No Structure

PaddleOCR extracted every character correctly. Zero errors. But it flattened the table into a list of words:

Description
Qty
Price
Total
Web Development Services
40
$150.00
$6,000.00

You can reconstruct the table with code, but you need to write the logic yourself. For simple "find the total" tasks, PaddleOCR works. For full line item extraction, you need post-processing.

GPT-4o: Perfect Everything

GPT-4o understood the invoice was a table and returned structured JSON:

{
  "invoice_number": "INV-2025-001",
  "date": "December 16, 2025",
  "vendor_name": null,
  "line_items": [
    {"description": "Web Development Services", "qty": 40, "price": 150.00, "total": 6000.00},
    {"description": "UI/UX Design", "qty": 20, "price": 125.00, "total": 2500.00},
    {"description": "Server Hosting (Annual)", "qty": 1, "price": 480.00, "total": 480.00}
  ],
  "subtotal": 8980.00,
  "tax": 763.30,
  "total": 9743.30
}

Every line item correctly extracted with quantity, unit price, and line total. The math checks out: 40 x $150 = $6,000. Subtotal + tax = total. This is what you want for invoice processing.

The cost is ~$0.01 per invoice (943 tokens). At 10,000 invoices/month, that's $100/month - less than most SaaS invoice processing tools.

Choosing Based on Privacy Needs

Can't send invoices to external APIs? (HIPAA, financial regulations, client NDAs)

• PaddleOCR runs entirely on your servers. No data leaves your infrastructure.
• Tesseract also runs locally, but worse accuracy than PaddleOCR for invoices.
• GPT-4o/Textract/Document AI all send data to cloud providers. Not suitable if privacy is a hard requirement.

Choosing Based on Budget

Break-even point: If you're processing over 10,000 invoices/month, PaddleOCR with custom post-processing pays for itself in engineering time within 2-3 months.

The Code

PaddleOCR: Extract Total

from paddleocr import PaddleOCR
import re

ocr = PaddleOCR(lang='en')
result = ocr.predict('invoice.png')

# Extract text
texts = []
for item in result:
    texts.extend(item.get('rec_texts', []))

# Find total (look for largest dollar amount)
amounts = []
for text in texts:
    match = re.search(r'\$([\d,]+\.\d{2})', text)
    if match:
        amount = float(match.group(1).replace(',', ''))
        amounts.append(amount)

total = max(amounts) if amounts else None
print(f"Invoice total: {total:,.2f{'}'}")

GPT-4o: Full Invoice Parsing

import base64
import json
from openai import OpenAI

client = OpenAI()

with open('invoice.png', 'rb') as f:
    img = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": """Extract from this invoice:
- invoice_number
- date
- vendor_name
- line_items (description, qty, price, total)
- subtotal
- tax
- total

Return as JSON."""},
        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img}"}}
    ]}]
)

data = json.loads(response.choices[0].message.content)
print(json.dumps(data, indent=2))

Common Questions

What if I'm already on AWS/Google Cloud?

Use Textract or Document AI if you're already in that ecosystem. They have pre-built invoice extractors that return structured data without custom prompting. But they're more expensive than GPT-4o and less flexible.

What if my invoices are scanned/photographed, not PDFs?

GPT-4o handles scanned invoices well. PaddleOCR and Tesseract struggle with poor quality scans. If you have low-quality images, budget for GPT-4o or invest in document scanning hardware.

What if I need to process invoices in multiple languages?

GPT-4o supports 50+ languages out of the box. PaddleOCR supports 80+ languages but requires language-specific models. Tesseract requires training data for each language.

What if I have custom invoice formats?

GPT-4o adapts to custom formats with prompt engineering. PaddleOCR requires writing custom post-processing code. The more standardized your invoices, the easier PaddleOCR becomes.

More

• Getting started with OCR in Python
• Best Python OCR libraries compared
• GPT-4o vs PaddleOCR deep dive