---
title: "lift"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/19d96276-f396-49fa-ba1e-2fb1868a574b"
updated: "2026-11-13"
---

# lift

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

lift is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by datalab-to

## 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.

```sh
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:

```sh
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:

```python
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.

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 |

Field accuracy on the card's 225-document test

| Label | Value |
| --- | --- |
| 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

## README

````markdown
# 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.

```table
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

```table
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.

```sh
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:

```sh
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:

```python
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)
```

```table
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.

```flow
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.

```table
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
```

```chart
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:

```sh
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.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[datalab-to/lift on Hugging Face](https://huggingface.co/datalab-to/lift)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| lift (this page) | 11,454 | 210 | 9.7B | openrail | 2026-10-05 |
| [THX-01](https://mindket.com/p/8a622893-ef99-4a72-b05f-85a7557c685b) | 789 | 93 | 322M | apache-2.0 | 2026-10-16 |
| [Parallel Constrained Decoding for Apple Silicon](https://mindket.com/p/a2bcfb76-45e6-47dc-9338-ace2e6f66514) | 0 | 592 | — | apache-2.0 | 2026-09-16 |
| [Qwen3.8-27B](https://mindket.com/p/2f430c52-7d18-419d-8817-08ca51666598) | 6,960,395 | 19,795 | 27.8B | apache-2.0 | 2026-11-07 |
| [Qwen3.5-9B](https://mindket.com/p/acc60a90-d19e-4344-a8c1-5f984b2637b3) | 6,259,809 | 2,353 | 9.7B | apache-2.0 | 2026-03-02 |
| [Qwen3.8-27B-FP8](https://mindket.com/p/79f1a984-4e81-485e-999d-dba1a831f37a) | 5,442,810 | 984 | 27.8B | apache-2.0 | 2026-11-07 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Bluesky · Sung Kim · 2026-06-19](https://bsky.app/profile/sungkim.bsky.social/post/3moofdjbo4c2s): 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. Model: huggingface.co/datalab-to/l... Code: github.com/datalab-to/l... Blog: datalab.to/blog/introdu...
- [Bluesky · probbrain.com · 2026-06-24](https://bsky.app/profile/probbrain.bsky.social/post/3mozrc27ylx2b): 🆕 AI news (last 15m): • HuggingFace: datalab-to/lift · 141♥ · 3216 dl • GitHub Trending: Interviewstreet's hiring-agent is an AI agent designed to evaluate and score resumes. • GitHub Trending: Orca is an ADE for managing parallel coding agents, available on desktop and mobil… → probbrain.com/news

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-05
- First published: 2026-06-19
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open datalab-to/lift on Hugging Face](https://huggingface.co/datalab-to/lift)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/19d96276-f396-49fa-ba1e-2fb1868a574b)
- [Its page on Mindket](https://mindket.com/p/19d96276-f396-49fa-ba1e-2fb1868a574b)
