Introducing lift: open-weights structured extraction

We’re releasing lift, a 9B open-weights vision model that extracts structured JSON from PDFs and images. You give it a JSON schema, it gives you back a JSON object that matches.

lift scores 90.2% field accuracy on our 225-document extraction benchmark - the best of any small self-hostable model we tested, and competitive with frontier closed models - while running at a median of 9.5s per document, faster than any other accurate model in the comparison.

We have extensive open source OCR work: chandra, marker, and surya, but lift is our first model purely for extraction.

Here’s what’s new:

• Model size: 9B params
• Single-pass multi-page: handles whole documents at once, including values that span pages
• Benchmark: 90.2% field accuracy on a 225-document, ~11,000-field extraction benchmark with adversarial cases planted throughout
• License: code is Apache 2.0, weights are modified OpenRAIL-M (free for research, personal use, and startups under $5M funding/revenue)

Get it:

• GitHub
• HuggingFace
• pip install lift-pdf
• Playground - try schemas interactively
• API - hosted, with per-field verification, citations, and confidence scores

Why a model just for extraction

Structured extraction is a tough challenge - values can conflict, be in non-obvious places in the document, or be small/illegible. lift is built end-to-end for structured extraction. It decodes against your schema, so the output is always valid JSON of the right shape. And it’s trained to leave fields null when the answer genuinely isn’t there.

Schema extraction

You pass standard JSON Schema, and lift extracts the fields you define:

{
  "type": "object",
  "properties": {
    "invoice_number": { "type": "string", "description": "Invoice identifier" },
    "total": { "type": "number", "description": "Total amount due" },
    "line_items": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "description": { "type": "string" },
          "amount": { "type": "number" }
        }
      }
    }
  },
  "required": ["invoice_number", "total"]
}

Abstention by default

The hardest part of real extraction isn’t reading the fields that are present - it’s not filling in the ones that aren’t. A model that hallucinates a tax ID or a due date is worse than one that returns nothing, because the error is silent.

lift accurately handles null fields without hallucination. The result is an extractor you can trust to say “this document doesn’t contain that.”

Benchmarks

We evaluated on a 225-document extraction benchmark: 6–64 pages per document, ~11,000 scored fields, with adversarial cases planted throughout - cross-page values, exhaustive lists, fields that must be left null, near-miss distractors, and multi-source aggregation. Every model receives the same rendered page images and extracts each document in a single pass. Scoring is deterministic exact-match against ground truth (numeric tolerance, normalized strings).

Model	Size	Field accuracy	Full-document accuracy	Median latency
Datalab API	—	95.9%	44.4%	30.8s
Gemini Flash 3.5	—	91.3%	40.0%	28.1s
lift	9B	90.2%	20.9%	9.5s
Azure Content Understanding	—	83.4%	22.2%	73.7s
NuExtract3	4B	81.5%	8.4%	8.3s
Qwen3.5-9B	9B	76.3%	24.0%	16.8s

lift is the strongest self-hostable model on the benchmark - ahead of NuExtract3 and Qwen3.5-9B.

Qwen3.5-9B (base) NuExtract3 (4B) lift (9B)

• Field accuracy
  76.3%

  81.5%

  90.2%
  +13.9

lift is also the fastest of the accurate models, at a 9.5s median per document - roughly 3x faster than Gemini Flash 3.5 and the Datalab API, while staying within a couple of points of their field accuracy. If you want the highest accuracy, plus per-field verification, citations, and confidence scores, the hosted Datalab API runs an improved extraction stack on top of the same approach.

Try it out

The fastest way to start is the CLI:

pip install lift-pdf

# Serve the model with vLLM (recommended)
lift_vllm

# Extract against a schema
lift_extract input.pdf ./output --schema schema.json

There’s also a Python API, a HuggingFace backend for local GPU inference, and Schema Studio - a small app for building, saving, and testing schemas against your own documents. See the GitHub repo for details.

You can try lift in the playground, or use the Datalab API for hosted extraction with verification and citations. For on-premise deployments, contact us at [email protected].

What’s next

lift is the first open-weights release in our extraction line, and we’re going to keep pushing it - more accuracy, better handling of long documents, and tighter schema support. If you have documents that today’s extraction tools get wrong, we’d love to see them: contact us.