How to Automate Invoice Processing with AI and OCR

Accounts payable is the last great manual data-entry job inside most companies, and it is finally automatable. The combination of OCR plus a vision-capable LLM hits over 95 percent extraction accuracy on standard invoices, beats traditional rules-based engines, and runs at pennies per document. Here is the exact pipeline I have built for clients, the model choices, the benchmarks, and the failure modes.

Why invoice automation finally works in 2026

The old approach was rules-based OCR — extract characters with Tesseract, then write regex for every vendor's invoice template. It worked, sort of. It broke every time a vendor changed their layout. Maintenance ate the savings.

The new approach is two layers. Run a high-quality OCR pass to get clean text, then hand the text plus the image to a vision LLM that outputs structured JSON. The LLM does not care about template changes because it understands the invoice semantically. Accuracy is now north of 95 percent on standard invoices, including handwritten line items, foreign currencies, and weird PDF layouts.

The numbers from a real client deployment last quarter: 4,200 invoices per month, 96.8 percent fully automated, 3.2 percent flagged for human review, $0.031 average cost per invoice end to end. Their previous BPO charged $1.80 per invoice.

The architecture

Seven stages:

1. Intake — email inbox, dropbox folder, or API webhook from vendors
2. Pre-processing — file format normalization, page splitting, deskewing
3. OCR — text extraction with AWS Textract, Google Document AI, or Azure Document Intelligence
4. Extraction — vision LLM produces structured JSON with vendor, amount, line items, tax, due date
5. Validation — vendor whitelist check, numerical sanity check, duplicate check
6. Approval routing — auto-post if confidence high, queue for review if not
7. Posting — write to QuickBooks, Xero, NetSuite, or SAP

The validation step is what makes this safe. Without it you are one hallucinated number away from paying $50,000 to the wrong account.

Step 1: Build the intake layer

Most invoices arrive as PDF email attachments. Set up:

• A dedicated email address (invoices@yourcompany.com)
• Forwarding rule that sends attachments to your processing service
• A whitelist of accepted senders or a "verify sender" flag for unknowns
• Optional: vendor portals or EDI feeds for high-volume suppliers

For Gmail-based intake, the Gmail API watches a label and triggers your service via Pub/Sub. For Outlook, use Microsoft Graph API with a subscription on the Inbox folder.

Step 2: Pre-process the document

Garbage in, garbage out. Before OCR:

1. Normalize to PDF if input is image (PNG, JPG, HEIC)
2. Deskew rotated scans (libraries like deskew or AWS Textract handles automatically)
3. Split multi-page PDFs into individual invoices if the vendor batches them
4. Reject anything under 200 DPI (you will get OCR garbage)

Tools that work: pdf2image, Pillow, pdfplumber, ImageMagick. For higher volumes, AWS Textract handles this internally.

Step 3: Pick your OCR provider

The shortlist for 2026 (verified May 2026 list pricing):

• Azure Document Intelligence Prebuilt Invoice — $10 per 1,000 pages (~$0.01/page) on pay-as-you-go; commitment tiers drop to $8 per 1,000 at 500K+ pages/month. Best price in this tier. Reported ~95 percent accuracy on standard invoices.
• AWS Textract — $0.0015 per page for raw text (DetectDocumentText) and $0.10 per page for AnalyzeExpense, which already extracts invoice-specific fields. Independent benchmarks put Textract at ~94.2 percent average accuracy. Best AWS integration.
• Google Document AI Invoice Parser — pay-per-page at the published rate; ~95.8 percent average accuracy in 2026 benchmarks and best-in-class language coverage (200+ languages). Best on weird layouts.
• Mindee — starts at $0.05/page with plans from 500 to 10,000 pages/month, 96.1 percent accuracy on a 2025 benchmark.
• Veryfi — purpose-built for AP, hit 98.7 percent overall accuracy in Veryfi's own 2025 benchmark and returns structured data in under 2 seconds. Vendor-priced, expect $0.08 to $0.20 per page.
• Tesseract — free, self-hosted, accuracy noticeably below the cloud options. Use only at scale where the cents matter.

Most teams run Azure Document Intelligence because price-to-accuracy is unbeatable at $0.01/page; pick Veryfi if you need the highest accuracy and don't mind paying for it. Tesseract is for very high volumes where you can afford the engineering investment.

Step 4: Extract structured fields with a vision LLM

This is the killer step. Send the OCR'd text plus the original image to GPT-5 ($1.25/$10.00 per 1M tokens) or Claude Sonnet 4.6 ($3/$15 per 1M tokens) and ask for structured JSON. GPT-5-mini ($0.25/$2.00) handles 80 percent of cases at a fraction of the cost — fall back to GPT-5 only when confidence is low.

You are an accounts payable assistant. Extract the following fields
from the invoice image and OCR text below.

Return JSON:
- vendor_name
- vendor_address
- invoice_number
- invoice_date (ISO 8601)
- due_date (ISO 8601)
- subtotal
- tax_amount
- total_amount
- currency (ISO 4217)
- line_items: array of {description, quantity, unit_price, total}
- po_number (if present)
- confidence: 0 to 1

Rules:
- Only extract values explicitly visible in the document.
- If a field is missing, return null. Never guess.
- If the total does not equal subtotal plus tax, lower confidence below 0.7.

The "never guess" instruction is the single most important line. Without it, models confidently invent invoice numbers that match no record.

Step 5: Validate before you trust

Run automatic checks on every extraction:

1. Vendor whitelist — does vendor_name match an entry in your vendor master? If not, flag for review.
2. Numerical sanity — does subtotal + tax_amount == total_amount within 1 cent? If not, flag.
3. Duplicate check — does invoice_number from this vendor_name already exist in the system? If yes, flag as potential duplicate.
4. Range check — is total_amount within the historical range for this vendor (e.g., 10x larger than usual)? If outlier, flag.
5. Date validity — is invoice_date within the last 90 days? Older means historical and needs special handling.

Each failed check decreases the auto-post confidence. If any critical check fails, the invoice goes to human review.

Step 6: Match to purchase orders

For PO-based companies, three-way matching is non-negotiable. The system needs to verify invoice line items against the PO and the goods receipt note. Either:

• Pull POs from your ERP and match line item by line item
• Use the LLM to do fuzzy matching ("Widget A 2024 model" matches PO line "Widget A")
• Flag mismatches for buyer review

The fuzzy matching step is where AI shines. Rules-based systems fail because PO line text rarely matches invoice line text exactly. LLMs handle the variation natively.

Step 7: Route to approval

Apply business rules for who approves what:

• Under $500 — auto-post if all validations pass
• $500 to $5,000 — manager approval
• $5,000 to $50,000 — director plus manager
• Over $50,000 — CFO

Use Slack approvals, email-with-button, or your accounting system's native workflow. I prefer Slack because the approval cycle time drops from days to minutes.

Step 8: Post to the accounting system

Final step. Push to QuickBooks Online, Xero, NetSuite, or SAP via API:

• QuickBooks Online — POST /v3/company/{id}/bill with line items and vendor reference
• Xero — POST /api.xro/2.0/Invoices with similar fields
• NetSuite — SuiteScript or REST integration to create vendor bills
• SAP — IDoc or BAPI calls; significantly more work

Always include the original PDF as an attachment to the bill record. Auditors will demand it.

Step 9: Build the human review queue

For everything that fails validation, build a clean review interface:

• The original PDF rendered next to the extracted JSON
• Editable fields so the reviewer can correct values
• A "submit correction" button that posts the fixed version
• Logging of which fields were corrected

Every correction feeds your eval set for prompt improvements. Within 30 days you should see the auto-post rate climb from roughly 70 percent to over 90 percent as the system learns your vendor patterns.

What this costs in production

For 1,000 invoices per month:

• OCR (Azure Document Intelligence Prebuilt Invoice at $10 per 1,000 pages): about $10 to $20 depending on page count
• LLM extraction (GPT-5-mini at $0.25/$2.00 per 1M tokens, fallback to GPT-5 at $1.25/$10.00 on low confidence): about $20 to $35 per month
• pgvector on existing Postgres for vendor matching: $0
• Hosting: $20 per month on Railway or Fly.io
• Initial build: 12 to 16 engineering hours

Total ongoing cost: about $50 to $80 per month for 1,000 invoices, or $0.05 to $0.08 per invoice. Compare that to a BPO charging $1 to $2 per invoice or Mindee at $0.05/page on the entry plan.

For 10,000 invoices per month, the math gets even better — Azure commitment tiers drop OCR to ~$0.0095/page and per-invoice total cost falls to roughly $0.03 to $0.04.

Common failure modes and fixes

Handwritten amounts on receipts. OCR mis-reads handwriting. Fix: lower confidence threshold, force human review for handwritten content (detectable with a vision-LLM pre-check).

Foreign currencies. Invoice lists EUR but the model reports USD. Fix: explicit currency field with ISO 4217 codes, validate against vendor's known currency.

Multi-page invoices stitched into one PDF. Page 2 line items get lost. Fix: split-then-process, or use Document AI's multi-page invoice mode.

Rotated or skewed scans. OCR fails. Fix: add a deskew step in pre-processing.

Vendors changing layouts. With LLM-based extraction this is much less painful than with rules, but flag a sudden drop in confidence for any specific vendor as an alert.

FAQ

The accounts payable team that wins in 2026 is not the one with the most clerks. It is the one with a pipeline that reads, validates, and posts invoices automatically — and a tight human review queue for the edge cases. Build it once, save the labor forever.