lift

lift

Pulls structured data out of PDFs and images. You supply a JSON schema, and it returns an object that matches it. A 9.7B vision-language model from Datalab for developers who process documents.

Made by datalab-to on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: lift is a document extraction model from Datalab. It reads PDFs and images and returns structured JSON. You give it a JSON schema, and it decodes under that schema, so the result is valid and correctly typed. It reads a multi-page document in one pass, including values that run across pages. It has 9.7B parameters and weighs about 19.3 GB in BF16.

Who it suits: It suits developers who turn invoices, reports and forms into database rows and want to run the extraction on their own hardware.

Industry | Who uses it | How they use it | Example
Finance | Teams that process invoices | Extract fields and line items from invoice PDFs | A schema with an invoice number, a total and a list of line items
Operations | Back-office developers | Turn forms and reports into structured records | Fields missing from a page come back as null
Research | Teams that build document pipelines | Compare extraction accuracy on long documents | The card tests 225 documents with about 11,000 scored fields

You can skip it if you only need plain text from a page, since it is built to fill a schema, and the weights carry a license with limits on competing use.

Where to use it:

• Python, through the lift-pdf package
• A local vLLM server, started with lift_vllm
• Hugging Face Transformers, for in-process use that needs torch
• Windows, macOS or Linux with Python
• A command line, for single files or whole folders

Use case | Who | What they get back
Invoice extraction | Finance developers | A JSON object with the invoice number, total and line items
Multi-page reports | Data engineers | Values that span pages, collected in a single pass
Schema design and testing | Analysts | Schema Studio, a small app for drafting and trying out schemas on sample files

How to set it up: You need Python, a GPU for the vLLM route and room for the weights.

• Python with pip
• The lift-pdf package
• Either a vLLM server, which is the recommended and lighter route, or torch for the Hugging Face route
• About 19.3 GB for the BF16 weights, or about 4.8 GB at 4-bit, which is an estimate

1. Install the lift-pdf package.
2. Start the vLLM server with lift_vllm.
3. Write a JSON schema file with the fields you want.
4. Run lift_extract on a PDF with that schema.

pip install lift-pdf
lift_vllm
lift_extract input.pdf ./output --schema schema.json

To download the model files yourself with the Hugging Face tools, use these two lines:

pip install -U huggingface_hub
hf download datalab-to/lift

How to use it: A schema is standard JSON Schema. Strings, numbers, integers, booleans, arrays and nested objects are supported. Describe any field with an unclear name. Mark a field required only if it must always be present. In Python, start the server first, then call extract:

from lift import extract
from lift.model import InferenceManager

# Start the vLLM server first with: lift_vllm
model = InferenceManager(method="vllm")
result = extract("document.pdf", "schema.json", model=model)
print(result.extraction)

Tool | What it does
lift_vllm | Starts the local vLLM server
lift_extract | Command line that extracts one file or a folder
extract | Python function that takes a document and a schema
InferenceManager | Chooses between the vllm and hf methods
page_range | Limits which PDF pages are read
VLLM_API_BASE | Points the client at a remote server

Example: You ask for an invoice number, a total and a list of line items. lift reads the PDF and returns one JSON object with those three keys. A field that is not in the document comes back as null instead of a guess.

For newcomers and experts: Think of it as a clerk who fills in a form for you from a pile of papers, and the form is your schema. A first small try is one invoice PDF and a three-field schema.

The constrained decoding means the output always parses and matches your types, though a valid value can still be wrong. The card scores each field by exact match, with tolerance for numbers. It reports that the model gets 90.2% of fields right but only 20.9% of whole documents fully right, so long documents still need review.

Write a JSON schema
Start the vLLM server or load the model
Pass a PDF and the schema to extract
The model decodes under the schema
Read the JSON result

Good to know: The card compares lift with other options on its own benchmark. Latency is per document with 8 concurrent requests, so treat it as relative.

Title: The card's benchmark
Model | 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 | 90.2% | 20.9% | 9.5s
Azure Content Understanding | 83.4% | 22.2% | 73.7s
NuExtract3 | 81.5% | 8.4% | 8.3s
Qwen3.5-9B | 76.3% | 24.0% | 16.8s

Title: Field accuracy on the card's 225-document test
Datalab API: 95.9%
Gemini Flash 3.5: 91.3%
lift: 90.2%
Azure Content Understanding: 83.4%
NuExtract3: 81.5%
Qwen3.5-9B: 76.3%

• Other versions: other people have published 15 quantized and 3 fine-tuned versions
• License: the code is Apache 2.0. The weights use a modified OpenRAIL-M license with a no-competition clause, and it is free for research, personal use or a startup below 5M in funding or revenue
• Cost to run: none named for local use, and the hosted API has its own pricing
• Data it reaches: the documents you pass in and the files you download, plus a remote server only if you point VLLM_API_BASE at one
• Not for: plain text reading, or fully unreviewed extraction from long documents

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 9.7B
• Weights: about 19.3 GB in BF16; about 4.8 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 11,454
• Likes: 210
• License: openrail
• Quantized versions: 15
• Fine-tunes: 3
• Tags: transformers, safetensors, qwen3_5, image-text-to-text, extraction, structured-data, json, conversational

Links

• Model: https://huggingface.co/datalab-to/lift
• Files: https://huggingface.co/datalab-to/lift/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download datalab-to/lift

Then follow the usage in its model card. Nothing in this kit runs by itself.