# Custom Bank Statement Parser Development | Tembrant

> We build bank statement parsers and extraction APIs that check every figure against the printed balances and hold any statement that doesn't tie out.

Source: https://tembrant.com/bank-statement-parser-development
Last updated: 2026-11-21

[Finance](https://tembrant.com/finance) / Custom bank statement parser development

# Custom bank statement parser development

Statement extraction that proves its own output against the bank's printed balances, delivered as a library or an API.

[Start a project](https://tembrant.com/contact)

On this page

* [Who this is for](#who-this-is-for)
* [How we build it](#how-we-build-it)
* [How the work is run](#how-the-work-is-run)
* [What you get](#what-you-get)

Every lender, fintech and bookkeeping team that works with bank statements hits the same wall. Banks publish PDFs, not data. Each bank prints its own layout, changes it without notice, and keeps several versions in use at once. A generic extractor reads most rows correctly, and the rows it gets wrong look exactly like the ones it got right.

That is the real problem. A deposit read as a withdrawal, a wrapped narration that swallows an amount, a page footer read as a transaction: none of these throws an error. They surface weeks later as a wrong credit decision, a ledger that won’t close, or an analyst re-keying a statement by hand.

We build parsers that check their own output against figures the bank already printed, and refuse to pass a statement that doesn’t tie out.

## Who this is for

* **Lenders and credit teams** reading statements to underwrite: income, obligations, bounced payments.
* **Fintechs** that need a statement extraction API behind their own product.
* **Bookkeeping outsourcers and accounting firms** turning client statements into ledger entries at volume.

## How we build it

We built and run this for our own product. [Lekhavo](https://tembrant.com/products/lekhavo) takes Indian chartered-accountant practices from bank statements to closed books, and its statement parser is a separate service that other applications call too. The full story is in the [bank statement parser case study](https://tembrant.com/case-studies/bank-statement-parser). The same method shapes client work.

### One parser per layout, picked automatically

Each bank layout gets its own parser. When a file arrives, every registered parser scores how well it matches, and the highest score wins, with a fixed tie-break so the same file always goes to the same parser. A file no parser recognizes is rejected as unsupported instead of being forced through the closest match.

### Geometry, not guesswork

For PDFs we read words with their positions on the page and assign them to columns by x-coordinate. Right-aligned amounts are clustered by their right edges. A number only counts as an amount if it lines up with an amount column; otherwise it stays in the narration, which keeps stray digits from payment reference strings out of your totals.

### The bank’s own figures are the test

A correctly parsed statement balances: each row’s running balance equals the previous balance plus that row’s amount, and the opening balance plus every transaction equals the closing balance. We check both, for every statement, on every parse. Where a bank prints a summary block with debit and credit totals or counts, the parser reads those too and compares the rows against them.

When a layout leaves something ambiguous, such as a sparse withdrawal column, the parser may infer the direction of each amount from the running balance. In our parser that correction is applied only when the inferred rows reproduce the printed opening, closing, totals and counts exactly. Otherwise the statement is left unbalanced so the check catches it, rather than being quietly rewritten.

### Failures are held, not hidden

A statement that doesn’t tie is stopped before its transactions are committed. The record keeps the gap to the paisa (or cent), the parser and its version, and the reason. A reviewer accepts it, rejects it or sends it back for a reparse once the parser is fixed. The [guide to validating bank statement extraction](https://tembrant.com/guides/bank-statement-extraction-accuracy) covers these checks in detail, and you can use it even if you never hire us.

### Duplicates without data loss

Overlapping statements and re-uploads are normal. We fingerprint each transaction by account, date, amount and normalized description, plus its position among identical rows, so a second copy of a statement adds nothing while two genuine identical payments on the same day both survive.

## How the work is run

We build with an AI software factory: many agents working in parallel, held to fixed gates. Each change starts from a written spec, gets its failing tests before its code, goes through independent reviews, and ships only after a human signs off. For a parser, the tests are real statements from your sample set, re-parsed on every change and held to the balance checks above. A new layout is done when its fixtures reconcile, not when a few rows look right.

## What you get

* Parsers for the banks and layouts in your sample set, as a library or behind an HTTP API.
* A typed output schema: statement metadata (bank, account, period, opening and closing balance) and transactions with the running balance after each row.
* Balance and total checks on every parse, with held statements and a review flow.
* For an API: asynchronous jobs, idempotent submission, signed webhooks, and each parse run in its own process under a hard time limit.
* A regression suite built from your own statements, so a layout change at the bank shows up as a failing test.
* Deployment on your infrastructure or ours, with the documentation your team needs to add the next layout.

If balances tie out, the data downstream can be trusted. If they don’t, you find out at import, not at month-end. If statements are a bottleneck for your team, [tell us about your banks and volumes](https://tembrant.com/contact).

## Questions

Which banks can you support?

Our own parser handles 16 Indian banks today, in PDF, CSV and Excel exports. For your project we build parsers for the banks and layouts in your sample set, wherever they are. The method carries over to any bank; each new layout still needs its own parser and real sample statements to test against.

What happens when a statement doesn't balance?

It is held before anything is written to your database, with the size of the gap recorded. A reviewer can accept it, reject it or send it back for a reparse, and each decision is logged. Nothing that fails the check reaches your ledger quietly.

Do you use OCR or a language model to read statements?

Our production parsers read the PDF's own text and its position on the page, then place each word into a column by its coordinates. That gives the same output for the same file every time and keeps amounts exact. If your inputs are scans, we discuss OCR as a separate step with its own checks.

Can we own the code and run it ourselves?

Yes. We can deliver a library your team imports, a containerized service you deploy, or a service we run for you. The tests and sample-statement fixtures come with the code.

What do you need from us to start?

Real statements from the banks you care about, with the period and the printed balances intact, and a description of where the output goes. We agree with you on handling the samples before they are shared, since they contain personal financial data.

## Related

* [How we built Lekhavo's bank statement parser](https://tembrant.com/case-studies/bank-statement-parser)
* [How to validate bank statement extraction](https://tembrant.com/guides/bank-statement-extraction-accuracy)
* [Custom reconciliation software development](https://tembrant.com/reconciliation-software-development)
* [Finance overview](https://tembrant.com/finance)

## Have financial data that has to tie out?

Tell us what you want to build. We reply with questions, a plan and an estimate.

[Start a project](https://tembrant.com/contact)

![](https://tembrant.com/emblem.webp)
