Pdf Processing

PDF Processing Skill

Overview

This skill provides comprehensive PDF processing capabilities leveraging Claude's native PDF support, which can:

• Extract and parse text content
• Identify and extract tables with structure preservation
• Analyze charts, graphs, and visual elements
• Understand document layout and formatting
• Generate summaries and insights
• Convert PDFs to various formats (Markdown, JSON, CSV, plain text)

When to Use

Claude should automatically activate this skill when:

• User provides a PDF file path or wants to process a PDF
• User asks to extract text, tables, or data from PDFs
• User requests PDF analysis, summarization, or conversion
• User needs to understand charts, diagrams, or visual content in PDFs
• User wants to transform PDF content to another format

Key Capabilities

1. Text Extraction

• Full document text extraction with formatting preservation
• Page-by-page text extraction
• Section and paragraph identification
• Header and footer detection

2. Table Extraction

• Automatic table detection and extraction
• Structure-preserving conversion to CSV, JSON, or Markdown
• Multi-page table handling
• Cell merging and complex table support

3. Visual Content Analysis

• Chart and graph interpretation
• Diagram and flowchart understanding
• Image and figure description
• Infographic analysis

4. Document Understanding

• Layout analysis and structure detection
• Multi-column text handling
• Form field identification
• Metadata extraction (title, author, creation date, page count)

5. Format Conversion

• PDF to Markdown (preserving headings, lists, tables)
• PDF to JSON (structured data extraction)
• PDF to CSV (table extraction)
• PDF to plain text

Instructions

Step 1: Validate PDF Input

First, determine how the PDF is provided:

Option A: File Path

# Verify the file exists and is a PDF
ls -lh /path/to/document.pdf
file /path/to/document.pdf

Option B: Base64-Encoded PDF If the user provides base64-encoded content, save it first:

# Decode and save base64 PDF
python .claude/skills/pdf-processing/scripts/decode_pdf.py --input base64_string.txt --output document.pdf

Option C: URL If the user provides a URL, download it:

# Download PDF from URL
python .claude/skills/pdf-processing/scripts/download_pdf.py --url "https://example.com/doc.pdf" --output document.pdf

Step 2: Read and Analyze PDF

Use the Read tool to access PDF files. Claude's native PDF support will:

• Display the PDF content visually
• Extract text and structure automatically
• Identify tables, charts, and images

# Example: Read PDF using the Read tool
# The Read tool handles PDFs natively and extracts text + visual content
Read(file_path="/absolute/path/to/document.pdf")

Step 3: Process Based on User Request

A. Text Extraction

For simple text extraction:

python .claude/skills/pdf-processing/scripts/extract_text.py \
  --input document.pdf \
  --output document.txt \
  --preserve-formatting true

For page-specific extraction:

python .claude/skills/pdf-processing/scripts/extract_text.py \
  --input document.pdf \
  --pages 1,3,5-10 \
  --output selected_pages.txt

B. Table Extraction

Extract all tables to CSV:

python .claude/skills/pdf-processing/scripts/extract_tables.py \
  --input document.pdf \
  --format csv \
  --output-dir ./extracted_tables/

Extract tables to JSON with structure:

python .claude/skills/pdf-processing/scripts/extract_tables.py \
  --input document.pdf \
  --format json \
  --output tables.json

C. Document Summarization

Generate a summary of the PDF:

python .claude/skills/pdf-processing/scripts/summarize_pdf.py \
  --input document.pdf \
  --output summary.md \
  --style concise  # Options: concise, detailed, executive

D. Format Conversion

Convert PDF to Markdown:

python .claude/skills/pdf-processing/scripts/convert_pdf.py \
  --input document.pdf \
  --output document.md \
  --format markdown \
  --preserve-images true

Convert PDF to structured JSON:

python .claude/skills/pdf-processing/scripts/convert_pdf.py \
  --input document.pdf \
  --output document.json \
  --format json \
  --extract-metadata true

E. Visual Content Analysis

Analyze charts and graphs:

python .claude/skills/pdf-processing/scripts/analyze_visuals.py \
  --input document.pdf \
  --output analysis.json \
  --elements charts,graphs,diagrams

Step 4: Post-Processing and Output

After extraction/conversion:

1. Validate Output: Check that the output file was created successfully

ls -lh output_file.{txt,md,json,csv}

2. Preview Results: Show the user a preview of the extracted content

head -n 20 output_file.txt  # For text files
cat output_file.json | python -m json.tool | head -n 50  # For JSON

3. Provide Summary: Summarize what was extracted and offer next steps

Step 5: Handle Edge Cases

Password-Protected PDFs

python .claude/skills/pdf-processing/scripts/extract_text.py \
  --input document.pdf \
  --password "user_provided_password" \
  --output document.txt

Scanned PDFs (OCR Required)

# Use OCR for scanned PDFs
python .claude/skills/pdf-processing/scripts/ocr_pdf.py \
  --input scanned_document.pdf \
  --output document.txt \
  --language eng  # Language code: eng, fra, deu, etc.

Large PDFs (Memory Optimization)

# Process large PDFs in chunks
python .claude/skills/pdf-processing/scripts/extract_text.py \
  --input large_document.pdf \
  --output document.txt \
  --chunk-size 10  # Process 10 pages at a time

Error Handling

Common Issues

1. File Not Found

• Verify the path with ls or Glob
• Check for typos in the filename
• Ensure absolute paths are used

2. Corrupted PDF

• Try reading with the Read tool first
• Use repair mode: python scripts/repair_pdf.py --input corrupted.pdf --output repaired.pdf

3. Unsupported PDF Features

• Some PDFs with complex DRM or encryption may fail
• Inform the user and suggest alternatives

4. OCR Failures

• Check if tesseract is installed: which tesseract
• Verify image quality is sufficient
• Try different language settings

Best Practices

1. Always use the Read tool first - This leverages Claude's native PDF support for best results 2. Preserve structure - When extracting tables or converting formats, maintain the original structure 3. Validate outputs - Always check that output files were created successfully 4. Provide context - Tell the user what was extracted and what they can do next 5. Handle errors gracefully - If processing fails, explain why and suggest alternatives 6. Respect privacy - Remind users not to upload sensitive documents without proper authorization

Output Formats

Text Output

Plain text with optional formatting preservation
Line breaks and paragraphs maintained
Special characters preserved

Markdown Output

# Document Title

## Section Heading

Paragraph text with **bold** and *italic* formatting.

| Column 1 | Column 2 | Column 3 |
|----------|----------|----------|
| Data 1   | Data 2   | Data 3   |

![Chart Description](chart_extracted.png)

JSON Output

{
  "metadata": {
    "title": "Document Title",
    "author": "Author Name",
    "pages": 42,
    "creation_date": "2024-01-15"
  },
  "content": [
    {
      "page": 1,
      "type": "text",
      "content": "Page 1 text content..."
    },
    {
      "page": 2,
      "type": "table",
      "headers": ["Col1", "Col2", "Col3"],
      "rows": [["A", "B", "C"], ["D", "E", "F"]]
    }
  ]
}

CSV Output (for tables)

Column1,Column2,Column3
Value1,Value2,Value3
Value4,Value5,Value6

Advanced Features

Batch Processing

# Process multiple PDFs
python .claude/skills/pdf-processing/scripts/batch_process.py \
  --input-dir ./pdfs/ \
  --output-dir ./extracted/ \
  --format markdown

Custom Templates

# Use custom conversion templates
python .claude/skills/pdf-processing/scripts/convert_pdf.py \
  --input document.pdf \
  --output document.md \
  --template .claude/skills/pdf-processing/assets/custom_template.md

Selective Extraction

# Extract only specific sections
python .claude/skills/pdf-processing/scripts/extract_sections.py \
  --input document.pdf \
  --sections "Introduction,Methods,Results" \
  --output extracted_sections.md

Integration with Other Tools

This skill works well with:

• Data analysis tools - Extract tables and feed to pandas/numpy
• Documentation generators - Convert PDFs to Markdown for wikis
• Search systems - Extract text for indexing
• Automation workflows - Batch process invoices, reports, forms

Examples

Example 1: Extract and Summarize

# User: "Please extract the key points from this research paper"
1. Read(file_path="/path/to/paper.pdf")
2. python scripts/summarize_pdf.py --input paper.pdf --output summary.md --style executive
3. Show the user the summary with key findings highlighted

Example 2: Extract Tables to CSV

# User: "Get all tables from this financial report"
1. Read(file_path="/path/to/report.pdf")
2. python scripts/extract_tables.py --input report.pdf --format csv --output-dir ./tables/
3. List the extracted CSV files and preview the first table

Example 3: Convert to Markdown

# User: "Convert this PDF to markdown"
1. Read(file_path="/path/to/document.pdf")
2. python scripts/convert_pdf.py --input document.pdf --output document.md --format markdown
3. Show preview of the markdown and confirm successful conversion

Dependencies

The scripts in this skill require:

• Python 3.8+
• PyPDF2 or pypdf (PDF parsing)
• pdfplumber (table extraction)
• pdf2image (image extraction)
• pytesseract (OCR for scanned PDFs)
• Pillow (image processing)
• requests (URL downloads)

These are installed via the requirements file in assets/requirements.txt.

References

See the references/ directory for:

• pdf_capabilities.md - Detailed breakdown of Claude's PDF support
• api_reference.md - Complete API documentation for all scripts
• examples.md - More usage examples and use cases
• troubleshooting.md - Common issues and solutions

Notes for Claude

• Always read PDFs with the Read tool first - This is the most reliable method
• After reading, analyze what the user needs - Text, tables, summary, conversion?
• Use the appropriate script - Don't try to do everything manually
• Validate outputs - Always check that files were created successfully
• Provide helpful context - Explain what was extracted and suggest next steps
• Handle errors gracefully - If something fails, explain why and offer alternatives
• Be efficient - Use batch processing for multiple PDFs
• Preserve structure - Maintain document formatting when converting

Version History

• 1.0.0 (2025-11-18) - Initial release with core PDF processing capabilities

PDF Processing Skill

A comprehensive Claude Code skill for processing, analyzing, and converting PDF documents.

Overview

This skill provides Claude with powerful PDF processing capabilities including:

• Text Extraction - Extract text from PDFs with formatting preservation
• Table Extraction - Extract tables and convert to CSV, JSON, or Markdown
• Document Conversion - Convert PDFs to Markdown, JSON, or plain text
• Summarization - Generate summaries with different styles
• Visual Analysis - Analyze charts, graphs, and visual content via Claude's native PDF support
• Utility Functions - Download PDFs from URLs, decode base64-encoded PDFs

Quick Start

Installation

1. Install required Python packages:

cd .claude/skills/pdf-processing
pip install -r assets/requirements.txt

2. (Optional) Install Tesseract for OCR support:

# Ubuntu/Debian
sudo apt-get install tesseract-ocr

# macOS
brew install tesseract

# Windows
# Download from: https://github.com/UB-Mannheim/tesseract/wiki

Usage

The skill activates automatically when working with PDFs. Claude will use the appropriate scripts based on your request.

Example requests:

• "Extract text from this PDF"
• "Get all tables from this financial report"
• "Convert this PDF to Markdown"
• "Summarize this research paper"
• "Download and process this PDF: https://example.com/doc.pdf"

Directory Structure

pdf-processing/
├── SKILL.md                    # Main skill definition (read by Claude)
├── README.md                   # This file
├── scripts/                    # Python scripts for PDF processing
│   ├── extract_text.py         # Text extraction
│   ├── extract_tables.py       # Table extraction
│   ├── convert_pdf.py          # Format conversion
│   ├── summarize_pdf.py        # Document summarization
│   ├── download_pdf.py         # Download PDFs from URLs
│   └── decode_pdf.py           # Decode base64-encoded PDFs
├── references/                 # Documentation
│   ├── pdf_capabilities.md     # Claude's PDF capabilities
│   ├── api_reference.md        # Complete API documentation
│   └── examples.md             # Real-world examples
└── assets/                     # Supporting files
    └── requirements.txt        # Python dependencies

Key Features

1. Native PDF Reading

Claude can read PDFs directly using the Read tool, which provides:

• Visual content understanding
• Text extraction
• Table recognition
• Chart and graph analysis
• Document structure analysis

2. Advanced Text Extraction

# Extract all text
python scripts/extract_text.py --input document.pdf --output document.txt

# Extract specific pages
python scripts/extract_text.py --input document.pdf --pages "1,5-10" --output text.txt

# Handle password-protected PDFs
python scripts/extract_text.py --input secure.pdf --password "secret" --output text.txt

3. Table Extraction

# Extract to CSV
python scripts/extract_tables.py --input report.pdf --format csv --output-dir ./tables/

# Extract to JSON
python scripts/extract_tables.py --input report.pdf --format json --output tables.json

# Extract to Markdown
python scripts/extract_tables.py --input report.pdf --format markdown --output-dir ./tables/

4. Format Conversion

# Convert to Markdown
python scripts/convert_pdf.py --input doc.pdf --output doc.md --format markdown

# Convert to JSON with metadata
python scripts/convert_pdf.py --input doc.pdf --output doc.json --format json --extract-metadata

# Convert to text
python scripts/convert_pdf.py --input doc.pdf --output doc.txt --format text

5. Document Summarization

# Concise summary
python scripts/summarize_pdf.py --input paper.pdf --output summary.md --style concise

# Detailed summary
python scripts/summarize_pdf.py --input paper.pdf --output summary.md --style detailed

# Executive summary
python scripts/summarize_pdf.py --input paper.pdf --output summary.md --style executive

Common Use Cases

Academic Research

• Extract key findings from research papers
• Extract data tables for analysis
• Generate literature review summaries

Financial Analysis

• Extract financial tables from reports
• Analyze quarterly statements
• Process invoices and receipts

Legal Documents

• Extract specific clauses from contracts
• Search across multiple documents
• Convert to searchable formats

Technical Documentation

• Convert PDF manuals to Markdown
• Extract API references
• Build searchable documentation

Dependencies

Required Python packages (see assets/requirements.txt):

• pypdf - PDF parsing
• pdfplumber - Advanced table extraction
• pdf2image - Image extraction
• pytesseract - OCR support
• Pillow - Image processing
• requests - URL downloads

Documentation

• [SKILL.md](SKILL.md) - Complete skill instructions for Claude
• [PDF Capabilities](references/pdf_capabilities.md) - Detailed breakdown of features
• [API Reference](references/api_reference.md) - Complete script documentation
• [Examples](references/examples.md) - Real-world use cases and workflows

Troubleshooting

Common Issues

Problem: "Module not found" errors

# Solution: Install dependencies
pip install -r assets/requirements.txt

Problem: Text extraction from scanned PDFs fails

# Solution: Use OCR
# 1. Install tesseract (see Installation above)
# 2. The skill will automatically detect scanned PDFs

Problem: Tables not detected

# Solution: Try different extraction settings or manual verification
# Some complex tables may need manual adjustment

Problem: Password-protected PDFs

# Solution: Provide password
python scripts/extract_text.py --input secure.pdf --password "yourpassword" --output text.txt

Performance

Best Practices

1. Always read PDFs with Claude's Read tool first - This provides the best understanding of content and structure 2. Use appropriate extraction method - Different PDFs require different approaches 3. Validate outputs - Always verify extracted data is accurate 4. Handle errors gracefully - Check for password protection, corruption, etc. 5. Respect privacy - Don't process sensitive documents without authorization

Version History

• 1.0.0 (2025-11-18) - Initial release
• Text extraction
• Table extraction
• Format conversion (Markdown, JSON, text)
• Document summarization
• PDF download from URLs
• Base64 PDF decoding
• Comprehensive documentation

Contributing

This skill is part of the ClaudeCodeFrameWork project. For issues or improvements, please refer to the main project repository.

License

This skill follows the license of the parent ClaudeCodeFrameWork project.

Support

For help with this skill: 1. Check the API Reference for detailed usage 2. Review Examples for common use cases 3. Refer to PDF Capabilities for technical details 4. Ask Claude for help - the skill is designed to work seamlessly with Claude's assistance

---

Note: This skill leverages Claude's native PDF processing capabilities combined with powerful Python libraries for comprehensive PDF handling.

PDF Processing Scripts - API Reference

Complete reference for all PDF processing scripts in this skill.

Table of Contents

1. extract_text.py 2. extract_tables.py 3. convert_pdf.py 4. summarize_pdf.py 5. download_pdf.py 6. decode_pdf.py

---

extract_text.py

Extract text content from PDF files with optional formatting preservation.

Usage

python extract_text.py --input INPUT_PDF [OPTIONS]

Arguments

Examples

# Extract all text
python extract_text.py --input document.pdf --output document.txt

# Extract specific pages
python extract_text.py --input document.pdf --pages "1,5-10,15" --output selected.txt

# Extract from encrypted PDF
python extract_text.py --input secure.pdf --password "secret123" --output document.txt

# Process large PDF in chunks
python extract_text.py --input large.pdf --chunk-size 10 --output document.txt

# Print to stdout
python extract_text.py --input document.pdf

Return Codes

• 0 - Success
• 1 - Error (file not found, processing failed, etc.)

Output Format

================================================================================
PAGE 1
================================================================================

[Page 1 text content...]


================================================================================
PAGE 2
================================================================================

[Page 2 text content...]

---

extract_tables.py

Extract tables from PDF files and convert to CSV, JSON, or Markdown.

Usage

python extract_tables.py --input INPUT_PDF [OPTIONS]

Arguments

Examples

# Extract all tables to CSV
python extract_tables.py --input document.pdf --format csv --output-dir ./tables/

# Extract to JSON
python extract_tables.py --input document.pdf --format json --output tables.json

# Extract to Markdown
python extract_tables.py --input document.pdf --format markdown --output-dir ./tables/

Output Files

CSV Format:

• table_1_page_2.csv
• table_2_page_5.csv
• etc.

JSON Format (single file):

[
  {
    "page": 2,
    "table_number": 1,
    "headers": ["Column 1", "Column 2", "Column 3"],
    "rows": [
      ["Data 1", "Data 2", "Data 3"],
      ["Data 4", "Data 5", "Data 6"]
    ]
  }
]

Markdown Format:

# Table 1 (Page 2)

| Column 1 | Column 2 | Column 3 |
|---|---|---|
| Data 1 | Data 2 | Data 3 |
| Data 4 | Data 5 | Data 6 |

Return Codes

• 0 - Success
• 1 - Error

---

convert_pdf.py

Convert PDF files to various formats (Markdown, JSON, plain text).

Usage

python convert_pdf.py --input INPUT_PDF --output OUTPUT_FILE [OPTIONS]

Arguments

Examples

# Convert to Markdown
python convert_pdf.py --input document.pdf --output document.md --format markdown

# Convert to JSON with metadata
python convert_pdf.py --input document.pdf --output document.json --format json --extract-metadata

# Convert to text
python convert_pdf.py --input document.pdf --output document.txt --format text

# Markdown with images and metadata
python convert_pdf.py --input document.pdf --output document.md --format markdown --preserve-images --extract-metadata

Output Formats

Markdown:

---
title: Document Title
author: Author Name
pages: 42
---

## Page 1

Document content...

### Table 1

| Col1 | Col2 |
|------|------|
| A    | B    |

JSON:

{
  "source": "/path/to/document.pdf",
  "metadata": {
    "title": "Document Title",
    "pages": 42
  },
  "content": [
    {
      "page": 1,
      "type": "text",
      "content": "..."
    },
    {
      "page": 2,
      "type": "table",
      "headers": ["Col1", "Col2"],
      "rows": [["A", "B"]]
    }
  ]
}

Return Codes

• 0 - Success
• 1 - Error

---

summarize_pdf.py

Summarize PDF content by extracting key information.

Usage

python summarize_pdf.py --input INPUT_PDF --output OUTPUT_FILE [OPTIONS]

Arguments

Summary Styles

Examples

# Concise summary
python summarize_pdf.py --input document.pdf --output summary.md --style concise

# Detailed summary
python summarize_pdf.py --input document.pdf --output summary.md --style detailed

# Executive summary
python summarize_pdf.py --input document.pdf --output summary.md --style executive

Output Format

# PDF Document Summary

**Source:** document.pdf
**Generated:** summarize_pdf.py

## Document Information

- **Title:** Document Title
- **Author:** Author Name
- **Pages:** 42
- **Words:** ~10,500
- **Tables:** 5

## Key Content

1. First key point extracted from document.
2. Second key point with important information.
...

---

*This summary was automatically generated.*

Return Codes

• 0 - Success
• 1 - Error

---

download_pdf.py

Download PDF files from URLs.

Usage

python download_pdf.py --url URL --output OUTPUT_FILE [OPTIONS]

Arguments

Examples

# Download PDF
python download_pdf.py --url "https://example.com/document.pdf" --output document.pdf

# Download without SSL verification (use with caution)
python download_pdf.py --url "https://example.com/doc.pdf" --output doc.pdf --no-verify-ssl

Output

Downloading PDF from: https://example.com/document.pdf
Progress: 100.0%
PDF downloaded successfully: document.pdf
File size: 2543.2 KB

Return Codes

• 0 - Success
• 1 - Error (network error, invalid URL, etc.)

---

decode_pdf.py

Decode base64-encoded PDF content.

Usage

python decode_pdf.py --output OUTPUT_FILE [INPUT_OPTIONS]

Arguments

\* Either --input or --string must be provided

Examples

# Decode from file
python decode_pdf.py --input base64_content.txt --output document.pdf

# Decode from string
python decode_pdf.py --string "JVBERi0xLjQKJeLjz9MKM..." --output document.pdf

# Decode data URI
python decode_pdf.py --string "data:application/pdf;base64,JVBERi..." --output document.pdf

Input Format

The script accepts:

• Plain base64 string
• Data URI format: data:application/pdf;base64,<base64-data>
• File containing base64 content

Output

Decoding base64 content...
PDF decoded successfully: document.pdf
File size: 1234.5 KB

Return Codes

• 0 - Success
• 1 - Error (invalid base64, not a PDF, etc.)

---

Common Error Handling

All scripts follow consistent error handling:

File Not Found

Error: PDF file not found: /path/to/document.pdf
Exit code: 1

Password Protected

Error: PDF is password-protected. Please provide password with --password
Exit code: 1

Invalid PDF

Warning: Decoded data doesn't appear to be a valid PDF

Processing Error

Error: Failed to extract text: [detailed error message]
Exit code: 1

Integration with Claude

All scripts are designed to work seamlessly with Claude's workflow:

1. Read PDF first - Use Claude's Read tool to analyze the PDF 2. Determine needs - Claude identifies what extraction is needed 3. Execute script - Run appropriate script with correct parameters 4. Validate output - Check that files were created successfully 5. Present results - Show user what was extracted

Example Integration

# Step 1: Claude reads PDF
Read(file_path="/path/to/document.pdf")

# Step 2: Claude determines user wants tables
# User said: "Extract all tables from this PDF"

# Step 3: Execute extraction
Bash: python .claude/skills/pdf-processing/scripts/extract_tables.py \
  --input /path/to/document.pdf \
  --format csv \
  --output-dir ./extracted_tables/

# Step 4: Validate
Bash: ls -la ./extracted_tables/

# Step 5: Present results
Read: ./extracted_tables/table_1_page_2.csv

Version History

• 1.0.0 (2025-11-18) - Initial API documentation

PDF Processing Examples

Real-world examples and use cases for the PDF processing skill.

Table of Contents

1. Academic Research 2. Financial Reports 3. Legal Documents 4. Technical Documentation 5. Form Processing 6. Invoice Extraction 7. Batch Processing 8. Advanced Workflows

---

Academic Research

Use Case: Extract Key Findings from Research Paper

Scenario: Researcher wants to quickly extract key findings from a 50-page academic paper.

Workflow:

# Step 1: Read PDF to understand structure
Read(file_path="/path/to/research_paper.pdf")

# Step 2: Generate executive summary
python scripts/summarize_pdf.py \
  --input /path/to/research_paper.pdf \
  --output paper_summary.md \
  --style executive

# Step 3: Extract tables with statistical data
python scripts/extract_tables.py \
  --input /path/to/research_paper.pdf \
  --format csv \
  --output-dir ./paper_tables/

# Step 4: Convert references section to text
python scripts/extract_text.py \
  --input /path/to/research_paper.pdf \
  --pages "48-50" \
  --output references.txt

Output:

• paper_summary.md - Executive summary with key findings
• ./paper_tables/ - CSV files with statistical data
• references.txt - Bibliography for citation

---

Financial Reports

Use Case: Analyze Quarterly Financial Statement

Scenario: Analyst needs to extract financial tables and key metrics from quarterly report.

Workflow:

# Step 1: Read PDF
Read(file_path="/path/to/Q4_2024_Financial_Report.pdf")

# Step 2: Extract all financial tables
python scripts/extract_tables.py \
  --input /path/to/Q4_2024_Financial_Report.pdf \
  --format json \
  --output financial_data.json

# Step 3: Extract key sections
python scripts/extract_text.py \
  --input /path/to/Q4_2024_Financial_Report.pdf \
  --pages "3-5,10-12" \
  --output key_sections.txt

# Step 4: Generate summary
python scripts/summarize_pdf.py \
  --input /path/to/Q4_2024_Financial_Report.pdf \
  --output report_summary.md \
  --style executive

Follow-up Analysis:

import json
import pandas as pd

# Load extracted tables
with open('financial_data.json') as f:
    tables = json.load(f)

# Convert to DataFrame for analysis
for table in tables:
    if table['type'] == 'table':
        df = pd.DataFrame(table['rows'], columns=table['headers'])
        # Perform financial analysis
        print(df.describe())

---

Legal Documents

Use Case: Extract Clauses from Contract

Scenario: Lawyer needs to extract specific clauses from a 100-page contract.

Workflow:

# Step 1: Read PDF
Read(file_path="/path/to/contract.pdf")

# Step 2: Convert to searchable format
python scripts/convert_pdf.py \
  --input /path/to/contract.pdf \
  --output contract.md \
  --format markdown \
  --extract-metadata

# Step 3: Extract specific pages (identified after reading)
python scripts/extract_text.py \
  --input /path/to/contract.pdf \
  --pages "15-20,45-50,80-85" \
  --output key_clauses.txt

Then search in Markdown:

# Search for specific terms
grep -i "liability" contract.md
grep -i "termination" contract.md
grep -i "indemnification" contract.md

---

Technical Documentation

Use Case: Convert PDF Manual to Markdown Documentation

Scenario: Developer wants to convert PDF user manual to Markdown for a wiki.

Workflow:

# Step 1: Read PDF
Read(file_path="/path/to/user_manual.pdf")

# Step 2: Convert to Markdown with metadata
python scripts/convert_pdf.py \
  --input /path/to/user_manual.pdf \
  --output user_manual.md \
  --format markdown \
  --preserve-images \
  --extract-metadata

# Step 3: Extract tables separately for review
python scripts/extract_tables.py \
  --input /path/to/user_manual.pdf \
  --format markdown \
  --output-dir ./manual_tables/

# Step 4: Generate TOC summary
python scripts/summarize_pdf.py \
  --input /path/to/user_manual.pdf \
  --output manual_overview.md \
  --style detailed

Post-Processing:

# Clean up Markdown formatting
# Add to version control
git add user_manual.md manual_tables/ manual_overview.md
git commit -m "Add converted user manual"

---

Form Processing

Use Case: Extract Data from Filled Forms

Scenario: Process hundreds of filled PDF forms and extract data to database.

Workflow:

# Step 1: Process single form to understand structure
Read(file_path="/path/to/forms/form_001.pdf")

# Step 2: Extract to structured JSON
python scripts/convert_pdf.py \
  --input /path/to/forms/form_001.pdf \
  --output form_001.json \
  --format json \
  --extract-metadata

# Step 3: Extract any tables (for multi-entry forms)
python scripts/extract_tables.py \
  --input /path/to/forms/form_001.pdf \
  --format json \
  --output form_001_tables.json

Batch Processing:

# Process all forms
for form in /path/to/forms/*.pdf; do
    base_name=$(basename "$form" .pdf)
    python scripts/convert_pdf.py \
        --input "$form" \
        --output "processed/${base_name}.json" \
        --format json
done

---

Invoice Extraction

Use Case: Extract Invoice Data for Accounting

Scenario: Accountant needs to extract invoice details from PDF invoices.

Workflow:

# Step 1: Read sample invoice
Read(file_path="/path/to/invoices/invoice_2024_001.pdf")

# Step 2: Extract text to identify key fields
python scripts/extract_text.py \
  --input /path/to/invoices/invoice_2024_001.pdf \
  --output invoice_text.txt

# Step 3: Extract invoice table (line items)
python scripts/extract_tables.py \
  --input /path/to/invoices/invoice_2024_001.pdf \
  --format csv \
  --output-dir ./invoice_data/

Parse Invoice Fields:

import re

with open('invoice_text.txt') as f:
    text = f.read()

# Extract invoice number
invoice_num = re.search(r'Invoice #(\d+)', text)
# Extract date
date = re.search(r'Date: (\d{2}/\d{2}/\d{4})', text)
# Extract total
total = re.search(r'Total: \$([0-9,]+\.\d{2})', text)

invoice_data = {
    'invoice_number': invoice_num.group(1) if invoice_num else None,
    'date': date.group(1) if date else None,
    'total': total.group(1) if total else None
}

---

Batch Processing

Use Case: Process Multiple PDFs in Bulk

Scenario: Process 100 PDF documents and extract all content.

Batch Script:

#!/bin/bash
# batch_process.sh

INPUT_DIR="./pdfs"
OUTPUT_DIR="./processed"
TABLES_DIR="./tables"
SUMMARIES_DIR="./summaries"

mkdir -p "$OUTPUT_DIR" "$TABLES_DIR" "$SUMMARIES_DIR"

# Process each PDF
for pdf in "$INPUT_DIR"/*.pdf; do
    base_name=$(basename "$pdf" .pdf)
    echo "Processing: $base_name"

    # Extract text
    python scripts/extract_text.py \
        --input "$pdf" \
        --output "$OUTPUT_DIR/${base_name}.txt"

    # Extract tables
    python scripts/extract_tables.py \
        --input "$pdf" \
        --format csv \
        --output-dir "$TABLES_DIR/${base_name}/"

    # Generate summary
    python scripts/summarize_pdf.py \
        --input "$pdf" \
        --output "$SUMMARIES_DIR/${base_name}_summary.md" \
        --style concise

    echo "Completed: $base_name"
done

echo "Batch processing complete!"

Run Batch:

chmod +x batch_process.sh
./batch_process.sh

---

Advanced Workflows

Use Case 1: PDF to Blog Post

Scenario: Convert a whitepaper PDF to a blog post with proper formatting.

# 1. Read PDF
Read(file_path="/path/to/whitepaper.pdf")

# 2. Convert to Markdown
python scripts/convert_pdf.py \
  --input /path/to/whitepaper.pdf \
  --output blog_draft.md \
  --format markdown \
  --preserve-images

# 3. Extract key quotes for callouts
python scripts/summarize_pdf.py \
  --input /path/to/whitepaper.pdf \
  --output key_points.md \
  --style executive

# 4. Manual editing in blog_draft.md
# - Add SEO meta tags
# - Format code blocks
# - Add call-to-action

Use Case 2: PDF Comparison

Scenario: Compare two versions of a document.

# 1. Extract text from both versions
python scripts/extract_text.py \
  --input document_v1.pdf \
  --output v1.txt

python scripts/extract_text.py \
  --input document_v2.pdf \
  --output v2.txt

# 2. Use diff to compare
diff -u v1.txt v2.txt > changes.diff

# 3. Or use a more sophisticated tool
git diff --no-index v1.txt v2.txt

Use Case 3: PDF Data Pipeline

Scenario: Automated pipeline for processing uploaded PDFs.

#!/usr/bin/env python3
# pdf_pipeline.py

import subprocess
import json
from pathlib import Path

def process_pdf_pipeline(pdf_path):
    """Complete PDF processing pipeline."""

    base_name = Path(pdf_path).stem
    output_dir = Path(f"./processed/{base_name}")
    output_dir.mkdir(parents=True, exist_ok=True)

    # Step 1: Extract metadata and convert to JSON
    json_path = output_dir / f"{base_name}.json"
    subprocess.run([
        'python', 'scripts/convert_pdf.py',
        '--input', pdf_path,
        '--output', str(json_path),
        '--format', 'json',
        '--extract-metadata'
    ])

    # Step 2: Extract tables
    tables_dir = output_dir / 'tables'
    subprocess.run([
        'python', 'scripts/extract_tables.py',
        '--input', pdf_path,
        '--format', 'csv',
        '--output-dir', str(tables_dir)
    ])

    # Step 3: Generate summary
    summary_path = output_dir / f"{base_name}_summary.md"
    subprocess.run([
        'python', 'scripts/summarize_pdf.py',
        '--input', pdf_path,
        '--output', str(summary_path),
        '--style', 'concise'
    ])

    # Step 4: Load and return results
    with open(json_path) as f:
        data = json.load(f)

    return {
        'pdf': pdf_path,
        'output_dir': str(output_dir),
        'metadata': data.get('metadata'),
        'tables_count': len(list(tables_dir.glob('*.csv'))) if tables_dir.exists() else 0,
        'summary': str(summary_path)
    }

# Use in automation
if __name__ == '__main__':
    result = process_pdf_pipeline('./uploads/new_document.pdf')
    print(json.dumps(result, indent=2))

Use Case 4: OCR for Scanned PDFs

Scenario: Extract text from scanned documents.

# 1. Convert PDF to images
python -c "
from pdf2image import convert_from_path
images = convert_from_path('scanned_document.pdf')
for i, img in enumerate(images):
    img.save(f'page_{i+1}.png', 'PNG')
"

# 2. Apply OCR to each page
for img in page_*.png; do
    tesseract "$img" "${img%.png}" -l eng
done

# 3. Combine all text files
cat page_*.txt > scanned_document_ocr.txt

# 4. Clean up temporary files
rm page_*.png page_*.txt

Use Case 5: PDF Search Index

Scenario: Build searchable index of PDF library.

#!/usr/bin/env python3
# build_search_index.py

import json
import subprocess
from pathlib import Path
from whoosh.index import create_in
from whoosh.fields import Schema, TEXT, ID
from whoosh.qparser import QueryParser

# Define search schema
schema = Schema(
    path=ID(stored=True),
    filename=TEXT(stored=True),
    content=TEXT,
    title=TEXT(stored=True),
    author=TEXT(stored=True)
)

# Create index
index_dir = Path("./search_index")
index_dir.mkdir(exist_ok=True)
ix = create_in(str(index_dir), schema)

# Process all PDFs
writer = ix.writer()
for pdf_path in Path("./pdf_library").glob("**/*.pdf"):
    print(f"Indexing: {pdf_path}")

    # Extract text
    result = subprocess.run([
        'python', 'scripts/extract_text.py',
        '--input', str(pdf_path)
    ], capture_output=True, text=True)

    text_content = result.stdout

    # Extract metadata
    metadata_result = subprocess.run([
        'python', 'scripts/convert_pdf.py',
        '--input', str(pdf_path),
        '--output', '/tmp/temp.json',
        '--format', 'json',
        '--extract-metadata'
    ], capture_output=True)

    with open('/tmp/temp.json') as f:
        data = json.load(f)
        metadata = data.get('metadata', {})

    # Add to index
    writer.add_document(
        path=str(pdf_path),
        filename=pdf_path.name,
        content=text_content,
        title=metadata.get('title', pdf_path.stem),
        author=metadata.get('author', 'Unknown')
    )

writer.commit()
print("Search index built successfully!")

# Example search
from whoosh.qparser import MultifieldParser

with ix.searcher() as searcher:
    query = MultifieldParser(["content", "title"], ix.schema).parse("machine learning")
    results = searcher.search(query, limit=10)

    print(f"\nFound {len(results)} results for 'machine learning':")
    for hit in results:
        print(f"  - {hit['filename']}: {hit['title']}")

---

Performance Tips

For Large PDFs (>100 pages)

# Use chunked processing
python scripts/extract_text.py \
  --input large_document.pdf \
  --chunk-size 20 \
  --output document.txt

For High-Volume Processing

# Parallel processing with GNU parallel
find ./pdfs -name "*.pdf" | \
parallel python scripts/extract_text.py --input {} --output {.}.txt

For Scanned PDFs

# Optimize OCR accuracy with preprocessing
convert input.pdf -density 300 -depth 8 -quality 85 output.pdf
python scripts/extract_text.py --input output.pdf --output text.txt

---

Troubleshooting Examples

Problem: Jumbled Text from Multi-Column PDF

Solution:

# Use pdfplumber for better layout analysis
python -c "
import pdfplumber
with pdfplumber.open('multi_column.pdf') as pdf:
    for page in pdf.pages:
        # Extract with layout preservation
        text = page.extract_text(layout=True)
        print(text)
"

Problem: Missing Tables

Solution:

# Try different table extraction settings
python -c "
import pdfplumber
with pdfplumber.open('document.pdf') as pdf:
    for page in pdf.pages:
        tables = page.extract_tables(table_settings={
            'vertical_strategy': 'text',
            'horizontal_strategy': 'text'
        })
        for table in tables:
            print(table)
"

---

Version History

• 1.0.0 (2025-11-18) - Initial examples documentation

Claude's PDF Processing Capabilities

Overview

Claude has native support for processing PDF documents, enabling comprehensive analysis and extraction without requiring external services. This document outlines Claude's PDF capabilities and how to leverage them effectively.

Native PDF Support

What Claude Can Do

Claude can directly read and process PDF files through the Read tool, which provides:

1. Visual Content Understanding

• View PDF pages as images
• Understand layout and formatting
• Analyze charts, graphs, and diagrams
• Interpret infographics and visual elements
• Describe images and figures

2. Text Extraction

• Extract text from standard PDFs
• Preserve paragraph structure
• Recognize headers and footers
• Handle multi-column layouts
• Maintain reading order

3. Table Recognition

• Detect tables automatically
• Preserve table structure
• Extract headers and data rows
• Handle merged cells
• Support multi-page tables

4. Document Structure Analysis

• Identify document sections
• Recognize headings and subheadings
• Detect lists and bullet points
• Understand document hierarchy
• Parse form fields

5. Metadata Extraction

• Title, author, subject
• Creation and modification dates
• Page count
• PDF version
• Creator application

Processing Workflow

Recommended Approach

When working with PDFs, follow this workflow:

1. Read PDF with Claude's Read tool
   ↓
2. Analyze content and structure
   ↓
3. Determine user's specific needs
   ↓
4. Use appropriate script for extraction/conversion
   ↓
5. Validate and present results

Example Workflow

# Step 1: Read PDF directly
Read(file_path="/path/to/document.pdf")

# Step 2: Claude analyzes the content automatically
# - Sees the visual layout
# - Extracts text content
# - Identifies tables and charts
# - Understands document structure

# Step 3: Based on analysis, use scripts for specific tasks
# e.g., Extract tables to CSV
Bash: python scripts/extract_tables.py --input document.pdf --format csv --output-dir ./tables/

# Step 4: Validate output
Bash: ls -la ./tables/
Read: ./tables/table_1_page_2.csv

Content Types and Handling

1. Text-Based PDFs

Characteristics:

• Generated from word processors or design tools
• Text is selectable
• High accuracy for text extraction

Best Practices:

• Use Read tool for initial analysis
• Extract with extract_text.py for bulk processing
• Convert to Markdown for documentation purposes

2. Scanned PDFs (Images)

Characteristics:

• Created from scanned documents
• Text is embedded in images
• Requires OCR for text extraction

Best Practices:

• Claude can still view and analyze visually
• Use OCR tools (pytesseract) for text extraction
• May require preprocessing for best results

3. Mixed Content PDFs

Characteristics:

• Combination of text, images, and graphics
• Complex layouts with multiple columns
• Embedded charts and diagrams

Best Practices:

• Read with Claude first to understand layout
• Use pdfplumber for table extraction
• Manually verify complex structures

4. Form PDFs

Characteristics:

• Interactive fields
• Structured data entry
• May include checkboxes and signatures

Best Practices:

• Extract field names and values
• Convert to structured JSON
• Maintain field relationships

Limitations and Considerations

Current Limitations

1. Encrypted/Password-Protected PDFs

• Requires password for processing
• Some DRM-protected PDFs may be unreadable
• Use --password flag in scripts

2. Scanned Documents

• Native extraction won't work
• Requires OCR (Optical Character Recognition)
• Quality depends on scan resolution

3. Complex Layouts

• Multi-column layouts may have reading order issues
• Rotated text may not extract correctly
• Mixed left-to-right and right-to-left text

4. Large Files

• Very large PDFs (>100MB) may be slow to process
• Memory constraints on large page counts
• Use chunked processing when possible

5. Non-Standard Fonts

• Custom or embedded fonts may cause issues
• Some characters may not extract correctly
• Unicode characters may need special handling

Performance Considerations

Advanced Features

1. Table Extraction

Claude and pdfplumber can extract tables with high accuracy:

# Automatic table detection
tables = page.extract_tables()

# Customized table extraction
tables = page.extract_tables(table_settings={
    "vertical_strategy": "lines",
    "horizontal_strategy": "lines",
    "intersection_tolerance": 3
})

2. Image Extraction

Extract embedded images from PDFs:

from pdf2image import convert_from_path

# Convert PDF pages to images
images = convert_from_path('document.pdf')
for i, image in enumerate(images):
    image.save(f'page_{i+1}.png', 'PNG')

3. Layout Analysis

Understand document structure:

# Get layout objects
layout = page.layout_objects
words = page.extract_words()
chars = page.chars

4. Coordinate-Based Extraction

Extract specific regions:

# Extract specific area
bbox = (x0, y0, x1, y1)  # Bounding box coordinates
region = page.within_bbox(bbox)
text = region.extract_text()

Format Conversion Best Practices

PDF to Markdown

Use Cases:

• Documentation
• Blog posts
• Wiki pages
• README files

Considerations:

• Preserve heading hierarchy
• Convert tables to Markdown tables
• Include image references
• Maintain list formatting

PDF to JSON

Use Cases:

• Data extraction
• API integration
• Structured data processing
• Database import

Considerations:

• Define clear schema
• Handle nested structures
• Preserve metadata
• Include data types

PDF to CSV

Use Cases:

• Spreadsheet import
• Data analysis
• Database loading
• Table-specific extraction

Considerations:

• One table per file
• Consistent column headers
• Handle merged cells
• Preserve data types

PDF to Plain Text

Use Cases:

• Full-text search indexing
• Text analysis
• Content migration
• Backup/archival

Considerations:

• Preserve reading order
• Maintain paragraph breaks
• Include page markers
• Handle special characters

Quality Assurance

Validation Checklist

After processing PDFs, verify:

• [ ] All pages processed successfully
• [ ] Text extraction is accurate
• [ ] Tables are properly structured
• [ ] Special characters are preserved
• [ ] Images/charts are identified
• [ ] Output format is correct
• [ ] File size is reasonable
• [ ] No data loss occurred

Common Issues and Solutions

Security and Privacy

Best Practices

1. Sensitive Documents

• Verify user authorization
• Don't log sensitive content
• Delete temporary files
• Use secure storage

2. Password Protection

• Never log passwords
• Clear from memory after use
• Validate before processing
• Handle errors securely

3. Data Handling

• Minimize data retention
• Use secure file permissions
• Encrypt output when needed
• Follow data protection regulations

Integration Examples

With Data Analysis

# Extract tables and analyze with pandas
import pandas as pd

# Extract table
tables = extract_tables_from_pdf('report.pdf')
df = pd.DataFrame(tables[0]['rows'], columns=tables[0]['headers'])

# Analyze
summary = df.describe()

With Search Systems

# Extract text for indexing
text = extract_text_from_pdf('document.pdf')

# Index with search engine
search_index.add_document({
    'id': doc_id,
    'content': text,
    'metadata': extract_metadata('document.pdf')
})

With Automation

# Batch process invoices
for pdf in invoices/*.pdf; do
    python scripts/extract_tables.py --input "$pdf" --format csv --output-dir ./data/
done

Resources

Python Libraries

• pypdf - Modern PDF parsing (successor to PyPDF2)
• pdfplumber - Advanced table extraction and layout analysis
• pdf2image - Convert PDF pages to images
• pytesseract - OCR for scanned PDFs
• PyMuPDF (fitz) - Fast PDF processing with advanced features
• tabula-py - Alternative table extraction (requires Java)

External Tools

• Tesseract OCR - Open-source OCR engine
• Ghostscript - PDF manipulation and conversion
• pdftk - PDF toolkit for merging, splitting, etc.
• wkhtmltopdf - HTML to PDF conversion

Documentation

• PyPDF Documentation: https://pypdf.readthedocs.io/
• pdfplumber: https://github.com/jsvine/pdfplumber
• PDF Reference (Adobe): https://www.adobe.com/devnet/pdf/pdf_reference.html

Version History

• 1.0.0 (2025-11-18) - Initial documentation