PDF Table Extraction API

Convert selected files before parsing

Use the Python batch recipe to save complete Markdown from a small selected folder. Apply the parser below to one saved output at a time. For invoice tables, continue with the invoice data extraction workflow to define fields and reconcile totals before export.

Keep rows, headers and spans together

Simple rectangular tables become escaped GFM pipe tables. Complex tables with merged cells or nested content remain sanitized HTML inside Markdown. The dated invoice capture demonstrates both representations.

Check table headers, units, totals and spanning labels against the PDF. A complete response does not guarantee every extracted cell is correct. For local alternatives, pdfplumber supports text and explicit-edge strategies as well as gridlines; see the current tool guide.

Parsing simple GFM output into pandas

First save validated conversion output as document.md. Install pandas in your Python environment, then save this script as table_to_csv.py and run it with Python 3. It reads a local file and exports only the first valid table candidate as CSV to stdout. If that first candidate is complex HTML, or no table exists, it fails explicitly. Later tables are not exported.

from pathlib import Path
import pandas as pd

# BEGIN SYNCED GFM TABLE PARSER
from html import unescape

def split_gfm_row(line):
    row = line.strip()
    if not (row.startswith("|") and row.endswith("|")):
        raise ValueError("Expected a GFM table row with outer pipes")

    cells, cell = [], []
    escaped = False
    for char in row[1:-1]:
        if escaped:
            if char in ("\\", "|", "*", "_", "`"):
                cell.append(char)
            else:
                cell.extend(("\\", char))
            escaped = False
        elif char == "\\":
            escaped = True
        elif char == "|":
            cells.append(unescape("".join(cell).strip()))
            cell = []
        else:
            cell.append(char)
    if escaped:
        cell.append("\\")
    cells.append(unescape("".join(cell).strip()))
    return cells

def parse_gfm_candidate(lines):
    if len(lines) < 2:
        return None
    rows = [split_gfm_row(line) for line in lines]
    width = len(rows[0])
    if width == 0 or len(rows[1]) != width:
        return None
    if any(cell != "---" for cell in rows[1]):
        return None
    if any(len(row) != width for row in rows[2:]):
        return None
    return rows

def iter_table_candidates(markdown):
    current = []
    for line in markdown.splitlines():
        row = line.strip()
        if row.startswith("|") and row.endswith("|"):
            current.append(row)
            continue
        if current:
            candidate = parse_gfm_candidate(current)
            if candidate is not None:
                yield "gfm", candidate
            current = []
        if "<table" in row.casefold():
            yield "html", markdown
    if current:  # flush a table at end of output
        candidate = parse_gfm_candidate(current)
        if candidate is not None:
            yield "gfm", candidate

def extract_gfm_tables(markdown):
    return [value for kind, value in iter_table_candidates(markdown) if kind == "gfm"]

def first_table_branch(markdown):
    return next(iter_table_candidates(markdown), ("none", None))
# END SYNCED GFM TABLE PARSER

markdown = Path("document.md").read_text(encoding="utf-8")
table_kind, table_rows = first_table_branch(markdown)
if table_kind == "html":
    raise ValueError("Complex sanitized HTML table found: use a non-rendering HTML parser; do not render it as trusted HTML.")
if table_kind == "none":
    raise ValueError("No valid table found")
header = table_rows[0]
data = table_rows[2:]
df = pd.DataFrame(data, columns=header)
print(df.to_csv(index=False), end="")

The helper splits structural pipes before unescaping cells. It requires a header, canonical separator and consistent row widths. Treat cell text as data. For complex sanitized HTML, use a non-rendering HTML parser that retains span attributes; do not render API output as trusted HTML.

Convert a document

Use the tested Python, JavaScript or curl workflow. Choose one input: a public PDF URL, Base64 bytes, or a raw PDF upload. Raw uploads avoid Base64 expansion; all three send the document to an external processor.

See the API reference for authentication, limits and recovery.