Puppeteer alternative for PDF generation

Generate PDFs from Node.js.
Without running Chromium.

Puppeteer is the right tool when you need general browser automation. BladePDF is a focused alternative for server-side PDF generation: your application sends HTML and the managed service operates Chromium.

Start free See the implementation

Official Node.js SDK No browser binary 200 renders free

invoice.ts javascript

import { BladePdf } from '@bladepdf/node';

const bladePdf = new BladePdf({
  apiKey: process.env.BLADEPDF_API_KEY!,
});

await bladePdf
  .fromHtml(html)
  .format('A4')
  .printBackground()
  .renderToFile('invoice.pdf');

HTML

stays yours

Assets

travel per request

Chromium

is managed

A narrower replacement

Replace the PDF browser workload—not Puppeteer itself.

A Puppeteer PDF call is concise, but production owns everything below it: a compatible Chrome binary, Linux libraries, fonts, sandboxing, process cleanup, crash recovery, memory limits, concurrency, and serverless packaging.

BladePDF removes that runtime from your Node.js deployment. It is not a browser testing or scraping library. It is a managed HTML-to-PDF boundary for applications that do not need arbitrary page automation.

Keep your HTML

Render EJS, Handlebars, Pug, Nunjucks, React SSR, or plain HTML inside your application and pass the result to the SDK.

Change the boundary

Your app owns data and templates. BladePDF owns browser installation, isolation, capacity, recovery, and updates.

Use a PDF API

Configure paper, margins, backgrounds, headers, footers, readiness, storage, metadata, and delivery without a general browser surface.

Before and after

The migration is small because your document can stay the same.

Both examples take an existing HTML string and write an A4 PDF. The difference is where Chromium runs and who is responsible for its lifecycle.

Puppeteer — application-owned browser javascript

import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();

try {
  const page = await browser.newPage();
  await page.setContent(html, {
    waitUntil: 'networkidle0',
  });
  await page.pdf({
    path: 'invoice.pdf',
    format: 'A4',
    printBackground: true,
  });
} finally {
  await browser.close();
}

BladePDF — managed browser javascript

import { BladePdf } from '@bladepdf/node';

const apiKey = process.env.BLADEPDF_API_KEY;
if (!apiKey) throw new Error('Missing API key');

const bladePdf = new BladePdf({ apiKey });

await bladePdf
  .fromHtml(html)
  .format('A4')
  .printBackground()
  .renderToFile('invoice.pdf');

Implementation note. @bladepdf/node is server-only and requires Node.js 22 or later. Keep the API key in server-side environment configuration. If you need page clicks, selectors, request interception, scraping, screenshots, or browser tests, keep Puppeteer for those workflows.

Two deliberate choices

Direct browser automation or a managed PDF boundary?

Both use Chromium-quality rendering. Choose according to the control you need and the infrastructure you want to own.

Self-hosted or self-integrated

Choose Puppeteer for browser control

Puppeteer exposes a general browser automation API and is a strong choice when PDF generation depends on custom navigation or page-level behavior.

◆ Direct access to pages, contexts, selectors, events, network interception, and Chrome DevTools Protocol
◆ Rendering can remain inside your own network and infrastructure
◆ Full control over the browser version, executable, launch arguments, and runtime
◆ The same library can support screenshots, scraping, automation, and testing

Managed

Choose BladePDF for PDF operations

BladePDF is a focused choice when your application has HTML and needs reliable PDF output, but a browser platform is not part of the product you want to operate.

No Chrome binary, Puppeteer dependency, sandbox, or browser pool in the application deployment
Approved local CSS, images, fonts, JavaScript, and SVG files can travel with the render request
Managed browser capacity, isolation, queues, recovery, and upgrades
Buffer, stream, atomic file, stored output, and signed webhook workflows

Managed Node.js rendering

Your application still owns the document.

The SDK changes where Chromium runs. It does not move your template engine, database access, or business rules into BladePDF.

Render HTML in Node.js

Load application data and render EJS, React, Handlebars, Nunjucks, or another server-side template exactly where it lives today.

Build one PDF request

Set page options and let the SDK attach local files from explicitly configured filesystem roots when the document needs them.

Receive the result you need

BladePDF renders in managed Chromium and returns a Buffer, Node.js stream, atomic file result, or stored asynchronous job.

Puppeteer vs BladePDF

Compare the complete production responsibility.

The important difference is not CSS fidelity—both paths use Chromium. It is the surface area your application must deploy, secure, observe, and scale.

Capability	Self-hosted Puppeteer	BladePDF Node SDK
Runtime	Node.js, Puppeteer, compatible Chrome, OS libraries, fonts, and writable runtime directories	Node.js 22+ and the zero-runtime-dependency SDK; Chromium runs in BladePDF
Browser API	General page automation and Chrome DevTools Protocol access	Focused HTML-to-PDF options, readiness controls, assets, storage, and delivery
Concurrency	Build a queue, cap pages, size memory, apply back pressure, and recover browser processes	Use plan concurrency; excess short bursts can wait in the managed render queue
Serverless	Package a compatible Chromium build and account for cold starts, bundle size, memory, and temp space	Deploy the SDK and make an outbound API request; no browser binary in the function
Local assets	Embed them, expose reachable URLs, or make the browser filesystem boundary explicit	Attach referenced files from approved roots and rewrite their document references
Security	Own the sandbox, egress, request interception, debugging endpoints, and untrusted HTML policy	Use a constrained PDF API; BladePDF operates the isolated browser environment
Data boundary	HTML and assets can remain fully inside your infrastructure	HTML and attached assets are processed by the BladePDF service
Cost model	Your compute plus engineering and operations time	Hosted service plan based primarily on rendering capacity

BladePDF is not a drop-in replacement for Puppeteer's complete API. It replaces the setContent() plus page.pdf() workload when a deliberate, managed PDF boundary is a better production architecture.

Choose honestly

The best option depends on what the browser does for you.

BladePDF is a strong fit when

✓ PDFs are required, but direct browser automation is not part of the feature.
✓ Chrome packaging, cold starts, memory, crashes, or pool capacity complicate deployment.
✓ You want typed Node.js delivery methods, managed async jobs, logs, and optional storage.
✓ Your approved local assets should render without creating public URLs.

Keep Puppeteer when

→ You need scraping, testing, screenshots, navigation, selectors, network interception, or arbitrary page scripting.
→ Documents must render without an external network dependency.
→ Policy requires render payloads to remain inside infrastructure you operate.
→ You already have a reliable browser platform and value its low-level control.

BladePDF tradeoffs

! Every render depends on network access to the BladePDF API.
! The service processes document HTML and any attached assets or cloud-template context.
! Plans have concrete concurrency, queue, payload, timeout, storage, and bandwidth limits.
! A focused PDF API cannot expose Puppeteer's full browser automation surface.

Documentation

Continue with the implementation details.

Node.js SDK quickstart

Install @bladepdf/node, configure a server-side API key, and render the first PDF.

SDK configuration

Configure local asset roots, transport timeouts, retries, custom fetch, and dependency injection.

Node.js SDK reference

Explore sources, PDF options, delivery methods, errors, background jobs, and webhook helpers.

Related guides

Choose the path closest to your current stack.

Operating Puppeteer PDF in production?

Read the engineering guide to browser reuse, concurrency, memory, serverless deployment, and security.

Read the guide →

Ready to use the Node.js SDK?

See the complete official SDK surface for HTML, local assets, streams, files, and background renders.

Read the guide →

Need framework examples?

Generate PDFs from Express, Fastify, Next.js, React SSR, EJS, or your existing template engine.

Read the guide →

FAQ

Questions teams ask before choosing the renderer.

Is BladePDF a complete replacement for Puppeteer?

No. BladePDF replaces a focused HTML-to-PDF workflow. Keep Puppeteer for scraping, testing, screenshots, navigation, selectors, request interception, or custom Chrome DevTools Protocol work.

Does BladePDF still use Chromium?

Yes. BladePDF renders with managed Chromium. The difference is that the browser binary, process lifecycle, isolation, capacity, recovery, and updates are outside your application deployment.

Can I keep EJS, Handlebars, Pug, Nunjucks, or React?

Yes. Render the template to HTML inside your Node.js application and pass the resulting string to fromHtml(). BladePDF does not replace your template engine.

Can the Node.js SDK return a stream?

Yes. Use renderStream() for a one-shot Node.js Readable, render() for a Buffer result, renderToFile() for atomic file output, or storePdf().submit() for a background render.

Do local images and fonts need public URLs?

No. Configure explicit documentRoot and searchRoots values and the SDK can attach referenced local files to the request. External URLs remain external and must be reachable by the renderer.

Does this work from AWS Lambda or Vercel Functions?

Yes, when the function can make an outbound HTTPS request and has enough duration for the render. The deployment does not include Chromium, which removes browser packaging and launch-time concerns from the function.

Send HTML. Get a PDF. Stop operating the browser.

Keep your Node.js templates and replace one Puppeteer PDF path with the managed SDK.

Start free Read the documentation


                $ npm install @bladepdf/node