# How to Load a PDF Document from Memory in pdf-inspector

> Learn to load PDF documents directly from memory using pdf-inspector's *_mem APIs. Process PDFs efficiently without filesystem I/O. Explore byte slice processing for seamless integration.

- Repository: [Firecrawl/pdf-inspector](https://github.com/firecrawl/pdf-inspector)
- Tags: how-to-guide
- Published: 2026-08-31

---

**pdf-inspector provides dedicated `*_mem` APIs that accept raw byte slices (`&[u8]`) to process PDFs entirely in memory without filesystem I/O.**

Loading PDFs directly from memory is essential for serverless environments, streaming pipelines, or any application where data arrives over the network. The pdf-inspector crate exposes a complete suite of memory-based functions that mirror its file-based API, all built on a single efficient loading pipeline in [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs).

## The Core Memory Loading Pipeline

All memory-based operations in pdf-inspector follow a standard four-step process:

1. **Validate the byte slice** — `validate_pdf_bytes` verifies the PDF header signature
2. **Load and parse** — `load_document_from_mem_with_password` (lines 66-71 in [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs)) creates a `lopdf::Document` and handles decryption if needed
3. **Process** — the document passes to `process_document` for type detection, layout analysis, and extraction
4. **Return results** — a `PdfProcessResult` containing detected type, page count, markdown output, and OCR metadata

Because the document parses exactly once, memory-based calls outperform their path-based equivalents by eliminating redundant filesystem operations.

## Available Memory-Based Functions in pdf-inspector

| Function | Purpose | Location |
|----------|---------|----------|
| `process_pdf_mem` | Full pipeline: detect + extract + markdown | [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs) |
| `detect_pdf_mem` | Fast metadata-only detection | [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs) |
| `extract_text_mem` | Plain text extraction | [`src/extractor/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/extractor/mod.rs) |
| `extract_text_with_positions_mem` | Text with positional metadata | [`src/extractor/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/extractor/mod.rs) |
| `extract_pages_markdown_mem` | Markdown for specific page ranges | [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs) |
| `process_pdf_with_ocr_mem` | OCR-enabled processing | [`src/vision/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/vision/mod.rs) |

Each function delegates to `load_document_from_mem_with_password`, which automatically repairs malformed PDFs and decrypts password-protected files.

## Loading a PDF from Memory in Rust

### Full Document Processing

The `process_pdf_mem` function runs the complete analysis pipeline on a byte buffer:

```rust
use pdf_inspector::{process_pdf_mem, PdfOptions, ProcessMode};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load PDF from any source: network request, embedded asset, database
    let pdf_bytes = std::fs::read("example.pdf")?;

    // Execute full pipeline with default options
    let result = process_pdf_mem(&pdf_bytes)?;

    println!("PDF type: {:?}\nPages: {}", result.pdf_type, result.page_count);
    
    if let Some(md) = result.markdown {
        println!("Markdown output:\n{md}");
    }
    
    Ok(())
}

```

### Fast Detection Without Extraction

Use `detect_pdf_mem` when you only need metadata:

```rust
use pdf_inspector::detect_pdf_mem;

let pdf_bytes = std::fs::read("sample.pdf")?;
let detection = detect_pdf_mem(&pdf_bytes)?;
println!("Detected type: {:?}", detection.pdf_type);

```

### Text-Only Extraction

For scenarios requiring just the text content:

```rust
use pdf_inspector::extract_text_mem;

let pdf_bytes = std::fs::read("my.pdf")?;
let text = extract_text_mem(&pdf_bytes)?;
println!("{text}");

```

The underlying implementation in [`src/extractor/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/extractor/mod.rs) (lines 62-68) provides both `extract_text_mem` and `extract_text_with_positions_mem` for spatial-aware extraction.

## Loading a PDF from Memory in Python

The Python bindings expose the same memory capabilities. In [`src/python.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/python.rs) (line 700+), Rust functions are wrapped for direct Python access:

```python
import pdf_inspector

# Read PDF into memory from any source

with open("doc.pdf", "rb") as f:
    data = f.read()

# Full processing pipeline

result = pdf_inspector.process_pdf_mem(data)
print(result["markdown"])

# Quick detection without full extraction

info = pdf_inspector.detect_pdf_mem(data)
print(info["pdf_type"])

```

## Source Code Reference Map

| File | Key Symbols | Line Range |
|------|-------------|------------|
| [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs) | `process_pdf_mem`, `detect_pdf_mem`, `load_document_from_mem_with_password` | 66-71, 299-314 |
| [`src/extractor/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/extractor/mod.rs) | `extract_text_mem`, `extract_text_with_positions_mem` | 62-68 |
| [`src/detector.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/detector.rs) | `detect_pdf_type_mem` | 110-115 |
| [`src/python.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/python.rs) | Python wrappers for memory functions | 700-808 |
| [`src/vision/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/vision/mod.rs) | `process_pdf_with_ocr_mem` | 54-56 |

## Performance and Security Considerations

- **Single-pass parsing**: The `load_document_from_mem_with_password` function parses once and reuses the `lopdf::Document` across all subsequent operations
- **Automatic repair**: Malformed PDF structures are handled transparently during load
- **In-memory decryption**: Password-protected PDFs decrypt without temporary files
- **Zero filesystem I/O**: Eliminates latency from disk operations and temporary file cleanup

## Summary

- pdf-inspector loads PDFs from memory using `*_mem` suffixed functions that accept `&[u8]` buffers
- The central loader `load_document_from_mem_with_password` in [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs) handles validation, parsing, decryption, and repair in one call
- Available functions span full processing (`process_pdf_mem`), fast detection (`detect_pdf_mem`), text extraction (`extract_text_mem`), and OCR (`process_pdf_with_ocr_mem`)
- Python bindings mirror the Rust API through wrappers in [`src/python.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/python.rs)
- Memory-based operations eliminate filesystem I/O and execute faster than path-based equivalents

## Frequently Asked Questions

### How does pdf-inspector validate a PDF before loading from memory?

The `validate_pdf_bytes` function checks for the `%PDF-` header signature before attempting to parse. This prevents wasted processing on non-PDF data and provides early error feedback when the byte slice contains incorrect or corrupted content.

### Can pdf-inspector handle encrypted PDFs loaded from memory?

Yes. `load_document_from_mem_with_password` accepts an optional password parameter and performs in-memory decryption using the same pipeline as file-based operations. No temporary decrypted files are written to disk.

### What is the difference between `process_pdf_mem` and `detect_pdf_mem`?

`process_pdf_mem` executes the full pipeline including text extraction, layout analysis, and markdown generation. `detect_pdf_mem` stops after type detection and metadata extraction, making it significantly faster when you only need to identify the PDF variant or count pages.

### How do I extract text from specific pages using the memory API?

Use `extract_pages_markdown_mem(buffer: &[u8], pages: Option<&[u32]>)` from [`src/lib.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/lib.rs). Pass `None` for all pages or a slice of page numbers (1-indexed) to limit extraction. For plain text with positional data, `extract_text_with_positions_mem` in [`src/extractor/mod.rs`](https://github.com/firecrawl/pdf-inspector/blob/main/src/extractor/mod.rs) returns a `Vec<TextItem>` containing bounding box coordinates for each text element.