Log inGet started
Features

One API for PDFs, Screenshots & Templates

Doppio replaces self-hosted Puppeteer, wkhtmltopdf, and fragile PDF libraries with a single, fully managed API. Send HTML, get back pixel-perfect documents.

Start for free Read the docs
HTML to PDF API

Generate Pixel-Perfect PDFs from Any HTML

Convert web pages, base64-encoded HTML, or saved templates into production-quality PDF documents. Doppio uses a Chromium-based renderer, so modern layouts such as Flexbox, CSS Grid, webfonts, and JavaScript-heavy pages can be rendered through a single API.

  • Pass a URL, base64-encoded HTML, or a template ID
  • Support for native CSS Paged Media and Paged.js-based workflows
  • Custom page sizes, margins, and landscape/portrait orientation
  • Background graphics, custom fonts, and emoji support
  • Configurable wait strategies for JavaScript-heavy pages
PDF API docs 
const response = await fetch('https://api.doppio.sh/v1/render/pdf/direct', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    page: {
      pdf: {
        printBackground: true,
        format: 'A4'
      },
      goto: {
        url: 'https://your-app.com/invoice/42'
      }
    }
  })
});
const pdfBuffer = Buffer.from(await response.arrayBuffer());
Screenshot API

Capture Full-Page or Element-Level PNG Screenshots

Take high-resolution screenshots of any web page or HTML snippet. Use custom viewports, retina scaling, and clip regions to capture exactly what you need — from full-page captures to cropped UI components.

  • Full-page or element-specific screenshots
  • Custom viewport width, height, and device scale factor
  • Retina-ready scaling with configurable device scale factor
  • Clip regions for precise element capture
  • Transparent backgrounds for overlay-ready PNGs
Screenshot API docs
Screenshot output
Pixel-perfect PNG from any web page or HTML. Custom viewport, retina scaling, transparent backgrounds.
2x
Retina scale
Any
Viewport size
<2s
Avg. render
PNG
Output format
HTML Templates

Design Once, Generate Thousands of Documents

Create reusable HTML templates directly in Doppio's built-in editor. Inject dynamic data via the API and generate invoices, contracts, reports, or marketing banners at scale — without touching a single line of front-end code each time.

  • Built-in HTML/CSS editor with live preview
  • Template placeholders and injected data via the API
  • Paged.js-compatible workflows for advanced multi-page layouts
  • Generate PDF or PNG from any template by ID
  • Version and manage templates from your dashboard
Template docs 
// Generate a document from a saved template
const response = await fetch('https://api.doppio.sh/v1/template/direct', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    templateId: 'tpl_invoice_v2',
    templateData: {
      DOP_company: 'Acme Corp',
      DOP_amount: '$1,250.00',
      DOP_date: '2026-03-05'
    }
  })
});
const pdfBuffer = Buffer.from(await response.arrayBuffer());
Storage & Webhooks

Upload to S3 & Get Notified When It's Done

Doppio can upload rendered documents to your own S3-compatible storage via presigned URLs. If you provide a presigned URL, the file is uploaded to your bucket; otherwise, Doppio can temporarily host the rendered document for sync responses. Combine this with async mode and webhooks for batch workflows.

  • Direct upload to Amazon S3, GCS, DigitalOcean Spaces, or MinIO
  • Presigned URL support for your own bucket
  • Asynchronous rendering with webhook callbacks
  • Fire-and-forget mode for batch document generation
  • Configurable retry and timeout policies
Storage docs
How async rendering works
1
You send a render request with a presigned URL
2
Doppio renders the document in an isolated instance
3
The file uploads directly to your S3 bucket
4
A webhook notifies your server that it's ready
Full capabilities

Everything You Need to Automate Document Generation

From rendering fidelity to developer ergonomics, every feature is built for production use.

PDF Generation

Convert HTML to PDF with full CSS3 support, custom page sizes, and background rendering.

Screenshot API

Capture full-page or element-level PNG screenshots with retina scaling and clip regions.

HTML Templates

Built-in template editor with data injection, optional Paged.js workflows, and version management.

S3 Upload

Upload rendered documents directly to your own S3-compatible bucket via presigned URLs.

Webhooks

Get notified when async renders complete. Fire-and-forget large document batches.

Sync & Async Modes

Choose real-time synchronous response or asynchronous rendering for complex documents.

Isolated Rendering

Each document renders in a sandboxed Chromium instance destroyed immediately after.

Render Logs

Full observability with detailed logs for every API call. Debug failed renders instantly.

Full CSS3 & JS

Flexbox, Grid, animations, variables — plus full JavaScript execution before capture.

Webfont Support

Full Google Fonts library plus custom @font-face for accurate typography in every document.

Technical Support

Live chat with our engineering team. Average response time under 2 hours.

Infinite Scalability

Distributed computing clusters handle workloads from hundreds to millions of documents without breaking a sweat.

Developer experience

Integrate in Minutes with Any Stack

Doppio is a simple REST API. If your stack can make an HTTP request, you can generate documents.

Node.js Python PHP Ruby Go Java C# / .NET cURL
1

Create an Account

Sign up for free in under 30 seconds. No credit card, no trial expiration.

2

Make an API Call

Send a POST request with your HTML or URL. Receive a PDF or PNG in the response.

3

Scale to Production

Upgrade your plan when you ship. Doppio handles auto-scaling, monitoring, and uptime.

Why Doppio

Doppio vs. the Alternatives

See how Doppio stacks up against self-hosted solutions and other PDF APIs.

Feature Doppio wkhtmltopdf Self-hosted Puppeteer Other SaaS APIs
Modern CSS (Flexbox, Grid) ✓ ✗ ✓ Varies
Managed infrastructure ✓ ✗ ✗ ✓
Auto-scaling ✓ ✗ DIY Varies
Direct S3 upload ✓ ✗ DIY Varies
Async + Webhooks ✓ ✗ DIY Varies
HTML template editor ✓ ✗ ✗ Varies
Paged.js support ✓ ✗ DIY ✗
GDPR & EU-hosted ✓ Self Self ✗
HDS certified ✓ ✗ ✗ ✗
Free tier ✓ 400 docs/mo Open source Server costs Varies
Security & compliance

Enterprise-Grade Security Built In

Doppio is built for companies that demand airtight data handling and regulatory compliance.

GDPR Compliance

All data processing is fully GDPR compliant. No document content is retained after rendering.

EU-Hosted Infrastructure

All servers are in Europe, ensuring data sovereignty and reduced latency for EU customers.

Sandboxed Instances

Every document renders in a dedicated Chromium sandbox that is destroyed immediately after processing.

HDS Certified

HDS (Hébergeur de Données de Santé) certified — a strong differentiator for healthcare data over US-based competitors.

Short-Lived Hosting

Sync responses can temporarily host rendered documents. If you need the file to live only in your own storage, use presigned URL upload.

Presigned URL Upload

With a presigned URL, the rendered file is uploaded to your own S3-compatible bucket instead of relying on Doppio's temporary hosting.

Start Generating Documents Today

Join 4000+ companies using Doppio to generate millions of PDFs and screenshots every month. Free plan, no credit card required.

Create free account Read the documentation