Elite GitHub Gem Seeker Pro: AI Tool Finder

Executive Recommendation: Use

pdfplumber (MIT) as your primary engine for born-digital financial PDFs, with

Docling (MIT) as a containerized fallback for scanned or layout-heavy files. Both are permissively licensed and safe to embed in a closed-source backend.

PyMuPDF and

Marker, which often top "best PDF extractor" lists, are blocked for your use case.

I did not query live GitHub data in this session. Star counts are Pantheon baselines marked (est.), and you should verify licenses on the current release tags before shipping.

7-Column Gem Scorecard

Deep License & Supply-Chain Audit

pdfplumber: The code is MIT. Its core dependency pdfminer.six is MIT, Pillow is HPND (permissive), and pypdfium2 (used for page images) is Apache-2.0/BSD-3. There are no model weights, so it is clean at all three layers.

Docling: The code is MIT, but its dependency tree is large. Run pip-licenses on your lockfile and check each model card (layout, TableFormer, OCR) for commercial terms. OCR engines vary: RapidOCR and EasyOCR are Apache-2.0, while Tesseract is Apache-2.0 but a system dependency.

Camelot: The code is MIT, but a Ghostscript backend (AGPL) would pull AGPL software into your stack. Do not use it unless you pin a pdfium-based backend and confirm that in the lockfile.

PyMuPDF: AGPL-3.0 covers network use, so serving it from a SaaS backend triggers disclosure unless you buy the Artifex license. pymupdf4llm inherits this.

Marker: GPL-3.0 code plus restricted weights fails both the code layer and the weights layer for closed-source use.

I can't give legal advice. Have counsel review the final dependency tree, particularly Docling's model checkpoints.

Zero-Pollution Quickstart

uv venv && source .venv/bin/activate
uv pip install pdfplumber pandas tabulate

import pdfplumber, pandas as pd

# Ruled financial tables: use "lines". Borderless tables: switch to "text".
SETTINGS = {
    "vertical_strategy": "lines",
    "horizontal_strategy": "lines",
    "snap_tolerance": 3,
    "intersection_tolerance": 5,
}

def extract_tables(path: str, settings: dict = SETTINGS) -> list[pd.DataFrame]:
    dfs = []
    with pdfplumber.open(path) as pdf:
        for page_no, page in enumerate(pdf.pages, start=1):
            for t in page.extract_tables(table_settings=settings):
                if not t or len(t) < 2:
                    continue
                df = pd.DataFrame(t[1:], columns=t[0])
                df.attrs["page"] = page_no
                dfs.append(df)
    return dfs

if __name__ == "__main__":
    for df in extract_tables("report.pdf"):
        print(f"--- page {df.attrs['page']} ---")
        print(df.to_markdown(index=False))

Fallback for scanned or borderless pages, run in a container:

from docling.document_converter import DocumentConverter

result = DocumentConverter().convert("report.pdf")
for table in result.document.tables:
    df = table.export_to_dataframe(doc=result.document)
    md = table.export_to_markdown(doc=result.document)

Production Gotchas

Routing: Detect whether a page has a text layer (page.extract_text() returns non-empty text). If it doesn't, send the file to the Docling worker instead of pdfplumber.

Isolation: Run Docling in its own container with memory limits (for example, 8 GB), a per-document timeout, and GPU or CPU pinning. Never run it in the web process. Wrap pdfplumber calls in a subprocess or worker with a timeout too, since malformed PDFs can hang parsers.

Financial-table quirks: Merged header cells, parenthesized negatives like (1,234), footnote markers, and multi-page tables split across pages all need post-processing. Normalize numbers explicitly and keep a validation step such as totals reconciliation.

Untrusted uploads: Treat PDFs as hostile input. Enforce file size and page limits, and consider qpdf (Apache-2.0) to sanitize or linearize files before parsing.

Pin versions and re-run license scans on every dependency bump. Camelot's and Docling's dependency graphs change between releases.

Accuracy: Build a small gold-standard set of your own PDFs and benchmark both engines on it before committing. Table-extraction quality varies heavily with document family.

💎 Powered by Open Source: pdfplumber

• Repository: https://github.com/jsvine/pdfplumber
• Tier & Traction: 🛡️ Battle-Tested Tier | ~6k+ ⭐ (est.) | Actively Maintained
• License: MIT (code and dependencies, no model weights). Commercial friendly.

Why This Gem Won: It is the only top-tier PDF table extractor with a fully permissive stack, no ML weights, and deterministic, tunable output that is safe to embed in closed-source software.

*

Support the Maintainers: If this saved you hours of custom coding, consider giving the repository a ⭐ star on GitHub!

*

Automate This Workflow: Reply

"Package as Skill" or

"Build Wrapper Script" and I will compile this exact configuration into a reusable, one-command skill or hardened production module for your workflow.

💎 Also Powering the Fallback: Docling

• Repository: https://github.com/DS4SD/docling
• Tier & Traction: 💎 Diamond Tier | ~25k+ ⭐ (est.) | Actively Maintained
• License: MIT code. Verify each model checkpoint's license before commercial use.

If you share a sample PDF, I can tune the pdfplumber settings against it and show you the actual extraction output.