liteparse

LiteParse

| | | | | | Docs

English | 简体中文

Looking for LiteParse V1? Follow this link to the old code

LiteParse is a standalone OSS PDF parsing tool focused exclusively on fast and light parsing. It provides high-quality spatial text parsing with bounding boxes, without proprietary LLM features or cloud dependencies. Everything runs locally on your machine.

Hitting the limits of local parsing? For complex documents (dense tables, multi-column layouts, charts, handwritten text, or scanned PDFs), you'll get significantly better results with LlamaParse, our cloud-based document parser built for production document pipelines. LlamaParse handles the hard stuff so your models see clean, structured data and markdown.

Sign up for LlamaParse free

Overview

• Fast Text Parsing: Spatial text parsing using PDFium, ~2-5ms per page
• Flexible OCR System:
  • Built-in: Tesseract (zero setup, bundled with the library)
  • HTTP Servers: Plug in any OCR server (EasyOCR, PaddleOCR, custom)
  • Standard API: Simple, well-defined OCR API specification
• Complexity Detection: Cheaply check whether a document needs OCR or heavier parsing — route, reject, or estimate cost before a full parse
• Screenshot Generation: Generate high-quality page screenshots for LLM agents
• Multiple Output Formats: Markdown, JSON, and Text
• Markdown Output: Structured Markdown with headings, tables, lists, images, and links — great for feeding LLMs and RAG pipelines
• Bounding Boxes: Precise text positioning information
• Multi-language: Use from Rust, Node.js/TypeScript, Python, or the browser (WASM)
• Worker Pool Mode (Python & Node.js): Parse in persistent worker processes for true parallelism (PDFium otherwise serializes concurrent parses) and hard per-parse timeouts — rogue documents are killed, identified by name, and never stall the pipeline
• Multi-platform: Linux, macOS (Intel/ARM), Windows

…

Benchmarks

LiteParse is measured on multiple public Doc→Markdown benchmarks. All numbers below were produced on this machine from one command (see Reproducing), with every tool at its latest release as of 2026-09-09. LiteParse and the "model-free" competitors use no ML model at all (no LLM, no layout model, no GPU). All tested methods have permissive licenses and can be run locally with minimal dependencies.

Benchmark Metric LiteParse + Tesseract OCR + PaddleOCR Best other model-free tool ParseBench (2,049 docs) Overall (mean of 5 categories) 0.364 0.380 0.389 pdf-inspector 0.283 opendataloader-bench (200 docs) Overall (NID + TEDS + MHS) 0.886 0.896 0.901 opendataloader 0.842 olmOCR-bench (1,403 pages) % tests passed 39.6 41.1 42.2 pdf-inspector 33.7 ParseBench

Rule-based scoring, no LLM judge. Each column is ParseBench's canonical per-category metric (Tables = GriTS/TRM composite; the others are rule pass-rates). Overall is the mean of the five, as on the ParseBench leaderboard.

Pipeline Overall Tables Charts Content Faithfulness Semantic Formatting Visual Grounding LiteParse + PaddleOCR 0.389 0.430 0.013 0.787 0.402 0.314 LiteParse + Tesseract 0.380 0.428 0.012 0.751 0.399 0.307 LiteParse (no OCR) 0.364 0.424 0.013 0.700 0.385 0.297 pdf-inspector 1.19 0.283 0.277 0.017 0.598 0.426 0.099 opendataloader 2.5.7 0.277 0.349 0.006 0.663 0.258 0.110 markitdown 0.1.7 0.185 0.158 0.020 0.652 0.001 0.110

Notes:

• Visual Grounding scores layout blocks with bounding boxes (lit parse --extract-blocks).
• Charts is near zero for every tool here — none reconstruct chart data.

opendataloader-bench

NID = reading-order similarity, TEDS = table structure, MHS = heading hierarchy. Overall is the harness's own mean.

Engine Overall NID TEDS MHS LiteParse + PaddleOCR 0.901 0.932 0.832 0.840 LiteParse + Tesseract 0.896 0.928 0.829 0.828 LiteParse (no OCR) 0.886 0.917 0.818 0.821 nutrient (commercial) 0.885 0.925 0.708 0.819 opendataloader 2.5.7 0.842 0.912 0.483 0.757 markitdown 0.1.7 0.589 0.844 0.273 0.000

Notes:

• nutrient has no runnable parser in this harness (commercial)
• The corpus is native-text PDFs, so OCR gains come from embedded figures and a handful of scanned pages.

olmOCR-bench

Score = average of per-category pass rates. The two math categories require LaTeX output and are 0% for every tool here; they still count in the average.

Engine Overall baseline headers_footers multi_column table_tests long_tiny_text old_scans arxiv_math old_scans_math LiteParse + PaddleOCR 42.2 99.9 48.7 69.1 54.0 46.4 19.4 0.0 0.0 LiteParse + Tesseract 41.1 99.9 52.1 66.2 54.1 42.5 13.9 0.0 0.0 LiteParse (no OCR) 39.6 99.9 55.8 66.3 52.5 29.2 13.3 0.0 0.0 pdf-inspector 1.19 33.7 82.9 62.1 49.7 43.6 17.6 13.3 0.0 0.0 opendataloader 2.5.7 32.5 86.9 36.6 63.7 24.9 34.8 13.3 0.0 0.0 markitdown 0.1.7 28.7 86.8 38.8 39.3 19.9 31.2 13.3 0.0 0.0

Notes:

• headers_footers expects letterhead and footer text to be absent. OCR recovers that text from logo and address images on single-page documents, where the repeated-header filter cannot fire, so the OCR rows score lower there by design. We chose not to drop text by page position. pdf-inspector 1.19 refuses scanned and image-based pages outright (192 of the 1,403), which is why it tops this category while scoring nothing on those pages elsewhere.
• old_scans is largely cursive handwriting; Tesseract cannot read it, PaddleOCR partially can.

How the runs are configured

• Same scorer for every tool. Each benchmark's own evaluator, unmodified. The ground truth in all three corpora is plain text, so every tool including LiteParse runs with hyperlink syntax off (--no-links); everything else is the default lit parse --format markdown.
• OCR modes. No OCR is --no-ocr. Tesseract is the built-in engine with no setup. PaddleOCR is the PP-OCRv5 mobile detector and English recognizer served over the OCR HTTP API by ocr/rapidocr, which runs the PaddleOCR models on ONNX Runtime — the same models as ocr/paddleocr, just 20–40× faster per page on CPU-only machines.
• Competitors are the free converters we could run locally, each at its latest release on 2026-09-09: markitdown 0.1.7, opendataloader-pdf 2.5.7 (its non-hybrid mode), pdf-inspector 1.19.0. Each benchmark's own runner for the tool is used as-is. Numbers from public leaderboards or LLM-assisted modes are not mixed in.
• Machine: Apple M2 Max, 12 cores, 32 GB. LiteParse rows: v2.14.4 (2026-09-09).

Reproducing the benchmarks

./run_benchmarks.sh --liteparse-only                # all three benches, no OCR
./run_benchmarks.sh --liteparse-only --ocr=tesseract
( cd ocr/rapidocr && uv run server.py ) &           # then:
./run_benchmarks.sh --liteparse-only --ocr=paddle
./run_benchmarks.sh --competitors-only              # re-run the free competitors only
./run_benchmarks.sh                                 # everything

Results and a SUMMARY.md land in bench_results/latest/.

Installation

Install via your preferred package manager. All versions (except WASM) ship with the same lit CLI.

Language Install Library Docs Node.js / TypeScript npm i -g @llamaindex/liteparse Node.js README Python pip install liteparse Python README Rust cargo install liteparse (CLI) / cargo add liteparse (lib) Rust README (crates.io) Browser (WASM) npm i @llamaindex/liteparse-wasm WASM README

Agent Skill

You can use liteparse as an agent skill, downloading it with the skills CLI tool:

npx skills add run-llama/llamaparse-agent-skills --skill liteparse

Or copy-pasting the SKILL.md file to your own skills setup.

See the Agent Skill guide for requirements and usage patterns.

CLI Usage

The CLI is the same across all installations (npm, pip, cargo install).

Parse Files

…

Markdown Output

LiteParse can render documents directly to Markdown. This means reconstructing headings, tables, lists, images, and links from the spatial layout. This is ideal for feeding documents to LLMs and RAG pipelines. This mode is purely heuristics and rule-based, so complex documents may not render perfectly, but it will be fast.

…

Image handling is controlled by --image-mode:

Mode Behavior placeholder (default) Emits `` references in reading order off Strips images entirely embed Emits the same image references as placeholder

--extract-images is the only option that enables embedded-image extraction. --image-output-dir requires it and writes the extracted bytes to disk. JSON output contains each image's name, path, page bbox, intrinsic pixel dimensions, rotation, format, and duplicate relationship; pixel bytes are never embedded in JSON. Identical image resources reuse the same output file.

Library callers can opt in with extract_images: true (Rust), extractImages: true (Node/WASM), or extract_images=True (Python). It defaults to false. Markdown image mode controls presentation only; placeholder refs are still discovered without bytes.

Markdown reconstruction quality varies with document complexity. For the hardest documents (dense tables, multi-column layouts, scans), LlamaParse remains the most accurate option.

Vector Graphics

Vector path output is opt-in because path-heavy PDFs can produce large payloads. Enable it with --extract-vector-graphics, Rust/Python extract_vector_graphics = true, or JavaScript/WASM extractVectorGraphics: true. Each page then includes vector_graphics (vectorGraphics in JavaScript) with:

• shapes: path bounding box, stroke/fill paint state and ARGB colors, and whether the path contains a Bezier curve.
• lines: compatible horizontal/vertical segments merged using stroke width and paint colors, with top-left 72-DPI viewport coordinates.

The representation follows LlamaParse PDFium path extraction; LiteParse calls the shape rectangle bbox rather than PDFium's coords, and uses width / height rather than w / h. The