Bank statement APIs: how they work, what they return and how to choose one

A bank statement API reads a statement PDF or scan. It returns the account details and the balances, plus every transaction, as JSON. Many also run checks, such as whether the balance after each transaction adds up. Lenders and fintechs call one when customers upload statements, so nobody retypes them. It differs from an account verification API, which confirms an account exists and belongs to your customer. It also differs from an open banking API, which pulls data straight from the bank with the customer's permission.

Vendor details below come from each vendor's own site and documentation, checked in September 2026. Links are in the sources at the end.

Bank statement APIs vs account verification and open banking APIs#

Three kinds of API get called a "bank statement API" or a "bank verification API". They take different inputs and prove different things.

A statement extraction API takes the statement file, digital or scanned, and returns the account details and the balances, plus the transactions, as JSON. It suits statements that customers upload, including from banks that no open banking API reaches.

An account verification API takes account and routing numbers, or a bank login. It tells you whether the account exists, is open and belongs to the customer. Use it before you debit or pay an account.

An open banking API starts with the customer's permission, given at their bank. It returns transactions and balances from the bank, or the bank's own PDF statements. Use it when the customer will log in.

When a statement API says it verifies, it checks the statement file itself. The statement must be complete, the numbers must add up, and the account must belong to the applicant. For the checks lenders run on top, see bank statement verification software.

How a bank statement API works#

Many statement APIs are asynchronous, which means they don't answer right away. When your app uploads a file, it does not wait for the result.

Your app uploads the file and gets a document ID back straight away. The service reads the header, the summary and every transaction row, and joins tables that run across pages. The better ones then check that the balances add up and flag values they aren't sure about. Some hold those for a person to review. When the statement is done, a webhook tells your app to fetch the JSON. Polling for the status works too.

What the response looks like#

Field names differ between vendors. A useful response still carries the account, the period and the balances, then every transaction with the page it came from. It ends with the results of the checks.

The response below uses the schema from our guide to converting bank statements to JSON.

{
  "document_type": "bank_statement",
  "bank_name": "Example Bank",
  "account_holder": "Acme Supply LLC",
  "account_number_last4": "4821",
  "account_type": "checking",
  "currency": "USD",
  "period_start": "2026-07-01",
  "period_end": "2026-07-31",
  "opening_balance": 12450.00,
  "total_credits": 6200.00,
  "total_debits": 10570.50,
  "closing_balance": 8079.50,
  "transactions": [
    {
      "date": "2026-07-02",
      "description": "ACH CREDIT STRIPE PAYOUT",
      "debit": null,
      "credit": 6200.00,
      "balance": 18650.00,
      "page": 1
    },
    {
      "date": "2026-07-03",
      "description": "CHECK 1045",
      "debit": 2150.00,
      "credit": null,
      "balance": 16500.00,
      "page": 1
    },
    {
      "date": "2026-07-15",
      "description": "ACH DEBIT PAYROLL",
      "debit": 8420.50,
      "credit": null,
      "balance": 8079.50,
      "page": 2
    }
  ],
  "checks": {
    "balances_reconcile": true,
    "running_balances_chain": true,
    "dates_within_period": true
  },
  "needs_review": [
    { "field": "transactions[2].description", "confidence": 0.64, "page": 2 }
  ]
}

Look for three things in the JSON that any vendor's API returns.

• Amounts as numbers, not text. Money out and money in sit in two separate fields, or in one field with + and − signs. Never both.
• A page for every transaction, so a reviewer can find the line on the statement.
• Check results and flagged fields, so your app knows whether to use the data now or wait for a person.

Some statement APIs also return analysis. That includes categorized transactions, true revenue and average daily balance, which bank statement analysis explains. Docsumo's cash flow analytics are on the Enterprise plan. Its field names and the upload and webhook calls are in its API documentation.

How to choose a bank statement API#

Run each check on 50 to 100 of your own statements. Clean samples make every API look good.

• Bank coverageStatements from the banks and credit unions your customers actually use, not just the largest banks.
• Scans and photosFaint scans and phone photos, not only clean digital PDFs.
• Tables across pagesTransactions that run across pages come back as one table, with nothing dropped or doubled at the page break.
• Balance checksOpening and closing balances reconcile and every running balance is checked, so a misread amount can't pass silently.
• Confidence scores and reviewUncertain values are flagged, and a person can check them against the source line before your app uses them.
• WebhooksA callback when each statement is done, so your app doesn't have to poll.
• SecurityA SOC 2 Type 2 report, encryption, data retention you control and a plain answer on whether your files train shared models.
• Pricing modelPer page, per statement or per plan. Model it on your real page counts, because 12 months of statements from a busy account can run to dozens of pages.

Bank statement APIs compared#

Docsumo is our product, so it's first. It reads the statements your customers upload. It doesn't connect to bank accounts or make the credit decision. Its bank statement extraction joins transaction tables that run across pages, checks running balances and sends uncertain fields to a reviewer. Cross-document validation, which checks statements against the rest of the file, is on the Enterprise plan. It's cloud only, and results reach your app through the API and webhooks.

• 99%99%field-level accuracy across 250+ document types
• 94%+94%+accuracy at Grid Finance
• <1 min<1 minper complex bank statement at Grid Finance

For a wider list of statement tools, including bookkeeping converters and enterprise platforms, see the best bank statement extraction software.

Why one statement's JSON isn't enough to decide on#

We'd judge a statement API by how it handles the whole loan file, not one statement. A loan decision needs several documents to agree. So checks that compare documents matter more than one perfectly read page. Whichever API you pick, decide before you start building which system will run the checks that compare statements.

A statement API fits when customers hand you statements. It turns each PDF or scan into JSON that your app can check and use. To confirm an account before moving money, use an account verification API. When customers will log in to their bank, an open banking API gets transactions without any documents. One lender can use more than one, with account verification before funding and statements for underwriting.

Docsumo covers the statements. It reads them, checks the balances and sends uncertain fields to a reviewer, then passes the data to your app through the API and webhooks. Cross-document validation is on the Enterprise plan. More on the lending workflow in IDP for lending.

Book a demo with a few of your own bank statements, or start a free trial.

Frequently asked questions#