Document AI & Intelligent OCR
Extract Structured JSON from Any Document in 300ms
Passports, national IDs, driving licences, invoices and bank statements — read straight from a phone photo or a scan, with no template to author first and no page ever written to disk.
Document Extraction, Demoed With Our Team
The extraction engine is not exposed as a public sandbox yet. Book a session and we will parse your own documents on the live engine.
Document AI sandbox is not public yet
Zero-template extraction runs on our hosted engine, which we have not opened for anonymous document uploads. Rather than print a scripted passport record, we would rather parse your real documents with you.
- Live extraction on your own document set
- Passports, national IDs, invoices, bank statements
- Accuracy measured on your samples, not ours
- Sandbox API keys and on-premise options
We do not publish simulated output for this engine — you will see results from a real run, or nothing at all.
What Happens Between the Photo and the JSON
Most of the work is not reading characters. It is deciding what the document is, where each value lives on a page nobody has seen before, and whether the answer can be trusted.
Capture Clean-Up
The page is located inside the photo, cropped away from the desk or hand holding it, de-skewed, and corrected for glare and shadow before a single character is read.
Document Classification
The model identifies what it is looking at — passport, national ID, licence, invoice, statement — and which country or issuer produced it. You do not have to tell it in advance.
Zero-Template Entity Reading
Text, layout and visual structure are read together, so a field is found by what it means on the page rather than by where a template said it would sit.
Validation & Scoring
MRZ checksums, date logic and invoice arithmetic are verified, and every field is returned with its own confidence so your workflow knows what to trust.
What It Reads, and Exactly What Comes Back
Four document families cover most of what a business actually receives. Each returns a stable set of keys, so the shape of your integration does not change when the layout does.
Passports
Both the printed page and the machine-readable zone are read, then cross-checked against each other.
- Document number, type and issuing state
- Full name, nationality, date of birth, sex
- Issue and expiry dates with validity flag
- MRZ lines with per-field checksum results
National IDs & Driving Licences
Front and back captures across a wide range of issuing countries, including non-Latin scripts.
- ID or licence number and holder name
- Address block, where the card carries one
- Licence categories and endorsement codes
- Back-of-card barcode and MRZ when present
Invoices & Receipts
Header fields plus the full line-item table, with totals reconciled against the rows above them.
- Supplier, buyer, invoice number and dates
- Line items with quantity, unit price, amount
- Tax, discount, subtotal and grand total
- Currency, payment terms and PO reference
Bank Statements
Transaction tables that run across page breaks are stitched into one continuous ledger.
- Account holder, account number, IBAN
- Statement period and opening balance
- Every transaction row with running balance
- Closing balance checked against the rows
Templates Are the Part That Breaks
Classic OCR works well right up until a supplier changes their invoice header or a country reissues its ID card. The extraction is fine; the map to the fields is what goes stale.
| Scenario | Template-Based OCR | Dynsimulation Document AI |
|---|---|---|
| Adding a new document layout | A developer maps field coordinates for that exact layout before a single document can be processed. | Send it to the same endpoint. Classification and extraction handle an unseen layout on the first request. |
| When an issuer redesigns a card | Extraction silently degrades until someone notices and rebuilds the template. | Fields are found by meaning, not position, so a redesign is read the same way the old version was. |
| Long-tail coverage | Only the layouts that were worth the engineering time get automated. The rest stay manual. | Rare issuers and one-off supplier formats go through the same path as your highest-volume documents. |
| Time to first extraction | Weeks of template authoring and QA per document family. | An API key and one POST request. |
Where Extraction Pays for Itself
The common thread: a queue of documents that someone is currently retyping, and a business process that waits for them to finish.
Customer Onboarding & KYC
Lift identity fields straight off a photographed passport or ID so the applicant is not retyping their own details — and so the details match the document you are storing as evidence.
Lending & Affordability Checks
Turn uploaded bank statements into structured transactions an underwriting model can score, instead of an analyst reading PDFs line by line.
Accounts Payable Automation
Parse supplier invoices into header fields and line items, match them against purchase orders, and route only the exceptions to a human.
Travel, Hospitality & Border Desks
Read a passport at check-in in the time it takes to hand it over, with MRZ validation catching altered or mistyped documents at the counter.
Back-Office Migration
Convert archives of scanned contracts, forms and statements into queryable records without authoring a template for every historical format.
Multi-Country Operations
One integration covers documents from every market you operate in, including non-Latin scripts, rather than a separate vendor per region.
Integrate Document AI in Minutes
Send multipart image or PDF documents to our REST endpoint. Receive structured key-value entities, line items, and confidence metrics.
- Supports Passports, National IDs, Invoices, and Bank Statements
- Automatic skew correction, glare mitigation & MRZ checksum validation
- Zero data stored on disk — ephemeral memory processing
curl -X POST https://api.dynsimulation.com/v1/doc-ai/extract \ -H "Authorization: Bearer YOUR_API_KEY" \ -F "document=@passport_scan.jpg" \ -F "auto_classify=true"
Every Field You Get Back
Extracted values alone are not enough to automate a decision. Each response carries the confidence and the validation evidence behind every field.
| Field | Type | Description |
|---|---|---|
| document_type | string | The classified document family and standard, e.g. PASSPORT_ICAO_9303 or COMMERCIAL_INVOICE. |
| extracted_entities | object | Flat key-value map of every header field found on the document, using stable snake_case keys. |
| line_items | array | Row objects for tabular documents — invoice lines or statement transactions — in document order. |
| field_confidence | object | Per-field confidence from 0 to 1, so you can auto-accept strong fields and review only the weak ones. |
| validation | object | Checksum and arithmetic results: MRZ check digits, expiry logic, and whether invoice totals reconcile. |
| execution_time_ms | number | Server-side processing time for the request, excluding network transfer. |
How It Behaves on Documents People Actually Send
Benchmark accuracy is measured on clean captures. Real uploads are photographed in car parks and re-scanned three times. Here is what that costs, and where a human still belongs in the loop.
| Condition | Impact | What to Expect |
|---|---|---|
| Phone photo at an angle, held in hand | Minor | Boundary detection and de-skew are built for exactly this. It is the most common capture we see in production. |
| Glare across a laminated ID | Minor | Usually recovered. A reflection sitting directly over the MRZ is the one case worth re-prompting the user for. |
| Fax-quality or heavily compressed scan | Moderate | Fields are still read, but confidence drops. Use field_confidence to route borderline pages to review. |
| Handwritten entries on a printed form | Moderate | Printed structure is read reliably; handwriting varies with legibility and returns lower confidence. |
| Torn, obscured or partially cropped page | Expected | Missing regions are reported as absent rather than guessed. A field you did not capture will not be invented. |
The 99.1% figure on this page refers to entity-level extraction accuracy on our internal evaluation set of legible captures. Your own rate depends on how your users capture documents, and we will measure it on your samples before you commit to an auto-accept threshold.
Identity Documents You Never Have to Store
A passport scan is one of the most sensitive files a business will ever hold. The architecture is built so the answer to “where are the documents kept?” is “nowhere”.
Nothing Written to Disk
Documents are processed in memory and released when the response is returned. There is no bucket of customer passports to breach, subpoena, or forget to delete.
Runs Inside Your Perimeter
Available as a managed REST API or as an air-gapped GPU container on your own hardware, for teams whose documents are not allowed to leave the building.
Auditable Field by Field
Every extraction carries per-field confidence and validation results, so a decision made downstream can be explained months later.
Built for Batch and Burst
Sub-second per document with webhook callbacks for bulk jobs, so a migration of a million pages does not have to be babysat.
Request Document AI & OCR API Access
Connect with our technical team to receive sandbox API keys, custom document schema configurations, or on-premises container licenses.
Frequently asked questions
Which documents can Document AI parse?
Passports, national ID cards, driver licences, invoices and bank statements, with coverage across more than 50 document types and issuing countries.
Do we need to build a template for each document type?
No. The parser is zero-template — it reads document structure directly rather than matching against a per-layout template, so a new document format does not require setup work before it can be processed.
How fast and how accurate is extraction?
Median processing latency is around 300ms per document, at a stated 99.1% entity extraction accuracy.
Does it validate passport MRZ data?
Yes. The machine-readable zone is read to the ICAO 9303 standard and its checksums are validated, so a mistyped or tampered MRZ is caught rather than silently accepted.
Are uploaded documents stored?
No. Documents are processed ephemerally in memory and never written to disk.
Can Document AI run inside our own infrastructure?
Yes. It is available as a managed REST API with webhook callbacks, or as an air-gapped GPU container deployed onto your own hardware.