DEV Community: Hichem Bed

Generate a PDF from Any URL in Node.js (Without Puppeteer)

Hichem Bed — Fri, 10 Apr 2026 15:00:55 +0000

Generate a PDF from Any URL in Node.js (Without Puppeteer)

There's a common pattern in web apps: user clicks "Export to PDF", and you need to turn a URL — a report page, an invoice, a dashboard — into a downloadable PDF file.

The go-to solution for years has been Puppeteer: launch a headless Chrome, navigate to the URL, call page.pdf(). It works. But it's a 150MB+ dependency, it needs a Chrome binary, and it fails silently in serverless environments.

Here's a lighter approach.

The Problem with Puppeteer in Production

// This is what most tutorials show you
const puppeteer = require('puppeteer');
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://example.com/report/123');
const pdf = await page.pdf({ format: 'A4' });
await browser.close();

This works locally. But in production:

Lambda/Vercel functions time out trying to spin up Chrome
Docker images balloon in size
Memory usage spikes on concurrent requests
You need to manage the browser lifecycle yourself

A Simpler Way: API-Based PDF Generation

Instead of running a browser yourself, you can call an API that handles the headless rendering and returns a PDF buffer.

const fetch = require('node-fetch');

async function urlToPdf(url) {
  const response = await fetch('https://api.renderpdfs.com/v1/pdf/url', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_API_KEY',
    },
    body: JSON.stringify({ url }),
  });

  if (!response.ok) {
    throw new Error(`PDF generation failed: ${response.statusText}`);
  }

  return response.buffer();
}

That's it. No browser binary. No memory management. No 150MB dependency.

Full Example: Express Endpoint

const express = require('express');
const fetch = require('node-fetch');

const app = express();

app.get('/export-pdf', async (req, res) => {
  const { url } = req.query;

  if (!url) {
    return res.status(400).json({ error: 'url param required' });
  }

  try {
    const response = await fetch('https://api.renderpdfs.com/v1/pdf/url', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${process.env.RENDERPDFS_API_KEY}`,
      },
      body: JSON.stringify({ url }),
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.statusText}`);
    }

    const pdfBuffer = await response.buffer();

    res.setHeader('Content-Type', 'application/pdf');
    res.setHeader('Content-Disposition', 'attachment; filename="export.pdf"');
    res.send(pdfBuffer);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000);

Call it with:

GET /export-pdf?url=https://yourapp.com/invoices/123

Passing Auth to the Target URL

If the URL you want to convert is behind authentication, you have two options:

Option 1: Use a pre-signed or token-based URL

// Generate a short-lived signed URL for the report
const signedUrl = generateSignedUrl('/invoices/123', { expiresIn: '5m' });

const pdf = await urlToPdf(signedUrl);

Option 2: Render HTML server-side and send it directly

// Render your template to HTML string
const html = await renderInvoiceHtml(invoiceId);

// Send the HTML directly instead of a URL
const response = await fetch('https://api.renderpdfs.com/v1/pdf', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${process.env.RENDERPDFS_API_KEY}`,
  },
  body: JSON.stringify({ html }),
});

Comparison

	Puppeteer	API Approach
Setup	Chrome binary + config	npm install + API key
Cold start	2–8s	~200ms
Memory	200–500MB	Minimal
Serverless	Painful	Works out of the box
Maintenance	Browser updates, crashes	Zero

When to Use Each

Use Puppeteer if:

You need full browser control (screenshots, interactions)
You're already running a persistent server with enough memory
You need to handle complex auth flows in the browser

Use the API approach if:

You're on serverless (Lambda, Vercel, Render)
You need PDF export as a feature, not a core product
You want to ship fast and not maintain infrastructure

The API is free to start (100 PDFs/month) at renderpdfs.com. No credit card needed.

How to Merge PDFs in Node.js (Without a 300-Line Library Setup)

Hichem Bed — Fri, 10 Apr 2026 14:58:21 +0000

How to Merge PDFs in Node.js (Without a 300-Line Library Setup)

PDF merging in Node.js has a few popular approaches, and they all converge on the same frustrating place: pdf-lib, hummus, or calling out to a Python script wrapping PyPDF2.

These work. But they're not lightweight. pdf-lib is capable, but merging PDFs with complex features — embedded fonts, form fields, digital signatures — can produce broken output. And when it breaks, the error messages are not helpful.

The Setup

npm install renderpdfs

Merging Two PDFs

import RenderPDFs from 'renderpdfs';

const client = new RenderPDFs('rpdf_your_key');

const merged = await client.merge([
  'https://example.com/files/contract.pdf',
  'https://example.com/files/appendix.pdf',
]);

import { writeFileSync } from 'fs';
writeFileSync('combined.pdf', merged);

The input is an array of PDF URLs. The output is a single merged PDF Buffer.

Real Use Case: Bundling a Contract with Its Attachments

app.post('/contracts/:id/bundle', authenticate, async (req, res) => {
  const contract = await db.contracts.findById(req.params.id);
  const attachments = await db.attachments.findByContractId(contract.id);

  const pdfUrls = [contract.pdfUrl, ...attachments.map(a => a.pdfUrl)];

  if (pdfUrls.length < 2) {
    return res.status(400).json({ error: 'Nothing to merge' });
  }

  const merged = await client.merge(pdfUrls);

  res.setHeader('Content-Type', 'application/pdf');
  res.setHeader('Content-Disposition', `attachment; filename="contract-${contract.id}-bundle.pdf"`);
  res.send(merged);
});

Generate + Merge in One Flow

// Step 1: Generate a cover page
const { url: coverUrl } = await client.generate({
  html: `<html><body style="font-family:sans-serif;padding:60px;text-align:center;">
    <h1 style="margin-top:200px;">${title}</h1>
    <p style="color:#555;">${subtitle}</p>
  </body></html>`,
  store: true,
});

// Step 2: Merge cover + body
const packet = await client.merge([coverUrl, existingDocumentUrl]);
res.setHeader('Content-Type', 'application/pdf');
res.send(packet);

Error Handling

try {
  const merged = await client.merge(urls);
} catch (err) {
  if (err.status === 422) {
    return res.status(400).json({ error: 'One or more PDF sources are invalid' });
  }
  throw err;
}

Getting Started

npm install renderpdfs

100 PDFs/month free at renderpdfs.com. API docs at renderpdfs.com/docs.

Markdown to PDF in Node.js: The API Approach

Hichem Bed — Mon, 06 Apr 2026 13:19:37 +0000

Here's the usual Markdown-to-PDF pipeline developers end up building:

Parse Markdown to HTML with marked or remark
Wrap it in a full HTML document with inline styles
Launch Puppeteer, navigate to the HTML, call page.pdf()
Handle Puppeteer teardown so it doesn't leak memory
Debug why code blocks don't have syntax highlighting
Repeat for every new document type

It works. But it's a lot of moving parts to maintain.

The Simpler Path

npm install renderpdfs

import RenderPDFs from 'renderpdfs';

const client = new RenderPDFs('rpdf_your_key');

const pdf = await client.generate({
  markdown: '# My Report\n\nHello **world**.',
});

That's a Buffer containing your PDF. No intermediate HTML, no browser.

Real Use Case: Exporting User-Written Content as PDF

app.post('/export/pdf', authenticate, async (req, res) => {
  const { markdown, filename = 'export' } = req.body;

  if (!markdown || typeof markdown !== 'string') {
    return res.status(400).json({ error: 'markdown field required' });
  }

  const pdf = await client.generate({ markdown });

  res.setHeader('Content-Type', 'application/pdf');
  res.setHeader('Content-Disposition', `attachment; filename="${filename}.pdf"`);
  res.send(pdf);
});

Generating a Report from a Template

function buildReportMarkdown({ title, author, date, sections }) {
  const sectionText = sections
    .map(({ heading, content }) => `## ${heading}\n\n${content}`)
    .join('\n\n');

  return `# ${title}\n\n**Author:** ${author}\n**Date:** ${date}\n\n---\n\n${sectionText}`;
}

const markdown = buildReportMarkdown({
  title: 'Q1 Performance Report',
  author: 'Analytics Team',
  date: '2026-04-01',
  sections: [
    { heading: 'Revenue', content: 'Revenue increased **24%** quarter-over-quarter.' },
    { heading: 'User Growth', content: 'Monthly active users reached **12,400**.' },
  ],
});

const pdf = await client.generate({ markdown });

Store and Get a Shareable URL

const { url } = await client.generate({ markdown, store: true });
return res.json({ downloadUrl: url });

What Markdown Features Are Supported?

Headings, paragraphs, bold, italic, strikethrough
Ordered and unordered lists, nested lists
Fenced code blocks with language tags
Tables, blockquotes, horizontal rules
Inline HTML

Getting Started

npm install renderpdfs

Free plan at renderpdfs.com: 100 PDFs/month, no credit card. Full API docs at renderpdfs.com/docs.

HTML to PDF in Node.js Without the Puppeteer Pain

Hichem Bed — Mon, 06 Apr 2026 13:14:16 +0000

If you've ever had to generate a PDF from HTML in Node.js, you know the story.

You reach for Puppeteer. The docs look reasonable. Then, three hours later, you're debugging a segfault in a Docker container because Chromium refuses to run without --no-sandbox, your CSS isn't rendering the same as it does in the browser, and your server's memory has ballooned to 800MB handling a single request.

This is not a Puppeteer bash post. Puppeteer is a solid project. The problem is that running a full browser in production is genuinely hard — and for most apps that need to generate PDFs, it's the wrong tool for the job.

Here's a better approach.

The Setup: One Package, One API Key

npm install renderpdfs

import RenderPDFs from 'renderpdfs';
const client = new RenderPDFs('rpdf_your_key');

Basic HTML to PDF

const pdf = await client.generate({
  html: '<h1>Hello, world</h1><p>This is a PDF.</p>',
});

import { writeFileSync } from 'fs';
writeFileSync('output.pdf', pdf);

That's it. No browser launch, no page lifecycle, no teardown.

A Real-World Example: Invoice PDF from a Template String

import express from 'express';
import RenderPDFs from 'renderpdfs';

const app = express();
const client = new RenderPDFs(process.env.RENDERPDF_API_KEY);

app.post('/invoices/:id/pdf', async (req, res) => {
  const invoice = await db.invoices.findById(req.params.id);

  const html = `
    <!DOCTYPE html>
    <html>
      <head>
        <style>
          body { font-family: sans-serif; padding: 40px; color: #111; }
          h1 { font-size: 24px; margin-bottom: 4px; }
          .meta { color: #555; font-size: 14px; margin-bottom: 32px; }
          table { width: 100%; border-collapse: collapse; }
          th { text-align: left; border-bottom: 1px solid #ddd; padding: 8px 0; }
          td { padding: 8px 0; border-bottom: 1px solid #f0f0f0; }
          .total { font-weight: bold; font-size: 16px; margin-top: 24px; text-align: right; }
        </style>
      </head>
      <body>
        <h1>Invoice #${invoice.number}</h1>
        <div class="meta">Issued: ${invoice.date} · Due: ${invoice.dueDate}</div>
        <table>
          <thead><tr><th>Item</th><th>Qty</th><th>Price</th></tr></thead>
          <tbody>
            ${invoice.items.map(item => `
              <tr>
                <td>${item.name}</td>
                <td>${item.qty}</td>
                <td>$${item.price}</td>
              </tr>
            `).join('')}
          </tbody>
        </table>
        <div class="total">Total: $${invoice.total}</div>
      </body>
    </html>
  `;

  const pdf = await client.generate({ html });
  res.setHeader('Content-Type', 'application/pdf');
  res.setHeader('Content-Disposition', `attachment; filename="invoice-${invoice.number}.pdf"`);
  res.send(pdf);
});

Want to Store the PDF and Get a URL Back?

const { url } = await client.generate({ html, store: true });

await db.invoices.update(invoice.id, { pdfUrl: url });
await emailService.send({
  to: customer.email,
  subject: `Invoice #${invoice.number}`,
  body: `Download your invoice: ${url}`,
});

Why Not Just Keep Using Puppeteer?

Memory: each Chromium instance is ~150–250MB
Cold starts: on serverless (Vercel, Lambda), launching a browser is slow and often fails
Docker complexity: you need the right Debian deps, flags, and user permissions
Maintenance: keeping Puppeteer and Chromium versions in sync is its own ongoing task

An API approach offloads all of that. Your server stays lean. The PDF renders consistently.

Getting Started

npm install renderpdfs

Free plan at renderpdfs.com: 100 PDFs/month, no credit card. Full API docs at renderpdfs.com/docs.

Auto-Generate PDF Invoices in Your SaaS App with One API Call

Hichem Bed — Sun, 29 Mar 2026 22:20:44 +0000

Every SaaS app eventually needs to send invoices. And every time, developers reach for a PDF library — pdfkit, puppeteer, jsPDF — and spend days wiring it up.

There's a better way. Here's how to auto-generate a pixel-perfect PDF invoice from a Stripe webhook in under 20 lines of code.

The Problem with PDF Libraries

If you've ever used pdfkit or puppeteer directly in production, you know the pain:

You bundle a headless browser or a heavy library into your app
You write 200+ lines of layout code for a simple invoice
It breaks on every Node.js version upgrade
You deal with font rendering, page breaks, and margins manually

For a SaaS app, this is a distraction from your core product.

The Setup: Stripe Webhook + RenderPDFs

Here's the full flow:

Customer pays → Stripe fires invoice.payment_succeeded
Your webhook handler builds an HTML invoice template
You call RenderPDFs API → get back a PDF URL
You email the PDF link to your customer

Let's build it.

Step 1: The Invoice HTML Template

Design your invoice in plain HTML and CSS — no special PDF syntax needed:

function buildInvoiceHTML(invoice) {
  return `
    <html>
    <head>
      <style>
        body { font-family: Arial, sans-serif; padding: 40px; color: #333; }
        .header { display: flex; justify-content: space-between; margin-bottom: 40px; }
        .company { font-size: 24px; font-weight: bold; color: #6d28d9; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th { background: #f3f4f6; padding: 12px; text-align: left; }
        td { padding: 12px; border-bottom: 1px solid #e5e7eb; }
        .total { font-size: 18px; font-weight: bold; text-align: right; margin-top: 20px; }
      </style>
    </head>
    <body>
      <div class="header">
        <div class="company">Acme SaaS</div>
        <div>Invoice #${invoice.number}<br>${new Date(invoice.created * 1000).toLocaleDateString()}</div>
      </div>
      <p>Bill to: <strong>${invoice.customer_email}</strong></p>
      <table>
        <tr><th>Description</th><th>Amount</th></tr>
        ${invoice.lines.data.map(line => `
          <tr><td>${line.description}</td><td>$${(line.amount / 100).toFixed(2)}</td></tr>
        `).join("")}
      </table>
      <div class="total">Total: $${(invoice.amount_paid / 100).toFixed(2)}</div>
    </body>
    </html>
  `;
}

Step 2: Call RenderPDFs from Your Stripe Webhook

import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

export async function POST(req) {
  const sig = req.headers["stripe-signature"];
  const event = stripe.webhooks.constructEvent(
    await req.text(),
    sig,
    process.env.STRIPE_WEBHOOK_SECRET
  );

  if (event.type === "invoice.payment_succeeded") {
    const invoice = event.data.object;

    // Build HTML invoice
    const html = buildInvoiceHTML(invoice);

    // Generate PDF with RenderPDFs
    const response = await fetch("https://api.renderpdfs.com/v1/pdf/html", {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.RENDERPDFS_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        html,
        options: { format: "A4", printBackground: true },
      }),
    });

    const { url } = await response.json();

    // Email the PDF link to your customer
    await sendEmail({
      to: invoice.customer_email,
      subject: `Your invoice #${invoice.number}`,
      body: `Your invoice is ready: ${url}`,
    });
  }

  return new Response("ok");
}

That's it. No library to maintain. No Puppeteer in your bundle. No PDF layout headaches.

Why This Works Better

Approach	Bundle size	Setup time	Maintenance
pdfkit	+15MB	2–3 days	High
Puppeteer in-app	+300MB	3–5 days	Very high
RenderPDFs API	0MB	30 min	None

The PDF URL returned has a 24-hour expiry — perfect for emailing customers without storing files yourself.

Get Started

Sign up at renderpdfs.com — free tier included
Grab your API key from the dashboard
Add RENDERPDFS_API_KEY to your environment variables
Copy the webhook code above and adapt your HTML template

First PDF in under 60 seconds. No credit card required.

Have questions about the implementation? Drop them in the comments — happy to help! 🚀

I Built a PDF Generation API — Here's the Tech Stack and What I Learned

Hichem Bed — Sun, 29 Mar 2026 13:10:25 +0000

I recently shipped RenderPDFs — a simple API that converts HTML or URLs to PDFs.
Here's the full breakdown: stack, architecture decisions, and the painful lessons along the way.

The Stack

Fastify — blazing fast Node.js framework, perfect for API services
Puppeteer — headless Chrome for pixel-perfect PDF rendering
PostgreSQL — API keys, users, usage tracking
Cloudflare R2 — PDF file storage with presigned URLs (S3-compatible, cheaper than AWS)
Next.js 15 — frontend dashboard and docs
Railway — deployment with zero DevOps headaches

How It Works

The core flow is dead simple:

const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.setContent(html, { waitUntil: "networkidle0" });
const pdf = await page.pdf({ format: "A4", printBackground: true });
await browser.close();

Send HTML, get a PDF. That's it. For URL-to-PDF I added SSRF protection to block requests to internal IPs — important if you're exposing this publicly.

The Auth Flow

Instead of exposing API keys in URLs, I built a login token system:

User signs in with Google OAuth
Server issues a short-lived UUID token (5 min expiry) stored in DB
Token is passed in the redirect URL to the frontend
Frontend exchanges it for the actual API key via a single-use endpoint
Token is deleted immediately after use

This prevents duplicate API keys on every sign-in and keeps credentials out of browser history.

What I Added for Production

Things that seem optional until they're not:

Rate limiting per API key + per IP (@fastify/rate-limit)- Sentry for error monitoring — caught silent failures immediately after deploy
PDF timeout + retry — Puppeteer hangs sometimes, you need a 30s hard timeout
R2 storage — stream PDFs to Cloudflare instead of holding them in memory
Request logs — users need to see their usage history in the dashboard

The Unexpected Differentiator: MCP Server

None of my competitors have an MCP server. MCP (Model Context Protocol) lets AI assistants like Claude call your API directly. I added a remote MCP endpoint so developers can generate PDFs from inside their AI tools without writing a single line of code:

"Generate a PDF invoice from this HTML template"
→ Claude calls RenderPDFs MCP server
→ Returns a download URL

This took a few hours to implement and immediately made the product stand out.

Lessons Learned

Google OAuth in production is painful. Cookie domain mismatches, wrong redirect URIs, Cloudflare proxy blocking Railway domain verification — it took a full day to fix what worked perfectly locally.

Railway + Cloudflare needs DNS-only mode. If you use Cloudflare proxy (orange cloud) on your API subdomain, Railway can't verify your custom domain. Switch to grey (DNS only).

Puppeteer needs babysitting. Set a timeout, add retry logic, and never trust it won't hang on complex pages.

Ship the MCP server early. AI-native integrations are a real differentiator right now — the developer community is actively looking for tools that plug into their AI workflows.

Try It

Free tier available, first PDF in under 60 seconds.

curl -X POST https://api.renderpdfs.com/v1/pdf/html \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Hello World</h1>", "options": {"format": "A4"}}'

Check it out at renderpdfs.com — happy to answer any questions about the stack or architecture in the comments!