Unstructured in. Evidence out.
The ingestion engine of the Verifiable Knowledge Layer: documents, scans, images, audio and video become structured, machine-readable evidence — layout, meaning, exact location and provenance. Standalone API, available in pilot; the first layer, not the final destination.
# parse a document, keep every span POST /v1/parse { "document": "s3://acme/contract_2024.pdf", "outputs": ["canonical_text", "structure", "spans"] } # 200 OK { "atoms": 1284, "tables": 17, "reading_order": "resolved", "source_spans": true, "certificate": "cert_9f2…" }
Parsing is where AI systems start lying.
Most parsers flatten documents into a string. Structure, geometry, tables and provenance are destroyed before any model sees the content — and no downstream step can recover what parsing lost.
Artifacts, not strings.
Canonical text
- deterministic
- stable coordinates
- addressable
Same document, same text — always.
Structure atoms
- tables
- lists · headers
- reading order
- geometry
Every element typed and addressable.
Built for verification
- certificate
- source spans
- coordinates
- provenance
Certificates in pilot; public verification at launch.
Three moves. Nothing hidden.
Submit
Send a document or point the API at a source. Nothing to install, nothing to host.
Parse
The measured champion stack for your document family runs — versioned and swappable.
Verify
Receive artifacts plus a certificate. Every element traces to its exact position in the source.
From page to artifact, stage by stage.
Each stage is run by a measured champion — benchmarked per document family, versioned, and swapped the day a better engine wins.
Where this engine sits in the platform → architecture
One artifact, exactly as the API returns it.
Left: the element on the page. Right: what you receive — typed, located, verifiable.
# artifact 47 — table, page 12 { "type": "table", "page": 12, "bbox": [143, 220, 502, 640], "reading_order": 47, "cells": 84, "canonical_text": "Q2 revenue by segment…", "source_span": "contract_2024.pdf#p12/143,220,502,640", "certificate": "cert_9f2…" } # artifact 51 — chart, page 14: the engine abstains { "type": "chart", "state": "ABSTAINED", "reason": "chart-to-table below the evidence bar" }
Representative artifact — the exact response contract is published with the pilot. The abstained chart is not a bug: fabricating a table would be.
Measured before claimed.
Public benchmarks
Pre-registered evaluations against named competitors — published with the pilot, every number with its n.
Internal evaluation
Running today on proprietary gold sets. A number appears below only after it survives its gate — until then, the honest state is shown.
| Dimension | Unit | Status | Notes |
|---|---|---|---|
| Reading order | F1 vs gold | measured · internal | publication after pre-registered eval |
| Tables | structure F1 | measured · internal | gold set expanding — n reported with every number |
| OCR | CER / WER | measured · internal | champions measured per document family |
| Forms | field F1 | publication pending | gold set in construction |
| Long documents | fidelity at 60+ pages | publication pending | long-document bench in progress |
| Charts | chart-to-table | UNKNOWN · fail-closed | the engine abstains instead of guessing |
Charts are the honest row: today the engine abstains rather than fabricate a table. Continuous benchmark →
Credits per unit of work.
Certificates included with every artifact. How pricing works →
Every artifact is verifiable.
Certification runs through everything Orves produces. Anyone can verify a certificate — free, forever, no account.
Integrate in minutes.
Everything is delivered through the API. Nothing to install, nothing to host.
FAQ
Why not an open-source parser — Docling, Unstructured, LlamaParse?
Those are engines. Orves is the measured layer above engines: a permanent championship benchmarks candidates per document family, and the winner ships behind one stable API with determinism, abstention and certificates. Engines keep changing; your contract doesn't — and you never operate, version or re-benchmark them yourself.
How deterministic is parsing?
Same document, same engine version — same output, byte for byte. Determinism is a platform invariant, checked with round-trip tests. It is what makes evidence reproducible and certificates meaningful.
What happens when parsing is uncertain?
The element is returned with an abstained state and the reason. UNKNOWN is a decision, not an error — nothing is fabricated.
How are tables represented?
As structure atoms: typed elements with geometry, cells, headers and reading order, addressable by coordinates. Not markdown soup — a table you can query, cite and verify cell by cell.
How are certificates generated?
Every parse records engine version, inputs, outputs and source spans; the certificate binds them, so any artifact traces back to its exact position on the page. Certificates are in pilot; the public verification endpoint ships at launch.
How do you benchmark the engine?
Pre-registered evaluations on gold sets, every number published with its n, champions re-measured as engines evolve. A claim appears on this site only after it survives its gate — until then you see the honest state.
How is pricing calculated?
1 page = 1 credit — flat. No multipliers for OCR, tables or file type, and certificates are never billed.
Can I self-host?
No. Orves is delivered exclusively as an API. Determinism, benchmarks and certificates are properties of the operated platform — we only guarantee them where we run the engines. Nothing to install, nothing to maintain.
Which formats are supported?
PDF, DOCX, XLSX, PPTX, HTML, images, scans and audio — plus databases, APIs and event streams through connectors. If a family is not yet measured, the API says so instead of silently degrading.
Can I use the Parser alone?
Yes. Parser is a standalone API with its own benchmarks — built for teams that already run their own pipelines, RAG or ingestion. Add Verifiable Knowledge when you need knowledge you can prove.