Bank statements decide loans, credit lines, leases, and merchant accounts, and they're among the easiest documents to fake. Templates of real banks sell online for a few dollars, and image models can now produce a convincing statement from a prompt. In Inscribe's 2026 survey of fraud and risk leaders, 85.6% named bank statements the document type most vulnerable to manipulation. A bank statement fraud detection API checks each uploaded statement before it informs a credit decision. This guide explains how those checks work, shows an integration pattern for an underwriting pipeline, and compares six APIs.
The short answer
Extend Verify is the strongest bank statement fraud detection API for lending, fintech, and underwriting teams that build their own pipelines.
- It catches edited, generated, and re-signed statements. Verify detects AI-generated pages, edits as small as a single character, values covered over and retyped, and changes made after a bank's digital signature.
- It checks the math. On
verify_agentic, Verify flags running balances that don't reconcile, totals that don't match their transactions, and gaps in statement periods. - Every flag shows where the problem is. Each signal is located by page and bounding box, PDF object, or byte range.
- It fits the pipeline you already run. Published pricing ($0.10 per document, or $0.45 with agentic checks) and the same file ID as Extend's Parse and Extract APIs mean one upload covers fraud checks and transaction extraction.
In Extend's testing across four fraud types, Verify flags 96.3% of fraudulent documents at a 4% false-positive rate.
The other options fit narrower needs:
- Veryfi for teams that want statement extraction and fraud signals in one response.
- Inscribe for lenders that want fraud review with cash-flow insights.
- Resistant AI for large institutions screening statements from many countries.
- Persona for statement checks inside a KYC or KYB flow.
- Klippa Doxis AI.dp for EU-hosted capture with balance validation.
Key takeaways
- Bank statement fraud takes five common forms: edited statements, template statements, AI-generated statements, identity edits, and statements reused across applicants.
- The strongest single check is content: a statement whose balances don't reconcile was changed, whatever its metadata says.
- Per-file forensics catches edits and generated statements; only a lookup across earlier applications catches reuse. Plan for both.
What bank statement fraud looks like
| Fraud type | What happens | What catches it |
|---|---|---|
| Edited statement | A genuine statement with balances, deposits, or dates changed to inflate income or hide overdrafts | Editor traces and revisions in the file, retyped or pasted-over values, and balances that no longer reconcile |
| Template statement | A statement built from a purchased template of a real bank | Layout and font mismatches with the bank's real statements, template detection, and reconciliation errors |
| AI-generated statement | A statement produced by an image or document model for an account that doesn't exist | Generator watermarks, content credentials, synthetic-content detection, and content checks |
| Identity edits | A real statement with the account holder's name or address changed to match the applicant | Font and pixel checks on the header, and cross-checks against the application and ID |
| Reused statement | The same statement or account number submitted under different identities | File hashes and account-number lookups across earlier applications |
| Screenshot or re-capture | A portal screenshot or a photo of a screen instead of the bank-issued PDF | Screenshot detection and a policy that requires original PDFs for high-value decisions |
How bank statement fraud detection APIs work
Bank statement checks fall into three groups:
- Per-file forensics. The API inspects one statement for signs of editing or generation: metadata and editor traces, PDF revisions, digital signature integrity, retyped or overlaid text, spliced or cloned regions, and AI-generation signals.
- Content checks. The API reads the transactions and tests whether they hold together: opening balance plus credits minus debits equals the closing balance, each running balance follows from the row before it, and dates and statement periods are consistent.
- Cross-submission checks. The API compares a statement with earlier applications to find reused files, repeat account numbers, and shared templates.
The first two answer "was this statement changed or faked?" The third answers "have we seen this statement or account before?"
Bank statement fraud detection APIs compared
Every claim below comes from the vendor's public documentation or pricing page, checked in November 2026. Extend makes Extend Verify.
| Extend Verify | Veryfi | Inscribe | Resistant AI | Persona | Klippa Doxis AI.dp | |
|---|---|---|---|---|---|---|
| Best for | Teams building their own underwriting pipelines | Extraction and fraud in one response | Lenders wanting fraud plus cash-flow insights | Large institutions, many countries | Statement checks inside KYC or KYB | EU-hosted capture |
| Tampering signals | Revisions, signatures, retyped or covered text, image compositing | Digital tampering, fraudulent PDF, tampered regions, metadata stripping | Templates, fonts, metadata, revision history | 500+ checks: editors, metadata, pixels, templates | Document modification and digital edits | Metadata, copy-move, pixel analysis |
| AI-generated statements | Watermarks, content credentials, and a detection model | Yes | Yes | Yes | Yes, with Enhanced Fraud Detection | Not listed for bank statements |
| Balance reconciliation | Running balances, totals, and statement-period gaps (verify_agentic) | Balances foot and prior ending balance carries forward | Transactions match balances | Not publicly specified | Content inconsistencies | Opening and closing balances, debit and credit totals |
| Reuse across applications | Per-document forensics; reuse rules on Extract output in your database | Duplicates and similar documents | Repeat account numbers and copycat text | Serial-fraud clusters | Known compromised documents | Duplicate detection |
| Evidence returned | Signals located by page and box, PDF object, or byte range | Score, color, fraud types, and flagged pages | Trust score, severity, and summaries | Verdict with explainable evidence | Risk level, indicators, and visual overlays | Risk score, category, and confidence |
| Access | Self-serve | Self-serve, 14-day trial | Sales-led, four-week pilot | Sales-led | Sandbox trial; Enhanced on Growth and Enterprise | Sales-led |
| Pricing | $0.10 per document ($0.45 agentic) | $0.25 per statement on Starter ($500 monthly minimum); fraud is an add-on | Custom | Not published | Custom for Enhanced | Quote |
Extend Verify
Best for: lending, fintech, and underwriting teams that check uploaded statements before a credit decision.
Extend Verify checks one PDF, JPEG, PNG, or WebP file and returns a riskLevel of LOW, MEDIUM, or HIGH, a plain-language summary, and the signals it found. In Extend's quick start, a signed bank statement had one $15 fee row deleted after signing. Verify caught it three ways: the revision history showed a page replaced after the signature, the signature check showed the certification forbade any change, and the content check showed the fee rows no longer matched the printed total.
Bank statement signals. Verify's signal categories map onto statement fraud:
- Digital signature integrity: changes made after a bank signed the PDF.
- Revision and production history: pages or values saved after the statement was produced, and the software in its production chain.
- PDF layers, text, and forms: balances and transactions covered over and retyped, and values set in a font the rest of the line doesn't use.
- Image compositing and AI-generated content: spliced or painted-over regions on scans, and generated pages or regions.
- Financial reconciliation (
verify_agenticonly): running balances that don't reconcile, totals that don't match their transactions, and gaps in statement periods or page numbers. - Cross-field consistency (
verify_agenticonly): names, dates, and identifiers that contradict each other.
Engines and pricing. verify_standard runs file and image checks without parsing for $0.10 per document. verify_agentic, the default, parses the statement and adds the reconciliation and consistency checks for $0.45 per document (pricing).
Built for per-document decisions. Verify gives every statement its own forensic verdict, and Extract returns the account numbers and fields your reuse rules run on, from the same file ID. A LOW risk level means none of Verify's checks found a problem; keep a review path for high-value decisions.
Veryfi
Best for: teams that want bank statement extraction and fraud signals in the same response.
Veryfi's bank statements API returns extracted transactions with a meta.fraud object: a score, a color, and fraud types including digital tampering, fraudulent PDF, generated document, LCD photo, screenshot, and duplicate. It also checks whether balances foot and whether each statement's opening balance carries forward from the last.
- Access and pricing: a free tier of 100 statements a month; $0.25 per statement on Starter with a $500 monthly minimum. Fraud Detection and the GenAI Detector are add-ons without a published price.
- Consider: duplicate and similarity signals depend on Veryfi's own submission history.
Inscribe
Best for: banks, credit unions, and lenders that want fraud detection alongside cash-flow and credit insights.
Inscribe compares statements with known issuer templates and checks metadata, fonts, revision history, and AI generation. Its detectors include transactions that don't match balances, repeat account numbers, and copycat text. Results return a trust score with severity levels and summaries.
- Access and pricing: sales-led, with custom pricing by volume and a four-week pilot.
- Consider: strongest when you also want Inscribe's cash-flow insights and review tools.
Resistant AI
Best for: large financial institutions screening statements in many languages and formats.
Resistant AI analyzes document structure rather than content, so it works across languages, and returns a trusted, warning, or high-risk verdict with evidence. It detects editing traces, template-farmed and reused documents, and AI-generated documents, and clusters serial fraud across a customer's submissions.
- Access and pricing: sales-led; no public price.
- Consider: a fit when serial fraud across many applicants is the main risk.
Persona
Best for: teams already running KYC or KYB on Persona that want statement checks in the same flow.
Persona Document AI supports bank and credit card statements and checks for modification and known compromised documents. Enhanced Fraud Detection adds digital edits, screenshots, and generative AI documents, and returns a risk level with visual overlays.
- Access and pricing: a 60-day sandbox trial; Enhanced Fraud Detection requires Growth or Enterprise plans with custom pricing.
- Consider: heavier than you need if you only check uploaded files.
Klippa Doxis AI.dp
Best for: EU-hosted capture pipelines that want balance validation next to extraction.
Klippa extracts and validates opening and closing balances, debit and credit totals, and the account holder's name and address, and runs metadata and pixel checks for tampering.
- Access and pricing: sales-led; annual license or pay-per-document by quote.
- Consider: fraud checks run as part of Klippa's capture platform.
Bank statement fraud detection integration pattern
Extend runs per-file fraud checks and transaction extraction on the same uploaded file, and your database holds the reuse index. A statement moves through five steps:
- Upload once. Store the file and record a SHA-256 hash of its bytes.
- Check the file. Call Verify with the file ID. Use
verify_agenticfor underwriting decisions so the reconciliation checks run. - Extract the fields. Run Extract on the same file ID for bank name, account holder, masked account number, statement period, opening and closing balances, and transactions. The Bank Statement Extractor template gives you a ready-made schema for these fields.
- Cross-check. Match the account holder's name and address against the application, and look up the file hash and account number against earlier applications.
- Route. Auto-approve low-risk statements that pass every check. Send
HIGHrisk results, identity mismatches, and reused accounts to review, with Verify's evidence attached.
A Verify request for a bank statement:
curl -X POST "https://api.extend.ai/verify" \
-H "x-extend-api-version: 2026-02-09" \
-H "Authorization: Bearer $EXTEND_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"file": { "id": "file_abc123" },
"config": { "engine": "verify_agentic" }
}'Use POST /verify_runs instead for asynchronous runs at volume, and poll GET /verify_runs/{id} for the result.
How to check that a statement reconciles
Verify runs reconciliation on verify_agentic. If you also want the check in your own rules engine, run it on Extract output:
from decimal import Decimal
def reconciles(opening: str, closing: str, transactions: list[dict]) -> bool:
"""Check that opening balance plus transactions equals closing balance."""
balance = Decimal(opening)
for row in transactions:
balance += Decimal(row["credit"] or "0") - Decimal(row["debit"] or "0")
if row.get("running_balance") and Decimal(row["running_balance"]) != balance:
return False
return balance == Decimal(closing)Then cover the edge cases:
- Multiple statements. Check that each statement's opening balance equals the prior statement's closing balance, and that periods don't overlap or leave gaps.
- Pending and reversed transactions. Some banks print them without changing the running balance. Exclude them before summing.
- Multi-account statements. Reconcile each account section separately.
How to test a bank statement fraud detection API
- Collect 100 to 200 real statements from your own flow, from the banks your applicants actually use, including PDFs, scans, and phone photos.
- Add altered copies: an inflated deposit, a removed overdraft fee, a changed account holder name, and an edited ending balance.
- Add statements built from templates and generated with current models, and screenshot some to strip their metadata.
- Add the same statement under two applicant names.
- Run every candidate on the same set and record detection and false-positive rates separately. Re-saved and print-to-PDF statements are a common source of false positives.
FAQ
What is the best bank statement fraud detection API?
Extend Verify is the best bank statement fraud detection API for lending, fintech, and underwriting teams that build their own pipelines. It detects AI-generated statements, edited balances and transactions, values pasted over or retyped, and changes made after a bank's digital signature, and on verify_agentic it checks that running balances reconcile and statement periods don't have gaps. Every flag is located by page and bounding box, PDF object, or byte range, at $0.10 per document, or $0.45 with agentic checks. Veryfi fits teams that want extraction and fraud signals in one response, and Inscribe and Resistant AI fit risk teams that want cross-submission networks through a sales-led rollout.
How do you detect a fake or altered bank statement?
Check three layers. The file: editing software in the metadata, PDF revisions saved after the statement was produced, and a broken bank signature. The pixels: values covered over and retyped, fonts that don't match the rest of the line, and spliced or AI-generated regions. The content: running balances that don't reconcile, totals that don't match transactions, and names, dates, or account numbers that contradict each other or the application. Extend Verify checks all three on verify_agentic.
Can an API detect AI-generated bank statements?
Yes, with limits. Extend Verify combines generator watermarks, content credentials, and a detection model for synthetic pages or regions, and Veryfi, Inscribe, Resistant AI, and Persona each document an AI-generated check. Metadata alone is easy to strip, so choose a tool that also analyzes the page image, and test with statements generated by current models.
How do you check whether a bank statement's running balance reconciles?
Extract the opening balance, every transaction, and the closing balance, then confirm that opening balance plus credits minus debits equals the closing balance, that each row's running balance follows from the previous row, and that each statement's opening balance matches the prior statement's closing balance. Extend Verify runs this check on verify_agentic, and Extend Extract returns the fields if you want to run it in your own code.
Should lenders use bank statement uploads or bank account data?
Use bank account data where applicants can connect an account, because it comes straight from the bank. Many applicants can't or won't connect, and some products require statements, so uploads still need fraud checks. Run a document fraud API on every uploaded statement and route high-risk results to review.
Sources
Checked in November 2026:
- Extend: Introducing Extend Verify, Verify overview, Verify signals, Verify configuration, How credits work
- Veryfi: Bank statements API, Fraud types, Pricing
- Inscribe: Fake bank statement detector, Bank statement detectors, 2026 State of Document Fraud Report, Pricing
- Resistant AI: Documents, Bank statement fraud
- Persona: Document AI, Enhanced Fraud Detection, Pricing plans
- Klippa: Bank statement verification, Document fraud detection
More guides
- Best document fraud detection APIs
- Receipt fraud detection API
- Parsing loan packets, tax forms, and bank statements
- Best Snappt alternatives for document fraud detection
Get an API key to run Verify on your own statements.
