PDFs — born-digital and scanned
PDF · up to 1,500 pages each
Born-digital pages keep their exact text; scanned or garbled pages are OCR’d page by page, and a searchable copy is kept beside the original.
Scans, faxes and handwriting. Hundred-page forms and tables that run across pages. Spreadsheets, email, call transcripts, photos and video, in the language they were written in. Botminds IDP reads it, checks it against your rules and your other documents, and hands a person a result where every value opens the page it came from.
Botminds IDP is the agentic intelligent document processing technology inside the Botminds platform. A crew of AI agents reads documents and records of every kind, extracts what matters by meaning rather than by position, checks it against rules and other documents, scores how sure it is, and hands the result to a person or a system — with every value linked to the page and region it came from.
It is not a separate product to integrate. It is the reading layer under every document solution in the Botminds library, so a solution for claims, credit, trials or invoices starts with the reading already done well. New to the term? Read our intelligent document processing buyer’s guide.
measured precision on the fields that pass automatically — held-out real financial statements, mostly French, a quarter scanned. The rest go to a reviewer.
measuredof mortgage files in 30 minutes — about 2,000 loan files — on a deployment scaled out for the wave.
scale-out sizingone loan file — OCR, layout, classification, splitting and extraction — read end to end in under 14 minutes.
measuredof extracted values carry a confidence score and a link to the exact page and region they came from.
by designEach generation of document processing fixed the last one’s worst problem and kept a new one. OCR gave us characters without meaning. Machine learning gave us meaning, one labeled document type at a time. Large language models read anything — and can invent a value no page contains. Botminds IDP keeps what each did well and binds every value to its evidence.
Characters from images; fields from fixed zones drawn per layout.
Classifiers and extractors trained per document type on labeled samples.
A large model reads the page and returns fields from a prompt.
Agents read, cross-check and decide with every value tied to its source, measured on your documents.
Classic IDP is a fixed pipeline: one model, one pass, one score. Agentic IDP gives each job on a file to an agent with its own instructions, tools and limits. The agents plan the work, use tools, check each other, and stop at a person where judgment is needed. Botminds IDP runs the whole file this way — and records every step.
Classifies every page, splits a packet into the documents inside it, types each one and says what is missing.
One per document type or section, working in parallel. Each fills the fields its schema defines and cites the region of every value.
Dates, currencies, names, codes and units normalized to your formats and your reference data.
Re-reads the values that matter, foots totals, applies your rules and returns a verdict that feeds the confidence score.
The same fact — name, employer, income, dates, amounts — compared in every document and against your systems.
Finds personal, financial, health and privileged data and proposes each box with the rule behind it.
Questions about a file or a whole library answered from the documents, each answer cited to its page.
Memos, letters, conditions and summaries written from checked values, every sentence traceable to a source.
If an agent’s tool settings are missing or broken, it gets no tools — never all of them.
You don’t wire agents together by hand. Tell Piper, the Botminds builder agent, what arrives and what must come out. It asks what it needs to know, shows you the plan — document types, fields, agents, review stages — and builds nothing until you confirm. Then it builds the crew and runs it on your sample files.
Sample conversation
Every document takes the same governed path. Each stage does one job, records what it did, and runs in parallel with the rest of the file — so a thousand-page packet and a one-page form travel the same road.
Uploads, mailboxes, SharePoint, cloud storage and APIs. Archives unpacked safely; exact duplicates dropped by fingerprint.
Pictures become pages, every TIFF frame included. Sideways pages are turned upright — before OCR and again after.
OCR runs only where a page has no usable text, so born-digital pages keep their exact characters. Handwriting is read from the image.
Words with boxes and confidence, reading order, paragraph roles, and tables as grids with header cells and merged spans.
Each page is classified; a packet is split into the documents inside it, and each split is typed.
Fields come from a schema that says what each value means. Section specialists work long files in parallel.
Values re-read and compared, totals footed, rules and formulas applied, documents checked against each other.
One calibrated confidence per value: the model’s own view, proof the value is on the page, re-read agreement and the QC verdict.
Values under the threshold go to a person, with the page open at the exact spot. Four-eyes where it matters.
Cited results to your systems by API and webhook; reviewer corrections feed the golden set the next change is tested on.
Work never arrives as one tidy PDF. It arrives as a scanned packet, a workbook, an email with nine attachments, a photo from a phone, a call. Botminds IDP takes each in its own form, and every one ends up as pages, regions and timestamps a value can cite.
PDF · up to 1,500 pages each
Born-digital pages keep their exact text; scanned or garbled pages are OCR’d page by page, and a searchable copy is kept beside the original.
TIFF (every frame) · JPEG · PNG · GIF · BMP · WebP
Phone photos, fax images and multi-frame TIFFs become pages, are turned upright and read like any scan.
handwritten fields · ticked boxes · redlines
Handwritten words are read from the page image with a confidence each; ticked boxes are detected from the ink, not guessed from text.
XLSX · XLS · CSV
Kept whole as the tables they are — tabs, headers and cell addresses intact — or split into rows when each row is its own record.
DOCX · DOC · PPTX · RTF
Text, tables and slide content read directly; legacy formats converted first, so nothing depends on a scan.
EML · MSG · ZIP
The message and every attachment become one linked set. Archives are unpacked with limits on size, count and depth.
HTML · TXT · MD · JSON · XML
Pages and structured files read as text with their structure kept, ready for the same extraction and checks.
transcripts · SRT · VTT · timestamped JSON
Transcripts from your recording platform are indexed with their timestamps, so every finding cites the second it was said.
frames sampled with timestamps
Video is sampled frame by frame for vision models; a finding points to the frame and the moment it came from.
OCR (optical character recognition) turns printed text in an image into characters. ICR (intelligent character recognition) does the same for handwriting. OMR (optical mark recognition) reads ticks and filled boxes. A real file needs all three on the same page — and a way to say how sure each reading is.
Botminds IDP checks every page first. A born-digital page keeps its exact text; only pages with no text, or text that is garbled, are sent to OCR, so nothing is re-read that was already right. Sideways pages are turned upright before and after OCR. The OCR and layout service runs inside each customer’s own environment, and the original stays beside a searchable copy.
Sample form, fictional claimant
A table is where document tools quietly fail: merged headers, columns without rules, a schedule that breaks across a page, a footnote that says “in thousands”. Botminds IDP rebuilds each table as a grid, reads every cell into a typed value, and re-adds the totals — so a misread figure announces itself.
Spreading a borrower’s statements is the hardest table work in finance; see commercial financial spreading and rent roll analysis.
| Line | FY2025 | FY2024 | Source |
|---|---|---|---|
| Net revenue | 48,210 | 44,975 | p.12 r3 |
| Cost of revenue | (29,804) | (28,113) | p.12 r4 |
| Gross profit | 18,406 | 16,862 | ✓ foots |
| Operating expenses continued p.13 | (11,920) | (11,407) | p.13 r1 |
| Depreciation | (2,140) | (1,988) | p.13 r2 |
| Operating income | 4,346 | 3,467 | ✓ foots |
Sample statement, fictional company
Evidence no longer arrives only as English text on paper. Botminds IDP reads a document in the language it was written in and answers in yours, with the citation pointing to the original words. Recordings, footage and photos go through the same pipeline and cite a second, a frame or a region.
Extraction reads the language natively rather than translating first, so nothing is lost in a round trip. Our hardest measured set — financial statements from one lender — is 91% French and a quarter scanned. See financial statement translation and international credential evaluation.
Transcripts from your recording platform — SRT, VTT or timestamped JSON — are indexed segment by segment.
04:12Agent: “…the late fee will be waived if paid by Friday.”04:19Finding: promise recorded, cited to 04:12 04:12Sampled frame by frame with timestamps for vision models.
frame 00:41Read as pages; findings point to a region.
region 2Loan files, claim files, submissions and data rooms arrive as one enormous PDF. Botminds IDP classifies every page, plans where one document ends and the next begins, types each split, and extracts each with the schema for its type — then says what the packet is missing.
Measured: a 607-page packet split into 61 documents, classified against 63 document types, in about 10 minutes with no errors · layout shown with sample types
Reading a document once is not enough; people and agents come back to it with questions. Botminds IDP keeps each page as layers — the words with their boxes, the layout, the sections, the passages — and indexes the passages two ways: by keyword, for names, numbers and clause ids, and by meaning, for questions phrased differently from the page.
A citation is not a page number in a footnote. It is the union of the glyph boxes the value was read from, in the coordinates of the displayed page — so the viewer opens the right page and highlights the exact words. Ask a question in plain words and the answer comes back the same way; see batch record search or derivatives documentation search.
Accuracy is decided less by the first read than by knowing which reads to trust. Botminds IDP answers two questions for every value: how confident should we be, and is it consistent — with a second read, with the arithmetic, with the rules and with every other document in the file.
Measured: on held-out real financial statements, 48.8% of fields passed automatically at 98% measured precision, with a calibration error of 2.1 points; the rest went to a reviewer. The threshold is set from measured error on your set — never by hope.
| Application | Pay stubs | Bank stmts | Tax return | |
|---|---|---|---|---|
| Name & address | ✓ | ✓ | ✓ | ✓ |
| Employer | ✓ | ✓ | — | ✓ |
| Monthly income | ✓ | ✓ | ✕ | ✓ |
| Running balance | — | — | ✓ | — |
Conflict: payroll deposits on the bank statements average $6,180 a month; the pay stubs and application say $7,450. Both sources are shown side by side for the underwriter to resolve.
A black rectangle drawn over a PDF leaves the text underneath, ready to be copied out. Botminds IDP takes the text out of the page itself and overwrites the pixels of images, after a person has approved every box and the rule behind it.
Sample letter, fictional person
Built on it: document redaction, subject access requests, public records requests and clinical trial disclosure.
An edited pay stub reads perfectly — that is the point of editing it. So Botminds IDP checks the file itself, not just its words, the moment it arrives, and holds a suspect document before anyone relies on it. These forensic checks need no AI model and run in well under a second.
A figure set in a different font or weight from the line around it — the classic trace of an edited number.
A shape drawn over the original text, with new text placed on top.
Metadata showing the file passed through an online PDF or design editor after it was issued.
Running balances and totals re-computed line by line; an edited deposit breaks the chain.
The same file submitted twice is caught by its fingerprint, whatever it is called.
Agents compare the same fact across documents — employer, income, dates, amounts.
A suspect file is held with its reasons before any agent or person relies on it.
Every signal is shown on the document for an investigator to judge.
Built on it: document fraud detection for claims, auto loan fraud detection, check fraud detection and duplicate payment recovery.
“99% accurate” means nothing without the documents, the fields and the method. We report accuracy the way an auditor would test it: on a golden set of your own documents, field by field, with the share that passes automatically and the precision of what passed — and we re-run it on every change.
Measured on held-out real financial statements from one lender — 91% French, a quarter scanned. Your documents get their own scorecard before go-live; our target for what leaves the system after review is 99% field accuracy.
Manual keying is not the error-free baseline it is assumed to be: a study of hand-entered pathology data found errors in 2.8% of fields, and only 76% of records fully correct. The comparison that matters is your process today against the new one, on the same documents.
Gates, not reports. Golden sets are versioned. Every model, prompt or configuration change runs against its baseline; a change that scores worse does not publish, and drift in production is watched continuously. Public benchmarks show why this matters: large vision-language models read unusual pages well, yet still invent or drop content on dense and difficult pages. Read how crew evaluations measure agents.
In Botminds, documents live in collections. A collection is not a folder; it is a small operating model for one kind of work: what the documents are, what to read from them, how they move, who works them, and which agents run when one arrives. A whole program is a handful of collections that know each other.
When policy allows and confidence clears the bar, a file goes straight through — untouched, and fully logged.
Go deeper: collections, taxonomy and lifecycles on the platform page.
Reading a document well is half the job; the other half is putting the result where each person works. Every screen below reads the same cited values, so the reviewer, the manager, the auditor and your loan system never disagree about what a document says.
Extracted fields beside the page; click a value and the page opens on it.
Stages become queues with owners and due times; four-eyes where you set it.
Questions in plain words, answered from the documents with the passage cited.
Straight-through rate, backlog and time per file, read from the same events as the work.
Drag a summary, a checklist, a conflict list or a chart onto a page — no front-end project.
Build, change and question the program by conversation: “how many files wait at L2?”
Embed a page, a chat or a workspace in your own site, with the same roles and audit trail.
Push documents and pull typed, cited results; copilots and IDEs connect over MCP.
Every result carries its citations, so the system downstream can show the source too.
A document program needs two things from its runtime: certainty about the path each document takes, and the ability to take ten thousand of them at once. Botminds IDP runs on both — and a team of agents reasons over the whole file when the work calls for judgment.
In a mortgage program all three work together: the mesh fans 2,000 files out into documents and sections across workers; an XFlow takes each document through the same steps; a team of agents reasons over the finished file. See teams, XFlows and mesh in depth.
Mortgage work arrives in waves — month-end, a portfolio purchase, a quality-control sample, a servicing transfer. Botminds IDP scales out to meet the wave: a deployment sized for it reads a million pages of loan files in half an hour — about 2,000 files of 500 pages — with every page accounted for and every value cited.
Pages per run · bars on a log scale
One loan file, end to end — Fifteen stages, run in parallel; extraction is the long pole.
under 14 minOne packet, split into 61 documents — Classified against 63 document types, with no errors; 6.5× effective parallelism.
about 10 minOne burst, all accounted for — 350 in, 350 out — nothing lost, nothing processed twice.
0 lostSection specialists in parallel — The same packet, split by section: 4–5 minutes down to under a minute.
35–61 sHow to read these numbers. The measured runs are single files and packets on one deployment. Throughput grows with the capacity a deployment is sized for: a million pages in 30 minutes is a deployment scaled out for that wave — OCR, model capacity and workers in proportion. We size yours from your own volumes and files. In production, documents processed this way have also run at more than 50,000 claim communications a day, sorted into over 200 categories.
Document programs carry residency rules: loan files that must stay in the country, health records that must stay in the region. Botminds IDP deploys where your policy says — our cloud, a dedicated environment, your own cloud subscription or your premises — in the region you choose, and everything it keeps stays in that region — or, for backup copies, its paired region in the same geography.
Runs in your private cloud or on‑premises.
Supported on Azure, AWS, Google Cloud and Oracle Cloud — and any other cloud you run.
If a region is lost, the database can be restored in its paired region from the geo-redundant backup. Queued work is durable, so documents in flight resume rather than restart.
The documents that flow through Botminds IDP are loan files, claims, contracts, medical records and statements — the most sensitive paper a business holds. Security is the operating assumption, from the certifications on the outside to the boundary around each agent on the inside.
Bring your security review: see security at Botminds for the controls by category, the certifications and the audit reports.
Access is decided by role, not by folder, and narrows step by step — from the platform down to a single action on a single stage. People, agents and systems are all held to it, and every answer the platform gives respects it.
| Processor | Underwriter | QC auditor | Builder | Admin | |
|---|---|---|---|---|---|
| See the file and its documents | ✓ | ✓ | ✓ | ✓ | ✓ |
| Correct an extracted value | ✓ | ✓ | flag | — | — |
| Move a file to the next stage | ✓ | ✓ | — | — | — |
| Approve at underwriter review | — | ✓ | — | — | — |
| Export results | — | ✓ | ✓ | — | ✓ |
| Change agents, fields and stages | — | — | — | ✓ | ✓ |
| Invite people and set roles | — | — | — | — | ✓ |
Example role set. Roles are yours to define, action by action and stage by stage. Here the QC auditor can flag a value but not change it, and only an underwriter can approve.
Confidentiality is not one control; it is the sum of where data lives, who can reach it and what the software is allowed to do with it. Here is the short list of things Botminds IDP never does with a document.
A processor sees the queue they work; an underwriter sees the files at their stage; an auditor sees the trail without the power to change it. Four-eyes review puts a second named person on the decisions that matter, and redacted copies let documents travel to people who should see only part of them.
Each document keeps its own timeline: when it arrived, which agents read it and what they returned, which values a person changed, who approved it and when. When someone asks who did what to a file, the answer is already written down.
Most document programs stop at the easy ten document types, review everything anyway, and cannot say how accurate they are. These are the reasons, and how Botminds IDP is built around each one.
| The problem | Why it happens | How Botminds IDP answers it |
|---|---|---|
| Templates break | Zonal and template tools read positions, not meaning. A vendor moves a field and the read silently fails. | Extraction is defined by what a field means, in a schema — never by where it sits. A new layout is read on the day it arrives. |
| The long tail of document types | The top ten types are easy. The next four hundred each need their own setup, so most programs stop at the head. | Classification and extraction learn from a description and a handful of examples, so the hundredth type costs what the tenth did. |
| Low straight-through rates | Confidence scores that don’t predict errors force people to review everything, and the business case evaporates. | Confidence is calibrated against your golden set, so the auto-accept threshold is chosen from measured error, not hope. |
| Handwriting and poor scans | Faxes, phone photos, skew, stamps and handwriting push character error rates up and confidence down. | Pages put upright, OCR only where text is missing, a confidence on every word, and low-confidence values routed to a person — never guessed. |
| Tables that don’t survive | Merged headers, borderless layouts and tables that run across pages come out as a jumble of text. | Tables are rebuilt as structure — header cells, rows, merged cells, units — and footed, so a misread number shows up as a total that doesn’t add up. |
| Values invented by a model | Generative extraction can produce a plausible number that is not on the page. | Every value must point to the page and region it came from. A value with no source is not accepted. |
| No audit trail | When a regulator or auditor asks where a number came from, nobody can show them. | One click from any value to its passage; every agent step, edit and approval is recorded. |
| Documents disagree | Extraction alone leaves the comparison — pay stub against deposit, invoice against contract — to people. | Consistency checks run across documents and against your systems, and each conflict is shown with both sources. |
| Mixed languages and scripts | Single-language tools drop the foreign-language half of the file, or translate and lose the original. | Read in the original language, answered in yours, cited to the original words. |
| Not just documents any more | Evidence arrives as calls, voicemail, photos and video, and sits outside the IDP tool entirely. | Transcripts, video frames and images go through the same pipeline and are cited to the second, the frame or the region. |
| Personal data everywhere | Every file carries data someone may not see, and manual redaction misses and over-cuts. | Redaction proposed with a rule for every box, approved by a reviewer, burned into the file, and logged. |
| Accuracy nobody measured | Most teams cannot say how accurate their system is, field by field, today. | Golden sets, field-level scores and a regression run on every change — on your documents, before you sign. |
| Model drift | A model update changes the reads, and nobody notices until a downstream report is wrong. | Every model or prompt change re-runs the evaluation set; a change that scores worse does not ship. |
| Cost per page | Sending every page to the largest model makes the economics fail at volume. | Each step uses the right engine: OCR only on pages without text, layout where it suffices, larger models only where reasoning is needed. |
| Volume arrives in waves | Month-end, a portfolio purchase or a backlog swamps a fleet sized for the average day, and files wait for days. | Workers follow the queue: capacity is added as the wave arrives and released as it drains, and intake is governed so nothing is dropped. |
| Sensitive files, wide access | Document tools grant access by folder, and AI answers can surface text the asker should never see. | Roles down to the collection, stage and action; answers drawn only from what the asker may open; agents scoped the same way. |
88% of the 1,062 solutions in the library start from documents, and every one of them runs on Botminds IDP. Here are 75, grouped by the capability they lean on hardest — across every industry we serve. Each opens its own page, with its screens and a demo.
Pages people wrote, stamped, faxed and photographed — read with a confidence on every line.
Multi-page forms with checkboxes and repeating sections — field by field, against the rules for that form.
Tables rebuilt cell by cell, joined across pages, then footed so the totals prove the read.
Workbooks read as the tables they are — every tab, header and cell address kept, never flattened into text.
Read in the language it was written in, answered in yours, cited to the original words.
Call transcripts, footage and photos read like documents — every finding cited to a second, a frame or a region.
Hundreds of pages in one file, split into the documents inside, typed, and checked for what is missing.
Agreements read under their own definitions, amendments applied in order, every clause cited.
Personal, privileged and protected data proposed for removal with a reason, approved by a person, and truly removed.
Mixed fonts, white-out, editing-tool traces, balances that don’t add up, duplicates and rings — each signal shown.
Documents checked against each other and against your systems — the comparison people spend most of their day on.
Ask in plain words; the answer comes back with the passage, page and version it came from.
Memos, responses and filings drafted from what was read — every sentence traceable to a source.
Browse all 1,062 solutions, or start from an industry: insurance, lending, banking, life sciences, investment management, utilities, airlines, education and cross-industry.
The question to ask any intelligent document processing software is not “can it read this?” Almost everything can, once. It is what happens on the thousandth document, the new layout, and the audit.
| Template OCR | LLM-only extraction | Botminds IDP | |
|---|---|---|---|
| A new layout arrives | A template is built and tested first | Read at once — but unverified | Read at once, by meaning, and checked |
| Where a value came from | A zone on a known layout | Usually nowhere | Page and region, one click away |
| Handwriting and ticked boxes | Separate engine, separate setup | Read, with no confidence | Read with a confidence per word; boxes from the ink |
| Tables | Fixed column zones | Rows often merged or dropped | Grid with header cells and spans, joined across pages, footed |
| Confidence | Per-engine scores, rarely calibrated | None, or the model’s own guess | Fused, grounded on the page, calibrated on your set |
| Documents checked against each other | Left to people | Left to people | Agents compare documents, rules and systems |
| Redaction | A separate product | Not done | Proposed with a rule, approved, burned in, logged |
| Tampered documents | Rarely checked | Not checked | Fonts, white-out, editing traces, arithmetic — at intake |
| Accuracy | Quoted from a demo set | Not measured | Golden sets, field by field, on every change |
| Who decides | A reviewer, without the evidence | Nobody, by default | A named person, with the evidence, recorded |
| How the work is done | One fixed pass per template | One model, one prompt | A crew of agents that plan, use tools and check each other |
| Volume | Servers sized for the average day | Bound by one model’s rate limit | Scales out with the queue — a million pages in 30 minutes, sized for it |
| Who can see what | Folder permissions | Whoever holds the prompt | Roles down to the collection, stage and action; answers respect them |
| Where it runs | A server you maintain | Wherever the model vendor runs it | The region you choose — our cloud, yours, or on-premises |
For a vendor-neutral introduction, see the IDP buyer’s guide and what agentic AI is.
Botminds IDP is the intelligent document processing technology inside the Botminds platform. It reads any document or record — scans, handwriting, complex forms, tables, spreadsheets, emails, photos, call transcripts and video, in the language they were written in — extracts what matters, checks it against rules and other documents, and hands a cited result to a person or a system. Every value links to the page and region it came from.
Intelligent document processing (IDP) is software that turns documents into checked, structured data and decisions. It sorts what arrives, extracts the fields and passages that matter, validates them against rules and other documents, and passes the result on, with a person reviewing what the system is unsure of. Our buyer’s guide explains IDP in depth.
OCR (optical character recognition) turns printed text in an image into characters. ICR (intelligent character recognition) does the same for handwriting. IDP uses both as early steps, then understands the layout, classifies the document, extracts the meaning, validates it and routes the result. OCR gives you text; IDP gives you checked data you can act on.
Agentic document processing gives each job on a file to an AI agent with its own instructions, tools and limits. In Botminds IDP an intake agent sorts and splits the file, extraction agents read each document by meaning, a standardization agent puts values in your formats, a quality agent checks the reads, a cross-document agent compares the file, and redaction, answering and drafting agents do the rest. They stop at a person where judgment is needed, every step is recorded and every value is cited, so the work can be audited.
Each agent has a written boundary: the collections it may read, the tools on its allow-list, the rules it must follow and the cases that need a person. An agent whose tool settings are missing or broken gets no tools at all. Text inside a document is treated as evidence, never as instructions, so a page cannot widen what an agent may do. Tools that change something can wait for a named person’s approval, and every change to an agent is tested on a golden set before it publishes.
A collection is the home for one kind of work: its document types and fields, its review stages and the automations on each stage, the agents that run when a document arrives, the policy for when AI may skip the reviewers, and who may see and act on it. A mortgage program, for example, is a loan-file collection with a child collection for the documents in each file, a structured collection for income and asset lines, a knowledge collection of guidelines, a work queue of conditions and a golden set for testing.
Yes. Handwriting is read from the page image alongside printed text, with a confidence on every word. Ticked boxes are detected from the ink on the page, not guessed from text. Anything below the confidence threshold goes to a person, who sees the original image next to the reading.
Scanned pages are put upright and read by OCR, then the layout model rebuilds each table as a grid — header cells, rows, merged cells and a confidence for every cell. Extraction agents join tables that continue across pages and read each cell into a typed value with its units. Totals are then re-added, so a misread number shows up as a sum that does not foot.
Native and scanned PDFs up to 1,500 pages each; images (TIFF with every frame, JPEG, PNG, GIF, BMP, WebP); faxes; Word, PowerPoint and legacy Office files; Excel and CSV, kept whole; email (EML, MSG) with its attachments; HTML, text, JSON and XML; ZIP archives, unpacked safely; call and meeting transcripts; and video, sampled frame by frame. Documents are read in the language they were written in and cited to the original words.
We measure accuracy field by field on a golden set of your own documents and report the numbers together: the share of fields that pass automatically, the precision of those automatic passes, and how well confidence is calibrated. On held-out real financial statements — mostly French, a quarter of them scanned — fields above the confidence threshold passed automatically at 98% measured precision, and the rest went to a reviewer. Our target for what leaves the system after review is 99% field accuracy, and we run the test on your documents before you sign.
Botminds IDP scales out with the queue: a deployment sized for the wave reads a million pages of mortgage files in 30 minutes — about 2,000 loan files of 500 pages, or roughly 556 pages a second. That is a sizing figure for a scaled-out deployment; the measured runs are single files. Pages, documents and sections fan out across workers that are added as the queue grows, model calls are pooled across several deployments, and intake is governed so nothing is dropped. Measured on single files, a 1,000-page loan file was read end to end in under 14 minutes, and a 607-page packet was split into 61 documents in about 10 minutes with no errors. In production, deployments have read 100,000 scanned invoice pages a day.
Every extracted value must point to the page and region it came from, and the confidence score checks that the value actually appears on that page. Values are re-read and compared, checked by a second reviewer agent, and tested against rules and other documents. Low-confidence values go to a person, and every change to a model or prompt re-runs the evaluation set before it ships.
Yes. Agents find personal, financial, health and privileged data and propose each redaction with the rule behind it; a reviewer approves before anything is removed. In PDFs the text is taken out of the page, not covered by a box, and in images the pixels are overwritten, so nothing can be copied back. Recordings and video are masked on playback. Every removal is logged with its reason.
In the region you choose — in the Botminds cloud, a dedicated environment, your own cloud subscription on Azure, AWS, Google Cloud or Oracle Cloud, or on your premises. Original documents, page images, extracted values, indexes and run history stay in that region, with backup copies in its paired region in the same geography; model calls go only to the model deployments you approve. Each core service runs as at least two copies, workers scale with the queue, and the database has point-in-time restore.
Access is set by role and narrows from the platform to the workspace, the project, the collection, the review stage and the single action — see, correct, approve, export or configure. Sign-in goes through your identity provider with SSO and SAML; a workspace can be locked to it and require two-factor sign-in. Chat and search answer only from collections the asker may see, agents are scoped to the collections they are attached to, and one view shows any person’s effective access.
Botminds holds SOC 2 Type II and ISO 27001 and supports GDPR. Data is encrypted with TLS in transit and AES-256 at rest, isolated per customer, and never used to train shared or third-party models; reviewers’ corrections improve only your own deployment. Every action by a person or an agent is in the audit trail, redaction removes data rather than covering it, and four-eyes review puts a second named person on the decisions that matter.
Yes. Forensic checks look for mixed fonts, white-out overlays, editing-tool metadata and running balances that do not add up; they need no AI model, take well under a second, and hold a suspect document at intake. Exact duplicates are caught by fingerprint, and agents look for contradictions across documents. Each signal is shown for an investigator to judge.
Send us the files your current tools get wrong. We’ll run Botminds IDP on them and show you the scorecard, field by field.