GuideOdoo AccountingMarch 13, 2026

Odoo 19 Bank Reconciliation:
Automating Statement Matching with AI Rules

INTRODUCTION

Bank Reconciliation Is the #1 Bottleneck in Monthly Closing

Every finance team knows the pain. The last week of the month arrives, and the accounting department disappears into a reconciliation black hole. Bank statements pile up. Transactions sit unmatched. The controller can't close the books until every line in the bank journal ties back to an invoice, bill, or GL entry—and in a company processing 2,000+ transactions per month, that means days of manual clicking.

The real cost isn't the labor—it's the delay. Every day your books stay open past month-end is a day your CFO is making decisions on stale data. Cash flow forecasts drift. Variance reports become meaningless. Board reporting slips. And if you're in a regulated industry, late closes trigger audit findings.

Odoo 19 ships with a reconciliation engine that most implementations barely configure. Out of the box, it handles simple one-to-one matching. But with the right reconciliation models, regex-based rules, and tolerance settings, you can automate 80-95% of bank statement matching—turning a 3-day monthly task into a 2-hour review. This guide shows you exactly how to set that up: the reconciliation model architecture, statement import configuration, AI-powered rule creation, complex matching scenarios, and the mistakes that silently corrupt your bank journals.

Understanding Odoo 19's Reconciliation Models: Auto-Match, Write-Off, and Manual

Before writing a single rule, you need to understand Odoo's three reconciliation model types and when to use each. Every reconciliation model in Odoo 19 is an account.reconcile.model record with a rule_type field that determines its behavior.

Rule Type	Technical Value	Behavior	Best For
Invoice Matching	`invoice_matching`	Matches bank lines to open invoices/bills by amount, reference, or partner	Customer payments, vendor payments, any transaction that maps to an existing journal entry
Write-off	`writeoff_suggestion`	Creates a new journal entry to balance the bank line (e.g., expense, fee, rounding)	Bank fees, interest income, payroll taxes, recurring charges with no matching invoice
Manual	`writeoff_button`	Adds a button in the reconciliation widget for one-click write-offs	Ad-hoc adjustments: rounding differences, small discrepancies, exchange rate gaps

How the Matching Engine Processes Rules

When you open the bank reconciliation widget, Odoo iterates through your reconciliation models in sequence order (lowest sequence number first). For each unreconciled bank statement line, it tests every model's conditions. The first model that matches wins—Odoo proposes that match and stops evaluating further models for that line.

# Odoo's internal matching logic (account/models/reconciliation_widget.py)
# Simplified for clarity — actual implementation handles batching

for st_line in bank_statement_lines:
    for model in reconcile_models.sorted('sequence'):
        # Test conditions: partner, amount, label regex, etc.
        candidates = model._get_reconciliation_proposition(st_line)
        if candidates:
            st_line.reconcile_model_id = model
            st_line.matched_entries = candidates
            break  # First match wins — order matters!

Architecture Insight

The auto_reconcile flag on a reconciliation model is powerful but dangerous. When enabled, matching lines are automatically reconciled without human review. Use this only for high-confidence rules (exact amount + exact reference + known partner). For everything else, let Odoo propose the match and require a human click to confirm.

Setting Up Bank Statement Import: OFX, CAMT.053, CSV, and Live Bank Feeds

Reconciliation rules are only as good as the data they operate on. Clean statement imports with consistent labels, references, and partner information are the foundation. Odoo 19 supports four import methods, each with different data quality characteristics.

Format Comparison

Format	Data Quality	Partner Info	Setup Effort	Notes
CAMT.053	Excellent	Full (name, IBAN, BIC)	Low	ISO 20022 standard. Best for EU banks. Structured references (SCOR) enable exact matching.
OFX/QFX	Good	Partial (payee name only)	Low	Common in North America. Transaction labels vary by bank. Install `account_bank_statement_import_ofx`.
CSV	Variable	Depends on bank export	Medium	Requires column mapping. Fragile—bank changes export format without notice.
Bank Feeds (API)	Excellent	Full	Medium-High	Live sync via Plaid, Yodlee, or Salt Edge. Best data but requires provider setup. Odoo.sh includes Salt Edge.

Configuring the Bank Journal for Imports

Each bank account in Odoo maps to a journal of type bank. The journal's configuration determines which import formats are accepted and how statement lines are parsed.

# Create a bank journal with import settings
bank_journal = env['account.journal'].create({
    'name': 'Bank of America - Operating',
    'type': 'bank',
    'code': 'BNKA',
    'currency_id': env.ref('base.USD').id,
    'bank_account_id': env['res.partner.bank'].create({
        'acc_number': '1234567890',
        'partner_id': env.company.partner_id.id,
        'acc_type': 'bank',
    }).id,
    # Import settings
    'bank_statements_source': 'file_import',  # or 'online_sync'
})

# For online sync (Salt Edge / Plaid):
# bank_journal.bank_statements_source = 'online_sync'
# bank_journal.online_bank_statement_provider = 'salt_edge'

CSV Import Column Mapping

CSV imports are the most common source of reconciliation headaches. The import wizard requires you to map columns manually, and one wrong mapping—swapping debit and credit, or mapping the wrong date format—silently corrupts your bank journal.

date,payment_ref,partner_name,amount,currency
2026-03-01,"INV/2026/0042 - Acme Corp","Acme Corporation",-4500.00,USD
2026-03-01,"Wire Transfer REF#98765","GlobalTech Inc",12750.00,USD
2026-03-02,"Monthly Service Fee","",-29.95,USD
2026-03-02,"Interest Income","",3.42,USD

Data Quality Tip

The payment_ref field (called "Label" or "Reference" in the import wizard) is the single most important field for automated matching. If your bank includes invoice numbers in this field, regex-based reconciliation rules can auto-match 70%+ of your transactions. If your bank only provides generic labels like "Wire Transfer," you'll need to rely on amount + partner matching, which has lower accuracy.

Creating AI-Powered Reconciliation Rules: Regex Patterns, Amount Tolerance, and Partner Matching

This is where the real automation lives. Odoo 19's reconciliation models support regex-based label matching, amount tolerance ranges, partner auto-detection, and multi-condition logic. A well-configured set of rules can auto-reconcile 80-95% of your bank statement lines.

Rule 1: Invoice Matching with Reference Regex

The highest-confidence automatic rule. When your customers include the invoice number in their payment reference, this rule extracts it with a regex pattern and matches it to the open invoice.

<odoo>
  <record id="reconcile_model_invoice_ref"
          model="account.reconcile.model">
    <field name="name">Invoice Reference Match</field>
    <field name="rule_type">invoice_matching</field>
    <field name="sequence">10</field>
    <field name="auto_reconcile">True</field>
    <field name="match_nature">both</field>

    <!-- Match when the bank label contains our invoice pattern -->
    <field name="match_label">contains</field>
    <field name="match_label_param">INV/</field>

    <!-- Tolerance: allow up to 0.05 currency units difference
         (covers rounding on international wires) -->
    <field name="match_amount">True</field>
    <field name="match_amount_min">99.5</field>
    <field name="match_amount_max">100.5</field>

    <!-- Must match an existing partner -->
    <field name="match_partner">True</field>
  </record>
</odoo>

Rule 2: Bank Fee Auto Write-Off

Bank fees appear every month with predictable labels. Instead of manually categorizing each one, a write-off rule matches the label pattern and posts to the correct expense account automatically.

<odoo>
  <record id="reconcile_model_bank_fees"
          model="account.reconcile.model">
    <field name="name">Bank Fees & Charges</field>
    <field name="rule_type">writeoff_suggestion</field>
    <field name="sequence">20</field>
    <field name="auto_reconcile">True</field>

    <!-- Regex: match common bank fee labels -->
    <field name="match_label">match_regex</field>
    <field name="match_label_param">
      (?i)(service\s+fee|monthly\s+fee|maintenance\s+charge|
      wire\s+fee|ach\s+fee|overdraft\s+fee|account\s+fee)
    </field>

    <!-- Only match debits (negative amounts) under $500 -->
    <field name="match_nature">amount_received_is_negative</field>
    <field name="match_amount">True</field>
    <field name="match_amount_max">500</field>
  </record>

  <!-- Write-off line: post to Bank Charges expense -->
  <record id="reconcile_model_bank_fees_line"
          model="account.reconcile.model.line">
    <field name="model_id" ref="reconcile_model_bank_fees"/>
    <field name="account_id" ref="account.a_expense"/>
    <field name="label">Bank Fee</field>
    <field name="amount_type">percentage</field>
    <field name="amount_string">100</field>
  </record>
</odoo>

Rule 3: Partner Detection from Bank Label

When the bank label contains a customer or vendor name but no invoice reference, Odoo can detect the partner and propose matching invoices. The key is the match_partner field combined with the partner's bank account or commercial name mapping.

# Add bank accounts to partners for automatic detection
# Odoo matches the counterpart IBAN on bank statement lines
# to partner bank accounts in res.partner.bank

partner = env['res.partner'].browse(partner_id)
env['res.partner.bank'].create({
    'partner_id': partner.id,
    'acc_number': 'DE89370400440532013000',  # Customer's IBAN
    'acc_type': 'iban',
})

# For name-based matching, ensure partner names are clean:
# "ACME CORP" in the bank label must match "Acme Corporation"
# Use the partner's commercial_company_name or add trade names
partner.write({
    'name': 'Acme Corporation',
    # Odoo also checks these for fuzzy matching:
    'ref': 'ACME',  # Internal reference
})

Regex Power Move

For companies with predictable invoice numbering, build a regex that extracts the reference from noisy bank labels. If your invoices are INV/2026/XXXX and bank labels look like "Wire Transfer INV/2026/0042 from Acme", the regex INV/\d{4}/\d{4,} extracts the invoice number regardless of surrounding text. Set this on the reconciliation model's match_label_param with match_label = 'match_regex'.

Handling Partial Payments, Batch Payments, and Multi-Invoice Matching

One-to-one matching is the easy case. Real-world reconciliation involves partial payments, batch deposits that aggregate multiple customer payments into a single bank line, and single payments that cover multiple invoices. Each requires different configuration.

Partial Payments

A customer pays $8,000 against a $10,000 invoice. Odoo needs to match the $8,000 bank line to the invoice and leave a $2,000 residual. The reconciliation model handles this through the match_amount tolerance settings:

<odoo>
  <record id="reconcile_model_partial_payment"
          model="account.reconcile.model">
    <field name="name">Partial Payment Match</field>
    <field name="rule_type">invoice_matching</field>
    <field name="sequence">30</field>
    <!-- Do NOT auto-reconcile partials — require review -->
    <field name="auto_reconcile">False</field>

    <field name="match_partner">True</field>
    <field name="match_nature">both</field>

    <!-- Allow payment to be 50-100% of invoice amount -->
    <field name="match_amount">True</field>
    <field name="match_amount_min">50</field>
    <field name="match_amount_max">100</field>

    <!-- Match the oldest open invoice for this partner -->
    <field name="matching_order">old_first</field>

    <!-- Allow partial reconciliation (leave residual) -->
    <field name="allow_payment_tolerance">True</field>
    <field name="payment_tolerance_type">percentage</field>
    <field name="payment_tolerance_param">50</field>
  </record>
</odoo>

Multi-Invoice Matching

A customer sends one payment for $25,000 that covers three invoices ($10,000 + $8,500 + $6,500). Odoo 19's reconciliation widget can match a single bank line to multiple invoices when the sum of selected invoices equals the bank line amount. The matching engine tries combinations automatically:

# Odoo's reconciliation engine tries combinations of open invoices
# for the same partner to find a group that sums to the bank amount

def _get_invoice_matching_proposition(self, st_line):
    partner = st_line.partner_id
    open_invoices = self.env['account.move.line'].search([
        ('partner_id', '=', partner.id),
        ('account_id.reconcile', '=', True),
        ('full_reconcile_id', '=', False),
        ('balance', '!=', 0),
    ], order='date_maturity ASC')

    target = abs(st_line.amount)
    # Try single invoice match first
    for inv in open_invoices:
        if abs(inv.amount_residual) == target:
            return inv

    # Try two-invoice combinations
    for i, inv1 in enumerate(open_invoices):
        for inv2 in open_invoices[i+1:]:
            if abs(inv1.amount_residual + inv2.amount_residual) == target:
                return inv1 | inv2

    # ... continues with 3-invoice combos up to a limit

Batch Payment Deposits

When you use Odoo's batch payment feature (Accounting > Customers > Batch Payments), multiple customer payments are grouped into a single bank deposit. The bank shows one line for the total deposit amount. To reconcile, you match the bank line against the batch payment record rather than individual invoices:

<odoo>
  <record id="reconcile_model_batch_deposit"
          model="account.reconcile.model">
    <field name="name">Batch Deposit Match</field>
    <field name="rule_type">invoice_matching</field>
    <field name="sequence">15</field>
    <field name="auto_reconcile">False</field>

    <!-- Match by batch payment reference in bank label -->
    <field name="match_label">match_regex</field>
    <field name="match_label_param">BATCH/\d{4}/\d+</field>

    <field name="match_amount">True</field>
    <field name="match_amount_min">99.9</field>
    <field name="match_amount_max">100.1</field>
  </record>
</odoo>

Batch Payment Workflow

The cleanest workflow for batch deposits: (1) Register individual customer payments in Odoo, (2) group them into a batch payment, (3) print the deposit slip with the batch reference, (4) take the deposit to the bank. When the bank statement arrives, the single deposit line matches the batch payment entry in Odoo's outstanding receipts. This turns a many-to-one matching problem into a simple one-to-one match.

Dealing with Bank Fees, Currency Differences, and Unreconciled Items

The last 5-20% of bank statement lines that don't auto-match are the ones that consume 80% of your reconciliation time. Bank fees, foreign exchange differences, payment processor deductions, and mystery transactions. Here's how to handle each systematically.

Bank Fees Deducted from Customer Payments

International wire transfers often arrive short. A customer sends $10,000 but your bank receives $9,975 after intermediary bank fees. Odoo needs to match the $9,975 to the $10,000 invoice and post the $25 difference to a bank charges account:

<odoo>
  <record id="reconcile_model_wire_with_fees"
          model="account.reconcile.model">
    <field name="name">Wire Payment (Bank Fee Tolerance)</field>
    <field name="rule_type">invoice_matching</field>
    <field name="sequence">25</field>
    <field name="auto_reconcile">False</field>

    <field name="match_partner">True</field>
    <field name="match_label">contains</field>
    <field name="match_label_param">wire</field>

    <!-- Allow up to 1% tolerance (covers most wire fees) -->
    <field name="allow_payment_tolerance">True</field>
    <field name="payment_tolerance_type">percentage</field>
    <field name="payment_tolerance_param">1</field>
  </record>

  <!-- The tolerance difference auto-posts to this account -->
  <record id="reconcile_model_wire_fees_line"
          model="account.reconcile.model.line">
    <field name="model_id" ref="reconcile_model_wire_with_fees"/>
    <field name="account_id" ref="account.a_expense"/>
    <field name="label">Wire Transfer Fee</field>
    <field name="amount_type">percentage_st_line</field>
    <field name="amount_string">100</field>
  </record>
</odoo>

Multi-Currency Reconciliation

If you invoice in EUR but your bank account is in USD, every payment creates a potential exchange rate difference. Odoo handles this through the currency exchange journal configured in Settings > Accounting > Default Exchange Difference Journal. The reconciliation engine automatically calculates the difference between the invoice exchange rate and the payment exchange rate, posting the gain or loss to the configured accounts.

# Ensure exchange difference accounts are configured
company = env.company
company.write({
    'currency_exchange_journal_id': env['account.journal'].search([
        ('code', '=', 'EXCH'),
        ('company_id', '=', company.id),
    ]).id,
    'income_currency_exchange_account_id':
        env['account.account'].search([
            ('code', '=', '765000'),  # FX Gain
        ]).id,
    'expense_currency_exchange_account_id':
        env['account.account'].search([
            ('code', '=', '665000'),  # FX Loss
        ]).id,
})

Payment Processor Deductions (Stripe, PayPal)

Payment processors deposit the net amount after deducting their fee. A $100 customer payment becomes a $97.10 bank deposit (Stripe's 2.9%). Create a write-off rule that splits the bank line into the payment amount and the processing fee:

<odoo>
  <record id="reconcile_model_stripe"
          model="account.reconcile.model">
    <field name="name">Stripe Payment (Net of Fee)</field>
    <field name="rule_type">invoice_matching</field>
    <field name="sequence">22</field>
    <field name="auto_reconcile">False</field>

    <field name="match_label">match_regex</field>
    <field name="match_label_param">(?i)stripe|py_</field>
    <field name="match_partner">True</field>

    <!-- Allow up to 4% tolerance (covers Stripe + intl cards) -->
    <field name="allow_payment_tolerance">True</field>
    <field name="payment_tolerance_type">percentage</field>
    <field name="payment_tolerance_param">4</field>
  </record>

  <!-- Post the fee difference to Payment Processing Fees -->
  <record id="reconcile_model_stripe_fee_line"
          model="account-reconcile.model.line">
    <field name="model_id" ref="reconcile_model_stripe"/>
    <field name="account_id" ref="account.a_expense"/>
    <field name="label">Stripe Processing Fee</field>
    <field name="amount_type">percentage_st_line</field>
    <field name="amount_string">100</field>
  </record>
</odoo>

Stripe/PayPal Integration

For high-volume e-commerce, consider Odoo's native Stripe integration (payment_stripe) which registers payments directly in Odoo when they occur. This creates the journal entry at payment time, and the bank reconciliation only needs to match the Stripe payout (which may batch multiple transactions). This is significantly cleaner than reconciling individual transactions from the bank statement.

3 Bank Reconciliation Mistakes That Silently Corrupt Your Books

You import a bank statement for March 1-15. Two weeks later, you import March 1-31. The overlapping transactions from March 1-15 are now posted twice in your bank journal. Your bank balance in Odoo is suddenly $50,000 higher than the actual bank balance, and every report downstream is wrong. This is the single most common bank reconciliation disaster, and Odoo's duplicate detection is not foolproof—especially with CSV imports that lack unique transaction IDs.

Our Fix

Use CAMT.053 or OFX formats whenever possible—they include unique transaction IDs that Odoo uses for duplicate detection. For CSV imports, always check the statement's start and end balance in the import wizard against your bank's actual balance. If you must import overlapping date ranges, use the "Import" journal setting that checks for duplicate unique_import_id values. For already-duplicated data, identify the duplicate statement in Accounting > Bank Statements, reset it to draft, and delete it.

Your bank journal is configured with USD as its currency. You import a statement that includes a EUR wire transfer. Odoo creates the bank statement line but uses the company currency (USD) for the debit/credit amounts while storing the foreign amount separately. If the exchange rate at import time differs from the rate when the invoice was created, you get a phantom exchange difference that makes reconciliation fail silently. The amounts appear to match in the reconciliation widget, but the underlying journal entries are off by the exchange rate delta.

Our Fix

If you regularly receive foreign currency payments, create separate bank journals per currency or configure the exchange difference journal and accounts (Settings > Accounting > Default Exchange Difference Journal). Always update exchange rates before importing statements: Accounting > Configuration > Settings > Automatic Currency Rates with a daily cron job pulling from the ECB or your central bank. The rate at import time must match reality or your reconciliation will perpetually show unexplained differences.

You create a general "Match by partner and amount" rule and a specific "Match Stripe payments with fee write-off" rule. Both are set to auto_reconcile = True. The general rule has sequence 10; the Stripe rule has sequence 30. A Stripe deposit comes in. The general rule matches it first—to the full invoice amount. But the bank deposit is net of the Stripe fee. The reconciliation creates a partial match with an unexplained residual, and the Stripe fee never gets posted to the correct expense account. Your P&L understates payment processing costs for months before anyone notices.

Our Fix

Always order specific rules before general rules. Stripe/PayPal fee rules should have sequence 15-25. General partner+amount matching should be sequence 50+. The rule evaluation is a first-match-wins system. Audit your rule order quarterly by going to Accounting > Configuration > Reconciliation Models and sorting by sequence. Test new rules on a draft statement (don't post it) to verify they match the correct transactions before enabling auto-reconcile.

BUSINESS ROI

What Automated Bank Reconciliation Saves Your Finance Team

Reconciliation automation isn't an IT project—it's a finance operations transformation:

80-95%Auto-Match Rate

Well-configured reconciliation rules match the vast majority of bank transactions without human intervention. Your team reviews exceptions, not every line.

3 days → 2 hoursMonthly Close Time

Bank reconciliation drops from the longest task in month-end close to a quick exception review. Your controller gets those days back for analysis and planning.

ZeroDuplicate Postings

Proper statement import configuration with unique transaction IDs eliminates the most common source of balance discrepancies and audit findings.

For a company processing 2,000 bank transactions per month with a fully-loaded accountant cost of $45/hour, reducing manual reconciliation time from 24 hours/month to 2 hours/month saves $11,880 per year in direct labor—and the faster close means your leadership team gets accurate financials a week earlier every month. That's better decision-making at every level of the organization.

SEO NOTES

Optimization Metadata

Meta Desc

Complete guide to automating Odoo 19 bank reconciliation. Configure reconciliation models, regex-based matching rules, bank statement imports, and handle partial payments, batch deposits, and currency differences.

H2 Keywords

1. "Odoo 19 Reconciliation Models: Auto-Match, Write-Off, and Manual"
2. "Bank Statement Import: OFX, CAMT.053, CSV, and Live Bank Feeds"
3. "AI-Powered Reconciliation Rules: Regex Patterns, Amount Tolerance, and Partner Matching"
4. "Partial Payments, Batch Payments, and Multi-Invoice Matching"
5. "3 Bank Reconciliation Mistakes That Silently Corrupt Your Books"