185 tools
Android library (built on PdfiumAndroid/PDFium, the same rendering engine Chrome uses) for displaying PDF documents with animated page transitions, gesture-based pinch/double-tap zoom, and page navigation controls baked into the view. One of the more widely-adopted Android PDF-viewing libraries historically, though ownership recently transitioned to new maintainers and the project is actively seeking contributors to keep it current.
JavaJava library and CLI toolset covering PDF creation from scratch (with embedded fonts and images), Unicode text extraction, splitting and merging, form field extraction and filling, PDF/A-1b validation via its Preflight module, rendering pages to PNG/JPEG, printing via the Java printing API, and digital signing. The de facto standard Java PDF library, used as the underlying engine behind numerous other tools in this directory (PDFsam, PDFLayoutTextStripper, PdfBox-Android, and more).
Content-analysis toolkit that detects file types and extracts text and metadata from over a thousand file formats (including PDF, DOCX, PPTX, XLSX) through a single parsing interface; supports OCR (via Tesseract), language detection, named-entity recognition, and parsing of embedded documents/attachments. Available as a Java library, CLI (tika-app), or REST server (tika-server).
Print formatter driven by XSL Formatting Objects (XSL-FO): reads an FO tree (often produced via XSLT from semantic XML) and renders it to PDF (its primary target, targeting the PDF 1.4 spec), plus PostScript, PCL, AFP, PNG, RTF, TXT, and other outputs. Handles multi-page tables, footnotes, static page regions, and external graphics; usable standalone, embedded, via servlet, or via an Ant task.
PythonPure-Python library for reading, creating, and manipulating PDFs, modeling the file as a JSON-like structure of nested lists/dictionaries/primitives for programmatic access — rather than the more common object-oriented page/content-stream abstraction most PDF libraries use. This structural, low-level modeling suits tasks that need direct access to a PDF's actual object graph rather than a higher-level document API. Ships with extensive documentation and example-driven tutorials.
PHPPHP package that drives headless Chrome (via Puppeteer, run through a small Node.js bridge script) to convert a URL, HTML string, or local HTML file into a PDF or image, getting genuine modern browser rendering rather than a PDF-specific rendering engine's approximation. Can also extract the rendered HTML body after JavaScript execution completes and list every network request the page triggered — useful for debugging what a page actually loaded before capture.
PerlPerl module (PDF 1.0–1.5) for reading and writing PDFs: extract/delete/duplicate pages, get page text/content trees, append/prepend pages from other PDFs, handle password-protected documents and permissions, list/add fonts, list/fill form fields, remove annotations, detect linearized PDFs, remove unused objects, and apply compression filters.
Extracts tables from text-based PDFs (not scanned documents) into pandas DataFrames, exportable to CSV/JSON/Excel/HTML/SQLite, with accuracy/whitespace quality metrics and a CLI. Five parsing strategies: `lattice` (ruled tables), `stream` (whitespace-based), `network`/`hybrid` (text-alignment), and an optional neural `ml` parser (Table Transformer) for hard borderless cases.
LispCross-platform Common Lisp library for generating PDF files without third-party tools: TrueType/Type 1 fonts (with Unicode), PNG image embedding, barcode generation, charting, optional zlib compression, and a PDF templating system; pairs with cl-typesetting for a full document-composition system.
Clojure library for generating PDFs from plain Clojure data structures — a document is just nested vectors/maps describing text, fonts, and layout, evaluated into a PDF via iText under the hood. Supports typography with custom TTF fonts, CSS-like stylesheets, lists, tables, multi-column layouts, SVG and image embedding, bar/line/pie charts, headers/footers, page numbering, document metadata, file attachments, and watermarks. A natural fit for generating reports from data already living in Clojure.
RubyPure-Ruby (no external dependencies) library to merge PDFs, extract and recombine specific pages, overlay watermarks/stamps (e.g. logos), and add customizable page numbering; parses PDFs from files, memory, or remote sources. The maintainer has stepped back from active maintenance and is seeking a new steward.
LaTeX/Pandoc template that separates CV content (stored in a YAML file) from a LaTeX presentation template, compiling to a professionally typeset PDF via a makefile; supports configurable fonts, sizes, language/hyphenation, and margins.
Set of Dart/Flutter packages — `pdf` for core PDF generation, `printing` for device print/preview integration — that let Flutter apps generate and print PDF files natively on both iOS and Android from the same Dart codebase. The `pdf` package builds documents with a widget-like API modeled after Flutter's own layout system (rows, columns, padding, flexible sizing), so Flutter developers reuse layout intuition they already have. `printing` then hands the result to the OS's native print/share dialog.
PythonApache-2.0 orchestration framework for document AI: combines layout detection and table recognition (via Detectron2/Transformers), OCR (Tesseract, DocTr, or AWS Textract), and document/token classification (LayoutLM family, LiLT, BERT-style models) into configurable pipelines for scanned documents and PDFs.
PythonExtracts higher-quality OCR text from poorly scanned PDFs and images (PDF, PNG, JPG, BMP, TIFF) by fixing common scan errors: crops to estimated text regions, deskews tilted pages, and optimizes images before running Tesseract OCR; supports bulk processing (splitting multi-page PDFs) and language-code hints for accuracy.
Go library, CLI, and HTTP service that converts PDF, DOC, DOCX, XML, HTML, RTF, ODT, Pages, and image files to plain text plus metadata (as JSON), aiming to be a single conversion entry point across many document formats rather than a PDF-specific tool. Optional OCR support (via Tesseract, enabled with the `ocr` build tag) handles image-based input. Its multi-format scope suits ingestion pipelines that need to normalize mixed document types into plain text.
Document-conversion toolkit that parses PDFs (and Office/image formats) into a unified structured representation, with layout analysis, OCR (EasyOCR by default), table structure recognition, and optional vision-language-model image description; exports to Markdown, HTML, or JSON.
JavaStandalone CLI tool and embeddable Java library that converts DOC, DOCX, PPT, PPTX, and ODT files to PDF without requiring a LibreOffice or Microsoft Office installation as a dependency — useful in server environments where installing a full office suite isn't practical. PPT/PPTX slides are converted to PDFs with each slide embedded as a rendered PNG image rather than reconstructed as native PDF content, preserving visual fidelity at the cost of the text no longer being selectable.
CLI utility and Ruby library that extracts searchable UTF-8 plain text from documents, generates page images and thumbnails in any format, splits documents into single-page or full PDFs, and extracts metadata (title, author, page count). Built by DocumentCloud for processing large volumes of source documents in journalism/investigative-reporting workflows, wrapping several underlying tools (Poppler, ImageMagick, Tesseract) behind one consistent CLI.
PHPPure-PHP (no external PDF library) HTML-to-PDF converter: CSS 2.1 (with some CSS3) including @import/@media/@page rules, most presentational HTML 4.0 attributes, external/inline stylesheets, complex table rendering (spans, border models), GIF/PNG/BMP/JPEG images, basic SVG, inline PHP, and embedded fonts (bundled DejaVu TrueType for Unicode). Does not support CSS Flexbox/Grid or multi-page table cells.
PythonOCR-free document-understanding transformer (PyTorch/Hugging Face) that classifies document types, extracts structured information (e.g. from receipts), answers questions about document content, and reads text sequences directly from document images without a separate OCR engine.
Rails-oriented gem (headless Chrome via Ferrum, no Node.js dependency) that renders HTML/URLs to PDF (`render ferrum_pdf: {}`) with paper size/margin/orientation/scale options and dynamic headers/footers, or captures PNG/JPEG screenshots (`render ferrum_screenshot: {}`) of the full page, viewport, or a CSS-selected element.
JavaRenders well-formed XML/XHTML using CSS 2.1 layout/formatting to Swing panels, images, or PDF (via an OpenPDF-based renderer, or by delegating to a headless Chrome shell for modern HTML5/CSS3 support); also offers SWT output for Eclipse-based apps.
PHPFree PHP class for generating PDF files in pure PHP, with no external PDF library or PHP extension dependency required — just the class files themselves. One of the longest-running PHP PDF-generation libraries, and a base a number of other tools in this directory were originally built on or inspired by. Its minimal-dependency design makes it a reliable fallback on shared hosting environments where installing PHP extensions isn't an option.
PythonUnicode TrueType font subset embedding, cell/multi-cell/plaintext writing with automatic page breaks, optional Markdown-like text styling, image embedding with transparency, SVG import, arbitrary path drawing, table generation, internal/external links, barcodes/charts/emoji, document encryption and digital signing, annotations (highlights, file attachments), HTML-to-PDF conversion, basic math rendering, and TOC/outline generation.
PythonExtracts text from many file formats — PDF, Word, HTML, and more — for search indexing, via pluggable per-format backend modules rather than one monolithic parser. Each supported format is handled by delegating to an appropriate existing extraction library or system tool under the hood, with `fulltext` providing the unified API and format-detection layer on top. Aimed specifically at indexing pipelines that need one consistent text-extraction call across mixed document types.
rOpenSci package for searching and retrieving full-text academic articles across open-access and subscription journals: Crossref metadata lookup, PDF text extraction, academic-document XML parsing, and text mining.
Rails gem that renders inline PDFs from normal Rails view templates (`.pdf.prawn` / `.pdf.erb`) using the Prawn library under the hood, exposing a `pdf` object in views with global or per-document configuration and metadata (title, author, page size). Lets a Rails app generate PDF responses the same way it already generates HTML views — same routing, same view-rendering pipeline — rather than a separate PDF-generation code path.
PostScript and PDF interpreter/renderer from Artifex — the reference engine that many other PDF tools build on or shell out to under the hood. Converts PostScript and PDF to raster images, plain text, DOCX, PCL, and XPS; compresses PDFs while preserving visual quality; converts to and validates against the PDF/A archival standard; and adds a searchable OCR text layer to scanned pages. Also handles imposition (N-up page layout), ICC color management, and ZUGFeRD/Factur-X e-invoicing embedding.
Free, portable utility for splitting and merging PDF files, distributed as a reusable library, a console tool, and a GUI — pick whichever interface fits a given workflow. Also converts JPG images directly into PDF pages. Requires no installation, running as a self-contained portable executable, which is its main draw over heavier split/merge alternatives in the same niche.
Go library for generating PDFs: text with UTF-8/RTL support, standard/TrueType/Type1 fonts, JPEG/PNG/GIF/TIFF images and basic SVG, vector graphics (lines, Bézier curves, arcs, gradients, transparency), barcodes, charts, outline bookmarks, internal/external links, page templates and importing existing PDFs as templates, layers, document protection/encryption, and file attachments/annotations.
Go library for generating PDFs: Unicode/CJK subfont text with kerning, alignment, sub/superscript, RGB/CMYK color; vector shapes (lines, ovals, rounded rectangles, polygons, curves); JPG/PNG images with masking; password protection with permissions; headers/footers, links, transparency/blend modes; table layout; page rotation; and importing/reusing existing PDF pages as templates.
GoGo library built on top of gopdf for generating banded PDF reports in the style of classic report-writing tools: page headers/footers, grouped headers and summaries, detail bands for row-level data, and an overall report summary section. Draws text cells, lines, rectangles/ovals, JPEG images, and TrueType fonts across multiple page sizes and orientations. Aimed at business-report generation (invoices, statements, listings) rather than general-purpose PDF creation.
GoGo wrapper around the Tesseract OCR C++ library via cgo bindings: feed it an input image and it returns the recognized text, with support for over 100 languages via Tesseract's trained-data files. Requires Tesseract itself (and its language data) installed as a system dependency, since gosseract only provides the Go-side binding rather than a self-contained OCR engine. A straightforward way to add OCR to a Go application without shelling out to the `tesseract` CLI directly.
RubyRuby gem (using ImageMagick and Ghostscript under the hood) that extracts a PDF page as an image — PNG or similar — or as page text, reports total page count, and iterates all pages in batch, with configurable image width/density/quality/colorspace/alpha and custom processor paths. Its text extraction is a thin wrapper around `pdftotext` rather than an independent implementation, so text-extraction fidelity matches whatever Poppler already produces.
Ruby gem that uses Puppeteer/headless Chromium (or Firefox) to convert URLs, inline HTML, local files, or Rails view templates into PDF, PNG, or JPEG: configurable page layout/margins/viewport, cookies/headers, CSS/JS injection, cover pages, HTTP basic auth, remote-browser connections, wait conditions (network idle, element visibility), and Rack middleware for URL-extension-triggered conversion.
RubyPDF library and CLI (positioned as a pdftk/Poppler-utils alternative): creates PDFs from scratch with vector drawing, JPEG/PNG/PDF image embedding, and TrueType text with subsetting; a high-level document composition engine (automatic layout, text flow, page breaks, lists, multi-column, reusable styles); modifies and merges existing PDFs; creates AcroForms with Adobe-like appearances; adds annotations, outlines, and file attachments; extracts metadata/text/images/files; encrypts (incl. PDF 2.0 AES-256) and digitally signs; and optimizes file size with object validation.
Node.js library that renders HTML (local strings or remote URLs) to PDF using headless Chrome/Chromium, or exports as PNG/JPEG/WebP screenshots; supports templated headers/footers, custom HTTP headers, configurable viewport/device-scale, and multiple render-completion triggers (callbacks, DOM events, timers).
PHPConverts specially-cleaned HTML (not arbitrary web pages) into PDF using TCPDF as the underlying engine, for generating documents like invoices and documentation; requires the gd and mbstring PHP extensions. Not designed to render existing websites or WYSIWYG-generated HTML directly.
JavaScriptClient-side (browser-only) library built on html2canvas and jsPDF that converts a webpage, DOM element, or canvas into a PDF entirely in the browser, with configurable margins, page breaks, image quality/type, and a promise-based worker API. Renders content as images, so output text is not selectable/searchable and files can be large.
JavaScriptFast Node.js module — a native binding around the C++ PDFWriter/PDFHummus engine (also published standalone as PDF-Writer) — for creating, parsing, and manipulating PDF files and streams. Being a native addon rather than a pure-JS implementation, it trades install-time complexity (native compilation) for meaningfully better performance on large documents. Superseded by muhammara, a drop-in replacement built on the same engine with modernized bindings and continued maintenance.
PerlComponent of Image::ExifTool that reads metadata from PDF files, including support for PDF-1.5 object streams (limited Filter/Predictor algorithms) and all standard PDF encryption methods through PDF-2.0 (including AESV2/AES-128 and AESV3/AES-256).
LaTeXLaTeX/Pandoc/XeTeX template that generates invoice PDFs from a YAML data file (`details.yml`), auto-calculating line totals and VAT via the `spreadtab` package, with configurable fonts/margins/currency/language, optional embedded signature image, and optional custom letterhead PDF layered underneath.
REST API that generates invoices as PDFs from supplied structured details (invoice number, dates, sender/recipient, line items, payment terms), removing the need to hand-build invoice layout/rendering logic. Ships official SDKs for JS/Node, Python, C#/.NET, PHP, Go, Dart, and Android, so the API can be called with a native client in most common stacks rather than raw HTTP requests. A hosted service rather than something self-run.
PythonExtracts structured data from invoice PDFs: pulls text via pdftotext, pdfminer, or OCR (tesseract/tesseract4/Google Cloud Vision), then matches fields (invoice number, date, amount, line items) using regex patterns defined in per-supplier YAML templates; exports to CSV, JSON, XML, or renames files based on extracted content; supports batch folder processing.
Pure-Ruby (no external system libraries) invoice-PDF generator, usable as a library, CLI, or server: A4/US Letter formats, purchaser/provider info boxes with addresses and tax IDs, SWIFT/IBAN payment details, itemized tables (description/quantity/price/tax/totals), automatic page numbering, customizable labels, custom fonts/logos/backgrounds/stamps/signatures/QR codes, and JSON-driven invoice data — fast enough for real-time request handling.
JavaCreate and manipulate PDFs, merge documents, digitally sign, create and fill AcroForm fields, generate PDF/A and PDF/UA archival/accessible output, encrypt (including FIPS-compliant crypto), generate barcodes, embed SVG, and redact content — the core feature set of the modern, actively-developed iText line. Separate official add-ons extend it further: pdfOCR (Tesseract- or ONNX-based optical character recognition) and pdfHTML (HTML/CSS-to-PDF conversion), both maintained by the same organization rather than third-party plugins.
JavaLegacy iText 5: core PDF creation/manipulation library (receiving security fixes only), with add-on modules for PDF 2.0 features (itext-xtra), PDF/A generation/validation (itext-pdfa), and XML/HTML-to-PDF conversion (xmlworker). Also reads existing PDFs via `PdfTextExtractor`. Targets Java 5 compatibility, which blocks upgrading some vulnerable dependencies.
Java reporting engine that compiles XML report templates (.jrxml) into executable reports (.jasper), pulling data from any data source to produce pixel-perfect documents; exports to PDF, HTML, Excel, Word, and OpenOffice formats, and renders Pie/Bar/Stacked Bar charts. Designed with Jaspersoft Studio and embeddable via API.
JavaScriptClient-side JavaScript library for generating PDFs in the browser or Node: configurable paper size/orientation/units, text with 14 standard fonts or custom embedded TTF/Unicode fonts, images, transformation matrices, patterns, and FormObjects; plugin ecosystem adds HTML-to-PDF (via html2canvas) and table generation. Ships as ES module, UMD, or with TypeScript typings. (Originally MrRio/jsPDF, now hosted under github.com/parallax/jsPDF, which the old URL redirects to.)
JavaScriptjsPDF plugin for generating PDF tables: parses existing HTML tables via CSS selectors or builds tables from JavaScript data (head/body/foot), with striped/grid/plain themes, custom colors/fonts/alignment, colspan/rowspan, automatic or manual page breaks (including horizontal breaks for wide tables), and lifecycle hooks for custom styling.
JavaScriptOpen-source report-rendering platform: design reports with templating engines (e.g. Handlebars) or a visual designer, and render them to PDF, HTML, Excel, DOCX, and other formats; includes user management, a REST API, scheduling, and email delivery. Usable standalone or embedded as a Node.js library.
PHPLaravel wrapper around Dompdf: converts HTML strings, files, or Blade views to PDF with paper size/orientation, DPI, fonts, CSS page breaks, and UTF-8 support; generates PDF/A-3b compliant output with embedded files and XMP metadata (for Zugferd/Factur-X e-invoicing); toggles JS/remote-content/PHP execution; outputs to disk, browser stream, download, or string.
PHPLaravel wrapper around mPDF: renders Blade views to PDF with data binding, custom headers/footers with page numbering, custom TTF fonts, document permission protection (copy/print/modify/extract/assemble), and per-file config overrides, with output via string, save, download, or browser stream.
Laravel wrapper around the Snappy library: generates PDFs or images from HTML strings, files, or Laravel views, with output to file/browser/download, wkhtmltopdf/wkhtmltoimage option passthrough (paper size, orientation, margins), and a fake mode for testing without real rendering.
PythonDeep-learning toolkit for document image layout analysis: detects layout elements (text blocks, titles, tables, figures) using pre-trained models, filters/crops regions by spatial location, loads layout data from JSON/CSV/PDF, runs OCR on detected regions, and visualizes detected layouts.
LaTeX/XeTeX/Pandoc template that generates letter PDFs from a Markdown file with a YAML header (recipient, date, subject); supports custom fonts, sizes, margins, language/hyphenation, an auto-embedded signature image, and an optional custom letterhead PDF background, built via a makefile.
ANSI C library for generating PDF documents entirely from scratch (no PDF import or editing) — a common embedded choice for C/C++ applications that need to produce reports or documents without shelling out to an external process. Draws lines, text, and images (PNG/JPEG, with CMYK, alpha-channel, and CCITT fax support), embeds Type1/TrueType/CJK fonts, and adds outlines plus text and link annotations. Supports document encryption, Deflate stream compression, and PDF/A-1b archival-compliant output.
PythonConverts PDFs, images, PPTX, DOCX, XLSX, HTML, and EPUB to Markdown, JSON, HTML, or chunks, preserving reading order: reconstructs tables (heuristics with VLM fallback for complex cases), recognizes math/equations as LaTeX, extracts and saves images, performs multilingual OCR via the Surya VLM, strips headers/footers/artifacts, and can optionally use an LLM to improve accuracy.
PythonConverts PDFs, Office documents, images, audio, HTML, and other formats to Markdown for use as LLM input; ships both a CLI and a Python library, and can keep embedded images as base64 data URIs instead of discarding them.
Converts PDF, DOCX, PPTX, XLSX, images, and web pages into Markdown or JSON: strips headers/footers/page numbers while preserving structure, converts formulas to LaTeX and tables to HTML, OCRs scanned/garbled PDFs in 109 languages, handles single/multi-column and complex layouts (incl. cross-page table merging), and extracts images with captions. Offers CLI, FastAPI, and Gradio WebUI, plus Python/Go/TypeScript SDKs; builds on PDF-Extract-Kit's models.
PerlPerl module (built on PDF::Reuse) for generating multi-page PDFs: text with font/size/color control, 14 built-in fonts plus custom TTF embedding (with Unicode), alignment and rotation, regex-based text formatting, JPEG image embedding, importing pages from existing PDFs as templates, horizontal rules, raw content streams, and auto-sized tables with headers, borders, padding, and page-overflow handling.
PHPGenerates PDFs from UTF-8 HTML (including CJK content): headers/footers, page numbering, TOC, color handling, embedded fonts, zlib-compressed output, XML-driven charset conversion, basic SVG, and optional barcode generation (via bcmath). Notably lacks state-of-the-art CSS support compared to headless-Chrome-based alternatives.
JavaScriptNode.js module for creating, reading, and modifying PDF files and streams — a drop-in replacement for HummusJS, built on the same underlying PDF-Writer/PDFHummus C++ engine but with modernized native bindings and active maintenance where HummusJS itself has stalled. Being a native addon rather than pure JavaScript, it offers meaningfully better performance on large documents than pure-JS PDF libraries, at the cost of requiring native compilation at install time.
CLightweight, fast C library, desktop viewer, and CLI toolset for PDF, XPS, and e-book formats, built by Artifex around the same rendering core used in Ghostscript. Renders pages and extracts text/images/metadata/structured content; creates, splits, merges, and compresses PDFs; adds annotations (highlights, stamps, shapes); permanently redacts content; and digitally signs documents. Converts between PDF, SVG, PNG, HTML, and PostScript, and embeds into web pages and native apps via its library bindings.
Pure-Java HTML/CSS-to-PDF and HTML-to-image renderer, positioned as a modernization of the original Flying Saucer project with updated dependencies and continued maintenance. Takes well-formed XHTML/XML styled with CSS 2.1 and lays it out using the same core rendering approach as Flying Saucer, producing PDF via an underlying PDF library rather than a browser engine. A lighter-weight alternative to browser-based HTML-to-PDF tools when the input HTML is already clean/well-formed rather than arbitrary web pages.
PhantomJS-based library that converts HTML to PDF, PNG, or JPEG via a file/stream/buffer API, with configurable paper size, orientation, margin, zoom, and header/footer options. No longer maintained since PhantomJS itself was deprecated years ago; its own README now directs users to migrate to a headless-Chrome/Puppeteer-based alternative instead, several of which appear elsewhere in this directory.
Neural OCR model (Meta/Facebook Research) that parses academic PDF papers into Markdown (.mmd), understanding LaTeX math and tables; supports single or batch PDF processing, page-range selection, and failure-detection heuristics for problematic pages.
PythonAdds a searchable OCR text layer beneath page images and produces a validated PDF/A file: deskews crooked pages, optionally cleans images pre-OCR, optimizes/compresses images, recognizes 100+ languages via Tesseract, rotates misrotated pages, edits output metadata, parallelizes across CPU cores, and processes multi-thousand-page files in place.
Renders a practical subset of XML/XHTML/HTML5 with CSS 2.1+ (incl. CSS3 transforms, gradients, multiple backgrounds) to PDF or images, with SVG and MathML plugin support, accessible/tagged PDF output (Section 508, PDF/UA, WCAG 2.0), PDF/A compliance, font fallback and embedding, RTL/bidi text, footnotes, and file embedding via link download attributes.
PDF creation/manipulation library: creates PDFs from scratch and modifies existing ones (add/remove pages, edit text); HTML-to-PDF conversion (openpdf-html module); text, fonts, graphics, images, and tables; page layout control; encryption and digital signing (via BouncyCastle); text extraction; PDF-to-image rendering (openpdf-renderer); and PDF 2.0 (ISO 32000-2) features including Brotli stream compression.
Zero-runtime-dependency document-parsing gem: parses PDFs, DOCX, XLSX, and images (with OCR), statically linking MuPDF and Tesseract directly into the compiled gem at install time, so no system libraries or external tools need to be separately installed. This trades a heavier, slower install (native compilation of two large C libraries) for zero runtime dependency headaches afterward — no version mismatches with a system-installed MuPDF or Tesseract to worry about.
Go package (rsc.io/pdf) for reading PDF files: opens (optionally password-encrypted) files, reads the page tree, outline/bookmarks, per-page fonts and their metrics, and low-level page content (text runs and drawn rectangles) via a low-level Value/object API. A known unpatched stack-overflow DoS vulnerability is reported against it (GO-2026-5781).
Converts scanned-book PDFs to Markdown or EPUB using OCR (DeepSeek OCR locally, or DeepSeek/Baidu vendor backends), recognizing complex structure including tables and formulas; extracts body text while filtering headers/footers, preserves footnotes/images/assets, auto-generates an EPUB table of contents (optionally LLM-enhanced), and offers configurable table (HTML/image) and formula (MathML/SVG/image) rendering. Runs fully offline as of v1.0.0.
GoSelf-hostable 'knowledge converter' that extracts highlighted text, formulas, and images from PDFs (plus Word/Excel/images, WeChat Reading notes, and mind maps) to generate Anki flashcards, using an LLM (Gemini, GPT-4, Claude, etc.) to identify key concepts automatically; also batch-exports Anki decks back to PDF.
PythonCompares the text layers of two PDFs and outputs the bounding boxes of changed text as JSON, identifying exactly which text regions differ between two versions of a document rather than just reporting that they differ. Then rasterizes the changed pages to a PNG with red outlines drawn around the differences, giving a visual diff alongside the structured JSON output. Useful for reviewing what actually changed between two revisions of a generated or edited PDF.
JavaScriptSet of tools (per its npm registry listing) that convert PDF files to usable formats for data processing: extracting text from searchable PDFs and performing OCR on scanned/image-only PDFs. Note: its GitHub source repository (nisaacson/pdf-extract) now returns 404 — likely deleted or made private; this description is sourced from the published npm package metadata instead.
Model toolbox for extracting content from complex PDFs: layout detection (images/tables/text/titles/formulas), formula detection and LaTeX recognition, OCR with text location, and table recognition to LaTeX/HTML/Markdown. Provides the underlying models that MinerU builds its PDF-to-Markdown application on top of.
JavaScriptNode.js module that converts PDF files into image buffers (PNG) directly in memory, without writing any intermediate file to disk. Built on pdf.js for rendering, so it inherits pdf.js's own rendering fidelity rather than shelling out to a native binary like Ghostscript or poppler-utils. A convenient choice specifically when the calling code needs the resulting image bytes in-process rather than a file on disk.
JavaScriptDependency-free JavaScript library (works in browsers, Node, Deno, React Native) to create PDFs from scratch or modify existing ones: add/insert/remove/copy pages, draw text (with embedded custom fonts), images (PNG/JPEG), vector graphics and SVG paths; create and fill AcroForm fields (text, checkbox, radio, dropdown) and read/flatten them; embed pages from other PDFs, split and merge documents, add file attachments, and read/set document metadata.
Node.js and browser library that merges multiple PDF documents — or selected parts/pages of them — into a single new PDF, running in either environment from the same codebase. Built on pdf-lib rather than a native binding, so it works in browser contexts (including client-side merging with no server round-trip) where native-addon PDF libraries can't run at all.
JavaScriptCross-platform TypeScript/JavaScript module extracting text, embedded images, tables, and document metadata/outline from PDFs, plus rendering pages to PNG screenshots — a broader capability set than most JS PDF-parsing libraries, which typically stop at plain text. A complete rewrite under new maintainership (mehmet-kozan) since the original gitlab.com/autokent/pdf-parse went unmaintained, actively published through late 2025.
Reads semi-structured positional text from PDFs, tracking each text fragment's on-page coordinates so downstream code can assemble structured data from invoices and similar documents where meaning depends on layout position (which column a number sits in, which line a label pairs with). Confirmed archived on GitHub; treat it as a documented approach rather than a maintained dependency.
Rust library to read, manipulate, and write PDF files: stable reading with examples for extracting content/metadata/names/text, plus Pathfinder integration for rendering and a companion `inspect-prim` tool for hierarchically exploring PDF structure. Modification and writing support are still experimental.
PHPConverts PDFs to JPG, JPEG, PNG, or WebP images via ImageMagick and Ghostscript under the hood: render specific pages or all of them, control output quality/DPI/dimensions/background color, read page count and page dimensions, and handle password-protected PDFs. Requires ImageMagick 7 specifically (not the older ImageMagick 6 many systems still ship), since it relies on API changes introduced in that major version.
HaskellHaskell PDF library supporting on-demand/streaming parsing (without loading the whole file into memory) at both high-level (catalog, page tree, pages) and low-level (xref, trailer, objects, incl. xref/object streams) abstraction; extracts text with exact glyph positions; supports incremental-update editing, basic PDF generation, and partial support for encrypted documents.
C++C++ library (also published as PDFHummus/PDFWriter, and the underlying engine behind the HummusJS and Muhammara Node.js bindings) for creating, parsing, and modifying PDFs from the ground up. Handles JPEG/PNG/TIFF image embedding, PDF 2.0-compliant encryption via OpenSSL, and FreeType-based text rendering with real font metrics rather than approximated glyph widths. Designed as a low-level building block other language bindings wrap, rather than an end-user tool on its own.
PerlPerl module for creating and modifying PDFs: page management (add/insert/import pages, page labels); built-in and embedded (TrueType/OpenType/Type1/bitmap) fonts; image import (GIF/JPEG/PNG/PNM/TIFF); barcode generation (Code128, Code39, EAN-13, QR, Codabar, ITF); spot/device colorspaces and custom color palettes; document metadata; outlines/bookmarks; and viewer preferences/page layout modes.
PerlPure-Perl (PDF 1.0–1.3), dependency-free module for creating PDFs: multi-page documents with standard paper sizes and page rotation/crop/bleed/trim boxes; built-in PostScript fonts with Unicode/international character support; lines, GIF/JPEG image embedding, and clickable URI link annotations; hierarchical outline/table of contents; and document metadata.
PDF::Reader-based analysis library built primarily to support Prawn's own test suite — verifying that Prawn actually produced the PDF content it was supposed to — but usable on any PDF for the same kind of low-level inspection. Extracts text as an array of per-operation string fragments (closer to the PDF's raw content stream than a clean text dump) and counts document pages, aimed at test assertions rather than end-user text extraction.
RubyLow-level Ruby library for programmatic PDF access (not a renderer): document version, metadata/info, and page count; per-page text and font extraction; raw page content access; direct PDF object access via ObjectHash; custom receiver objects to walk page rendering programs; UTF-8 text normalization; and Ascii85 stream decoding.
Perl module for building PDFs by reusing existing pages as templates/backgrounds: adds positioned/rotated text, embeds JPEG images, hyperlinks, and raw PDF operators; supports built-in and embedded TrueType (UTF-8) fonts, hierarchical bookmarks, attached/embedded JavaScript actions, form field value assignment, and content stream compression.
PerlPerl module that generates PDFs from XML templates (an HTML::Template-style approach) using PDFlib as the rendering backend, with precise element positioning, parameter substitution with hierarchical scoping, automatic page breaks accounting for headers/footers, and one header/footer per page definition.
Perl port of the Ruby PDFKit library: converts HTML strings, URLs, or files to PDF using wkhtmltopdf's WebKit rendering engine as the actual conversion backend, with external stylesheet injection and PDF options (page size, margins, orientation) settable via constructor args, global config, or HTML meta tags embedded directly in the source document. Requires wkhtmltopdf itself installed as a system binary, since this module is a Perl API layer over it rather than a native PDF renderer.
Community-driven, web-standards-based PDF engine maintained by Mozilla and built into Firefox as its native PDF viewer. Renders pages to canvas for in-browser viewing and exposes a document API (incl. `getTextContent()`) for reading page content programmatically. Ships as both an embeddable viewer UI and the underlying `pdfjs-dist` library, usable standalone in Node for headless processing without a browser.
Simple async Node.js PDF text reader built directly on Mozilla's PDF.js, extracting text content along with each item's x/y position on the page rather than just a flat text dump. Useful when downstream code needs to know where text sits on the page — for reconstructing tables or matching extracted text back to its visual location — without dealing with pdf.js's own lower-level rendering API directly.
PythonConverts PDF files to DOCX (Word) format, preserving formatting and layout — fonts, positioning, images — rather than dumping plain text into a Word document, and extracts tables as genuine Word tables rather than flattened text. Offers both a CLI and a GUI, covering scripted batch conversion and one-off interactive use. A common need for taking a PDF that needs further editing back into an editable Word document.
C++Converts PDF to HTML while preserving text/layout fidelity (native positioned text with original fonts), producing a single self-contained file or a paged on-demand-loading version; carries over hyperlinks, outlines/bookmarks, SVG backgrounds, Type 3 and CJK fonts, and print support. Built on Poppler and FontForge; this pdf2htmlEX/pdf2htmlEX fork continues the original coolwanglu/pdf2htmlEX as an open community effort.
PythonWraps Poppler's `pdftoppm`/`pdftocairo` to convert PDFs (whole documents or page ranges) into PIL Image objects: PPM/JPEG/PNG output, multi-threaded batch conversion, grayscale mode, custom sizing, and password-protected PDF support.
Node.js library/CLI (built on Mozilla's pdf.js engine) that converts PDFs to JSON: extracts text (with position, rotation, styling, color, and font metadata), page layout, and interactive AcroForm field data (text inputs, checkboxes, radio buttons, dropdowns, signature fields); also outputs plain-text files, and runs as a REST service or stream-based parser.
Node.js utility for converting PDF pages to image formats, with output written directly to a file, returned as base64, or handed back as an in-memory buffer depending on what the caller needs. Built on GraphicsMagick/ImageMagick via Ghostscript for the actual PDF rasterization rather than a pure-JS rendering path, meaning both need to be installed as system dependencies alongside the Node package.
JavaScriptDisplays and inspects individual text boxes within PDF documents by converting them to pdf2xml format (via poppler-utils) and rendering the boxes with D3.js in a browser — useful for examining OCR-processed 'sandwich' PDFs before extraction. Companion tool to pdftabextract, for viewing the row/column grids it detects.
Android port of Apache PDFBox for reading and manipulating PDF documents on-device, without needing a server round-trip for PDF processing. Handles the same core PDFBox operations — text extraction, content editing, image handling — adapted to run within Android's runtime constraints, with optional JPX/JPEG2000 image support via the separate JP2Android library. Used where an Android app needs real PDF manipulation capability, not just viewing.
Go PDF processor (CLI + library) supporting PDF up to 2.0 (ISO 32000-2): validate, optimize, split, trim, and merge PDFs; encrypt/decrypt; resize, rotate, and crop pages; extract/manipulate images, fonts, and metadata; manage attachments and portfolios; validate, report, and remove digital signatures; add/remove stamps and watermarks; process forms, bookmarks, and annotations; and generate booklets, N-up/N-down layouts, grids, and posters.
Django-friendly wrapper around ReportLab for generating PDFs: report and letter templates (including a confidential-report variant with security markings), headings/paragraphs/lists/tables/rules/spacers/page breaks, a predefined style system, SVG drawing (via svglib), watermarks/confidentiality markers, mini-HTML markup, and direct ReportLab canvas access.
PDF editing library, GUI application, and command-line tools for viewing and directly editing the internal structure of PDF documents — raw objects, streams, and cross-reference tables — rather than just visual page content. Particularly useful for inspecting and repairing malformed or non-standard PDFs that better-behaved editors refuse to open. A Flatpak build is available for running it on modern Linux distributions despite the project itself being unmaintained since 2020.
Tool and library for extracting distinct text areas from PDFs, particularly scholarly article PDFs — isolating body text, references, and headers from the rest of the document rather than treating the page as one undifferentiated text blob. Built by CrossRef specifically for processing academic paper metadata and citation extraction at scale, reflecting its research/citation-indexing origin rather than general-purpose PDF text extraction.
Extracts figures, tables, captions, figure names/numbers, section titles, and in-figure text from scholarly (computer science) PDFs, with page location and bounding boxes; renders extracted figures as raster (PNG/JPEG) or vector (SVG/PS/EPS, via pdftocairo) images; supports multi-threaded batch processing and includes debugging visualization tools.
Swift/iOS library that generates PDFs from UIViews (including full scrollable content of UIScrollView/UITableView/UICollectionView/UIWebView), UIImages, image file paths/binary data, CGImages, or blank pages; supports multi-page output to Data or disk, custom DPI (72/300), and password protection with separate user/owner passwords.
WinForms control wrapping Google's PDFium rendering engine (the same engine behind Chrome's built-in PDF viewer), for embedding PDF viewing directly inside .NET desktop applications. Split into three cooperating pieces: `PdfDocument` for loading and querying page/document data, `PdfRenderer` for rendering pages with zoom and scroll support, and `PdfViewer` for a ready-made toolbar UI covering printing and saving. No longer maintained.
PDF generation library targeting both server- and client-side JavaScript from a single codebase, for building PDFs programmatically with drawing primitives (text, shapes, images) rather than converting from another format. Not to be confused with Mozilla's PDF.js, a PDF rendering/viewing engine with an unrelated codebase that just happens to share this project's name — a common source of confusion when searching for either one.
JavaScriptPDF generation library (Node and browser) with an HTML5-canvas-like vector graphics API (paths, SVG path parsing, gradients, transformations), text with line-wrapping and bulleted lists, embedded/subsetted TrueType/OpenType/WOFF/WOFF2 fonts, JPEG/PNG image embedding, tables, annotations (links, notes, highlights), AcroForms, document outlines, encryption with granular permission controls, and Tagged-PDF/PDF-UA accessibility support.
RubyRuby gem that generates PDFs from HTML+CSS via wkhtmltopdf (WebKit rendering): converts HTML strings, URLs, or files; attaches stylesheets; passes cookies; configures default/global wkhtmltopdf options; and provides Rack/Rails middleware for `.pdf`-suffixed routes with forced-download support.
Subclass of Apache PDFBox's own `PDFTextStripper` specifically built to preserve a PDF's original layout and spatial positioning when converting it to plain text — where PDFBox's default stripper reflows text into reading order and loses column/table alignment, this one keeps whitespace positioned to match the source layout. Makes it noticeably easier to extract structured data such as tables and form content from the resulting plain text, at the cost of extra leading whitespace in the output.
Declarative, pure-JavaScript (client/server) PDF generation library: text with line-wrapping/alignment, numbered/bulleted lists, page breaks and sections, tables (auto/fixed/star column widths, spanning, repeating headers, multi-column snaking layouts), images and vector graphics, static/dynamic headers and footers, background layers, custom page size/orientation/margins, embedded fonts, table of contents, and PDF metadata.
PythonTranslates scientific PDF documents while preserving layout, formulas, charts, tables of contents, and annotations; supports Google Translate, DeepL, Ollama, OpenAI, and other translation backends via CLI, GUI, Docker, or a Zotero plugin, with batch/directory translation and partial-document translation.
PythonOriginal PDFMiner: text extraction with location, font, and size data, layout analysis for reconstructing reading order from a page's raw content stream, format conversion to HTML/XML, table-of-contents/outline extraction, RC4/AES decryption, and multi-font/CJK text support. Python 2-only and unmaintained since its author moved on; fully superseded by the community-maintained Pdfminer.six fork, which carries the same core engine forward with Python 3 support and active development.
Pure-Python PDF-1.7 parser/extraction library: text, images, HTML, or hOCR output with exact text location/font/color data; AcroForm and tagged-content extraction; outline/TOC extraction; embedded image extraction (JPG, PNG, TIFF, JBIG2, bitmaps); CJK and vertical-writing support; Type1/TrueType/Type3/CID fonts; RC4/AES decryption; and decoding of ASCIIHex/ASCII85/LZW/Flate/RunLength/CCITTFax compression filters.
Lightweight JavaScript utility for dynamically embedding PDFs in web pages via an iframe, with automatic detection of inline-PDF browser support, graceful fallback content for unsupported browsers/mobile, base64 PDF handling, and support for Adobe PDF Open Parameters (e.g. linking to a specific page).
RustPDF toolkit built around a Rust engine, exposed as native bindings for ~20 languages (Python, JavaScript/TypeScript, Go, C#/.NET, Java, and more), a CLI, and an MCP server for AI-assistant integration: text/character-level and image extraction, form-field reading and filling, Markdown/HTML conversion with heading detection, PDF creation and editing, watermarking, merging/splitting, regex-based search, and metadata access.
PDF watermark-removal library/CLI targeting academic-publisher watermarks (institution names, personal identifiers, IP addresses, timestamps) for AIP, IEEE, JSTOR, RSC, and SPIE papers; also removes arbitrary user-specified strings from page content and/or XMP/DocInfo metadata, with in-place overwrite support.
PHPParses PDF objects and headers to extract text (page by page) and metadata (author, description, and similar fields), with support for compressed PDFs, Mac OS Roman charset encoding, and hex/octal-encoded text — all implemented in pure PHP with no external binary dependency. Does not support secured/encrypted documents or form data extraction, a real limitation worth knowing before reaching for it on PDFs that might be password-protected.
C#C# port of Apache PDFBox for reading and extracting content from PDFs: text, individual words and letters (with position and font data), images, annotations, hyperlinks, embedded files, and bookmarks, plus layout/reading-order analysis for reconstructing a page's visual structure. Also supports basic PDF creation, merging multiple files, read-only inspection of AcroForm fields, and opening password-protected documents. A pure-.NET alternative to shelling out to a native PDF binary.
PythonExtracts text (with layout preservation, tolerance settings, regex search, and word bounding boxes), detects and extracts tables (via ruling-line or text-alignment strategies), and provides low-level access to characters, lines, rectangles, curves, images, annotations, hyperlinks, and form fields, with page cropping/filtering, password-protected PDF support, and visual debugging (page-to-image rendering with overlay annotations, incl. Jupyter display). Does not generate, modify, or OCR PDFs.
Python library (built on pdfminer, lxml, and pyquery) for scraping PDF data using jQuery-like or XPath selectors: select elements by bounding-box location or text content, bulk-extract multiple fields at once, target specific page ranges, batch-process multiple PDFs, and cache parsed results for speed.
Node.js library that reads text from PDFs and parses tabular data using automatic column detection combined with rule-based parsing rather than a fixed grid layout. Aimed specifically at extracting structured data (tables, forms) from PDFs programmatically, rather than general-purpose text dumping — the rule-based parser lets callers define matching patterns for specific document layouts they expect to process repeatedly.
PythonReads and writes PDFs: subset/merge/rotate pages, modify metadata, build reusable Form XObjects, N-up and booklet layouts, watermarking (overlay/underlay), image and Form-XObject extraction, poster-sized output, and splitting 2-up PDFs; integrates with ReportLab (embedding existing PDF content into newly generated documents) and rst2pdf. No encryption/decryption support, and limited compression-filter support (external tools like pdftk needed for full decompression).
PDFsharp creates and processes PDFs on the fly using GDI+-style drawing routines (text, images, shapes) shared across screen, PDF, and metafile output — draw once, render to any of the three. MigraDoc layers a higher-level document object model on top (paragraphs, tables, charts, sections, styles) with automatic pagination, bookmarks, tables of contents, and indexes, rendering that same document model to either PDF or RTF. The two projects ship together and are commonly used as a pair.
C#.NET Standard port of PDFsharp that strips out the original's Windows-only GDI+ dependency, substituting SixLabors.ImageSharp for image handling and SixLabors.Fonts for typography. Brought PDF creation and manipulation to Linux/macOS and other non-Windows .NET Core targets that the original PDFsharp couldn't reach at the time it was forked, while keeping PDFsharp's own drawing-routine-based API largely intact for easy migration between the two.
PythonToolkit for extracting tabular data from OCR'd ('sandwich') PDFs already converted to pdf2xml format: splits scanned double pages, detects lines via image processing, corrects page skew/rotation, clusters lines/text into table columns and rows, and exports to pandas DataFrames (CSV, Excel, etc.). Not an OCR tool itself — requires pre-OCR'd input from Tesseract/ABBYY; the authors recommend trying `pdftotext` first.
R bindings for extracting content from PDFs: `pdf_text()` for per-page text, `pdf_info()` for metadata (author, creation date, tags), `pdf_toc()` for table of contents/section headers, `pdf_fonts()` for font info, embedded-attachment access, and `pdf_render_page()` to rasterize pages to bitmap (e.g. PNG/WEBP). Does not handle table extraction (recommends the `tabulizer`/`tabulapdf` package) or OCR of scanned text (recommends the `tesseract` package).
JavaAndroid widget that displays PDF documents — from app assets, SD card, or remote URLs — inside Activities or Fragments, with built-in pinch-zoom and panning gestures baked into the widget itself. Requires Android API 21+, since it's built directly on the platform's own `PdfRenderer` class rather than bundling a separate rendering engine like PDFium or pdf.js. A lightweight choice specifically because it leans on what Android already ships rather than adding a rendering dependency.
Generates PDFs two ways from the same package: DOCX templating (variable substitution like `${FOO}`, block cloning, table row duplication, then converted to PDF) for template-driven document generation, or direct HTML-to-PDF conversion via PhantomJS for cases where a DOCX template isn't the right fit. The DOCX-templating path is the more distinctive of the two, letting non-developers design the template layout directly in Word.
Writes and reads OOXML (Word 2007+), ODF (ODT), RTF, HTML, and PDF documents: sections with headers/footers/page numbering, styled text runs and paragraphs, tables, images (local/remote/watermark), drawing shapes, charts (pie/bar/line/area/scatter/radar), OLE objects, TOCs, footnotes/endnotes, form fields, lists, template-based generation, and XSL transforms.
PythonPythonic wrapper around qpdf for reading, writing, and manipulating PDFs: merge, split, rotate, rearrange, and delete pages; read/write XMP and DocumentInfo metadata (auto-synced); losslessly extract or replace embedded images (preserving original JPEG compression); open password-protected files and save with RC4, AES-128, or AES-256 encryption (or remove it); linearize for 'fast web view'; direct object-level/content-stream access; automatic repair on open; access to qpdf's Job API; and Jupyter notebook preview rendering.
C++C++17 library for reading, writing, and modifying PDFs: full-featured low-level Unicode text extraction (with CJK support), text drawing with automatic CID encoding and font subsetting, incremental-update saving, PAdES-B digital signing (RSA/ECDSA, async), and PDF/A and PDF/UA compliance preservation when adding annotations or form fields. Does not yet render PDF content, and text shaping/kerning is limited.
PDF rendering library and command-line suite — a fork of Xpdf that's become the de facto standard PDF engine underlying much of the open-source PDF ecosystem, powering tools like Evince, Okular, and countless downstream wrappers. Ships pdftotext, pdfimages, pdftoppm, pdftocairo, pdftohtml, pdftops, pdfinfo, pdffonts, pdfdetach, pdfattach, pdfseparate, pdfunite, and pdfsig, covering text/image extraction, page rendering, format conversion, metadata, attachments, and signature verification.
Pure-Ruby PDF generation library: vector drawing (lines, polygons, curves, ellipses); flowing text with inline formatting, builtin/embedded TrueType fonts, UTF-8, RTL, and fallback fonts; PNG/JPG image embedding; a basic grid layout system; encryption and password protection; repeatable headers/footers/page numbers; PDF outlines; and low-level PDF object access for extensions. Explicitly not an HTML-to-PDF generator, though it offers limited inline styling.
PerlPart of the Prima Perl graphics toolkit (a cross-platform GUI toolkit predating most modern alternatives): provides a PDF output interface to `Prima::Drawable`, letting any code already using Prima's drawing API render the same drawing calls directly to PDF instead of a screen widget. Ships alongside sibling modules for PostScript and Type1 font output, so the same drawing code can target multiple output formats without rewriting it per format.
RubyRails wrapper around the PrinceXML PDF generator: renders PDF templates via a `:pdf` render option, registers PDF as a respond_to MIME type, provides a `make_and_send_pdf` helper, and supports custom layouts/stylesheets/locals, asset path rewriting, inline/attachment disposition, JS and PDF-form flags, and configurable timeouts.
PythonPipeline library for extracting information from unstructured documents with low memory/CPU overhead: PDF table extraction, image analysis with OCR, document question-answering via LLM integration, vector index creation, and support for most common document formats.
Python port of the PHP FPDF library for generating PDFs: Unicode (UTF-8) TrueType font subset embedding, I2of5/Code39 barcodes (QR planned), PNG/GIF/JPG images (incl. transparency/alpha), and templates with a visual designer plus basic HTML-to-PDF.
Python bindings for MuPDF covering text extraction (plain, rich dictionary with font/size/color/bbox, HTML/XML, raw blocks, table-to-Markdown); embedded image extraction and high-DPI page rendering to Pixmaps; Tesseract-based OCR (100+ languages); reading/writing annotations (highlights, notes, stamps, ink) and redactions (with permanent apply); AcroForm reading and filling; page insert/delete/reorder, merge/split, and metadata editing; PDF creation and Markdown-to-PDF conversion; password protection/RC4/AES encryption; hyperlink and cross-reference handling; and outline/bookmark read-write.
PythonMarkdown-conversion layer built on PyMuPDF: converts PDF pages to Markdown while preserving headings, tables (ruled-line or text-position-based detection), and images, specifically tuned for feeding PDF content to LLMs as clean, structured Markdown rather than raw extracted text. A sibling package to base PyMuPDF rather than a separate engine — it reuses PyMuPDF's own C-level parsing and adds the Markdown-shaping layer on top.
Pure-Python PDF library: split, merge, crop, and transform pages; add passwords/encryption and decrypt (with optional AES support); read and add metadata; extract text; read and create annotations; and attach custom data/viewer settings. Companion CLI tool `pdfly` offers additional command-line operations.
PythonOriginal pure-Python PDF manipulation library: reading, merging, cropping, and rotating pages, encryption/decryption, and text extraction — the ancestor codebase that both PyPDF2 and, eventually, today's pypdf were built from. The project's own page states it is 'no longer updated,' with its last release dating to December 2012; kept here for historical completeness rather than as something to newly adopt.
Python ctypes bindings to Google's PDFium: renders pages to images, extracts text, reads metadata/bookmarks/page properties, creates new PDFs and inserts images/pages, and searches for text — with both convenience helper classes and raw PDFium API access.
PythonPython wrapper around wkhtmltopdf: converts HTML from URLs, files, or strings (single or multiple at once) to PDF, with configurable wkhtmltopdf options, TOC generation, cover pages, external CSS, and HTML meta-tag-based settings.
Low-level, content-preserving PDF structure tool: linearizes PDFs for fast web view, encrypts and decrypts, splits and merges files, inspects and edits PDF object structure directly, and repairs damaged files without altering actual page content. Explicitly does not render pages or extract text — its own documentation is clear this is a structural transformation tool, not a content-reading one, and points elsewhere (e.g. the `pdftools` R package) for extraction needs.
R bindings for the qpdf C++ library, exposing content-preserving PDF transformations from R: splitting, combining/merging, and compressing PDF files (e.g. `pdf_compress()`). Does not read PDF content itself — the maintainers point to the 'pdftools' R package for text/data extraction.
C#Fluent-API PDF generation library for .NET: page layout, headers/footers, tables, columns, sections, watermarks, text/fonts/colors/backgrounds/borders, images, SVG, alignment/padding/scaling/rotation/layering, loops/conditionals/reusable components for data-driven documents, merging, encryption, metadata, page extraction, and PDF/A, PDF/UA, and EN 16931 (e-invoicing) compliance.
JavaScriptDisplays existing PDFs in React apps (built on PDF.js): renders pages via `<Document>`/`<Page>` with canvas, custom, or no rendering; shows outline/table of contents and thumbnails; selectable text and annotation/link layers; form rendering; page rotation and zoom; password-protected PDF handling; JPEG2000 and non-Latin (cMap) support. (Complementary to @react-pdf/renderer, which creates PDFs rather than displaying them.)
JavaScriptCreates PDF files using React components (`Document`, `Page`, `Text`, `View`) with a StyleSheet/flexbox styling API; renders in-browser via `<PDFViewer>` or saves to file/buffer in Node. (Complementary to wojtekmaj/react-pdf, which displays existing PDFs rather than creating them.)
JavaScriptLibrary for creating PDF documents directly from React components in the browser, capturing a rendered component's DOM output and converting it to PDF client-side rather than requiring a server-side rendering step. A convenient choice for 'export this part of my React UI as a PDF' use cases (invoices, certificates, reports rendered as normal React components) without setting up a separate PDF-generation backend.
PythonOpen-source Python library for programmatic PDF generation: precise low-level canvas drawing (text, vector graphics, images) plus a higher-level Platypus layout engine (flowables, paragraphs, tables, automatic pagination) for building complex reports and documents; widely used as the rendering engine underneath other PDF tools (e.g. the included PDFDocument wrapper).
RubyGhostscript-based document API that generates documents programmatically and converts between PDF, PS, GIF, TIF, PNG, and JPG, wrapping Ghostscript's own command-line interface behind a Ruby-friendly API rather than reimplementing format conversion. Supports EPS templates for merging generated content with pre-designed layouts, plus optimizations for handling large documents without loading everything into memory at once.
Pure-Python, batch-mode document processor that renders reStructuredText or CommonMark to PDF (and can run as a Sphinx builder in place of LaTeX): page layout with columns, running headers/footers, floats and footnotes; auto-generated TOC and index; auto-numbered/cross-referenced headings, figures, and tables; OpenType/TrueType/Type1 fonts with kerning/ligatures/small-caps (incl. 1000+ bundled Google Fonts); embedded PDF/PNG/JPEG images with preserved transparency/color profiles; and optional math typesetting.
RubyRuby-GNOME project's binding of poppler-glib, exposing Poppler's PDF rendering and parsing capabilities — text/image extraction, page rendering, metadata — to Ruby through GObject Introspection bindings rather than a Ruby-native reimplementation. Requires the system poppler-glib library installed separately, since this package is purely the Ruby-side binding over it. Gets Poppler's actual rendering fidelity, at the cost of that native dependency.
JavaScriptOCR and text-extraction library for images and PDFs: extracts existing text from text-native PDFs, runs OCR on image-native PDFs/scans, and can insert a text layer into an existing PDF to make it searchable. Usable from the browser, Node.js, or its own CLI; a hosted GUI is available separately at scribeocr.com.
PHPPHP wrapper around wkhtmltopdf/wkhtmltoimage that generates PDFs or image snapshots/thumbnails from URLs or HTML, merges multiple URLs into a single PDF, supports XSL-based tables of contents, and passes through wkhtmltox options (page size, margins, cookies, JS); includes Symfony, Laravel, and Zend Framework integrations.
ScalaScala wrapper around wkhtmltopdf that generates PDFs from HTML/CSS/JS: accepts input as files, streams, URLs, Scala XML elements, or raw strings; writes to files or output streams; supports wkhtmltopdf's extended parameters (orientation, page size, margins); referenced images/stylesheets; async conversion via Scala `Future`; and a `WrappedPdf` mode for headless environments (e.g. via xvfb-run).
Extends the Prawn PDF library with a `chart()` method for drawing bar, line, and other graph types directly into PDF documents from hash-based data, without needing a separate charting library or image-generation step. Built specifically as a Prawn plugin rather than a standalone charting tool, so it only makes sense in a project already using Prawn for its PDF generation.
Plugin for PDFKit that inserts SVG graphics directly into PDF documents generated with PDFKit, translating SVG path/shape elements into PDFKit's own drawing calls rather than rasterizing the SVG to an image first. Preserves the SVG as genuine vector content in the output PDF (scalable, crisp at any zoom level) instead of an embedded bitmap, at the cost of only supporting the subset of SVG features PDFKit's drawing API can represent.
JavaScript-only SVG-to-PDF conversion utility that runs in the browser, built on top of jsPDF for the actual PDF output. Parses and renders SVG path/shape elements as genuine vector PDF content rather than rasterizing to an image, so the result stays crisp at any zoom level. Being pure JavaScript with no native dependencies, it works entirely client-side with no server round-trip needed for the conversion.
JavaTable-extraction library (powers the Tabula tool) that pulls tabular data out of PDFs using lattice mode (ruled cell borders) or stream mode (no borders), exporting to CSV, TSV, or JSON; usable as a CLI for batch processing or as a Java API, with support for selective pages, custom extraction areas, and password-protected files.
R bindings to the Tabula Java library (an R clone of the Tabula CLI) that computationally extracts tables from PDF documents via `extract_tables()`, returning results as R tibbles/data frames. Requires a Java runtime (rJava, OpenJDK 11 recommended).
PHPUTF-8/RTL text with TrueType/OpenType/Type1/CID-0 font support and subsetting; HTML/CSS and SVG rendering with multi-column layouts, headers/footers, bookmarks, and TOC; JPEG/PNG/SVG images (plus GIF/BMP/TIFF/etc. via GD); RC4/AES-256 encryption; PAdES/PKCS#7 digital signatures with RFC 3161 TSA timestamps and LTV; PDF/A, PDF/X, and PDF/UA compliance modes; page import/reordering; AcroForm fields; and companion-package barcode support.
PHPPure-PHP PDF and barcode generation library requiring no external extensions, covering text and vector graphics, digital signatures, form fields, password and public-key encryption, and HTML/CSS rendering for converting simple markup directly into PDF layout. One of the most widely deployed PHP PDF libraries historically, bundled by default with several major PHP CMS and e-commerce platforms rather than needing separate installation.
Node.js module (CLI + API) that extracts text from HTML, PDF, DOC/DOCX, ODT, RTF, XLS/XLSX/XLSB/XLSM, CSV, ODS, PPTX/ODP, XML, Markdown, EPUB, and image formats (PNG/JPG/GIF via Tesseract OCR); wraps external tools (pdftotext, antiword, tesseract, unrtf) and supports password-protected PDFs and configurable OCR language.
Ruby wrapper providing a simple, unified API over several external CLI tools (rather than reimplementing extraction itself) to pull text from PDF and Word documents, delegating the actual parsing to whichever underlying tool is installed and available. A thin convenience layer for Ruby code that just wants one consistent method call rather than shelling out to different tools per document type.
Comprehensive Go PDF toolkit for reading, writing, and processing PDFs: text/image/table extraction, merging/splitting/rotating/rearranging pages, form creation and filling, encryption/decryption, digital signing, watermarking, and image-to-PDF conversion.
Go PDF library (pure Go): generates reports/invoices with styled text and tables; creates and fills forms; merges, splits, reorders, and rotates pages (incl. N-up layouts); extracts text (with position/formatting), images, and tabular data to CSV; adds/converts images to PDF; removes or adds password protection; validates and applies digital signatures; compresses/optimizes files; adds watermarks; and supports CCITTFax/JBIG2 image decoding.
JavaScriptOpen-source, IIIF-based media viewer for sharing books, manuscripts, newspapers, film, audio, and 3D objects on the web — used widely by libraries, archives, and museums as their public-facing digitized-collection viewer. Renders images, PDFs, audio, video, and 3D files through a single embeddable npm package driven by the IIIF (International Image Interoperability Framework) presentation API, rather than format-specific custom viewers for each media type.
PythonOpen-source ETL library that converts complex documents (including PDFs) into clean, structured data for LLM ingestion: PDF text extraction, OCR on scanned pages (via tesseract-ocr/poppler-utils), document layout detection, and partitioning into logical elements via a single `partition()` auto-detection function.
JavaIndustry-backed, open-source validation library and CLI for checking PDF files against the PDF/A and PDF/UA standards, developed by a consortium including the PDF Association and major archives/libraries specifically to be the reference validator for these standards. Produces a detailed machine-readable validation report identifying exactly which conformance rules a file violates, rather than a simple pass/fail result. Widely used in digital-preservation workflows where formal PDF/A compliance is a hard requirement.
JavaScriptVue 2 component for displaying PDFs from URLs, file paths, or binary data: page navigation, 90°-increment rotation, password-protected PDF handling, per-page or range printing, load-progress tracking, text extraction/selection, clickable internal links, and rendering multiple page instances at once.
Python library that renders HTML and CSS to PDF using a custom Python-built CSS layout/pagination engine (not WebKit/Gecko), targeting print-oriented CSS/HTML standards for generating reports, invoices, tickets, and similar structured documents.
RubyRails plugin that uses wkhtmltopdf to render standard HTML views (or raw HTML/URLs/files) as PDF, avoiding a specialized PDF DSL: `format.pdf` controller responses, saving/emailing PDFs, CSS styling and JS execution, custom headers/footers, Rack middleware for `.pdf`-suffixed URLs, and an HTML debug-preview mode.
C++Headless command-line tool (and C library) that renders HTML into image files using the Qt WebKit rendering engine, without requiring a display server or window manager — useful for automated screenshot/thumbnail pipelines running on a server. Can capture live URLs or local HTML files, applying the same CSS/JavaScript rendering a real browser would. Shares its rendering engine and codebase with the companion wkhtmltopdf; both are archived and unmaintained, since Qt WebKit itself was deprecated in favor of Chromium-based headless rendering.
Headless command-line tool (and C library) that renders HTML into PDF using the Qt WebKit rendering engine, without requiring a display server or window manager — long the default choice for server-side 'print this webpage to PDF' pipelines before headless Chrome existed. Can capture live URLs or local HTML files, applying the same CSS/JavaScript rendering a real browser would. Archived and unmaintained since Qt WebKit was deprecated; numerous language wrappers throughout this directory still drive it as a subprocess.
Merges DOCX/ODT template documents (authored normally in MS Word or OpenOffice/LibreOffice, with placeholder fields marked up directly in the document) with a Java data model to generate populated reports, then converts the result to PDF, XHTML, or back to the original office format. Ships an iText-based PDF converter alongside its own DOCX/ODT-native converters, so template authors can design reports visually rather than programmatically laying out PDF content.
PythonPure-Python HTML-to-PDF converter built on ReportLab, html5lib, and pypdf, supporting HTML5 and CSS 2.1 (with partial CSS3) without any external browser or native rendering engine dependency. Offers a choice of cairo or the legacy RenderPM graphics backend for bitmap/vector output. Being pure Python with no headless-browser dependency eases deployment in restricted environments, at the cost of less complete modern-CSS support.
JavaJava reporting library (developed by Haulmont for the CUBA Platform) that fills templates with data (loaded via SQL, Groovy, or other sources) and generates reports in Office formats (doc/docx/xls/xlsx), HTML, FreeMarker, CSV, or custom text — headless, with no built-in UI, for embedding into host applications.
RubyRuby library built on Apache Tika that extracts text, metadata (as a hash, e.g. Content-Type), and MIME type from PDFs, Microsoft Office, OpenDocument, Apple iWork, and RTF files; accepts local paths, remote URLs, streams, or raw binary data as input.
OCR/document-ingestion library (Node/TypeScript and Python implementations) that converts PDFs, Word/Excel/PowerPoint files, and images to page images, then sends each to a vision-language model (OpenAI, Azure OpenAI, AWS Bedrock, Google Gemini, or Vertex AI) to produce Markdown, preserving tables/charts; supports structured JSON-schema extraction, page selection, concurrent processing, and orientation/edge correction.