How to Automate Invoice Processing:
Python, Power Automate & AI

Why invoice processing is worth automating

Manual invoice processing is one of the highest-leverage automation targets in any finance or operations team. The work is repetitive, high-volume, error-prone, and requires zero judgment — a perfect candidate for automation.

Consider what typically happens: an invoice arrives by email, someone opens the PDF, manually reads vendor name, invoice number, line items, amounts, tax, and due date — then types it into an ERP or Excel tracker. Multiply that by 50–500 invoices per month and you're looking at a significant drain on skilled staff time.

Beyond time savings, automation also eliminates keying errors, creates an automatic audit trail, enables faster approval cycles, and makes it easy to generate reports on vendor spend, outstanding liabilities, and payment timing.

Anatomy of an invoice automation pipeline

Before writing a line of code, it helps to understand the stages of a complete invoice automation system. Most implementations share the same core pipeline:

1. Ingestion — Collecting invoices from email attachments, a shared folder, a vendor portal, or a WhatsApp/API feed.
2. Extraction — Pulling structured fields (vendor, date, invoice number, line items, total, tax, bank details) from the PDF or image.
3. Validation — Checking extracted data against expected formats, known vendor lists, or purchase orders.
4. Transformation — Mapping extracted fields to your target schema (Excel, ERP fields, database columns).
5. Output — Writing the structured data to Excel, posting it to an ERP via API, or routing it for human approval.
6. Exception handling — Flagging invoices where confidence is low or validation failed, and routing them for manual review.

The elegance of a good invoice automation system isn't in replacing every step — it's in making exceptions obvious, so your team only touches the 5–10% of invoices that genuinely need human attention.

Choosing the right tool: Python vs Power Automate vs AI

The right approach depends on your invoice format consistency, IT environment, and team's technical comfort. Here's a direct comparison:

Building with Python (pdfplumber + regex)

This is the fully local, zero-cost approach. It works exceptionally well when your invoices come from a consistent set of vendors with predictable PDF layouts.

Install the dependencies

pip install pdfplumber pytesseract openpyxl pillow

Step 1 — Extract raw text from the PDF

import pdfplumber

def extract_text_from_pdf(pdf_path: str) -> str:
    with pdfplumber.open(pdf_path) as pdf:
        all_text = []
        for page in pdf.pages:
            text = page.extract_text()
            if text:
                all_text.append(text)
    return "\n".join(all_text)

Step 2 — Parse key fields with regex

import re
from datetime import datetime

def parse_invoice_fields(text: str) -> dict:
    patterns = {
        "invoice_number": r"Invoice\s*(?:No|Number|#)[:\s]*([A-Z0-9\-]+)",
        "invoice_date":   r"(?:Invoice\s*Date|Date)[:\s]*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})",
        "due_date":       r"(?:Due\s*Date|Payment\s*Due)[:\s]*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})",
        "vendor_gstin":   r"GSTIN[:\s]*([0-9A-Z]{15})",
        "total_amount":   r"(?:Grand\s*Total|Total\s*Amount|Amount\s*Due)[:\s]*[₹$]?\s*([\d,]+\.?\d*)",
        "tax_amount":     r"(?:GST|Tax|VAT)[:\s]*[₹$]?\s*([\d,]+\.?\d*)",
    }

    result = {}
    for field, pattern in patterns.items():
        match = re.search(pattern, text, re.IGNORECASE)
        result[field] = match.group(1).strip() if match else None

    return result

Step 3 — Extract line items (table rows)

def extract_line_items(pdf_path: str) -> list:
    line_items = []
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            tables = page.extract_tables()
            for table in tables:
                for row in table[1:]:  # skip header row
                    if row and any(cell for cell in row):
                        line_items.append({
                            "description": row[0] or "",
                            "quantity":    row[1] or "",
                            "unit_price":  row[2] or "",
                            "amount":      row[-1] or ""
                        })
    return line_items

Step 4 — Process a folder of invoices in bulk

import os
from pathlib import Path

def process_invoice_folder(folder_path: str) -> list:
    results = []
    pdf_files = Path(folder_path).glob("*.pdf")

    for pdf_file in pdf_files:
        try:
            text = extract_text_from_pdf(str(pdf_file))
            fields = parse_invoice_fields(text)
            fields["file_name"] = pdf_file.name
            fields["status"] = "extracted"
            fields["line_items"] = extract_line_items(str(pdf_file))
            results.append(fields)
        except Exception as e:
            results.append({
                "file_name": pdf_file.name,
                "status": "error",
                "error": str(e)
            })

    return results

The Power Automate + Azure approach

If your organisation runs on Microsoft 365, Power Automate paired with Azure Document Intelligence (formerly Form Recogniser) gives you a low-code invoice processing flow that can be set up without writing Python.

The basic flow

1. Trigger: "When a new email arrives" or "When a file is created in SharePoint"
2. Condition: Check if attachment is a PDF
3. Action: Save attachment to a SharePoint/OneDrive folder
4. Action: Call Azure Document Intelligence — Prebuilt Invoice model
5. Action: Parse the JSON response for VendorName, InvoiceId, InvoiceDate, SubTotal, TotalTax, InvoiceTotal
6. Action: Add a row to an Excel table on SharePoint, or POST to your ERP API
7. Condition: If confidence score < 0.85, send an approval email with the extracted data for human review

When to choose Power Automate

Choose this route if: your team is non-technical, you're already in the Microsoft ecosystem, you need the solution deployed without IT involvement, or you want visual monitoring of each flow run through the Power Automate dashboard.

Using AI for unstructured invoices

When invoices come from dozens of different vendors with no consistent layout — handwritten notes, non-standard formats, mixed languages — regex and even form recognition models struggle. This is where a large language model like Claude or GPT-4o genuinely shines.

The approach: PDF → base64 → AI extraction

import anthropic
import base64, json
from pathlib import Path

client = anthropic.Anthropic()  # uses ANTHROPIC_API_KEY env var

def extract_invoice_with_ai(pdf_path: str) -> dict:
    # Read and encode the PDF
    pdf_bytes = Path(pdf_path).read_bytes()
    pdf_b64 = base64.standard_b64encode(pdf_bytes).decode("utf-8")

    prompt = """Extract the following fields from this invoice as JSON only, 
no preamble, no markdown. Use null for any missing fields:
{
  "vendor_name": "",
  "invoice_number": "",
  "invoice_date": "YYYY-MM-DD",
  "due_date": "YYYY-MM-DD",
  "subtotal": 0.00,
  "tax_amount": 0.00,
  "total_amount": 0.00,
  "currency": "",
  "line_items": [
    {"description": "", "quantity": 0, "unit_price": 0.00, "amount": 0.00}
  ]
}"""

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_b64
                    }
                },
                {"type": "text", "text": prompt}
            ]
        }]
    )

    return json.loads(message.content[0].text)

This approach handles invoices in any language, any layout, with messy formatting — and returns clean structured JSON every time. The cost per invoice is roughly $0.01–0.03 depending on page count and model used.

Outputting to Excel or your ERP

Once you have extracted and validated invoice data, writing it out cleanly is straightforward. Here's how to output to a structured Excel database with auto-generated ticket numbers:

import openpyxl
from openpyxl.styles import Font, PatternFill, Alignment
from datetime import datetime

def write_to_excel(invoices: list, output_path: str):
    wb = openpyxl.Workbook()
    ws = wb.active
    ws.title = "Invoice Log"

    headers = ["Ticket No", "File Name", "Vendor", "Invoice No",
               "Invoice Date", "Due Date", "Subtotal", "Tax", "Total", "Status"]

    # Style the header row
    header_fill = PatternFill("solid", fgColor="1c1814")
    for col, header in enumerate(headers, 1):
        cell = ws.cell(row=1, column=col, value=header)
        cell.font = Font(bold=True, color="c9943a", size=10)
        cell.fill = header_fill
        cell.alignment = Alignment(horizontal="center")

    # Write data rows
    for idx, inv in enumerate(invoices, 1):
        ticket = f"INV-{datetime.now().strftime('%Y%m')}-{idx:04d}"
        ws.append([
            ticket,
            inv.get("file_name"),
            inv.get("vendor_name"),
            inv.get("invoice_number"),
            inv.get("invoice_date"),
            inv.get("due_date"),
            inv.get("subtotal"),
            inv.get("tax_amount"),
            inv.get("total_amount"),
            inv.get("status", "Pending Review")
        ])

    # Auto-size columns
    for col in ws.columns:
        max_len = max(len(str(cell.value or "")) for cell in col)
        ws.column_dimensions[col[0].column_letter].width = min(max_len + 4, 40)

    wb.save(output_path)
    print(f"Saved {len(invoices)} invoices to {output_path}")

Posting to an ERP

For Oracle, SAP, or Tally integrations, the pattern is the same — extract and validate first, then POST to the ERP's REST API (or use a file-based import if REST isn't available). Always log each submission with a status field so exceptions are visible without re-processing everything.

Common pitfalls and how to avoid them

1. Assuming all PDFs are text-based

Many vendors send scanned image PDFs. Always check if page.extract_text() returns meaningful content. If it returns blank or garbage, fall back to OCR via pytesseract.

2. Brittle regex patterns

Patterns like Total: ₹1,23,456.00 break when vendors write TOTAL AMOUNT: Rs. 1,23,456. Build regex patterns with generous whitespace matching (\s*) and handle multiple currency symbols and formats.

3. No exception routing

Any automation without a clear exception path is dangerous. When extraction fails or confidence is low, the invoice must land somewhere visible for human review — not silently discarded. Always write a separate "exceptions" sheet or send an alert email.

4. Processing duplicates

Invoices often arrive multiple times (vendor re-sends, forwarded emails). Store a hash of each invoice (vendor + invoice number + amount + date) and check for duplicates before writing to the database.

5. Not handling multi-page invoices

Line items often span multiple pages. Make sure your extraction loops over all pages, and that you're merging tables correctly when a table continues across a page break.

Implementation checklist

• ✦ Define all invoice sources (email, folder, portal, WhatsApp)
• ✦ Audit a sample of 20–30 invoices for layout variation
• ✦ Choose extraction approach: rule-based / AI / hybrid
• ✦ Build extraction → test on sample → measure field accuracy
• ✦ Add validation rules for each critical field
• ✦ Design exception routing for low-confidence extractions
• ✦ Build output: Excel, ERP API, or database table
• ✦ Add duplicate detection (hash check before write)
• ✦ Test with 3 months of historical invoices
• ✦ Run in parallel with manual process for 2 weeks before switching over
• ✦ Document the system and train the team on exception handling

Abhijit Khairnar

Automation specialist with 8+ years in financial services. Builds invoice, reconciliation, and reporting automation systems for finance and operations teams globally.

purelyautomated.com LinkedIn Upwork