# How to Parse Specific Page Ranges in PDF Documents Using LiteParse

> Effortlessly parse specific page ranges in PDF documents with LiteParse. Use the targetPages option or CLI flag to extract only the pages you need, streamlining your workflow.

- Repository: [LlamaIndex/liteparse](https://github.com/run-llama/liteparse)
- Tags: how-to-guide
- Published: 2026-06-25

---

**LiteParse parses specific page ranges in PDF documents by accepting a comma-separated string of single pages and ranges (e.g., `"1-5,10,15-20"`) via the `--target-pages` CLI flag or `targetPages`/`target_pages` options in its language bindings, which internally expands into a filtered vector to process only selected pages.**

Parsing large PDF documents can be resource-intensive when you only need specific sections. The **run-llama/liteparse** library provides a built-in mechanism to parse specific page ranges in PDF documents, allowing you to extract content from only the pages you need while skipping the rest.

## How Page Range Parsing Works Internally

LiteParse implements page range filtering through a three-stage pipeline that converts user input into optimized extraction instructions.

### Configuration Parsing in [`config.rs`](https://github.com/run-llama/liteparse/blob/main/config.rs)

The process begins in [`crates/liteparse/src/config.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/config.rs), where the `LiteParseConfig::parse_target_pages` function (lines 9-53) handles the initial string parsing. This function accepts a comma-separated list where each entry is either a single page number or a range expressed as `start-end`. It expands these ranges into a `Vec<u32>` and stores them in the configuration struct for later use.

### Range Resolution in [`parser.rs`](https://github.com/run-llama/liteparse/blob/main/parser.rs)

When the parser executes, `LiteParse::resolve_target_pages` in [`crates/liteparse/src/parser.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/parser.rs) (lines 81-110) reads the parsed page vector from the configuration. This method validates the requested pages against the document's actual page count and prepares the final list for extraction.

### Low-Level Extraction in [`extract.rs`](https://github.com/run-llama/liteparse/blob/main/extract.rs)

The actual filtering occurs in [`crates/liteparse/src/extract.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/extract.rs) (lines 30-77) within the `extract_pages_from_document` function. This low-level component receives the optional page slice and loads only the specified pages from the PDFium document, ignoring all others to save memory and CPU time.

## Syntax for Specifying Page Ranges

LiteParse uses a consistent string format across all bindings:

- **Single pages**: Specify individual page numbers as integers (e.g., `3,7,12`)
- **Inclusive ranges**: Use hyphen-separated start and end values (e.g., `1-5`, `15-20`)
- **Mixed specifications**: Combine singles and ranges in a comma-separated list (e.g., `1-5,10,15-20`)

Page numbers are 1-indexed and the ranges are inclusive of both endpoints.

## Implementation Examples Across Languages

### Command Line Interface

The Rust CLI exposes the functionality via the `--target-pages` argument in [`crates/liteparse/src/main.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/main.rs) (lines 239-358):

```bash

# Parse pages 1-5, page 10, and pages 15-20

lit parse document.pdf --target-pages "1-5,10,15-20" --format json -o subset.json

```

### Node.js and TypeScript

The Node.js binding exposes `targetPages` as a string option in [`packages/node/src/lib.ts`](https://github.com/run-llama/liteparse/blob/main/packages/node/src/lib.ts) (lines 48-60):

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

const parser = new LiteParse({
  outputFormat: 'markdown',
  targetPages: '2-4,7,9-12'
});

const result = await parser.parse('report.pdf');
console.log(result.text);

```

### Python

The Python binding accepts `target_pages` as an optional string argument in [`packages/python/liteparse/parser.py`](https://github.com/run-llama/liteparse/blob/main/packages/python/liteparse/parser.py) (lines 44-58):

```python
from liteparse import LiteParse

parser = LiteParse(
    output_format='json',
    target_pages='3,5-8'
)

result = parser.parse('invoice.pdf')
print(result['text'])

```

### WebAssembly (Browser)

The WASM binding exposes `target_pages` as a configuration field in [`crates/liteparse-wasm/src/lib.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse-wasm/src/lib.rs) (lines 45-78):

```javascript
import init, { LiteParse } from '@llamaindex/liteparse-wasm';

await init();
const parser = new LiteParse({
  target_pages: '1-3,6'
});

const pdfBytes = await fetch('file.pdf').then(r => r.arrayBuffer());
const result = await parser.parse(pdfBytes);
console.log(result.text);

```

## Safety Limits and Validation

To prevent accidental memory exhaustion attacks, LiteParse enforces a hard-coded safety limit defined as `MAX_TARGET_PAGES = 100_000` in [`crates/liteparse/src/config.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/config.rs) (lines 100-107). If your range string expands to more than 100,000 individual pages, the parser will reject the configuration before attempting extraction.

## Summary

- **LiteParse** filters PDF pages by accepting comma-separated range strings via the `--target-pages` CLI flag or `targetPages`/`target_pages` options in language bindings.
- The string parser expands ranges in [`config.rs`](https://github.com/run-llama/liteparse/blob/main/config.rs), resolves them in [`parser.rs`](https://github.com/run-llama/liteparse/blob/main/parser.rs), and executes selective extraction in [`extract.rs`](https://github.com/run-llama/liteparse/blob/main/extract.rs).
- Supported syntax includes single pages (`5`), ranges (`1-10`), and mixed combinations (`1-5,10,15-20`).
- A safety limit of 100,000 pages prevents accidental resource exhaustion.
- All bindings (CLI, Node.js, Python, and WASM) implement identical range specification semantics.

## Frequently Asked Questions

### What is the correct format for specifying page ranges in LiteParse?

LiteParse accepts a comma-separated string where each element is either a single 1-indexed page number or an inclusive range using a hyphen (e.g., `"1-5,10,15-20"`). This format is consistent across the CLI (`--target-pages`), Node.js (`targetPages`), Python (`target_pages`), and WASM (`target_pages`) interfaces.

### Does LiteParse support parsing specific page ranges in all language bindings?

Yes, according to the source code in `run-llama/liteparse`, the `target_pages` functionality is exposed in every official binding: the Rust CLI ([`main.rs`](https://github.com/run-llama/liteparse/blob/main/main.rs)), Node.js/TypeScript ([`lib.ts`](https://github.com/run-llama/liteparse/blob/main/lib.ts)), Python ([`parser.py`](https://github.com/run-llama/liteparse/blob/main/parser.py)), and WebAssembly ([`lib.rs`](https://github.com/run-llama/liteparse/blob/main/lib.rs)). Each binding passes the range string to the same underlying Rust parser for consistent behavior.

### What happens if I specify a page number that exceeds the PDF's total pages?

The `LiteParse::resolve_target_pages` function in [`parser.rs`](https://github.com/run-llama/liteparse/blob/main/parser.rs) validates the requested pages against the document's actual page count. If you specify pages beyond the document's length, the parser will handle the error appropriately, typically by ignoring out-of-range pages or raising a validation error depending on the specific binding's error handling implementation.

### Is there a performance benefit to using page range filtering?

Yes, by specifying `target_pages`, you prevent LiteParse from loading the entire PDF into memory. The `extract_pages_from_document` function in [`extract.rs`](https://github.com/run-llama/liteparse/blob/main/extract.rs) only requests the specific pages from the underlying PDFium library, significantly reducing memory usage and processing time for large documents when you only need a subset of pages.