# Does LiteParse Support Encrypted and Password-Protected PDFs?

> LiteParse natively supports encrypted and password-protected PDFs. Learn how to securely parse them using user-supplied passwords with PDFium integration.

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

---

**Yes. LiteParse natively supports parsing encrypted PDFs by forwarding a user-supplied password to the underlying PDFium library through configuration options available in every language binding.**

LiteParse, the Rust-based document parsing library from the run-llama organization, provides first-class support for **encrypted PDF files** through a unified password field exposed across all interfaces. Whether you are processing documents via the command line, Rust crate, or language bindings for Node.js, Python, or WebAssembly, you can supply decryption credentials that enable seamless text extraction and analysis of password-protected documents.

## How Password Protection Works in LiteParse

The library delegates decryption to the PDFium engine. When you provide a password, LiteParse forwards it directly to PDFium to unlock the document before parsing begins. According to the run-llama/liteparse source code, the password flows through a consistent configuration pipeline:

- **Configuration struct**: The `LiteParseConfig` struct in [`crates/liteparse/src/config.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/config.rs) defines `password: Option<String>` at line 25, establishing the central parameter used throughout the stack.
- **Error handling**: If you attempt to parse an encrypted PDF without supplying the correct password, PDFium returns `PdfiumError::PasswordRequired`, which LiteParse surfaces as a clear runtime error.
- **Parser integration**: The core parser implementation in [`crates/liteparse/src/parser.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/parser.rs) (lines 86-104) retrieves `self.config.password` and passes it to the document loader when opening files.

## Providing Passwords Across All Interfaces

LiteParse exposes the password option consistently across every supported interface, ensuring you can decrypt documents regardless of your runtime environment.

### Command-Line Interface

The CLI accepts a `--password` flag defined in [`crates/liteparse/src/main.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/main.rs) at line 83. Use this flag when running the `run` command to process protected files:

```bash
liteparse run input.pdf --password "mySecret"

```

### Rust Library

When using the crate directly, construct a `LiteParseConfig` with the password field populated. The `load_document` and `load_document_from_bytes` functions in [`crates/liteparse/src/extract.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/extract.rs) (line 5) accept this as `Option<&str>`:

```rust
use liteparse::LiteParse;
use liteparse::LiteParseConfig;

let cfg = LiteParseConfig {
    password: Some("mySecret".to_string()),
    ..Default::default()
};
let parser = LiteParse::new(cfg);
let result = parser.parse("input.pdf").await?;

```

### Node.js Binding

The Node.js wrapper mirrors the configuration object. As implemented in [`crates/liteparse-napi/src/types.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse-napi/src/types.rs) (lines 33-74), the constructor accepts a password option:

```javascript
import { LiteParse } from 'liteparse';

const parser = new LiteParse({ password: "mySecret" });
const output = await parser.parse("input.pdf");
console.log(output);

```

### Python Binding

The Python module exposes the parameter as a keyword argument. The binding code in [`crates/liteparse-python/src/lib.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse-python/src/lib.rs) (lines 212-326) handles the string conversion:

```python
from liteparse import LiteParse

parser = LiteParse(password="mySecret")
result = parser.parse("input.pdf")
print(result)

```

### WebAssembly (Browser)

For browser environments, the WASM binding in [`crates/liteparse-wasm/src/lib.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse-wasm/src/lib.rs) (lines 49-116) accepts the same configuration object, allowing client-side decryption:

```javascript
import { LiteParse } from 'liteparse-wasm';

const parser = new LiteParse({ password: "mySecret" });
const pdfData = await fetch("input.pdf").then(r => r.arrayBuffer());
const output = await parser.parse(pdfData);
console.log(output);

```

## Summary

- LiteParse supports **encrypted PDF parsing** natively by integrating PDFium's decryption capabilities.
- The `password` option lives in `LiteParseConfig` ([`crates/liteparse/src/config.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/config.rs)) and propagates through all language bindings.
- Every interface—CLI, Rust, Node.js, Python, and WASM—exposes identical password functionality.
- Missing or incorrect passwords trigger explicit `PdfiumError::PasswordRequired` errors rather than silent failures.

## Frequently Asked Questions

### What happens if I omit the password for an encrypted PDF?

If you attempt to parse a password-protected file without providing the `password` parameter, LiteParse returns a runtime error originating from PDFium's `PasswordRequired` status. The library does not attempt to bypass encryption or process the encrypted binary as text.

### Can LiteParse crack or recover lost PDF passwords?

No. LiteParse only handles user-supplied passwords. It does not implement brute-force attacks, password recovery algorithms, or owner-password bypass techniques. You must provide the correct user or owner password through the configuration options.

### Is password support available in all LiteParse distributions?

Yes. The password field is implemented in the core Rust crate (`crates/liteparse`) and exposed in all official bindings including Node.js (`crates/liteparse-napi`), Python (`crates/liteparse-python`), and WebAssembly (`crates/liteparse-wasm`). Each binding maps the native string option to the underlying Rust `Option<String>`.

### Does decrypting PDFs impact parsing performance?

The decryption overhead is negligible for CPU-bound parsing workloads. PDFium handles decryption during the document loading phase in [`crates/liteparse/src/extract.rs`](https://github.com/run-llama/liteparse/blob/main/crates/liteparse/src/extract.rs), after which text extraction, layout analysis, and projection proceed at normal speed regardless of the original encryption state.