Choose by rendering model first. Use a browser-driven engine such as Puppeteer when your PDF depends on JavaScript, client-rendered charts, dynamic tables, or exact Chrome behavior. Choose a dedicated paged-media engine such as WeasyPrint or Prince when print layout, page breaks, running headers, footnotes, counters, bookmarks, forms, or predictable pagination are the priority. Then validate accessibility, fonts, deployment, security, maintenance, and licensing with your own representative documents.
Start with the output your PDF must produce
HTML-to-PDF tools are not interchangeable “converters.” They implement different rendering models, so the right choice depends on what happens between your HTML and the final pages.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
PDF Explained: The ISO Standard for Document Exchange | $14.41 | Buy on Amazon |
| 2 |
|
Adobe Acrobat 6 PDF For Dummies | $13.00 | Buy on Amazon |
| 3 |
|
Debugging: The 9 Indispensable Rules for Finding Even the Most Elusive Software and Hardware... | $13.39 | Buy on Amazon |
- Browser pipeline: launches Chromium (often through Puppeteer), runs page JavaScript, loads the same browser CSS behavior users see, and prints with the print CSS media type.
- Dedicated paged-media pipeline: parses HTML and CSS with an engine such as WeasyPrint or Prince, emphasizing print controls rather than full browser compatibility.
If a chart appears only after JavaScript executes, begin with a real browser. If your input is server-rendered HTML for invoices, contracts, books, or reports, begin with a paged-media engine and test its pagination features.
Browser engines and paged-media engines compared
| Decision axis | Browser engine (Puppeteer/Chromium) | Dedicated paged-media engine (WeasyPrint or Prince) |
|---|---|---|
| JavaScript | Runs page scripts before capture; suitable for client-rendered content. | Verify support for your workflow; do not assume application JavaScript executes like a browser. |
| Browser fidelity | Closest to what Chrome prints, including browser CSS behavior. | May intentionally differ from browser layout to provide stronger print-specific controls. |
| Long documents | Basic print controls can work for simple reports. | Compare @page, margin boxes, counters, running headers, footnotes, page selectors, and cross-references. |
| Runtime footprint | Usually includes or depends on a browser binary and its runtime resources. | Often lighter as a library or binary, but native dependencies and fonts still need verification. |
| Accessibility and archiving | Validate generated PDFs with your own conformance tools. | WeasyPrint documents PDF/A and PDF/UA generation, but says validity is not guaranteed automatically. |
| Operations | Plan for sandboxing, browser patch cadence, container requirements, startup time, and memory. | Plan for engine licensing, native libraries, font and image dependencies, and server integration. |
When Puppeteer or another browser path is the better fit
JavaScript-generated content
Use a browser when the final DOM is assembled by React, Vue, charts, data grids, or other client code. Your capture flow can wait for a selector, a network-idle condition, or an application-specific “rendered” flag before calling page.pdf(). This avoids exporting the empty shell that a non-browser parser would see.
Recommended Free Tools
#1 Best Overall
Exact Chrome behavior matters
Puppeteer’s PDF operation prints with the print CSS media type. That makes it a practical choice when your acceptance test is “match what Chrome’s print preview produces,” including browser font metrics, flexbox behavior, SVG, and modern CSS interactions.
Trade-offs to budget for
A browser process consumes more memory than a small rendering library and introduces a binary distribution, sandbox, patch cadence, and container-startup concerns. Concurrency limits, browser crashes, blocked network requests, and missing system fonts must be handled as production failures rather than treated as ordinary application exceptions.
When WeasyPrint or Prince is the better fit
Print-first documents
Dedicated engines are designed for reports, invoices, contracts, books, and other documents where page geometry is a product requirement. Evaluate page size, bleed, marks, named pages, margin boxes, running elements, page counters, footnotes, table splitting, and cross-references using your own fixtures.
Predictable pagination and document features
Prince describes a workflow that converts HTML or Markdown and XML, styled with CSS, into documents intended for printing, downloading, and archiving. Its documentation covers JavaScript, common image formats, and server-side integration. WeasyPrint documents hyperlinks, bookmarks, attachments, and forms, as well as CSS paged-media features; it also warns that generated PDF/A or PDF/UA output must be checked against the relevant specifications.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesTrade-offs to budget for
Do not assume a dedicated engine executes your application’s browser JavaScript. Confirm support for the exact CSS and HTML you use, install every required font and native library in production, and review the engine’s license before embedding it in a SaaS or redistribution model.
Build acceptance fixtures before selecting a product
A demo page hides the failures that appear in production. Keep a fixture set under version control and require every candidate to render it.
- A normal article with headings, links, lists, images, and selectable text.
- A long invoice or report with repeated headers, totals, and a table that spans pages.
- Web fonts, SVG, high-resolution raster images, and missing-image fallbacks.
- A JavaScript-rendered chart or data table that appears after the initial HTML response.
- Right-to-left and multilingual text if your users need it.
- A form, tagged-accessibility sample, or archival sample when PDF/UA or PDF/A is required.
- Intentional page-break cases, widows and orphans, footnotes, running headers, and generated bookmarks.
Record page count, rasterized-page differences, extracted text, hyperlinks, bookmarks, metadata, form fields, tagging, and font embedding. Re-run the set whenever you change the engine, browser build, CSS, or installed fonts.
A practical selection sequence
- Classify the source. Mark each template as JavaScript-dependent, server-rendered, or mixed. A hard JavaScript requirement points to Puppeteer or another real-browser path.
- Specify pagination. Write down paper size, margins, bleed, backgrounds, page-break rules, repeated headers and footers, counters, footnotes, table splitting, and bookmark expectations.
- Define PDF semantics. Require searchable text, working link targets, bookmarks, forms, metadata, tagging, font embedding, and any PDF/A or PDF/UA conformance you actually need. A feature claim is not proof of conformance.
- Measure operations. Test cold and warm render time, memory, concurrency, container size, startup behavior, network access, sandboxing, and recovery after a crashed or timed-out render.
- Review maintenance and license. Record release activity, security advisories, support model, browser or engine update cadence, and whether the license permits your deployment and redistribution model.
- Run visual and text regression tests. Compare page images, page count, extracted text, links, bookmarks, and metadata across representative fixtures before every upgrade.
Implementation patterns
Browser-based PDF with Puppeteer (Node.js)
import puppeteer from 'puppeteer';
const browser = await puppeteer.launch({
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
try {
const page = await browser.newPage();
await page.goto('https://example.com/report', { waitUntil: 'networkidle0' });
await page.waitForSelector('#report-ready', { timeout: 30000 });
await page.emulateMediaType('print');
await page.pdf({
path: 'report.pdf',
format: 'A4',
printBackground: true,
preferCSSPageSize: true,
margin: { top: '18mm', right: '14mm', bottom: '18mm', left: '14mm' }
});
} finally {
await browser.close();
}In production, keep navigation and selector timeouts explicit, restrict outbound network access, and remove --no-sandbox unless your container policy requires it and you understand the security consequence. The important behavior is waiting for the application’s finished state before printing.
Rank #2
Dedicated-engine workflow
With WeasyPrint or Prince, feed a fully rendered HTML document and its stylesheet to the engine, then inspect the resulting PDF with text extraction, link checks, visual diffs, and accessibility or archival validators. Keep CSS paged-media rules such as @page, named pages, counters, and running elements in a fixture so an engine upgrade cannot silently change pagination.
Fonts, international text, and assets
Install the exact production fonts in the renderer’s environment and verify that the PDF embeds the intended subsets. A missing font can change line wrapping, which changes every later page break. Test right-to-left scripts, combining marks, CJK text, emoji, SVG, and large images if they occur in your documents. Decide whether remote assets are allowed; blocking network access improves isolation but requires a reliable asset-bundling strategy.
Accessibility and archival requirements
Selectable text and visible links do not prove that a PDF is accessible. Check reading order, tags, language metadata, alternate text, table structure, focus order for forms, and link annotations with conformance tooling. Likewise, a tool’s ability to emit a PDF/A or PDF/UA option does not establish validity; validate the produced file against the specification and retain the validator version in your build records.
Security, reliability, and cost considerations
Security
Treat HTML as untrusted input when users can supply templates or URLs. Sandbox browser processes, restrict egress, cap navigation time and document size, prevent access to internal address ranges, and isolate temporary files. For dedicated binaries, apply the same input limits and patch policy.
Reliability
Classify failures separately: navigation timeout, script error, missing asset, font failure, renderer crash, and invalid output. Retry only transient conditions, use an idempotent job key, and retain enough logs to identify the URL, engine version, fixture, and failure class without storing sensitive document content.
Cost and capacity
Measure cost per page or document under your real concurrency, not just a single warm render. Browser systems may need a pool of long-lived workers; dedicated engines may be cheaper to start but still require native dependencies and license fees. Include validator, storage, queue, and font-management costs in the operating model.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If you need a hosted capture rather than operating Chromium or a rendering binary, ScreenshotNeo accepts one GET request and returns a clean PNG, JPEG, WebP, or PDF. Before capture it accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and each response identifies the result with X-Page-Verdict and X-Billed headers. An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
See the ScreenshotNeo API documentation for output and capture options. The following calls use the supplied API pattern:
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →cURL
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Every feature is available on every plan: full-page capture with lazy images loaded, CSS-selector element capture, dark mode, device presets and custom viewports, retina scale, PDF paper size and margins, custom CSS and JavaScript, clicks, waits, blocking rules, headers, cookies, user agents, authorization, timezone and geolocation, transparent backgrounds, resizing, configurable-TTL caching, signed links, asynchronous jobs with signed webhooks, bulk capture for 100 URLs per call, usage API, OpenAPI specification, and compatibility with parameter names used by other screenshot APIs.
Rank #3
- Used Book in Good Condition
| Plan | Included shots | Price |
|---|---|---|
| Free | 1,000 per month | $0, no card |
| Starter | 3,000 | $5 |
| Growth | 15,000 | $15 |
| Pro | 60,000 | $39 |
| Scale | 250,000 | $99 |
| Business | 1,000,000 | $249 |
Yearly billing provides two months free. Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card.
Troubleshooting checklist
The PDF is blank or missing a chart
Cause: the capture ran before client-side rendering finished, or scripts were blocked. Wait for a specific ready selector or network-idle state, then confirm the chart exists in the final DOM.
Page breaks move after deployment
Cause: different fonts, browser builds, paper settings, or device scale. Install and embed the same fonts, pin the renderer version, set paper size and margins explicitly, and compare rasterized pages in CI.
Remote images or stylesheets disappear
Cause: blocked egress, expired credentials, certificate errors, or relative URLs resolved against the wrong base. Bundle required assets or allow-list their hosts and log failed requests.
PDF/A or PDF/UA validation fails
Cause: missing tags, metadata, fonts, alternate text, or specification-specific constraints. Treat the validator output as the fix list; do not infer conformance from the engine’s option name.
Renderer times out or exhausts memory
Cause: unbounded pages, large images, hung scripts, or too much concurrency. Set document and navigation limits, cap image dimensions, terminate stuck workers, and tune the worker pool from measured memory data.
Decision summary
- Choose Puppeteer or another browser when JavaScript execution and Chrome fidelity are non-negotiable.
- Choose WeasyPrint or Prince when paged-media controls and repeatable long-document layout dominate.
- Choose only after your fixtures prove fonts, international text, links, bookmarks, forms, accessibility, archival output, performance, security, and licensing requirements.
- Use a hosted service when operating browser binaries or rendering infrastructure is the problem you are trying to avoid.
Frequently Asked Questions
Should I keep the original HTML and CSS after generating a PDF?
Yes. Retaining the exact source, asset manifest, renderer version, and font package lets you reproduce a disputed document and explain pagination changes later.
Free tools Windows power users keep installed
One-click scans. No signup required.
Can I switch engines without changing templates?
Sometimes, but CSS paged-media support and browser behavior differ enough that you should expect template adjustments. Run the complete fixture set before treating a migration as drop-in.
Is a PDF screenshot suitable as the only document format?
No when users must search, copy, reflow, complete forms, or use assistive technology. Confirm semantic text, links, tags, and form fields in the generated PDF rather than relying on its visual appearance.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
