datalab-to/omni_extract_bench

Omni Extract Bench

We weren’t satisfied with the current benchmarking options for extraction. They were biased, didn’t use realistic data and were hard to audit. Our view is that an extraction benchmark should do two things:

• Help customers choose the right vendor; and
• Give engineers a way to diagnose what’s actually going wrong in a given model.

That’s why we built OmniExtractBench.

OmniExtractBench is a comprehensive structured extraction benchmark, developed by Datalab. It tests how accurately models pull specific values out of documents when given a schema and a PDF. OmniExtractBench includes:

• 620 diverse documents from several vendor benchmarks (Reducto, Extend, LlamaIndex, Datalab) to eliminate bias;
• Clear, consistent and auditable scoring; and
• A wide variety of extraction edge cases tested (scans, dense tables, forms, etc)

Read more in our blog post. Also see the GitHub for the scoring and prediction harnesses.

Data

Results

Layout

manifest.parquet        one row per document; the schema is in it
pdfs/<doc_id>.pdf       the document
gold/<doc_id>.json      the ground-truth extraction
licenses/               the upstream licence for each suite
assets/                 

column
doc_id	unique; a descriptive name, which the files carry. Some contain spaces
doc_path	pdfs/<doc_id>.pdf, relative to the dataset root
gt_path	gold/<doc_id>.json, relative to the dataset root
schema	the JSON Schema itself, inline as bytes
suite	which part of the benchmark it came from

suite names the part of the benchmark a document came from, and rides through to your scores, so results can be read per suite as well as overall.

Get it

uv pip install 'omni-extract-bench[benchmark]' polars   
hf download datalab-to/omni_extract_bench --repo-type dataset --local-dir benchmark

Score your own predictions

One JSON file per document, named however you like. Join them onto the manifest by doc_id and hand the result to the scorer:

import pathlib
import polars as pl

mine = pathlib.Path("my-predictions").resolve()      # absolute: these are yours, not the corpus's
files = sorted(mine.glob("*.json"))                  # once, so the two columns stay aligned
preds = pl.DataFrame({"doc_id": [f.stem for f in files],
                      "pred_path": [str(f) for f in files]})

(pl.read_parquet("benchmark/manifest.parquet")
   .join(preds, on="doc_id")                         # an inner join scores the subset you have
   .write_parquet("jobs.parquet"))

oeb score --root benchmark --manifest jobs.parquet --out run/ --jobs 4

Resolve pred_path to an absolute path, as above. A relative one would be read from --root, which is where the corpus lives and your predictions do not.

Or predict with the harness

If the provider is one the harness speaks, there is nothing to join — its output table is a score manifest, with gt_path carried through from this one:

# predict;
oeb predict --root benchmark --manifest benchmark/manifest.parquet \
            --out preds/ --provider datalab

# then score
oeb score   --root benchmark --manifest preds/manifest.parquet --out run/

Providers: azure-cu, claude, datalab, datalab-accurate, extend, gemini, gpt, gpt-pro, llamaextract, mistral, reducto. Each needs its own credentials in the environment, and the adapters live behind an extra: uv pip install 'omni-extract-bench[harness]'.

Read the results

Two tables land in run/: scores.parquet/ has a row per document, verdicts.parquet/ a row per address.

import polars as pl

scores = pl.read_parquet("run/scores.parquet")
graded = scores.filter(pl.col("status") == "scored")
print(f"{graded['accuracy'].mean():.2f} over {len(graded)} of {len(scores)} documents")

What the metric does

• Normalize document;
• Flatten prediction and gold JSON dictionary to addresses mapped to their scalar values;
• Normalize scalar values of the flattened addresses; and
• For each array that appears, Hungarian match (recursively for nested arrays) based on array element content to align ambiguous predicted and gold addresses (there may unmatched predicted addresses — false positives, and unmatched gold addresses — false negatives).

For each document, this process produces one Verdict per unique scalar address, aligned via Hungarian matching when needed. The options are:

• matched: was matched and the values match;
• misread: was matched and the values don’t match;
• unfound: ground-truth has the address, prediction doesn’t;
• fabricated: schema offered the address, ground-truth is silent but prediction exists;
• invented_item: an array element’s scalar prediction that paired with nothing; or
• invented_field: an address the schema never declared.

These are mutually exclusive in our code and also semantically. The one interesting judgement call we made here is that an address falls under invented_item it falls within an unpaired item (i.e. row), even if the address was an invented field within that array element’s schema. We think this is the right call: it signals that this was counted against the model for inventing an item. Addresses outside of arrays that the schema never declared is invented_field.

License

CC BY 4.0. The full texts are in licenses/.

suite	documents	upstream licence	credit to
extractbench	329	Apache 2.0	upstream authors
internal	202	Apache 2.0	Datalab — synthetic, generated for this benchmark
longarray	42	CC BY 4.0	Extend AI — cite LongArray-Extract, not this assembly
micro1	47	MIT	Micro1

The scorer itself is separate and Apache 2.0.

Citation

@misc{omni_extract_bench,
  title  = {Omni Extract Bench},
  author = {Datalab},
  year   = {2026},
  url    = {https://github.com/datalab-to/omni_extract_bench}
}