Web Page to PDF API

Convert any URL or raw HTML into a print-quality PDF. Real Chromium rendering — every CSS property, web font, and layout respected. No wkhtmltopdf quirks, no headless Chrome setup.

One API Call, Any Page

curl -X POST https://api.snapapi.pics/v1/pdf   -H "X-Api-Key: sk_live_xxx"   -H "Content-Type: application/json"   -d '{
    "url": "https://example.com/report",
    "format": "A4",
    "printBackground": true,
    "marginTop": "15mm",
    "marginBottom": "15mm"
  }'

Common Use Cases

Invoice generation: Pass a fully rendered HTML invoice template with your branding. Chromium handles fonts, colors, tables, and page breaks correctly every time.

SaaS report exports: Let users export their dashboard as a PDF. Capture the live page with real chart data — no separate report-rendering pipeline needed.

Contract generation: Render a populated HTML contract and capture it as PDF for storage, signature workflows, or email attachments.

Scheduled reports: Cron job captures a data page nightly, stores the PDF in S3, and emails it to stakeholders. No headless browser on your server.

Why Not wkhtmltopdf?

wkhtmltopdf uses an old Qt WebKit engine, frozen in 2020. It doesn't support Flexbox correctly, breaks CSS Grid, ignores many modern font features, and chokes on JavaScript-rendered content. SnapAPI uses Chromium — the same engine as Chrome — so modern CSS works perfectly, JavaScript executes before capture, and you get the same output your users see in their browser.

Response Format

{
  "url": "https://storage.snapapi.pics/pdfs/abc123.pdf",
  "base64": "JVBERi0xLjQK...",
  "pages": 3,
  "size": 84231
}

The url is valid for 24 hours. Use base64 for immediate processing or permanent storage. pages and size (bytes) are always returned.

Pricing

Free: 200 PDFs/month. Starter $19/mo: 5K. Pro $79/mo: 50K. Business $299/mo: 500K. Get started free.

Web to PDF API — Deep Dive

Chromium vs. wkhtmltopdf vs. Headless Libraries

Most developers reach for wkhtmltopdf or Puppeteer when they first need PDF generation. wkhtmltopdf uses WebKit from 2012 — no Flexbox, no Grid, no modern fonts, no JavaScript execution. Puppeteer works but requires Chromium bundled with your deployment (300MB+ addition, not suitable for serverless). PDFKit and Prawn generate PDFs programmatically from scratch — powerful for data-driven reports but require you to write layout code in a proprietary DSL.

SnapAPI uses Playwright with Chromium — the same engine as modern Chrome. Your HTML renders exactly as users see it. CSS Grid, custom web fonts, SVG charts, CSS animations (first frame), and JavaScript-rendered content all work. You write HTML and CSS you already know, not a PDF layout DSL.

Multi-Language Examples

# Ruby
require 'faraday'
require 'json'

res = Faraday.post('https://api.snapapi.pics/v1/pdf') do |req|
  req.headers['X-Api-Key']    = ENV['SNAPAPI_KEY']
  req.headers['Content-Type'] = 'application/json'
  req.body = {
    html:            File.read('invoice.html'),
    format:          'A4',
    marginTop:       '15mm',
    marginBottom:    '15mm',
    printBackground: true
  }.to_json
end
pdf_url = JSON.parse(res.body)['url']

# Go
body, _ := json.Marshal(map[string]interface{}{
    "url":             "https://example.com/report",
    "format":          "Letter",
    "landscape":       true,
    "printBackground": true,
})
req, _ := http.NewRequest("POST", "https://api.snapapi.pics/v1/pdf", bytes.NewReader(body))
req.Header.Set("X-Api-Key", os.Getenv("SNAPAPI_KEY"))
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

Custom Page Sizes

Beyond standard sizes (A4, Letter, Legal), you can specify exact dimensions using width and height in inches. This is useful for shipping labels (4x6 in), index cards, custom stationery, or any non-standard document format. 

{
  "url": "https://yourapp.com/label/12345",
  "width": "4in",
  "height": "6in",
  "marginTop": "0",
  "marginBottom": "0",
  "marginLeft": "0",
  "marginRight": "0",
  "scale": 2
}

Integrating with Storage

SnapAPI returns a hosted URL valid for 24 hours. For permanent storage, download the PDF immediately using the base64 field and push it to your own S3 bucket, Cloudflare R2, or database. Here is a Node.js pattern for storing to S3: 

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

const { base64, pages } = await snapApiResponse.json();
const buffer = Buffer.from(base64, 'base64');

await s3.send(new PutObjectCommand({
  Bucket: 'my-pdfs',
  Key: `invoices/${invoiceId}.pdf`,
  Body: buffer,
  ContentType: 'application/pdf',
  ContentDisposition: 'inline',
}));

Scaling PDF Generation

For high-volume PDF generation — thousands of invoices in a batch at month-end — enqueue jobs to a message queue (BullMQ, Sidekiq, Celery) and process them concurrently. SnapAPI handles concurrent requests across all paid plans; rate limits are per-second, not per-job, so a queue with controlled concurrency (e.g. 10 workers) stays well within limits on the Pro plan.

Start with the free tier (200/month) to validate your integration, then upgrade to Starter ($19/mo, 5K) or Pro ($79/mo, 50K) as your volume grows. Get your free key.

Frequently Asked Questions

Does the PDF include clickable links?

Yes. Chromium preserves hyperlinks in the generated PDF. Anchor tags render as clickable links in the output file, which is useful for table-of-contents navigation and external references in long-form documents.

Can I generate a PDF from a page behind authentication?

Yes — two approaches work well. First, use a signed URL pattern: generate a time-limited token, append it to the URL, and verify it in your middleware before serving the HTML. Second, use the html parameter to pass the fully rendered HTML directly, bypassing authentication entirely since the content never needs to be fetched by SnapAPI.

How do I control fonts in the PDF?

Self-hosted fonts (served from your own domain or a CDN) work reliably. Google Fonts via @import also works since SnapAPI fetches them over the network. For offline rendering when using the html parameter, base64-encode your font files and embed them directly in the HTML as data URIs in a <style> tag.

Is the API GDPR-compliant?

SnapAPI does not retain page content after PDF generation. Screenshots and PDFs are stored temporarily (24 hours) via the returned URL for your retrieval, then purged. For sensitive documents, use the base64 response field and process the PDF immediately in memory without relying on the hosted URL.

What's the maximum page size?

There is no hard page limit, but very long pages may approach the 30-second render timeout. For documents over 50 pages, consider splitting them into sections and generating PDFs in parallel. Merge the resulting files with a tool like pdf-lib (Node.js) or PyPDF2 on your server.

Can I add watermarks?

Use the customCss parameter to inject a watermark overlay before capture. A fixed-position, semi-transparent div with a repeating diagonal pattern covers the entire page and appears in the PDF: customCss: "body::after { content: 'DRAFT'; position: fixed; opacity: 0.1; font-size: 120px; transform: rotate(-45deg); top: 40%; left: 20%; }"

Convert Your First Page to PDF Free

200 PDFs per month on the free tier. No card required. Live in under 5 minutes.

Get Free API Key

Real-World PDF Workflows

SaaS subscription receipts: On successful payment (via Stripe webhook), generate a PDF receipt from your invoice HTML template and store it in S3. Send the customer a link. No library dependencies — just an HTTP call in your webhook handler.

Real estate listing PDFs: Agencies often need one-page property listings with photos, maps, and floor plans. Render the listing page (which already exists for the web) and capture it as a PDF. Agents download it and email it to clients — no separate InDesign workflow.

Medical records and forms: Healthcare platforms generate patient-facing summaries from rendered HTML views. Using the html parameter keeps PHI off any URL and ensures the content is never cached by intermediate systems.

E-learning certificates: On course completion, generate a personalized certificate PDF from an HTML template with the student's name and completion date. Store it on the user profile so they can download it any time.

All of these workflows follow the same pattern: render HTML on your side, call SnapAPI, get a hosted PDF URL or base64 blob. The heavy browser rendering happens on SnapAPI's infrastructure — your servers handle only the lightweight HTTP round-trip.

Getting Started in 5 Minutes

Register at snapapi.pics/register.html to get your free API key. Verify your email to activate the key, then make your first request. The Free plan includes 200 captures per month with no credit card required — enough to fully validate the integration in your project before deciding on a paid plan.

API documentation is at snapapi.pics/docs.html, including live playground, all parameters, response schemas, and code examples in 8 languages. The MCP server (snapapi-mcp on npm) also makes SnapAPI available directly in Claude Code, Cursor, and other AI coding environments.

Questions? Email support@snapapi.pics or open the support chat on any page. Average response time is under 4 hours.

Supported Output Formats

Beyond PDF, SnapAPI captures the same page as PNG, JPEG, or WebP via the screenshot endpoint. This means you can generate both a PDF version and a thumbnail image of the same document in two parallel API calls — useful for email previews (image) and download links (PDF) on the same workflow.

Video recording (POST /v1/video) captures page interactions as MP4 — useful for generating product tour videos or recording animated states that a static PDF would miss. The AI analysis endpoint (POST /v1/analyze) can also inspect the page and return structured data from it, which pairs well with PDF generation for report workflows that combine data extraction and document output in the same pipeline.

All SnapAPI features — screenshot, PDF, scrape, extract, video, analyze — use the same X-Api-Key header and the same request quota from your plan. No separate API keys or billing accounts per feature.