My goal is to create a PDF from HTML in my backend service. What is the best HTML-to-PDF generation API?

If your backend already has HTML + CSS templates and you want a reliable PDF in production, my default recommendation is a Chromium-based API rather than an older HTML-to-PDF library.

My shortlist

🥇 What I'd pick

Browserless is a particularly good fit if your requirement is simply:

POST HTML → receive application/pdf Its PDF endpoint accepts either a URL or raw HTML and exposes browser/Puppeteer-style options such as page format, headers/footers, cookies, waiting, etc.

That gives you the major advantage of Chrome rendering: modern CSS including Flexbox/Grid, web fonts, JavaScript-rendered content, charts, and essentially the same rendering model developers see in a browser.

For example, conceptually your backend becomes:

Your API
   │
   │ POST HTML + PDF options
   ▼
Browserless
   │
   │ Chromium renders HTML
   ▼
application/pdf

When I'd choose DocRaptor instead

If you're generating invoices, contracts, financial reports, books, legal documents, or other documents where pagination is extremely important, I'd seriously consider DocRaptor.

It uses Prince, which is designed specifically for paginated documents and has substantially stronger support for print-oriented CSS features such as sophisticated headers/footers, footnotes, page numbering, and complex page layouts.

The tradeoff is that it's generally a more specialized—and more expensive—solution.

When I'd skip an API entirely

If you have the infrastructure expertise and generate a lot of PDFs, Playwright + a persistent Chromium process is arguably the best long-term architecture.

You avoid per-document API charges and get complete control over:

• Chromium version
• fonts
• networking
• authentication
• caching
• concurrency
• timeouts
• HTML/CSS/JS
• PDF options

The downside is that you now own browser infrastructure—memory management, crashes, concurrency, browser updates, container sizing, etc. That's the operational problem managed APIs are selling you a solution to.

One important thing I'd avoid

I wouldn't start a new project with wkhtmltopdf. It's based on the old Qt WebKit engine and is no longer a good match for modern HTML/CSS. Chromium-based rendering is a much safer choice for a new backend service.

My recommendation:

• Fastest path to production: Browserless or PDFShift
• Best document/pagination quality: DocRaptor
• Best if you want to own the infrastructure: Playwright
• Best self-hosted HTTP microservice: Gotenberg

If you tell me your backend language (Node, Python, Go, .NET, Java, etc.), expected PDFs/month, and whether the HTML contains JavaScript/charts, I can narrow this down to the best choice and show the actual API integration.

POST HTML → receive application/pdf Its PDF endpoint accepts either a URL or raw HTML and exposes browser/Puppeteer-style options such as page format, headers/footers, cookies, waiting, etc.

That gives you the major advantage of Chrome rendering: modern CSS including Flexbox/Grid, web fonts, JavaScript-rendered content, charts, and essentially the same rendering model developers see in a browser.

For example, conceptually your backend becomes:

Your API
   │
   │ POST HTML + PDF options
   ▼
Browserless
   │
   │ Chromium renders HTML
   ▼
application/pdf

When I'd choose DocRaptor instead

If you're generating invoices, contracts, financial reports, books, legal documents, or other documents where pagination is extremely important, I'd seriously consider DocRaptor.

It uses Prince, which is designed specifically for paginated documents and has substantially stronger support for print-oriented CSS features such as sophisticated headers/footers, footnotes, page numbering, and complex page layouts.

The tradeoff is that it's generally a more specialized—and more expensive—solution.

When I'd skip an API entirely

If you have the infrastructure expertise and generate a lot of PDFs, Playwright + a persistent Chromium process is arguably the best long-term architecture.

You avoid per-document API charges and get complete control over:

When choosing the best HTML-to-PDF generation approach for a backend service, the "best" choice depends on whether you want a fully managed cloud API (SaaS) or a self-hosted library/headless browser running on your own infrastructure.

Phase 1: Top Managed Cloud APIs (SaaS)

Best if you don't want to manage headless Chrome instances, memory spikes, scaling infrastructure, or font dependencies on your server.

- **How it works:** Fast, reliable REST API powered by high-performance headless Chrome rendering.
- **Pros:** Extremely easy integration, handles complex CSS3/Flexbox/Grid and JavaScript well, generous developer-friendly free tier.
- **Cons:** Cloud-dependent; pricing scales based on volume.[](https://craftmypdf.com/blog/best-pdf-generation-apis-for-html-to-pdf/) [[1]](https://craftmypdf.com/blog/best-pdf-generation-apis-for-html-to-pdf/)[[2]](https://apryse.com/blog/html-to-pdf-conversion-methods)

- **How it works:** Uses the commercial **Prince XML** engine rather than standard Chromium.
- **Pros:** Unmatched support for advanced print-specific CSS (multi-column layouts, complex running headers/footers, precise page numbering like *Page X of Y* , page breaks, and XML tagging). Generates true, accessible tagged PDFs.
- **Cons:** Significantly more expensive than Chromium-based wrappers.[](https://apryse.com/blog/html-to-pdf-conversion-methods) [[1]](https://apryse.com/blog/html-to-pdf-conversion-methods)

- **How it works:** Mature, highly optimized conversion engine.
- **Pros:** Very low entry-level pricing plans, supports scaling from tiny serverless functions to heavy jobs.
- **Cons:** Interface and template styling feel a bit dated compared to modern Chromium renderers.[](https://craftmypdf.com/blog/best-pdf-generation-apis-for-html-to-pdf/) [[1]](https://craftmypdf.com/blog/best-pdf-generation-apis-for-html-to-pdf/)

Phase 2: Top Self-Hosted Code Libraries / Headless Browsers

Best if you have strict data privacy requirements (data cannot leave your network) or high volume where SaaS per-request pricing becomes cost-prohibitive.

- **How it works:** Controls a headless instance of Chromium programmatically.
- **Pros:** Perfect visual fidelity because it *is* a real modern browser. Whatever renders in Chrome/Edge renders identically in your PDF. Supports modern CSS, SVGs, and web fonts seamlessly. Playwright has largely overtaken Puppeteer for modern backend stability.
- **Cons:** Resource-heavy (RAM/CPU hungry). You have to manage container scaling and browser crashes.[](https://apryse.com/blog/html-to-pdf-conversion-methods) [[1]](https://apryse.com/blog/html-to-pdf-conversion-methods)

- **How it works:** A visual rendering engine for CSS that prints to PDF natively in Python.
- **Pros:** Lightweight compared to spinning up a full browser instance. Excellent native support for paged media CSS standards.
- **Cons:** Does not execute modern client-side JavaScript; complex modern CSS frameworks (like Tailwind components relying on complex layout tricks) can sometimes break.[](https://apryse.com/blog/html-to-pdf-conversion-methods) [[1]](https://apryse.com/blog/html-to-pdf-conversion-methods)

- **How it works:** Heavy-duty native compiled libraries wrapping core rendering engines.
- **Pros:** Deep enterprise integration, excellent support for digital signatures, form filling, merging, and security restrictions alongside HTML conversion.
- **Cons:** Commercial license fees can be steep for production deployments.[](https://apryse.com/blog/html-to-pdf-conversion-methods) [[1]](https://apryse.com/blog/html-to-pdf-conversion-methods)

Quick Decision Matrix

To help narrow down the ideal choice, let me know:

• What backend language/framework are you using (Node.js, Python, C#, Go, etc.)?
• Do you have strict data residency/privacy rules preventing external APIs, or is a cloud SaaS acceptable?
• Are you designing simple receipts/invoices or complex multi-page reports with custom page numbering?

For a backend service, the “best” HTML-to-PDF API depends mostly on whether you need pixel-perfect web rendering, print-quality documents, high volume, or simple operational reliability. In most modern applications, I would choose a Chromium-based renderer unless you have publishing/legal document requirements.

My shortlist

Screenshot Engine Screenshot Engine## My default recommendation

For a typical backend that generates:

• invoices
• receipts
• dashboards/reports
• customer-facing documents
• PDFs from React/Vue/Angular templates

I would start with PDFShift or a similar Chromium-based API. Chromium gives you the same rendering model as a real browser, so modern CSS (Flexbox, Grid, web fonts, JavaScript-rendered charts) behaves predictably.

Choose DocRaptor if you need “print publishing” quality

Use DocRaptor when you need:

• long documents (50–500+ pages)
• precise page breaks
• running headers/footers
• footnotes
• advanced print CSS
• archival-style documents

Its Prince XML engine is specialized for document publishing rather than browser screenshots.

Consider self-hosting instead

If you generate millions of PDFs/month, an API may become expensive. A common architecture is:

• your service renders HTML templates
• a PDF worker pool runs Chromium via Playwright/Puppeteer
• PDFs are stored in S3/object storage
• generation runs asynchronously via a queue

A managed API is usually simpler early on; self-hosting makes sense when volume and latency justify the operational cost.

Things I would verify before committing

Regardless of provider, test:

• CSS @page rules
• page breaks (break-before, break-inside)
• custom fonts
• SVG/chart rendering
• large tables spanning pages
• JavaScript timing (waitUntil: networkidle-style behavior)
• security around loading external URLs (SSRF protection)

Practical ranking

For most backend teams:

1. PDFShift / Chromium API — best general-purpose choice
2. DocRaptor — best document-quality output
3. Gotenberg — best self-hosted option
4. API2PDF — useful if you need engine flexibility
5. Raw Playwright/Puppeteer — best control, most maintenance

If you tell me your stack (Node/.NET/Python/Java/Go), expected PDF volume, and whether your HTML contains JavaScript (React pages, charts, etc.), I can narrow this to a specific recommendation.

Choosing the "best" HTML-to-PDF generation API for your backend depends heavily on your scaling needs, budget, and how complex your CSS layouts (flexbox, grid, custom fonts, or charts) are.

Third-party managed APIs relieve your backend from maintaining heavy headless browsers or PDF layout engines. The top industry choices are categorized below by their strengths:

1. Best for Developer Simplicity & Modern CSS: PDFShift

• Why it's great: It relies on an up-to-date headless Chrome engine, meaning whatever renders in your browser (Flexbox, Grid, Tailwind CSS, SVGs) renders identically in the PDF. It offers a straightforward REST API with fast response times and generous starter tiers.
• Best use case: General-purpose modern web apps, invoices, and reports built with modern CSS frameworks.
• Check out pricing and docs:

2. Best for Enterprise & Advanced Print Styling: DocRaptor

• Why it's great: DocRaptor is unique because it uses the Prince XML rendering engine rather than standard Chromium. Prince is the gold standard for complex print CSS, supporting advanced paged-media features like native running headers/footers, complex multi-column layouts, page numbering ("Page X of Y"), and accessible PDF tagging.
• Best use case: Complex multi-page financial reports, books, legal documents, or strict corporate/governmental formatting requirements.
• Check out pricing and docs: DocRaptor

3. Best for Visual Template Building: PDFMonkey or ApiTemplate.io

• Why it's great: Instead of raw-coding HTML/CSS strings inside your backend, these services provide a visual template builder dashboard. Your backend simply pushes dynamic JSON data to an API endpoint, and they merge it into the visual template.
• Best use case: Teams where non-developers (like product managers or designers) need to tweak the invoice or certificate layout without rewriting backend code.
• Check out options: PDFMonkey or

4. Best Multi-Tool Swiss Army Knife: CloudConvert or PDF.co

• Why it's great: If your backend needs to do more than just HTML-to-PDF (e.g., merge PDFs, convert DOCX to PDF, extract tables, or compress files), a broader file-conversion platform saves you from integrating multiple niche APIs.
• Best use case: Document-heavy workflows requiring varied conversions.
• Explore the platform: CloudConvert

Alternative: Self-Hosted (No API Fee)

If you prefer not to use a paid cloud API, running a headless browser directly inside your backend infrastructure via Playwright (Node.js/Python/Go) is currently the community favorite over older tools like Puppeteer or the deprecated wkhtmltopdf.

To help narrow down the ideal choice, let me know:

• What backend language/framework are you using (Node.js, Python, Ruby, Go, .NET)?
• Roughly how many PDFs do you expect to generate per month?
• Are you designing simple single-page invoices or complex multi-page reports with custom pagination?

Choosing the "best" HTML-to-PDF generation API for your backend service depends on whether you prefer a managed cloud SaaS (zero infrastructure to manage), a self-hosted container (data privacy/cost-scale), or a code-level library.

The top options are categorized below by their strengths:

1. Managed Cloud APIs (Best for Ease & Speed)

• PDFShift (Top Pick for Cost/Performance): Highly reliable, fast, and uses a modern rendering engine. It is widely considered one of the most cost-effective managed options for standard HTML-to-PDF conversion.
• DocRaptor (Best for Complex Print & Enterprise): Powered by the Prince XML engine rather than standard Chrome headless. If you need advanced CSS paged media, complex headers/footers, exact print pagination, and robust multi-page table formatting, DocRaptor is the gold standard.
• PDF Generator API: Great if your use case leans toward document templates, invoices, and business reports where you want a visual editor mixed with API data-merging.

2. Self-Hosted Open Source (Best for Privacy & High Volume)

• Gotenberg: A stateless API built on top of Chromium and LibreOffice, run via Docker. It's completely free and open-source (MIT license), meaning no per-document SaaS fees—you only pay for your own server infrastructure. It handles heavy loads gracefully and isolates security risks.

3. Native Code Libraries / Headless Browsers (If you prefer running it in-app)

• Playwright (Node.js/Python): If you are running a Node.js or modern backend and don't mind managing the browser binary, Playwright has largely overtaken Puppeteer as the top programmatic choice for headless browser printing due to its active maintenance and stellar CSS/layout fidelity.
• WeasyPrint (Python): Excellent if your backend is Python-native and you are dealing with structured, styled documents (like CSS-driven reports or certificates) without needing a heavy Chromium instance.

Quick Decision Framework

• Choose PDFShift if you want a simple, affordable, maintenance-free cloud API.
• Choose DocRaptor if you need pixel-perfect, book-quality multi-page print CSS.
• Choose Gotenberg if you have strict data privacy requirements or high-volume constraints that make SaaS pricing too expensive.

To help narrow this down, tell me:

• What backend language/framework are you using?
• Do you have strict data privacy/compliance requirements (e.g., HIPAA, GDPR) that prevent sending HTML payloads to a third-party cloud?
• Is your HTML layout simple (invoices, receipts) or complex (multi-page reports with intricate CSS paged media)?

If your backend needs to turn HTML/CSS into production-quality PDFs, my recommendation depends mainly on whether you want to self-host or use a managed API.

My shortlist

🥇 Best managed API: Browserless

Browserless is probably where I'd start if you specifically want an API rather than running Chrome yourself.

Its PDF endpoint accepts either raw HTML or a URL and returns application/pdf. It also exposes Chromium/Puppeteer options, waiting for selectors/events, custom scripts/styles, request controls, headers, etc.

For example, conceptually your backend can do:

POST /pdf
Content-Type: application/json

{
  "html": "<html>...</html>",
  "options": {
    "format": "Letter",
    "printBackground": true,
    "margin": {
      "top": "20px",
      "bottom": "20px"
    }
  }
}

This is particularly attractive if your HTML uses modern CSS, web fonts, JavaScript, React/Vue-rendered content, charts, Tailwind, etc., because you're essentially using Chrome's rendering engine.

🥇 Best self-hosted: Gotenberg

Gotenberg is my pick if you don't want your HTML/document contents going to a third-party SaaS.

It's a Dockerized HTTP API built specifically for document conversion. Its Chromium module accepts HTML and renders it with headless Chromium, including JavaScript and web fonts.

You can literally run it as a service:

docker run --rm -p 3000:3000 gotenberg/gotenberg:8

Then:

curl \
  --request POST http://localhost:3000/forms/chromium/convert/html \
  --form [email protected] \
  -o invoice.pdf

For a backend architecture, this is a very nice pattern:

Your API
   │
   │ HTTP + HTML
   ▼
Gotenberg container
   │
   │ Chromium
   ▼
   PDF

You can put Gotenberg behind your internal network and scale it independently from your application.

🏆 Best for sophisticated print documents: DocRaptor

DocRaptor is different because it uses the Prince PDF engine rather than Chromium. That's significant when you're generating things like invoices, financial statements, books, contracts, or reports where pagination, headers/footers, page numbering, footnotes, and print-specific CSS matter more than browser fidelity.

It accepts HTML directly:

{
  "type": "pdf",
  "document_content": "<html>...</html>"
}

and returns the PDF binary.

Its downside is that you're choosing a more specialized/expensive document-rendering engine rather than simply getting "Chrome as an API."

What I'd choose

For a normal web backend generating invoices, reports, receipts, certificates, etc.:

Browserless if you want managed infrastructure; Gotenberg if you want to self-host. I'd use DocRaptor instead if your PDFs have demanding publishing requirements—especially complex pagination, running headers/footers, footnotes, or other print-oriented CSS.

I would not start a new project with wkhtmltopdf. It's based on an old WebKit engine and lacks support for much of modern CSS; current comparisons generally recommend Chromium-based approaches instead.

If you tell me your backend language (Node, Python, Go, Java, .NET, etc.), expected PDFs/minute, and whether you need to self-host, I can recommend the specific architecture and API—including a production-ready implementation.

If your backend already generates the HTML and you want a reliable hosted API that turns that HTML into a PDF, my default recommendation is PDFShift.

My shortlist

1. PDFShift — best general choice

I'd start here if your requirements are things like invoices, receipts, reports, statements, certificates, or customer-generated documents.

It uses Chromium, so your HTML/CSS behaves much more like a modern web page than it would with older engines such as wkhtmltopdf. It accepts HTML/URLs and provides asynchronous processing for larger jobs. Current comparisons also highlight its straightforward API and broad SDK examples.

The architecture is essentially:

Your backend
    │
    │ POST HTML + options
    ▼
PDFShift
    │
    │ PDF bytes / result
    ▼
Your backend → S3 / database / HTTP response

2. DocRaptor — if PDF quality matters more than cost

DocRaptor is the one I'd choose for very sophisticated documents where pagination and typography are important. It uses PrinceXML, which is specifically designed for high-quality paginated documents rather than simply printing a browser page.

It's particularly attractive if you need things like:

• sophisticated @page rules
• running headers/footers
• page counters
• precise pagination
• print-oriented CSS
• long financial/legal reports

The tradeoff is cost and somewhat less "browser-like" rendering.

3. Browserless — if your HTML is really a web application

I'd consider Browserless if your PDF generation requires JavaScript execution, authentication, dynamic charts, React/Vue applications, or other browser automation. It gives you access to a real browser environment rather than just a specialized document converter.

What I would choose

For a typical backend service:

PDFShift → first choice

For highly sophisticated print documents:

DocRaptor → first choice

For maximum infrastructure/control:

Gotenberg + Chromium → self-hosted choice

I would not start a new project with wkhtmltopdf. Its WebKit rendering engine is old and the project is no longer a good fit for modern HTML/CSS.

One important consideration: don't choose based on a simple HTML demo. Test your actual templates—especially fonts, CSS Grid/Flexbox, images, JavaScript, page breaks, headers/footers, and very long documents. That's where the differences between these services become significant.

If you tell me your backend language (Node, Python, Go, Java, .NET, etc.), approximate PDFs/month, and whether the HTML contains JavaScript, I can narrow this down to the best 1–2 options and show the actual API integration.

When choosing the best HTML-to-PDF generation API for a backend service, the "best" option heavily depends on your layout complexity, scaling budget, and whether you prefer a managed cloud API or self-hosting via Docker.

The top options on the market are categorized below by their primary strengths:

• DocRaptor — Best for absolute CSS fidelity and complex layouts. It is powered by the PrinceXML engine rather than standard headless browsers. It excels at multi-page documents, paged media (headers, footers, page numbers), books, and legal documents where formatting cannot break.
• PDFShift — Best for simple, fast, and minimal API-first conversions. It takes raw HTML strings or URLs and converts them via a high-performance headless Chrome infrastructure without requiring heavy configuration.
• Gotenberg — Best open-source, self-hosted option (via Docker). If your backend security/privacy constraints prohibit sending HTML payloads to a third-party SaaS cloud, Gotenberg provides a robust, developer-friendly REST API wrapper around Chromium for local/private infrastructure deployment.
• PDF Generator API — Best for embedding user-facing template editors. If your end-users (like clients or non-technical staff) need to design and tweak their own invoice or receipt templates via a drag-and-drop interface, this is purpose-built for that workflow.
• Playwright / Puppeteer (Self-Managed) — Best if you prefer writing custom Node.js code rather than paying a third-party wrapper API. Running a headless browser directly inside a serverless or containerized backend gives you maximum control, though you take on the maintenance overhead of managing browser crashes and memory spikes.

To help narrow down the ideal choice, let me know:

• Is your backend more suited for a managed cloud SaaS API or a self-hosted Docker container?
• What is your expected monthly volume of PDFs?
• Are you dealing with complex multi-page layouts (like books/reports) or simple single-page documents (like invoices)?

If your backend already produces HTML and you want a reliable production HTML → PDF API, my default recommendation is docraptor.com.

My ranking

Why I'd choose DocRaptor

DocRaptor is particularly strong when the PDF is a document rather than just a screenshot of a webpage. It uses the Prince rendering engine and supports things like:

• CSS page breaks
• Headers/footers
• Page numbers
• Different page sizes/orientations
• Footnotes
• PDF bookmarks
• Accessible PDFs
• Forms
• Font embedding
• Advanced print CSS
• JavaScript when required

It accepts the HTML directly in a REST request and returns the PDF binary, so your backend integration can be very simple.

For example, conceptually your backend does:

POST https://api.docraptor.com/docs
Content-Type: application/json

{
  "type": "pdf",
  "document_content": "<html>...</html>"
}

and receives the PDF bytes back.

When I'd pick PDFShift instead

If your HTML is basically normal web HTML/CSS—invoices, receipts, reports, simple documents—and you don't need advanced print typography, I'd seriously consider PDFShift. Its API is straightforward, supports HTML/URLs, and uses a Chromium-based renderer.

That's potentially a better fit if your priorities are simplicity, modern browser CSS, and cost rather than sophisticated print layout.

One important distinction

If your HTML contains things like:

<div class="invoice">
  ...
</div>

and you're relying heavily on modern CSS/JavaScript, a Chromium-based solution such as PDFShift or self-hosted Playwright/Puppeteer can be attractive.

If you're generating:

• invoices
• contracts
• financial reports
• legal documents
• multi-page reports
• documents with precise headers/footers/page numbering
• print-quality PDFs

I'd favor DocRaptor/Prince. Its rendering engine is designed specifically around paged documents rather than treating the PDF as a screenshot of a scrolling browser page.

Bottom line: DocRaptor if PDF quality and complex pagination matter most. PDFShift if you want a simpler, Chromium-style API. Gotenberg + Chromium if you want to keep everything inside your own infrastructure.

If you tell me your backend language (Node, Python, Go, Ruby, .NET, Java, etc.) and approximate PDFs/month, I can narrow this down to the best choice and show the integration architecture.

Choosing the "best" HTML-to-PDF generation API depends heavily on whether your layout requires complex print-specific typography (like advanced pagination and books) or standard digital documents (like invoices and receipts).

The top options are categorized below by their rendering engine and use case:

• 1. DocRaptor — Best for Print Quality & Complex CSS Paged Media
  • Engine: PrinceXML
  • Pros: The undisputed gold standard for professional publishing, complex multi-page layouts, running headers/footers with dynamic page numbers, and strict PDF/UA accessibility compliance.
  • Cons: Significantly more expensive than Chromium-based competitors.
  • Use case: Official publications, legal documents, academic books, and complex enterprise reports.
• 1. PDFShift — Best Cost-to-Performance for Standard SaaS Docs
  • Engine: Headless Chromium
  • Pros: Incredibly fast, highly reliable, supports modern CSS/JavaScript execution, and offers one of the most budget-friendly pricing structures for high-volume invoice or certificate generation.
  • Cons: Lacks advanced native Paged Media features found in PrinceXML-backed alternatives.
  • Use case: E-commerce invoices, receipts, shipping labels, and routine dashboard exports.
• 1. Api2Pdf — Best for Flexibility & High Concurrency
  • Engine: Multiple choices (Chromium, wkhtmltopdf, or LibreOffice via AWS Lambda)
  • Pros: Scalable pay-as-you-go pricing with no monthly subscription traps. You can choose your preferred rendering backend.
  • Cons: Interface and tooling are more barebones/developer-centric.
  • Use case: High-volume bursts of background PDF generation where you want serverless scalability.
• 1. Pdfcrowd — Best for Simple, Lightweight Integrations
  • Engine: Proprietary / Custom
  • Pros: Extremely easy REST API setup, great documentation, and robust handling of raw URL-to-PDF scraping.
  • Cons: Can struggle with hyper-modern heavy JavaScript framework rendering (like React/Vue single-page apps) compared to a pure headless Chrome instance.
  • Use case: Quick archiving of web pages or simple form-to-PDF pipelines.

Alternative: Self-Hosted Headless Browser

If you prefer not to use a managed third-party SaaS API and have the infrastructure to support it, running Playwright (Node.js) inside your own container is currently the top open-source developer pick. It gives you full control over a headless Chrome instance, matches browser rendering perfectly, and keeps data completely in-house—though you have to manage memory scaling and infrastructure uptime yourself.

To help narrow down the best fit, tell me:

• What kind of document are you generating (e.g., invoices, reports, books)?
• Do you expect a high volume (thousands of PDFs per month) or a low-to-moderate volume?
• Do you prefer a fully managed SaaS API or a self-hosted library?