Automated Accounting Reconciliation with AI Agents

The Accounting Reconciliation Nightmare

For entrepreneurs and professionals handling their own accounting, the monthly reconciliation ritual is a dreaded task. You have a bank statement from Revolut or your local bank with dozens of transactions. You have a folder full of PDF invoices and receipts collected over the month.

The problem? They rarely match perfectly.

• 

• Dates don't align: You paid for a subscription on the 1st, but it cleared your bank on the 3rd.

• Names vary: The invoice says "Amazon Web Services," but the bank statement says "AMZN MKTPLC PAYMENTS."

• Amounts differ: Currency conversion rates or slight rounding differences make a $100 invoice appear as $99.98 or $101.05.

Currently, this means opening every single PDF, checking the date and amount, searching your spreadsheet or accounting software for a matching transaction, and manually linking them. It’s tedious, prone to error, and a massive drain on time that could be spent growing your business.

The Solution: An AI Agent That "Thinks" Like an Accountant

Imagine a system that watches a folder for new invoices. When you drop a PDF in, it wakes up, reads the document, understands who it's from and what it's for, and then intelligently hunts for the matching transaction in your financial records.

If the dates are a few days off? It knows that's normal. If the vendor name is slightly different? It figures it out. If the currency conversion makes the amount slightly different? It understands.

This isn't just simple keyword matching; it's an AI Agent using semantic understanding to reconcile your books exactly like a human would—but in seconds instead of hours.

What You'll Learn

In this use case, we'll explore how to build an automated reconciliation workflow using n8n and Large Language Models (LLMs).

Quick Navigation:

• The Experience: Drag, Drop, Done
• How It Works: The n8n Workflow
• Key Benefits
• Getting Started

The Experience: Drag, Drop, Done

Let's walk through the new, automated workflow.

The Scenario

You are a freelancer or business owner. It's the end of the month. You've downloaded your bank statement (CSV) into a Google Sheet and you have a folder of 50 PDF invoices.

Step 1: The Upload

You simply drag all 50 PDF files into a specific "To Process" folder in Google Drive. That's your only manual action.

Step 2: The AI Analysis

Behind the scenes, the agent picks up the first file. It's an invoice from "Anthropic API" for $24.50 dated November 12th.

The agent reads the PDF and extracts:

• Vendor: Anthropic
• Date: 2025-11-12
• Amount: 24.50

Step 3: The Intelligent Match

The agent looks at your Google Sheet. It filters for transactions around November 12th (giving a 3-day buffer). It finds:

1. Nov 11 - STARBUCKS - $5.50
2. Nov 12 - ANTHROPIC TECHNOLOGIES - $24.50
3. Nov 14 - UBER TRIP - $15.20

A simple exact match script might fail if the vendor name on the bank statement ("ANTHROPIC TECHNOLOGIES") doesn't perfectly match the invoice ("Anthropic").

But our AI Agent looks at the candidates and determines: "Transaction #2 matches the vendor 'Anthropic' and the amount is exact. The date is the same. This is a match."

Step 4: The Reconciliation

The agent automatically:

1. Renames the PDF file to include the transaction ID (e.g., 2025-11-12_Anthropic_24.50_0f83fs-2d3k2.pdf).
2. Updates your Google Sheet, adding the filename to the transaction row so you have a direct link.
3. Moves the PDF to a "Processed" folder.

The Result

When you check your folder a few minutes later, it's empty. Your "Processed" folder is full of neatly renamed files. Your Google Sheet is fully populated with links to every invoice. You've just saved 2-3 hours of work every single month.

How It Works: The n8n Workflow

This solution utilizes n8n, a powerful workflow automation tool, to orchestrate the process.

Click to open the full n8n workflow diagram for this reconciliation agent.

Key Components

1. Local File Trigger This node watches a local directory (or a cloud folder like Google Drive) for new files. As soon as a PDF invoice is dropped into the folder, it initiates the workflow.

2. Invoice Details Extraction A sequence of nodes that reads the invoice file and uses an OpenAI Chat Model to extract key details. It parses the PDF text and returns a structured JSON object containing the date, vendor_name, and total_amount.

3. Filter Transaction Candidates The workflow connects to your Google Sheet to retrieve existing transactions. It uses a function node to filter these records, selecting only transactions that occurred within a +/- 3 day window of the invoice date. This drastically reduces the "noise" for the AI model.

4. Find Match (LLM Chain) This is the decision-making core. It uses a Basic LLM Chain connected to an OpenAI model. We feed it the extracted invoice data and the filtered transaction candidates. The model analyzes the potential matches and uses a Structured Output Parser to return the exact row ID of the matching transaction.

5. Matched Invoice Handler If a match is found (determined by an If node), the workflow proceeds to:

   • Generate filename: Creates a standardized name (e.g., YYYY-MM-DD_Vendor_Amount_Transaction-Id.pdf).
   • Update sheet: Writes the new filename into the corresponding transaction row in Google Sheets.
   • Rename and move file: Moves the processed PDF to a "Processed" folder.

6. Unmatched Invoice Handler If no match is found, the file is moved to a separate "Unmatched" or "Review" folder for manual inspection, ensuring nothing gets lost.

Key Benefits

Getting Started

Ready to implement this? Here is a roadmap.

Phase 1: The Setup

Goal: Get the data flowing.

• Set up a Google Drive folder structure: Inbox and Processed.
• Create a Google Sheet with your bank transactions.
• Install an n8n instance (local Docker image, desktop app, or a small cloud VM) and make sure it can access your invoice folder and Google account.
• Create a basic n8n workflow with a File Trigger node that watches your invoice folder for new PDFs and passes the file path to the next nodes.

Phase 2: The Intelligence

Goal: Accurate extraction and matching.

• Add the PDF extraction node. Test it with different invoice formats to ensure it captures the date and amount reliably.
• Implement the "candidate search" logic in Google Sheets (filtering by date).
• Add the LLM node for the matching logic. Start with a strong model like GPT-4o for best reasoning capabilities.

The Matching Prompt We Use

In the LLM node, we use a structured prompt that behaves like a forensic accountant and enforces strict matching rules on amounts, dates, and vendors:

You are an expert forensic accountant. Your goal is to match a PDF invoice to a bank transaction line item with 100% accuracy.

Task: Compare the INVOICE data below with the list of CANDIDATE TRANSACTIONS.

### CRITICAL MATCHING LOGIC:

1. **PRIORITIZE "OrigAmount":** - The bank export contains `Amount` (often converted to EUR/CHF) and `OrigAmount` (Original Transaction Currency).

   - **Check `OrigAmount` FIRST.** If the Invoice is 20.16, look for 20.16 in the `OrigAmount` field. This is the strongest match signal.

   - Only check the standard `Amount` field if `OrigAmount` is null or zero.

2. **IGNORE NEGATIVE SIGNS:** - Bank transactions are debits (negative numbers). Invoices are positive.

   - Treat `-20.16` and `20.16` as an EXACT MATCH. Compare absolute values only.

3. **DATE BUFFER:** - The Bank Date is usually 1-5 days *after* the Invoice Date.

   - Example: Invoice Nov 23 matches Bank Nov 24 or Nov 27.

4. **FUZZY VENDOR & PARTIAL MATCHING:**

   - **Substring Check:** Check if the Invoice Vendor is strictly contained inside the Bank Description (or vice versa).

   - **Ignore Tech Suffixes:** Treat "Mongodbcloud", "MongoDB Inc", "MongoDB.com", and "MongoDB" as the SAME vendor.

   - **Ignore Payment Processors:** If the bank says "Stripe*Mongodb" or "Paddle*Cursor", match it to "MongoDB" or "Cursor".

   - *Example:* "Mongodbcloud" matches "MongoDB".

   - Mongodb and Mongodbcloud should be considered the same transaction.

### Input Data:

Invoice Vendor: {{ $json.invoice_vendor }}

Invoice Amount: {{ $json.invoice_amount }}

Invoice Date: {{ $json.invoice_date }}

### Candidates:

{{ JSON.stringify($json.candidates) }}

### Output:

Return strictly a JSON object with the matched transaction details. If no match is found, return "matched": false.

You can further tune this prompt for your own bank exports (field names, currencies, or vendor patterns), but this pattern already delivers highly reliable matches.

Phase 3: From Match to Clean Records

Goal: Turn every successful match into a clean, auditable accounting record.

• Configure the file operations so that matched PDFs are renamed with a stable pattern (date, vendor, amount, transaction id) and moved from the Inbox to a Processed folder.
• Add the Update Row node to Google Sheets so the matched transaction row is enriched with the final filename, match status, and any additional metadata you care about (e.g., confidence score, tags).
• Optionally, add a second branch for unmatched invoices that moves them to a separate Review folder and marks them in the sheet, giving you a clear queue for manual follow-up instead of scattered edge cases.

Build or Buy?

This kind of agent can be implemented in two main ways: build your own workflow (e.g., in n8n) or adopt an off-the-shelf tool.

In practice, many teams start by building this workflow once in n8n, prove the value on their own data, and only then decide whether to extend it or move to a broader platform.

Conclusion

Accounting doesn't have to be a manual drudge. By combining simple file automation with a narrowly focused AI agent, you can turn a multi-hour monthly chore into a background system that quietly keeps your books clean.

The deeper shift is mindset: instead of adopting one big tool and bending your process around it, you can compose small agents that each solve a specific, well-defined job—like matching invoices to transactions. Once you’ve proven this pattern for reconciliation, you can reuse it for other workflows (subscriptions, payroll, refunds) and gradually build an automation layer that fits your business instead of the other way around.