Enterprise PDF for Python · C# · Go · PHP · Ruby · Node · Delphi · Swift

The enterprise PDF library
the rest of your stack doesn't have.

Generate archival PDF/A, sign documents with PAdES, encrypt with AES-256, and produce accessible PDF/UA, natively in the language you already use. It runs entirely on your servers, so there are no per-document SaaS fees, no data leaving your network, and no AGPL strings.

Validated by independent tools you can run yourself: veraPDFpdfsigopenssl cmsqpdfmutool → verify it yourself

Generate documents at the speed of your API

A memory-safe Rust core with no garbage collector and a lock-free, Send object model. No GC pauses, no spikes, predictable latency, and throughput that scales with every core you add.

10,000 full PDFs generated in ~3 seconds
2.4 ms to build a real, text-heavy page
~22 MB RAM generating thousands in parallel

Near-linear scaling across cores

documents / second · one independent document per task
1 core 413
2 cores 758
4 cores 1,411
8 cores 2,601
14 cores 3,415 · 8.3×

* Each document is a one-page report (header, title and 35 lines of shaped, subsetted Unicode text), benchmarked on an Apple M3 Max. Numbers are reproducible: cargo run --release -p pdf --example stress.

"Serious" PDF support is scarce and uneven

Almost every language can emit a simple PDF. Almost none have a modern, complete library for what regulated businesses actually need: legal archival (PDF/A), juridically-valid signatures (PAdES), AES-256 for LGPD/GDPR, and accessibility (PDF/UA).

So teams settle for old incomplete libs, fragile HTML→PDF via headless Chrome, or expensive per-document SaaS that ships your sensitive data off-site. Building it right takes years of ISO 32000 + validator work.

  • Runs on your servers: your documents never leave your network, and nothing phones home.
  • Auditable output: the same input always produces the same file, so you can diff and verify it.
  • Dependable: a memory-safe core that won't crash the service generating your documents.
  • Predictable pricing: a per-application annual license, never a meter that bills you per document.
  • No legal landmines: none of the AGPL or per-server licensing of iText / Aspose.

Free to build with. Licensed when you ship.

Prototype and generate everyday PDFs for free, forever. When you need the regulated-grade features (archival, signatures, encryption, accessibility), one license unlocks them all, in every language you use.

Community free

  • Pages & vector graphics
  • Embedded/subset fonts, Unicode shaping
  • Justified paragraphs & tables
  • Images (JPEG/PNG/alpha/16-bit)
  • Hyperlinks, bookmarks & watermarks
  • Form fill & flatten
  • Merge / split / rotate, text & image extraction

Corporate licensed

  • PDF/A: 1b / 2b / 2a / 3b / 3a / 4 / 4e / 4f, plus convert existing PDFs to basic profiles (1b/2b/3b)
  • Digital signatures: PKCS#7, visible & multiple
  • PAdES: B-B / B-LT / B-LTA + RFC 3161 timestamps
  • Signature validation: verify any signed PDF
  • ZUGFeRD / Factur-X: electronic invoices
  • Redaction: truly remove page content
  • Encryption: RC4 / AES-128 / AES-256 (R6)
  • Page rendering: render a page to a PNG image
  • Accessibility: Tagged PDF / PDF/UA-1
  • AcroForm: fields with generated appearances

One engine. Eight languages. Identical behavior.

The same engine powers every binding, so you get identical results in any language. Every feature behaves the same everywhere, with no per-language quirks to debug in production.

Author a tagged PDF/A in a few lines

# pip install rustpdf
import rustpdf

with rustpdf.Document() as doc:
    doc.pdfa(rustpdf.PdfaLevel.A2A).set_info(title="Report")
    f = doc.add_font_file("Roboto-Regular.ttf")
    doc.add_page()
    doc.show_text(f, 20, 72, 760, "Title", heading_level=1)
    data = doc.to_bytes()

with rustpdf.EditableDoc.load(data) as ed:
    ed.encrypt(owner="owner", method=rustpdf.Encryption.AES256)
    ed.save("secured.pdf")
// npm install rustpdf
const { Document, Encryption } = require("rustpdf");

const doc = new Document();
doc.pdfa();                       // PDF/A-2b
const f = doc.addFontFile("Roboto-Regular.ttf");
doc.addPage();
doc.showText(f, 20, 72, 760, "Invoice #1024");
const bytes = doc.toBytes();      // archival-grade PDF
// dotnet add package RustPdf
using RustPdf;

using var doc = new Document();
doc.Pdfa(PdfaLevel.A2a).Tagged().SetInfo(title: "Report");
int f = doc.AddFontFile("Roboto-Regular.ttf");
doc.AddPage();
doc.ShowText(f, 20, 72, 760, "Title", headingLevel: 1);
byte[] bytes = doc.ToBytes();      // archival-grade PDF
// go get github.com/rustpdf/rustpdf-go@latest
doc, _ := rustpdf.New()
defer doc.Close()
doc.PdfaLevel(rustpdf.A2a)
doc.Tagged()
doc.SetInfo(rustpdf.Info{Title: "Report"})
f, _ := doc.AddFontFile("Roboto-Regular.ttf")
doc.AddPage()
doc.ShowText(f, 20, 72, 760, "Title", 1) // heading level 1 = H1
data, _ := doc.ToBytes()
// composer require rust-pdf/rustpdf
use RustPdf\Document;
use RustPdf\PdfaLevel;

$doc = new Document();
$doc->pdfa(PdfaLevel::A2a)->setInfo(title: 'Report');
$f = $doc->addFontFile('Roboto-Regular.ttf');
$doc->addPage()->showText($f, 20, 72, 760, 'Title', 1);
$bytes = $doc->toBytes();          // archival-grade PDF
# gem install rustpdf
doc = RustPdf::Document.new
doc.pdfa(RustPdf::Pdfa::A2A).info(title: "Report")
f = doc.add_font_file("Roboto-Regular.ttf")
doc.add_page
   .show_text(f, 20, 72, 760, "Title", heading_level: 1)
data = doc.to_bytes               # archival-grade PDF
// add RustPdf.pas to your unit search path (rustpdf.dev/docs/delphi)
Doc := TPdfDocument.Create;
try
  Doc.Pdfa(palA2A).Tagged.SetInfo('Report', '', '', '', '');
  F := Doc.AddFontFile('Roboto-Regular.ttf');
  Doc.AddPage.ShowText(F, 20, 72, 760, 'Title', 1);   // heading level 1 = H1
  Bytes := Doc.ToBytes;            // archival-grade PDF
finally
  Doc.Free;
end;
// SwiftPM: download the rustpdf-swift package from rustpdf.dev/docs/swift
import RustPdf

let doc = try Document()
try doc.pdfa(.a2a).tagged().setInfo(DocumentInfo(title: "Report"))
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 20, x: 72, y: 760, "Title", headingLevel: 1)
let bytes = try doc.toBytes()      // archival-grade PDF, links on macOS & iOS
# No rebuild. One environment variable activates every binding:
export RUSTPDF_LICENSE="010f0000…"   # the token we email you

# …or point at a file:
export RUSTPDF_LICENSE_FILE=/etc/rustpdf/license.txt

# …or activate in code:
#   pdf::activate_license(token)?            // Rust
#   rustpdf.activate_license(token)          # Python

Don't take our word for it. Run the validators.

Generate a document, then check it with the same independent tools we gate every release on. No account, no upload: it all runs on your machine, against the bytes rust-pdf produced.

# 1 · author an archival, accessible, signed PDF (Rust example shown)
cargo run --release -p pdf --example report -- out.pdf

# 2 · PDF/A + PDF/UA conformance, reference validator
verapdf --flavour 2a out.pdf          PASS, isCompliant=true

# 3 · signature + RFC 3161 timestamp
pdfsig signed.pdf                     Signature is Valid
openssl cms -verify -inform DER ...   CMS Verification successful

# 4 · structure
qpdf --check out.pdf && mutool info out.pdf

Each release is gated on these passing for PDF/A 1b–3a and A-4, PDF/UA-1 and PAdES B-B/B-LT/B-LTA. More in the validation FAQ or your language's reference docs.

Pick the plan you need.

Per-application annual pricing, in every language, with no per-document metering, no per-server fees and no usage caps. Run one application on as many servers as you like. Start with Pro for archival and encryption; move to Enterprise when you need juridically-valid signatures and accessibility. What counts as an application?

Pro

$1,500/year

Per application · renews yearly · offline · all eight languages

  • ✓ PDF/A (1b / 2b / 2a / 3b / 3a / 4 / 4e / 4f) + convert existing PDFs (basic 1b/2b/3b)
  • ✓ ZUGFeRD / Factur-X electronic invoices
  • ✓ Encryption (RC4 / AES-128 / AES-256)
  • ✓ Page rendering (PDF page to PNG image)
  • ✓ AcroForm fields with appearances
  • ✓ All language bindings, no rebuild to activate
  • ✓ Token emailed instantly after checkout

OEM & Site

Custom

Unlimited applications org-wide, or redistribute rust-pdf inside your own product

  • Everything in Enterprise
  • Site license: unlimited applications across your organization
  • OEM: redistribution rights in the product you ship
  • ✓ Volume licensing, purchase orders & invoicing
  • ✓ SLA, onboarding & security-review support
Talk to sales

Secure checkout by Stripe · cancel anytime · activates offline in seconds. Questions? Talk to sales.

FAQ

How does activation work?

After checkout we email you a license key. Set one environment variable (RUSTPDF_LICENSE) or call activate_license() once. No rebuild, and it works the same in every language.

Is anything sent off my servers?

No. Activation is fully offline, so nothing about your documents or your usage ever leaves your servers. There are no network calls of any kind. Ideal for government, banking and healthcare.

What can the free tier do?

Pages, vector graphics, Unicode text with embedded/subset fonts, paragraphs, tables, images, hyperlinks, bookmarks, watermarks, form fill & flatten, merge/split, text & image extraction and optimization. Forever free, no license.

What's the difference between Pro and Enterprise?

Pro unlocks PDF/A archival (including converting existing PDFs to basic profiles 1b/2b/3b), ZUGFeRD / Factur-X e-invoices, encryption (RC4 / AES-128 / AES-256), and page rendering (rasterizing a PDF page to a PNG image). Enterprise adds everything you need for juridical and public-sector work: digital signatures and PAdES (B-B / B-LT / B-LTA), RFC 3161 timestamps with LTV, signature validation, true redaction, and PDF/UA accessibility, plus priority support. Embedding rust-pdf inside a product you ship? That's the OEM plan: talk to sales.

What counts as an application?

An application is one product or system you build and operate, defined by what it does for your business, not by how it's deployed. A few specifics:

  • Microservices count as one. All the services and workers that make up a single product are one application.
  • Scaling is free. Run it on as many servers, containers or replicas as you like, with no per-server fees.
  • Non-production doesn't count. Development, staging, test and CI environments are free; only production counts.
  • A multi-tenant SaaS is one application, no matter how many of your customers use it.
  • Separate products are separate applications. A billing system and an HR portal are two, or cover both with one Site license.

Need unlimited applications across your organization? That's a Site license: talk to sales.

Do you license per server or per developer?

Neither. You license per application, per year, so scaling out across more servers, containers or developers never costs more. There's no per-document metering and no per-server fees, and none of the AGPL strings of iText or Aspose. Need unlimited applications across your whole organization? That's a Site license: talk to sales.

How is this validated?

Output is checked by independent tools: veraPDF (PDF/A 1b–3a and A-4 + PDF/UA-1), pdfsig and openssl cms (signatures), and qpdf/mutool (structure). It isn't "conformance marketing".

What happens when the license expires?

The corporate features stop producing output and return a clear license error; basic generation keeps working. Renew to receive a fresh token.