Document Extraction and Parsing

The fastest option for digital-native PDFs. Directly accesses the PDF's internal text stream without OCR. Supports text extraction, table detection (since v1.23), image extraction, and metadata reading. Written in C with Python bindings — processes thousands of pages per second.

import fitz  # pip install PyMuPDF

doc = fitz.open("report.pdf")
for page_num, page in enumerate(doc):
    # Basic text extraction (fast, no layout awareness)
    text = page.get_text()

    # Structured extraction with layout awareness
    blocks = page.get_text("dict")["blocks"]
    for block in blocks:
        if block["type"] == 0:  # Text block
            for line in block["lines"]:
                for span in line["spans"]:
                    print(f"Font: {span['font']}, Size: {span['size']}")
                    print(f"Text: {span['text']}")

    # Table extraction (PyMuPDF 1.23+)
    tables = page.find_tables()
    for table in tables:
        df = table.to_pandas()
        print(df)

Best for: digital-native PDFs, high-volume batch processing, simple layouts. Not for scanned documents.

IBM's open-source document converter. Uses a pipeline of ML models for layout detection (DocLayNet), table structure recognition (TableFormer), and OCR (EasyOCR or Tesseract). Outputs clean Markdown, JSON, or a structured document model. Handles PDFs, DOCX, PPTX, images, and HTML.

from docling.document_converter import DocumentConverter

converter = DocumentConverter()
result = converter.convert("contract.pdf")

# Export to Markdown (most common for RAG)
markdown = result.document.export_to_markdown()
print(markdown)

# Export to structured JSON (for programmatic access)
doc_dict = result.document.export_to_dict()
for element in doc_dict["body"]:
    print(f"Type: {element['label']}")

# Iterate over tables specifically
for table in result.document.tables:
    df = table.export_to_dataframe()
    print(df)

Best for: production pipelines needing layout-aware parsing. Good balance of accuracy and speed. Runs on CPU (GPU optional).

The most format-versatile option. Handles PDFs, DOCX, PPTX, XLSX, HTML, images, emails, and more. Partitions documents into typed elements (Title, NarrativeText, Table, Image, ListItem) with metadata including coordinates, page number, and parent hierarchy. Available as open-source library or hosted API.

from unstructured.partition.auto import partition

# Auto-detect format and partition into elements
elements = partition("report.pdf")

for element in elements:
    print(f"Type: {type(element).__name__}")
    print(f"Text: {element.text[:100]}...")
    print(f"Page: {element.metadata.page_number}")
    print()

# Filter by element type
from unstructured.documents.elements import (
    Table, Title, NarrativeText
)
titles = [e for e in elements if isinstance(e, Title)]
tables = [e for e in elements if isinstance(e, Table)]
body = [e for e in elements if isinstance(e, NarrativeText)]

Best for: enterprise pipelines with mixed document types. Strong element classification. Hosted API for scale.

Purpose-built for converting books, papers, and long documents to Markdown. Uses a pipeline of ML models: layout detection, OCR, table recognition, and equation conversion. Particularly strong on academic content — preserves LaTeX equations, handles two-column layouts, and extracts inline images with references.

from marker.converters.pdf import PdfConverter
from marker.models import create_model_dict

models = create_model_dict()
converter = PdfConverter(artifact_dict=models)

# Convert PDF to markdown with extracted images
rendered = converter("research_paper.pdf")
markdown_text = rendered.markdown

# Images are saved separately with references in markdown
# Tables are converted to markdown tables
# Equations are preserved as LaTeX
print(markdown_text)

Best for: academic papers, textbooks, documents with equations and figures. Strong on long documents.