Enterprise PDF for Python · C# · Go · PHP · Ruby · Node · Java
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.
"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)
- Merge / split / rotate
- Text extraction & optimize
Corporate licensed
- PDF/A: 1b / 2b / 2a / 3b / 3a archival
- Digital signatures: PKCS#7, visible & multiple
- PAdES: B-B / B-LT / B-LTA + RFC 3161 timestamps
- Encryption: RC4 / AES-128 / AES-256 (R6)
- Accessibility: Tagged PDF / PDF/UA-1
- AcroForm: fields with generated appearances
One engine. Seven 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
let mut doc = pdf::Document::new();
doc.pdfa_a(); // PDF/A-2a (archival + accessible)
let font = doc.add_font_file("Roboto-Regular.ttf")?;
doc.add_page()
.text(font, 24.0)
.at(72.0, 740.0)
.show("Olá, açúcar — café"); // shaped, kerned, Unicode
let signer = pdf::Signer::from_pkcs8_der(&key, &cert)?;
let signed = pdf::sign(&doc.to_bytes()?, &signer, &Default::default())?;
// pdfsig → "Signature is Valid. Total document signed."
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")
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
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
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()
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
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
try (Document doc = new Document()) {
doc.pdfa(PdfaLevel.A2A).tagged().setTitle("Report");
int f = doc.addFontFile("Roboto-Regular.ttf");
doc.addPage().showText(f, 20, 72, 760, "Title", 1);
byte[] bytes = doc.toBytes(); // archival-grade PDF
}
# 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
Pick the plan you need.
Per-application annual pricing, in every language, with no per-document metering or usage caps. Start with Pro for archival and encryption; move to Enterprise when you need juridically-valid signatures and accessibility.
Pro
$1,490/year
Per application · renews yearly · offline · all seven languages
- ✓ PDF/A (1b / 2b / 2a / 3b / 3a)
- ✓ Encryption (RC4 / AES-128 / AES-256)
- ✓ AcroForm fields with appearances
- ✓ All language bindings, no rebuild to activate
- ✓ Token emailed instantly after checkout
Enterprise
$3,000/year
Everything in Pro, plus signatures & accessibility · priority support
- ✓ Everything in Pro
- ✓ Digital signatures & PAdES (B-B / B-LT / B-LTA)
- ✓ RFC 3161 timestamps + LTV (DSS)
- ✓ Accessibility (Tagged PDF / PDF/UA-1)
- ✓ Priority email support
OEM
Custom
Redistribute rust-pdf inside your own product · volume & POs
- ✓ Everything in Enterprise
- ✓ Redistribution rights for your product
- ✓ Volume & multi-application licensing
- ✓ Purchase orders & invoicing
- ✓ SLA & onboarding support
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, merge/split, text extraction and optimization. Forever free, no license.
What's the difference between Pro and Enterprise?
Pro unlocks PDF/A archival and encryption (RC4 / AES-128 / AES-256). 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, and PDF/UA accessibility — plus priority support. Embedding rust-pdf inside a product you ship? That's the OEM plan — talk to sales.
How is this validated?
Output is checked by independent tools: veraPDF (PDF/A 1b–3a + 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.