LiteParse API Reference

Targets liteparse 2.15.0 (Python), @llamaindex/liteparse 2.15.0 (Node 18+), and Rust crate liteparse = "2.15.0". Reviewed 2026-10-01. Python examples were exercised with synthetic PDF/PNG fixtures; Node/Rust snippets are illustrative and source-checked, not executed.

Python: LiteParse

from liteparse import LiteParse, ParseResult, ParsedPage, TextItem, ScreenshotResult, search_items

Constructor options

Other useful constructor options:

extract_annotations, extract_form_fields, extract_structure_tree, extract_vector_graphics, extract_text_metadata, and include_complexity are opt-in booleans, all false by default. Use the released constructor for advanced crop/orientation/document metadata options; do not assume every API option has a CLI flag.

parse(file_data)

Input: file path (str / Path) or raw document bytes (bytes). PDF bytes are the simplest path; supported binary formats are detected for conversion. Named files are preferable when a format is ambiguous.

Returns: ParseResult

@dataclass
class ParseResult:
    pages: List[ParsedPage]
    text: str              # document text, or Markdown in markdown mode
    total_pages: int       # source count before page selection/cap
    page_errors: List[PageError]  # page_number, message; inspect for partial output

    @property
    def num_pages(self) -> int: ...  # len(pages), not source total

    def get_page(self, page_num: int) -> Optional[ParsedPage]: ...  # 1-indexed

@dataclass
class ParsedPage:
    page_num: int
    width: float
    height: float
    text: str
    text_items: List[TextItem]
    markdown: str
    page_label: Optional[str]

@dataclass
class TextItem:
    text: str
    x: float
    y: float
    width: float
    height: float
    font_name: Optional[str]
    font_size: Optional[float]
    confidence: Optional[float]   # 0.0–1.0 when from OCR

The type sketches show commonly used fields, not complete constructors.

Raises: FileNotFoundError, ParseError, and ParseTimeoutError in pool mode.

screenshot(file_path, *, page_numbers=None)

Input: path to document (PDF or convertible format).

Returns: List[ScreenshotResult] with PNG bytes.

@dataclass
class ScreenshotResult:
    page_num: int
    width: int
    height: int
    image_bytes: bytes

Non-PDF formats convert through LibreOffice (Office) or bundled image converters. Screenshots return pixel dimensions; text boxes use page coordinates. See output_formats.md before overlaying them.

get_config()

Returns resolved LiteParseConfig dataclass.

search_items(items, phrase, *, case_sensitive=False)

Search a list of TextItem for a phrase that may span multiple items. Returns merged TextItem objects with combined bounding boxes.

from liteparse import search_items

matches = search_items(page.text_items, "Figure 1", case_sensitive=False)

Process pools and page integrity

In-process PDFium parsing serializes under a process-global lock. num_workers controls OCR concurrency, not parallel PDF parses. A pool provides separate processes and parse_timeout kills/replaces a timed-out worker:

from liteparse import LiteParse

with LiteParse(ocr_enabled=False, pool_size=2, parse_timeout=30, quiet=True) as parser:
    result = parser.parse("document.pdf")
    if result.page_errors:
        raise RuntimeError(f"Partial document: {result.page_errors}")

A page cap or explicit target_pages is an intentional subset: compare actual page numbers with the requested range and result.total_pages. A nonempty result is not proof every page was ingested. is_complex(path_or_bytes) returns per-page needs_ocr/reasons heuristics; it does not certify transcription quality.

TypeScript / Node.js

import { LiteParse } from '@llamaindex/liteparse';

const parser = new LiteParse();
const result = await parser.parse('document.pdf');
console.log(result.text);

for (const page of result.pages) {
  console.log(`Page ${page.pageNum}: ${page.textItems.length} items`);
}

Constructor options (camelCase)

Parse from bytes

import { readFile } from 'fs/promises';

const pdfBytes = await readFile('document.pdf');
const result = await parser.parse(pdfBytes);

Screenshots

const screenshots = parser.screenshot('document.pdf', [1, 2, 3]);
for (const s of screenshots) {
  // s.pageNum, s.width, s.height, s.imageBuffer (PNG)
}

Install: npm i @llamaindex/liteparse@2.15.0 (includes lit CLI).

Browser/edge uses the separate @llamaindex/liteparse-wasm package; native examples are not browser APIs. Consult its WASM README for runtime-specific requirements (not exercised here).

Rust (library)

use liteparse::{LiteParse, LiteParseConfig};

let parser = LiteParse::new(LiteParseConfig::default());
let result = parser.parse("document.pdf").await?;

Custom OCR: implement OcrEngine trait and .with_ocr_engine(Arc::new(engine)).

CLI: cargo install liteparse

Sources: Python API, Node API, Rust API.