A Step-by-Step Tutorial: Building Automated Invoice Processing Workflows Using AI

Automated invoice processing with AI is revolutionizing how businesses handle financial documents, reducing manual effort, minimizing errors, and accelerating payment cycles. In this hands-on tutorial, we'll walk you through building a robust, end-to-end workflow for invoice processing using AI-powered tools and open-source frameworks.

As we covered in our complete guide to AI workflow automation in document management, invoice processing is a prime candidate for automation. Here, we'll take a deeper, builder-focused dive into the practical steps, from document ingestion to data extraction, validation, and integration with your accounting system.

If you're exploring broader document automation or want to compare tools, check out our review of the best AI tools for document approval workflows and our 2026 tutorial on automating invoice processing with AI.

Prerequisites

• Python 3.10+ installed
• pip (Python package manager)
• Docker (for running supporting services, e.g., OCR engines, databases)
• Basic knowledge of REST APIs
• Familiarity with JSON and webhooks
• Accounts/Access to:
  • Google Cloud Vision API or Azure Form Recognizer (for OCR/data extraction)
  • Sample invoice PDFs or images
• Optional: Access to an accounting system with an API (e.g., Xero, QuickBooks)

1. Define the Automated Invoice Workflow

1. Document ingestion (upload via API or email)
2. AI-powered OCR and data extraction
3. Data validation and enrichment
4. Export to accounting system or database
5. Optional: Human-in-the-loop review for flagged invoices

This tutorial will implement steps 1-4 using Python, Google Cloud Vision, and a simple SQLite database. We'll also highlight where to add review steps, as discussed in our guide to human-in-the-loop workflows.

2. Set Up Your Project Environment

1. Create a project directory and virtual environment:

   mkdir ai-invoice-workflow
   cd ai-invoice-workflow
   python3 -m venv venv
   source venv/bin/activate

2. Install required Python packages:

   pip install flask google-cloud-vision requests pydantic sqlalchemy

3. Set up Google Cloud credentials:
   • Go to Google Cloud Console and enable the Vision API.
   • Create a service account and download the JSON key file.
   • Export the credentials as an environment variable:

   export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/key.json"

4. Prepare sample invoices:
   • Place a few PDF or image invoices in a ./invoices/ folder.

3. Build the Document Ingestion API

We'll use Flask to expose an endpoint for invoice uploads.

from flask import Flask, request, jsonify
import os

UPLOAD_FOLDER = 'invoices'
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

@app.route('/upload', methods=['POST'])
def upload_invoice():
    if 'file' not in request.files:
        return jsonify({'error': 'No file part'}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    filepath = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
    file.save(filepath)
    return jsonify({'message': 'File uploaded', 'path': filepath}), 200

if __name__ == '__main__':
    app.run(port=5000, debug=True)

Test the upload endpoint:

curl -F "file=@invoices/sample-invoice.pdf" http://localhost:5000/upload

4. Integrate AI-Based OCR and Data Extraction

We'll use Google Cloud Vision to extract text from invoice images. For PDFs, you'll need to convert them to images first (using pdf2image or similar).

1. Install the PDF-to-image converter (if needed):

   pip install pdf2image

2. Sample extraction code:

   
   
   from google.cloud import vision
   from pdf2image import convert_from_path
   import io
   
   def extract_text_from_image(image_path):
       client = vision.ImageAnnotatorClient()
       with io.open(image_path, 'rb') as image_file:
           content = image_file.read()
       image = vision.Image(content=content)
       response = client.text_detection(image=image)
       texts = response.text_annotations
       return texts[0].description if texts else ""
   
   def pdf_to_images(pdf_path):
       images = convert_from_path(pdf_path)
       image_paths = []
       for i, image in enumerate(images):
           img_path = f"{pdf_path}_page_{i}.png"
           image.save(img_path, 'PNG')
           image_paths.append(img_path)
       return image_paths
   

3. Update the upload endpoint to trigger extraction:

   
   
   from ocr import extract_text_from_image, pdf_to_images
   
   @app.route('/process', methods=['POST'])
   def process_invoice():
       data = request.json
       filepath = data.get('path')
       if not filepath or not os.path.exists(filepath):
           return jsonify({'error': 'Invalid file path'}), 400
   
       if filepath.lower().endswith('.pdf'):
           images = pdf_to_images(filepath)
           text = "\n".join([extract_text_from_image(img) for img in images])
       else:
           text = extract_text_from_image(filepath)
   
       return jsonify({'extracted_text': text}), 200
   

   Test the extraction endpoint:

   curl -X POST -H "Content-Type: application/json" -d '{"path": "invoices/sample-invoice.pdf"}' http://localhost:5000/process

   Screenshot description: JSON output with extracted invoice text.

5. Parse and Validate Invoice Data Using AI

Next, extract structured fields (invoice number, date, total, vendor) from the raw OCR text. For production, consider fine-tuned models or services like Azure Form Recognizer. Here, we'll use simple regex and Pydantic for validation.

import re
from pydantic import BaseModel, ValidationError

class InvoiceData(BaseModel):
    invoice_number: str
    invoice_date: str
    total_amount: float
    vendor: str

def parse_invoice(text):
    number = re.search(r'Invoice[\s#:]*([A-Za-z0-9-]+)', text)
    date = re.search(r'Date[\s:]*([0-9]{4}-[0-9]{2}-[0-9]{2})', text)
    total = re.search(r'Total[\s:]*\$?([0-9,]+\.\d{2})', text)
    vendor = re.search(r'From[\s:]*([A-Za-z &]+)', text)

    data = {
        "invoice_number": number.group(1) if number else "",
        "invoice_date": date.group(1) if date else "",
        "total_amount": float(total.group(1).replace(',', '')) if total else 0.0,
        "vendor": vendor.group(1).strip() if vendor else ""
    }
    try:
        return InvoiceData(**data)
    except ValidationError as e:
        return {"error": str(e)}

Integrate parsing into the workflow:

from parser import parse_invoice

@app.route('/process', methods=['POST'])
def process_invoice():
    data = request.json
    filepath = data.get('path')
    if not filepath or not os.path.exists(filepath):
        return jsonify({'error': 'Invalid file path'}), 400

    if filepath.lower().endswith('.pdf'):
        images = pdf_to_images(filepath)
        text = "\n".join([extract_text_from_image(img) for img in images])
    else:
        text = extract_text_from_image(filepath)

    parsed = parse_invoice(text)
    return jsonify({'parsed_invoice': parsed.dict() if hasattr(parsed, 'dict') else parsed}), 200

6. Store Invoice Data in a Database

We'll use SQLAlchemy with SQLite for simplicity. In production, use PostgreSQL or another robust DB.

from sqlalchemy import create_engine, Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class Invoice(Base):
    __tablename__ = 'invoices'
    id = Column(Integer, primary_key=True)
    invoice_number = Column(String)
    invoice_date = Column(String)
    total_amount = Column(Float)
    vendor = Column(String)

engine = create_engine('sqlite:///invoices.db')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

from models import Invoice, Session

@app.route('/save', methods=['POST'])
def save_invoice():
    data = request.json
    parsed = data.get('parsed_invoice')
    if not parsed:
        return jsonify({'error': 'No invoice data provided'}), 400

    session = Session()
    invoice = Invoice(**parsed)
    session.add(invoice)
    session.commit()
    session.close()
    return jsonify({'message': 'Invoice saved'}), 200

Test saving invoice data:

curl -X POST -H "Content-Type: application/json" -d '{"parsed_invoice": {"invoice_number": "INV-1001", "invoice_date": "2026-06-01", "total_amount": 1200.00, "vendor": "Acme Corp"}}' http://localhost:5000/save

7. (Optional) Integrate with Your Accounting System

Most modern accounting platforms (e.g., Xero, QuickBooks) offer REST APIs. Use requests to POST invoice data. See our deep dive on automating financial reconciliation with AI for integration best practices.

import requests

def send_to_accounting(invoice_data):
    url = "https://api.your-accounting.com/invoices"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    response = requests.post(url, json=invoice_data, headers=headers)
    return response.status_code, response.json()

Tip: Always validate and sanitize data before sending to external systems.

Common Issues & Troubleshooting

• OCR misses key fields: Try higher-resolution scans or alternative OCR engines (e.g., Tesseract, Azure Form Recognizer). For advanced extraction, see our 2026 AI invoice automation tutorial.
• Parsing errors: Regex patterns may need tuning for your invoice formats. Consider using AI document parsers for more complex layouts.
• API authentication failures: Ensure your cloud credentials are set and have the correct permissions.
• Database errors: Check for schema mismatches or locked DB files. Restart your app and ensure no other process is using the database.
• PDF conversion issues: Some PDFs may be encrypted or have complex layouts. Use pdf2image with additional parameters or try alternative conversion tools.

Next Steps

Congratulations! You've built a basic but extensible automated invoice processing workflow powered by AI. From here, you can:

• Add human-in-the-loop review steps for flagged or ambiguous invoices. See our guide to human-in-the-loop workflow design.
• Expand to batch processing and email ingestion.
• Integrate with workflow automation platforms for end-to-end process orchestration.
• Experiment with different AI extraction tools—see our 2026 roundup of AI document workflow tools.
• Explore more advanced use cases in our AI workflow automation pillar guide.

Automated invoice processing with AI is a rapidly evolving field. By following this tutorial, you're well on your way to building smarter, faster, and more reliable document workflows for your organization.