How to Convert PDF to CSV: A Developer & Ops Guide to Table Extraction

In modern operations, few tasks are as deceptive as being asked to "just convert this PDF table to a CSV file." To a human eye, a PDF bank statement, invoice, or supplier catalog displays clean, straight columns of numbers. But to a computer, a PDF is not a spreadsheet. It is a digital piece of paper—a set of coordinate instructions telling a printer where to draw lines and render individual characters on a screen.

Because PDFs completely lack structural concepts like "rows" or "columns," programmatically extracting tables requires specialized parsers. This guide will walk you through the structural challenges of PDF data, demonstrate how to write custom Python parsing pipelines, and show you where DIY scripts reach their breaking points.

Why PDFs are Hostile to Spreadsheet Tables

Under the hood, a PDF document represents text as absolute coordinates. A snippet of a PDF's raw layout stream might look like this:

BT
/F1 12 Tf
72.00 712.00 Td
(Date) Tj
144.00 0.00 Td
(Description) Tj
360.00 0.00 Td
(Amount) Tj
ET

Notice that there are no columns here. The instruction 72.00 712.00 Td simply positions a virtual print-head at 72 points from the left and 712 points from the bottom of the page, and prints the string "Date". The next word, "Description", is placed 144 points to the right.

If a transaction description is too long, the PDF layout engine wraps it onto a new line, printing another string at a lower vertical coordinate. To a simple parser, this wrapped text looks like an entirely new row of data. Reassembling these independent printing actions back into a coherent .csv spreadsheet is the core challenge of PDF extraction.

Method 1: The Developer Path (Python)

When building internal automation, developers have two main libraries at their disposal for extracting tabular data from PDF files: pdfplumber and Camelot.

Extracting Tables with pdfplumber

pdfplumber is excellent for documents with clear horizontal and vertical grid lines, or where you can define explicit vertical columns. Below is a copy-pasteable script to extract tables and write them to CSV:

import pdfplumber
import csv

def pdf_to_csv(pdf_path, csv_path):
    with pdfplumber.open(pdf_path) as pdf:
        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            
            for page_num, page in enumerate(pdf.pages, 1):
                # Extract tables using default threshold settings
                tables = page.extract_tables()
                
                for table in tables:
                    for row in table:
                        # Clean up None values and strip extra spacing
                        cleaned_row = [cell.strip() if cell else "" for cell in row]
                        # Filter out completely empty rows
                        if any(cleaned_row):
                            writer.writerow(cleaned_row)
                
                print(f"Processed Page {page_num}")

pdf_to_csv("bank_statement.pdf", "transactions.csv")

Extracting Tables with Camelot

Camelot is highly powerful because it offers two separate parsing flavors: Lattice (which uses computer vision to detect explicit bounding grid-lines) and Stream (which uses whitespace analysis to cluster text blocks into columns).

import camelot

# For documents with explicit grid lines (e.g., invoices, bills)
tables = camelot.read_pdf('supplier_bill.pdf', pages='all', flavor='lattice')

# Export all detected tables directly to a directory of CSVs
tables.export('extracted_tables.csv', f='csv', compress=True)

# For borderless, whitespace-aligned columns (e.g. standard bank statements)
borderless_tables = camelot.read_pdf('statement.pdf', pages='1-3', flavor='stream')
borderless_tables[0].to_csv('page_1_transactions.csv')

Method 2: The Command Line Path

For rapid CLI automation or shell-script integrations, the poppler-utils library provides robust tools like pdftotext. If you run it with the -layout flag, it preserves the visual whitespace columns of the original document, which can then be parsed with Regex.

# Install poppler utilities (Ubuntu/Debian)
sudo apt-get install poppler-utils

# Extract text while attempting to preserve column coordinates
pdftotext -layout input_statement.pdf output_raw_text.txt

Once you have the text file with layout columns preserved, you can process it using Python or standard bash tools like awk to replace clusters of multiple spaces with commas.

The Breaking Points of DIY Parsing Scripts

While Python libraries work well for uniform, single-page PDFs, they quickly collapse under the complexity of real-world business documents:

• Multi-Page Table Spans: When a table spans multiple pages, column coordinates frequently shift by several pixels from page 1 to page 2. This causes libraries to break columns apart or merge adjacent values.
• Wrapped Descriptions: If a description takes up two lines (e.g., a merchant description spanning multiple lines), standard parsers will extract it as two separate rows, throwing off transaction totals.
• Scanned/Image-Only PDFs: Standard text-extractors return empty strings when encountering scanned PDFs, requiring an OCR preprocessing pipeline (like Tesseract) which introduces significant character errors (e.g., misreading 8 as B, or 1 as l).
• Template Drift: A script written perfectly for a Chase Bank statement PDF will fail immediately when fed an SVB, Bank of America, or Wells Fargo statement, requiring ongoing maintenance.

The Automated Alternative: Multi-Model Extraction

If your operations team receives different financial documents from multiple customers daily, building and maintaining custom Python parser scripts is a massive engineering drain.

This is where a modern document ingestion pipeline excels. Elvity’s PDF data extraction platform uses advanced multi-LLM consensus parsing. Rather than relying on rigid coordinate boundaries or brittle whitespace patterns, Elvity reads the document semantically—exactly like a human would.

By combining AI-driven vision models with deterministic column alignment, Elvity normalizes transaction records, handles multi-line cell wraps automatically, and translates messy tables directly into an audit-ready, QuickBooks-compliant CSV with 99.9% accuracy.