Document Extraction API — Invoices, Receipts & Statements

Extract any document in one call

Base64-encode the document and POST it. You don't need to tell the API what it is — classification is automatic and returned in the response `type`. Create a key in the API dashboard.

curl -X POST https://flowparse.io/api/v1/extract \
  -H "Authorization: Bearer pf_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{ "file": "JVBERi0xLjcK...", "filename": "receipt.pdf" }'

flowparse.io

What it extracts, by type

The API auto-classifies and returns the fields that matter for each type. A mixed document (an invoice with an attached statement, say) returns both objects.

A receipt, structured

{
  "type": "receipt",
  "pages": 1,
  "billedPages": 1,
  "data": {
    "type": "invoice",
    "data": {
      "supplier_name": "Corner Cafe",
      "invoice_date": "2024-10-02",
      "currency": "USD",
      "tax_amount": 1.20,
      "total": 15.20,
      "line_items": [
        { "description": "Flat white", "quantity": 2, "unit_price": 5.00, "amount": 10.00 },
        { "description": "Croissant",  "quantity": 1, "unit_price": 4.00, "amount": 4.00 }
      ]
    }
  }
}

Validation as a quality gate

Extraction is only useful if you can trust it, so the API ships a deterministic validator. `POST /api/v1/validate` returns a 0–100 quality score, a grade and concrete checks — invoice totals and tax math, statement balance reconciliation, duplicate and out-of-order rows, low-confidence fields. Auto-accept high grades, queue the rest. The full rule set is documented on the validation engine and the AI VAT auditor adds tax-specific review on top.

curl -X POST https://flowparse.io/api/v1/validate \
  -H "Authorization: Bearer pf_live_xxx" \
  -d '{ "type": "invoice", "data": { ... } }'
# → { "validations": [ { "score": { "value": 96, "grade": "A" }, "checks": [ ... ] } ] }

Classify → extract → act

flowparse.io

Beyond extraction: export and reconcile

Most pipelines need more than JSON. `POST /api/v1/export` converts any extracted document into XLSX, CSV, XML, QuickBooks/Quicken (`.QBO`/`.QFX`/`.OFX`), Xero, DATEV or 1С — base64, previews free. `POST /api/v1/reconcile` matches a set of invoices against bank payments and returns matched and unmatched items with a reconciliation report, the same engine behind the reconciliation feature. And `POST /api/v1/merge` consolidates up to 100 documents into one reconciled Excel.

Together these turn the extraction API into a full back-office automation surface: capture an invoice, validate it, export it to your ledger, then reconcile it against the bank statement you extracted from the same API — no manual re-keying anywhere in the chain.

flowparse.io

Pricing, keys and limits

Extraction and file exports bill per page from your page balance; classification is part of extraction, and validation, reconciliation and previews are free. Over-budget calls return `429` with the exact shortfall. Manage keys, rotate per environment, and watch per-key usage in the dashboard. The per-page rate and plans are on the pricing page, the complete reference is in the API docs, and you can try requests in the playground.

flowparse.io

What teams automate with it

Why AI extraction, not templates or rules

Traditional intelligent-document-processing stacks are built from per-template rules: you define where each field lives for each vendor or document layout, and maintain that library forever. It works until a supplier redesigns an invoice, a bank moves a column, or a customer uploads a format nobody anticipated — then the rule misfires silently and bad data flows downstream. The whole approach scales badly because every new layout is an engineering ticket.

An AI document extraction API generalises instead of memorising. It understands that 'the total is the largest tax-inclusive amount near the bottom' or 'this column of dated rows is a transaction table' regardless of exact position, font or wording, so a document it has never seen returns the same clean schema on the first request. That's the difference between an automation that needs constant babysitting and one that just keeps working as your document mix grows. Pair it with the deterministic validation engine and you get generalisation *and* a hard correctness check — the combination most rule-based stacks lack.

flowparse.io

Integrate from any stack

There's no SDK to adopt and no language constraint: the API is JSON over HTTPS, so any HTTP client works. The shape is always the same — base64-encode the document, POST it to `/api/v1/extract`, read the classified `type` and typed `data`, then branch your logic on the type. Because every endpoint shares that schema, a thin internal wrapper of `extract`, `validate`, `export` and `reconcile` functions is usually all you need, and it stays valid as the contract is versioned under `/api/v1`.

A clean pattern at volume is a queue plus workers: enqueue each uploaded document, have a worker call extract then validate, write the result and notify your own system — effectively your own webhook, fully under your control. Make jobs idempotent on a file hash so retries don't duplicate records, cap worker concurrency so a big batch can't drain your page budget at once, and log the billed pages and validation grade for a complete audit trail. The API docs have copy-paste curl, and the playground runs real requests in the browser.

Status codes, billing and limits

Standard HTTP codes make error handling simple, and no call returns unbilled data. `200` carries the structured JSON; `400` is a malformed request; `401` is a bad or missing key; `422` means the document was unreadable or had nothing extractable (not billed for a file); `429` means the page budget is exhausted, with the exact shortfall in the message; and `503` is transient — retry with backoff. Extraction and file exports bill per page from your page balance, while classification is part of extraction and validation, reconciliation and previews are free.

Documents up to 20 MB and multiple pages are supported. For high throughput, extract each document individually and in parallel rather than in one giant call, and consolidate the results with Smart Merge when you need a single workbook. You can build and test the entire flow for free against validation and previews, then enable billed extraction at go-live — plans and the per-page rate are on the pricing page.

Classification and accuracy you can gate on

A document extraction API earns its place only if you can trust what it returns, so two things matter: correct classification and correct fields. Classification comes first — the engine decides whether a file is an invoice, a receipt, a bank statement or a mixed document, and returns that in the response `type` so your code branches correctly without you sniffing the file yourself. Get this wrong and everything downstream is wrong; get it right and each document flows to the right handler automatically.

Field accuracy is then protected the same way across every type. The engine reconstructs tables from the document's own geometry rather than guessing from flat text, types every value (numbers as numbers, dates as ISO-8601), and records lower confidence instead of inventing data when a source is ambiguous. You convert that into a decision with `/api/v1/validate`, which scores invoices on totals and tax math and statements on balance reconciliation, duplicates and date order. Auto-accept the clean ones, review the rest — and keep the original values in `raw_table` for a complete audit trail. That combination of broad coverage and a hard, per-document check is what makes the API safe to run unattended.

flowparse.io

Best practices for document automation

Treat the extraction API as one step in a pipeline, not a magic box. Validate every document and branch on the grade so a human only ever sees the genuinely ambiguous cases. Prefer original digital files over scans where you can, since the text layer is read exactly. Persist the classified type, the validation score and `billedPages` with each record so you have a queryable audit trail of what was captured, what it cost and what was auto-accepted versus reviewed — invaluable when finance or compliance asks how a number got into the books.

Run extraction behind a queue with a capped worker pool rather than inline on a request, make jobs idempotent on a file hash so retries don't duplicate records, and handle `429` (top up and resume) and `503` (exponential backoff) explicitly. Store only the fields you need and keep PII out of logs. Build and test the whole flow for free against validation and previews, then switch on billed extraction at go-live. Done this way, a document extraction API turns accounts payable, expense capture and statement onboarding into reliable, unattended automation — the guide walks the full pattern with code.

Monitoring usage and controlling cost

Running extraction at volume means watching two things: spend and quality. Every API key tracks its own request count, page total and cost, visible in the dashboard, so you can see exactly what each integration or customer is consuming and spot anomalies — a sudden spike usually means a retry loop or a malformed batch. Setting a budget that matches your plan, and capping worker concurrency so a single run can't exhaust it, keeps cost predictable rather than surprising.

On the quality side, log the validation grade and `billedPages` with every document and chart the auto-accept rate over time. A falling auto-accept rate is an early signal that input quality has dropped — a new scanner, a worse photo flow, a new bank format — and lets you act before bad data reaches the books. Together these two habits turn the API from a black box into an observable, controllable part of your pipeline; the per-page rate and plan limits are on the pricing page.

flowparse.io

Choose where to start

If statements are your focus, start with the bank statement API or the bank statement OCR API for scans. For the generic PDF contract, see the PDF to JSON API. To build a complete integration with batching and error handling, follow the guide to parsing bank statements with an API. Everything is documented at /api-docs.

flowparse.io

Frequently asked questions

Related