AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I convert a bank statement PDF into an Excel or CSV of transactions for free without uploading it?

Open AnyTool’s Bank Statement Parser, upload your bank-statement PDF (digital or scanned), and click Parse. It gets the text entirely in your browser — for a digital PDF it reads the embedded text layer with pdfjs while keeping each text item’s X/Y position, then hands those positioned items to a rule-based engine that clusters them into rows and infers the date column and the right-aligned debit, credit and balance columns by their geometry; a scanned page or image is OCR’d with tesseract.js and parsed from the line text instead. The result is an editable transaction table (date, description, debit, credit, balance) plus a summary (transaction count, total debits/out, total credits/in, opening and closing balance), which you can correct cell-by-cell and export as a real .xlsx (via exceljs) or CSV (via papaparse), or copy. Everything runs locally, so your statement is never uploaded — safe for confidential documents. A statement is text at coordinates, not a real table, and bank layouts vary enormously, so this is a best-effort reconstruction: always review every row and verify the totals and closing balance against the original before using it for accounting, a loan or taxes.

  • Upload a bank-statement PDF — pdfjs reads the positioned text layer, tesseract.js OCRs scans & images, all in your browser
  • A rule-based engine rebuilds the table: clusters rows by Y, infers the date / debit / credit / balance columns by X
  • Editable transactions (date, description, debit, credit, balance) + summary: count, total debits/credits, opening/closing balance
  • Export a real .xlsx (exceljs) or CSV (papaparse), or copy straight into Excel / Google Sheets
  • 100% client-side — your statement is never uploaded; reconstruction, so verify totals & closing balance before accounting/loans/taxes

What is

Bank statement parsing (PDF table reconstruction)

Bank statement parsing is the process of turning a statement document into a structured transaction table — date, description, debit (money out), credit (money in) and running balance — so it can be exported, reconciled or imported into a spreadsheet or accounting software instead of being retyped. The hard part is that a statement PDF is not a real table: it is text placed at (x, y) coordinates on the page. AnyTool’s Bank Statement Parser does the whole job in the browser: for a digital PDF it reads the text layer with pdfjs keeping each item’s position, then clusters items into rows by their Y coordinate and infers the date column and the right-aligned amount/balance columns by clustering the right edges of numeric tokens; for a scan it falls back to tesseract.js OCR and a regex line parser. Because bank layouts vary enormously (separate debit/credit columns vs a single signed amount vs a Dr/Cr suffix, wrapped descriptions, summary rows, many date formats), it is a best-effort reconstruction rather than true comprehension — every cell is editable and is meant to produce a reviewed draft, and nothing is ever uploaded.

Generators

Related terms

Bank statement to ExcelPDF table extractionTransaction reconciliationpdfjs text layertesseract.jsDebit / credit / balance

Frequently Asked Questions

Upload the statement PDF and click Parse. The tool reads the positioned text in your browser, rebuilds the transaction table, and lets you correct any cell, then export a real .xlsx or CSV.

Open the Bank Statement Parser and upload your statement — a PDF (digital or scanned) or an image. When you click Parse, the tool gets the text locally: for a born-digital PDF it reads the embedded text layer with pdfjs and keeps each text item’s X and Y position, then a rule-based engine clusters those items into rows by their Y coordinate and works out where the date column and the right-aligned debit, credit and balance columns sit by clustering the right edges of the numeric tokens. For a scanned page or an image it renders the page and runs tesseract.js OCR, then parses the line text with date and amount heuristics. The reconstructed transactions appear in an editable table — date, description, debit, credit and balance — alongside a summary (count, total debits and credits, opening and closing balance). You can fix any mis-parsed cell, add or remove rows, then export a real two-sheet .xlsx (via exceljs), a CSV (via papaparse), or copy the table straight into Excel or Google Sheets.

No. The PDF or image is opened, read and OCR’d entirely in your browser. Nothing is sent to a server, so it is safe for confidential statements.

The Bank Statement Parser runs completely client-side. The PDF text layer is read with pdfjs and any scan or image is recognised with tesseract.js — both libraries load from the app’s own bundle, with no server, no API, no AI and no CDN call for your document — and the page works offline once cached. The file you upload never leaves the page; nothing is sent, logged or stored. That is the key difference from cloud “PDF bank statement to Excel” converters, which upload your file to their servers — exposing your account number, balances and every transaction, and sometimes using the data to train models. Because your statement stays on the device, the tool is safe for confidential bank statements, and only the .xlsx or CSV you choose to export ever leaves the page.

An editable table with date, description, debit (money out), credit (money in) and balance, plus a summary: transaction count, total debits, total credits, and opening and closing balance.

Each reconstructed transaction has five fields: the date, the description (the narration / payee, with wrapped lines joined back together where possible), the debit (money out), the credit (money in) and the running balance. The engine handles the common layouts — separate debit and credit columns, a single signed amount column, and Dr/Cr suffixes — and normalises amounts across US (1,234.56) and European (1.234,56) formats, treating parentheses and a trailing minus as debits. Above the table is a summary: the number of transactions, the total debits and total credits (summed from the rows, updating live as you edit), and the opening and closing balance (detected from labelled summary rows, or inferred from the first and last balance). The amounts in the exported .xlsx are written as real numbers so they sum correctly, with a separate Summary sheet.

Treat it as a draft, not a final record. It reconstructs the table with rules, not AI, so accuracy depends on the layout and scan quality — always review every row and verify the totals and closing balance against your original statement before using it for accounting, a loan or taxes.

Accuracy depends heavily on the statement. A clean, born-digital PDF reconstructs very well because the tool has the real column geometry from the text layer, whereas a low-quality scan or photo relies on OCR (which misreads characters) and an unusual layout can defeat the column inference. Crucially, a bank statement is text at coordinates rather than a real table, and bank layouts vary enormously — wrapped multi-line descriptions, merged columns, summary rows, separate debit/credit vs a single signed amount — so rows and amounts will sometimes parse wrong: a debit can land in the credit column, a balance can be read as a movement, a description can split, or a row can be off by one. That is why every cell is editable. Use it to do the bulk of the typing and to keep confidential statements on your device, but review every row and verify the totals and the closing balance against the figures printed on your original statement before you rely on it for bookkeeping, reconciliation, a loan application or taxes. It is not an AI, not an accountant, and not a substitute for checking the numbers.

Detailed Explanation

Methodology

Why a Bank Statement Is Not a Table: Position-Based Reconstruction

AnyTool’s Bank Statement Parser converts a statement PDF into a transaction table entirely on the device, and the core idea is that a statement is not a table at all — it is text placed at (x, y) coordinates on each page. For a born-digital PDF it reads the embedded text layer with pdfjs-dist while keeping each text item’s X and Y position and width, and hands those positioned items to the bankStatementEngine. The engine clusters the items into rows by Y proximity (page by page, top to bottom), then infers the numeric columns by clustering the RIGHT EDGES of the money tokens — because banks right-align numbers — keeping the columns that recur across many rows. The right-most column is treated as the running balance; when three or more numeric columns are present it reads them as separate Debit, Credit and Balance columns. Each row’s leading date is detected, the remaining non-numeric items become the description (wrapped continuation lines with no date and no numbers are appended to the previous transaction), and a date-count sanity gate decides whether the layout really looks like a transaction table. This positional path is the accurate one because it uses the real column geometry rather than guessing from raw text.

  • A statement PDF is text at (x, y) coordinates, not a real table — the engine reconstructs the grid from positions
  • pdfjs keeps each item’s X/Y/width; rows are clustered by Y proximity, page by page, top to bottom
  • Numeric columns are inferred by clustering the RIGHT EDGES of money tokens (banks right-align numbers)
  • Right-most numeric column = running balance; three or more columns ⇒ separate Debit / Credit / Balance
  • Wrapped description lines (no date, no numbers) are appended to the previous transaction
Technical Details

Amount Parsing, Layout Variants and the OCR Fallback

Bank layouts vary enormously, so the engine is built to handle the common variants. Amounts are parsed by a tolerant money tokeniser: it normalises US (1,234.56) and European (1.234,56) formats by deciding which separator is the decimal, and it treats parentheses, a trailing or leading minus, and a Dr suffix as debits while Cr / a positive value is a credit. When the layout has separate debit and credit columns the engine maps each amount to its column by X; when there is a single signed Amount column plus a balance, the sign or the Dr/Cr marker decides the direction. Obvious non-transaction lines (headers like “Date Description Withdrawal Deposit Balance”, page markers, account/IBAN/sort-code lines and brought-/carried-forward rows) are skipped, and opening and closing balances are captured from labelled summary rows or inferred from the first and last balance. If the PDF is a scan with little or no embedded text, the tool renders the page to a canvas at 2× and OCRs it with tesseract.js, then uses the line-based parser (parsePlainLines): it pulls a leading date off each line and reads one to three trailing money tokens as movement and balance. An uploaded image is OCR’d directly. Both libraries load from the app’s own bundle, with reading and OCR progress shown.

  • Amounts normalised across US (1,234.56) and EU (1.234,56) formats; parentheses, trailing minus and Dr ⇒ debit, Cr ⇒ credit
  • Separate debit/credit columns mapped by X; a single signed amount column resolved by sign / Dr-Cr marker
  • Header, page, account/IBAN and brought-/carried-forward rows are skipped; opening/closing balances captured or inferred
  • Scanned pages are rendered at 2× and OCR’d with tesseract.js, then parsed line-by-line (parsePlainLines)
  • pdfjs and tesseract.js load from the app’s own bundle — no CDN, no server
Privacy & Security

Privacy and the Honest Limits

The whole pipeline — opening the file, reading the PDF text layer, rendering and OCR’ing scanned pages or images, reconstructing the rows and columns, and building the spreadsheet — runs in the browser. There is no server, no API, no AI/LLM and no CDN call for the document, and the page works offline once cached, so a confidential bank statement (with its full account number, balances and every transaction) never leaves the device; only the .xlsx or CSV the user chooses to export ever leaves the page, and the tesseract worker is terminated, object URLs are revoked and the pdf document is destroyed when parsing finishes or the component unmounts. This is the deliberate contrast with cloud “PDF bank statement to Excel” converters, which upload the file to a server. The tool is equally clear about what it is not: it reconstructs the transaction table with rule-based heuristics, NOT AI, and because bank layouts vary so much — wrapped multi-line descriptions, merged columns, separate debit/credit vs a single signed amount, Dr/Cr suffixes, scanned copies, many date formats — rows, columns and amounts WILL sometimes parse wrong (a debit landing in the credit column, a balance read as a movement, a split description, an off-by-one row). Because of that, every cell is editable, the summary totals are summed live from the rows, and the repeated guidance is to review every row and verify the totals and closing balance against the original statement before using anything for accounting, a loan application, taxes or reconciliation.

Bank statement to spreadsheet: AnyTool vs cloud converters vs manual entry
CapabilityAnyToolCloud PDF-to-Excel converter / AIManual entry
ApproachIn-browser pdfjs positional text + tesseract OCR + rulesServer-side OCR / AI modelHuman typing
InputStatement PDF (digital or scanned) or imagePDF / imageAnything
OutputEditable date/desc/debit/credit/balance + summaryXLSX / CSVWhatever you build
Editable outputYes — every cell editable; add/remove rowsSometimesInherently
ProcessingRuns in your browserUploads your statementNo software
PrivacyNever uploaded; safe for confidential statementsAccount no., balances & transactions sent off-devicePrivate but slow
HonestyStates it reconstructs; verify totals & balanceMarketing may overstate accuracyError-prone, tedious

AnyTool reads and OCRs the statement locally and never uploads it; it reconstructs the table with rules, not AI — always verify the totals and closing balance against your original.