AI agents accounts payable automation is no longer a lab experiment; it’s a pragmatic way to cut manual invoice processing from days to minutes. This guide walks through building a production-grade agent that ingests PDFs, extracts line items with an LLM, matches purchase orders, and posts approvals to your ERP.
Step 1: Stand up invoice ingestion
Start by pulling invoices from a source of truth. Most AP teams dump PDFs into an S3 bucket or forward them to a dedicated mailbox. Use a scheduled worker that lists new objects and downloads them locally. If you use email, parse MIME and strip attachments; either way the goal is a local file per invoice.
import boto3, pdfplumber, os
s3 = boto3.client("s3")
BUCKET = "ap-invoices"
LOCAL = "/tmp/invoices"
def fetch_new_invoices():
os.makedirs(LOCAL, exist_ok=True)
resp = s3.list_objects_v2(Bucket=BUCKET, Prefix="incoming/")
for obj in resp.get("Contents", []):
key = obj["Key"]
if not key.endswith(".pdf"):
continue
path = os.path.join(LOCAL, os.path.basename(key))
s3.download_file(BUCKET, key, path)
yield pathConvert each PDF to raw text before sending it to the model. pdfplumber handles multi-column layouts better than naive parsers, but it is CPU-heavy. Run extraction in a worker pool and cache the text keyed by PDF hash so you don’t re-extract on retries.
def pdf_to_text(path):
with pdfplumber.open(path) as pdf:
return "\n".join(page.extract_text() or "" for page in pdf.pages)Store the raw text alongside the PDF. A common mistake is to discard the source after extraction; keep it for audit and for human review queues.
Step 2: Extract structured fields with an LLM agent
The core of AI agents accounts payable automation is reliable field extraction. Define a strict JSON schema and force the model to comply. Use function calling or response_format to avoid free-form drift. Pick a small model for the bulk of invoices and a larger one only for low-confidence rescues.
from openai import OpenAI
import json, os
client = OpenAI(
base_url="https://api.n4n.ai/v1", # OpenAI-compatible, 240+ models, fallback built in
api_key=os.environ["LLM_KEY"]
)
EXTRACT_SCHEMA = {
"type": "object",
"properties": {
"invoice_number": {"type": "string"},
"vendor_name": {"type": "string"},
"po_number": {"type": "string"},
"total_amount": {"type": "number"},
"currency": {"type": "string"},
"line_items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"sku": {"type": "string"},
"qty": {"type": "number"},
"unit_price": {"type": "number"}
}
}
},
"confidence": {"type": "number"}
},
"required": ["invoice_number", "vendor_name", "total_amount"]
}
def extract_invoice(text):
resp = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": text}],
response_format={"type": "json_schema", "schema": EXTRACT_SCHEMA}
)
return json.loads(resp.choices[0].message.content)If you need resilient model access, point the client at an OpenAI-compatible gateway such as n4n.ai, which provides automatic fallback when a provider is degraded and per-token metering. The schema enforces that the agent returns only what your downstream code expects.
Prompt design and caching
Add a short system prompt: “You are an AP clerk. Extract only values present in the text. Set confidence to 1.0 if all fields clear, lower if ambiguous.” Keep the user content to the raw text plus a one-line instruction to follow the schema.
Cache extractions by invoice hash. Provider cache-control hints forwarded by the gateway cut repeat costs on identical invoices from the same vendor. For a batch of 500 invoices from one supplier, that cache hit rate often exceeds 80 percent because the header layout is identical.
Step 3: Match invoices to purchase orders
Extracted po_number and vendor_name let you reconcile against your procurement system. Query your PO store; reject if no match or if amounts diverge beyond tolerance.
def match_po(extracted, tolerance=0.01):
po = db.query(
"SELECT total, vendor FROM purchase_orders WHERE po_number = %s",
(extracted["po_number"],)
)
if not po:
return False, "PO not found"
if po.vendor != extracted["vendor_name"]:
return False, "Vendor mismatch"
if abs(po.total - extracted["total_amount"]) / po.total > tolerance:
return False, "Amount exceeds tolerance"
return True, "OK"Keep the tolerance configurable. Two-way matching (PO vs invoice) is enough for most services; three-way adds receiving notes. For three-way, join on goods-receipt records and confirm quantities booked. AI agents accounts payable automation shines when it flags partial deliveries instead of blindly approving.
Step 4: Validate and route exceptions
Not every invoice clears automatically. Set a confidence threshold from the model and push low-confidence cases to a human queue. Design the queue so a reviewer sees the PDF, the extracted JSON, and the failure reason side by side.
def route_invoice(extracted, text):
ok, reason = match_po(extracted)
if not ok:
queue_human_review(extracted, text, reason)
return "review"
if extracted.get("confidence", 1.0) < 0.9:
queue_human_review(extracted, text, "Low model confidence")
return "review"
return "approved"A key benefit of AI agents accounts payable automation is handling exceptions without blocking the queue. Failed items should land in a dead-letter bucket with the exact step recorded. Never let the agent mutate ERP state on a review path.
Step 5: Post approved invoices to ERP
Once approved, push the invoice to the ERP system. Most expose a REST endpoint; authenticate with OAuth2. Make the call idempotent by keying on invoice_number so a retry doesn’t double-pay.
import requests
def post_to_erp(extracted):
token = get_erp_token()
payload = {
"external_id": extracted["invoice_number"],
"vendor": extracted["vendor_name"],
"amount": extracted["total_amount"],
"currency": extracted["currency"],
"po_ref": extracted["po_number"]
}
r = requests.post(
"https://erp.internal/api/v1/bills",
json=payload,
headers={"Authorization": f"Bearer {token}"}
)
r.raise_for_status()
return r.json()["id"]Wrap this in a retry with exponential backoff. ERP APIs are flaky at 5pm. If the ERP returns a duplicate error, treat it as success and fetch the existing bill ID.
Step 6: Verify success and monitor
Verification is concrete. After the agent runs, confirm:
- The invoice PDF moved from
incoming/toprocessed/in S3. - The ERP returns a bill ID and the record shows status
approved. - Your metering dashboard shows token usage per extraction call.
# Check processed bucket
aws s3 ls s3://ap-invoices/processed/ | grep INV-2024-001
# Query ERP
curl -H "Authorization: Bearer $ERP_TOKEN" https://erp.internal/api/v1/bills?external_id=INV-2024-001Audit trail
For AI agents accounts payable automation to stay trustworthy, log every LLM request ID and the matched PO. Store the raw response alongside the normalized JSON so you can reconstruct why a decision was made six months later. If a provider degrades, the gateway fallback ensures the pipeline doesn’t stall. Per-token metering lets you attribute cost to each vendor batch.
Build the agent incrementally: start with extraction only, then add PO matching, then ERP posting. Each step is independently testable with the verification commands above. When a new invoice format appears, add one few-shot example to the prompt and bump the cache key—no model retraining required.