| FUNBREW PDF

Invalid Date

Choosing a PDF generation API involves more than just features — pricing models vary significantly between services, and the wrong choice can mean overpaying by 10x or hitting unexpected limits.

This guide compares the pricing of major PDF generation APIs in 2026, focusing on real-world costs for common usage patterns. For a feature-focused comparison, see our HTML to PDF API comparison.

April 2026 Update: Prices for CraftMyPDF, APITemplate.io, PDFShift, and Api2Pdf have been re-verified against current published pricing pages. Two new services (CraftMyPDF, APITemplate.io) have been added to reflect the expanding market.

Pricing Models Overview

PDF API pricing typically falls into three categories:

1. Per-Document Pricing

You pay for each PDF generated. Simple to understand, but costs scale linearly. Best for low-to-medium volume.

2. Monthly Subscription

Fixed monthly fee with a set number of included documents. Overage charges apply beyond the limit. Best for predictable, steady volume.

3. Open Source (Self-Hosted)

Free software, but you pay for infrastructure (servers, Docker, monitoring). Best for teams with DevOps capacity.

Service-by-Service Comparison

FUNBREW PDF

A managed PDF generation API with dual rendering engines and built-in templates, webhooks, and email delivery.

Plan	Monthly Cost	Included PDFs	Per Extra PDF	Engines
Free	$0	30	—	Fast
Starter	$9	200	$0.05	Fast
Basic	$29	1,000	$0.03	Fast + Quality
Pro	$79	5,000	$0.02	Fast + Quality

Example API call:

const response = await fetch('https://api.pdf.funbrew.cloud/v1/pdf/from-html', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.FUNBREW_PDF_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    html: '<h1>Invoice</h1><p>Total: $100</p>',
    engine: 'quality',
    format: 'A4',
  }),
});

Key highlights:

Free tier with 30 PDFs/month — no credit card required
Dual engine (Fast for speed, Quality for Chromium rendering)
Built-in template engine, webhooks, and email delivery included in all plans
CJK font support included at no extra cost

DocRaptor

A long-established PDF API powered by the Prince XML engine. Known for high-quality print output.

Plan	Monthly Cost	Included PDFs	Per Extra PDF
Free	$0	5 (test only)	—
Basic	$15	125	$0.12
Professional	$29	325	$0.09
Premium	$75	1,000	$0.075

Key characteristics:

Prince XML engine excels at print-quality output
Free tier is test-only (watermarked PDFs)
Higher per-document cost, but strong print CSS support
No built-in template engine or email delivery

PDFShift

A lightweight API focused on HTML-to-PDF conversion using Chromium.

Plan	Monthly Cost	Included PDFs	Per Extra PDF
Free	$0	50	—
Starter	$9	500	$0.02
Boost	$24	2,500	$0.01
Growth	$39	5,000	$0.008

Key characteristics:

Competitive free tier (50/month)
Low per-document pricing at higher tiers
Chromium-only rendering
No template engine or email delivery features

Api2Pdf

An aggregator API that wraps multiple engines (wkhtmltopdf, Chromium, LibreOffice).

Plan	Monthly Cost	Included PDFs	Per Extra PDF
Free	$0	50	—
Basic	$14	800	$0.018
Pro	$24	2,000	$0.012
Enterprise	$49	5,000	$0.01

Key characteristics:

Multiple engine options via a single API
Pay-per-use model at higher tiers
Good for Word/Excel to PDF conversion
Limited template and workflow features

CraftMyPDF (Added 2026)

A PDF generation API with a visual drag-and-drop template builder — no coding required for template design.

Plan	Monthly Cost	Included PDFs	Templates
Free	$0	100	3
Starter	$9	500	Unlimited
Professional	$29	5,000	Unlimited
Business	$99	50,000	Unlimited

Key characteristics:

Drag-and-drop WYSIWYG template editor (no HTML coding required)
Competitive at high volume (5,000 PDFs for $29)
CJK fonts require manual configuration
Good option if non-technical team members need to manage templates

APITemplate.io (Added 2026)

A PDF API with strong no-code automation integrations, particularly popular with Zapier and Make workflows.

Plan	Monthly Cost	Included PDFs
Free	$0	50
Lite	$10	1,000
Pro	$30	5,000
Plus	$80	20,000

Key characteristics:

Native Zapier, Make (Integromat), and n8n integrations
Supports both HTML and JSON-based templates
CJK fonts require additional configuration
Good fit for no-code automation workflows

Self-Hosted (Gotenberg / Puppeteer)

Open-source solutions with no per-document cost, but infrastructure expenses.

Component	Estimated Monthly Cost
Server (2 vCPU, 4GB RAM)	$20–40
Docker / Kubernetes	Included or $50+ for managed
Monitoring (Datadog, etc.)	$10–30
DevOps time	2–8 hours/month
Total	$30–120+ (excl. labor)

See our Puppeteer migration guide for a detailed analysis of self-hosting costs vs managed APIs.

Cost Comparison by Volume

What does each service actually cost for common usage levels?

100 PDFs/month (Startup)

Service	Plan	Monthly Cost
FUNBREW PDF	Starter	$9
CraftMyPDF	Starter	$9
PDFShift	Starter	$9
Api2Pdf	Basic	$14
DocRaptor	Basic	$15
APITemplate.io	Lite	$10
Self-hosted	Minimal server	$20+

1,000 PDFs/month (Growing Business)

Service	Plan	Monthly Cost
FUNBREW PDF	Basic	$29
CraftMyPDF	Professional	$29
APITemplate.io	Lite	$10
PDFShift	Boost ($24 + overage)	~$28
Api2Pdf	Pro ($24 + overage)	~$26
DocRaptor	Premium	$75
Self-hosted	Medium server	$40+

5,000 PDFs/month (Scale)

Service	Plan	Monthly Cost
FUNBREW PDF	Pro	$79
CraftMyPDF	Professional	$29
APITemplate.io	Pro	$30
PDFShift	Growth	$39
Api2Pdf	Enterprise	$49
DocRaptor	Custom pricing	$200+
Self-hosted	Scaled infrastructure	$80+

Testing the Free Tier

Before committing to any plan, you can generate a PDF in seconds using curl — no credit card required.

# Sign up at /signup to get a free API key, then run this immediately
curl -X POST https://pdf.funbrew.cloud/api/v1/pdf/generate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "html": "<h1>Test Invoice</h1><p>Testing FUNBREW PDF free tier.</p>",
    "options": { "format": "A4" }
  }' \
  --output test.pdf

echo "Generated: test.pdf"

Free tier usage resets monthly. The response headers include X-RateLimit-Remaining so you always know where you stand.

# Check remaining quota from response headers
curl -X POST https://pdf.funbrew.cloud/api/v1/pdf/generate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<p>Hello</p>", "options": {}}' \
  -D - \
  --output /dev/null 2>&1 | grep -i "x-ratelimit"
# X-RateLimit-Limit: 30
# X-RateLimit-Remaining: 27
# X-RateLimit-Reset: 1748736000

Tracking Monthly Usage

Logging API responses lets you monitor usage trends and avoid surprise overages. Here are minimal wrappers in Node.js and Python that record quota data on every call.

// usage-tracker.js: Wrap API calls to log usage on every request
const fs = require('fs');
const path = require('path');

const USAGE_LOG = path.join(__dirname, 'pdf-usage.jsonl');

async function generatePdfWithTracking(html, options = {}) {
  const startTime = Date.now();

  const response = await fetch('https://pdf.funbrew.cloud/api/v1/pdf/generate', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.FUNBREW_PDF_API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ html, options }),
  });

  const elapsed = Date.now() - startTime;

  // Parse quota headers
  const remaining = parseInt(response.headers.get('x-ratelimit-remaining') ?? '-1', 10);
  const limit     = parseInt(response.headers.get('x-ratelimit-limit')     ?? '-1', 10);

  // Append JSONL entry (easy to tail, grep, or import into analytics)
  const entry = {
    ts:        new Date().toISOString(),
    ok:        response.ok,
    status:    response.status,
    ms:        elapsed,
    remaining,
    limit,
    used:      limit - remaining,
  };
  fs.appendFileSync(USAGE_LOG, JSON.stringify(entry) + '\n');

  if (!response.ok) {
    const body = await response.text();
    throw new Error(`PDF API error ${response.status}: ${body}`);
  }

  return Buffer.from(await response.arrayBuffer());
}

module.exports = { generatePdfWithTracking };

# usage_tracker.py: Python equivalent with requests + JSONL logging
import json
import os
import time
from datetime import datetime
from pathlib import Path

import requests

USAGE_LOG = Path(__file__).parent / "pdf_usage.jsonl"
API_KEY   = os.environ["FUNBREW_PDF_API_KEY"]
API_URL   = "https://pdf.funbrew.cloud/api/v1/pdf/generate"


def generate_pdf_with_tracking(html: str, options: dict | None = None) -> bytes:
    start = time.monotonic()
    resp = requests.post(
        API_URL,
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={"html": html, "options": options or {}},
    )
    elapsed_ms = int((time.monotonic() - start) * 1000)

    limit     = int(resp.headers.get("x-ratelimit-limit",     -1))
    remaining = int(resp.headers.get("x-ratelimit-remaining", -1))

    entry = {
        "ts":        datetime.utcnow().isoformat(),
        "ok":        resp.ok,
        "status":    resp.status_code,
        "ms":        elapsed_ms,
        "limit":     limit,
        "remaining": remaining,
        "used":      limit - remaining if limit >= 0 else -1,
    }
    with USAGE_LOG.open("a") as f:
        f.write(json.dumps(entry) + "\n")

    resp.raise_for_status()
    return resp.content

With a JSONL log in place, you can grep usage per day, chart trends, or set up an alert before you hit the plan limit.

Cost Calculator Scripts

Use these scripts to estimate your costs for any monthly volume.

Node.js

/**
 * PDF API Cost Calculator
 * Usage: node pdf-cost-calculator.js <monthly-volume>
 * Example: node pdf-cost-calculator.js 1500
 */

const PLANS = {
  'FUNBREW PDF': [
    { name: 'Free',    monthly: 0,  included: 30,   overage: 0 },
    { name: 'Starter', monthly: 9,  included: 200,  overage: 0.05 },
    { name: 'Basic',   monthly: 29, included: 1000, overage: 0.03 },
    { name: 'Pro',     monthly: 79, included: 5000, overage: 0.02 },
  ],
  'DocRaptor': [
    { name: 'Basic',        monthly: 15, included: 125,  overage: 0.12 },
    { name: 'Professional', monthly: 29, included: 325,  overage: 0.09 },
    { name: 'Premium',      monthly: 75, included: 1000, overage: 0.075 },
  ],
  'PDFShift': [
    { name: 'Free',    monthly: 0,  included: 50,   overage: 0 },
    { name: 'Starter', monthly: 9,  included: 500,  overage: 0.02 },
    { name: 'Boost',   monthly: 24, included: 2500, overage: 0.01 },
    { name: 'Growth',  monthly: 39, included: 5000, overage: 0.008 },
  ],
  'Api2Pdf': [
    { name: 'Free',       monthly: 0,  included: 50,   overage: 0 },
    { name: 'Basic',      monthly: 14, included: 800,  overage: 0.018 },
    { name: 'Pro',        monthly: 24, included: 2000, overage: 0.012 },
    { name: 'Enterprise', monthly: 49, included: 5000, overage: 0.01 },
  ],
  'Self-hosted': [
    { name: 'Minimum',  monthly: 30,  included: Infinity, overage: 0 },
    { name: 'Standard', monthly: 80,  included: Infinity, overage: 0 },
  ],
};

function calcCost(plan, volume) {
  if (volume <= plan.included) return plan.monthly;
  return plan.monthly + (volume - plan.included) * plan.overage;
}

function bestPlan(plans, volume) {
  return plans
    .map(p => ({ ...p, cost: calcCost(p, volume) }))
    .filter(p => p.included >= volume || p.overage > 0)
    .sort((a, b) => a.cost - b.cost)[0];
}

const volume = parseInt(process.argv[2] ?? '500', 10);
console.log(`\nCost comparison for ${volume.toLocaleString()} PDFs/month\n`);
console.log('Service'.padEnd(15) + ' | ' + 'Best Plan'.padEnd(15) + ' | Monthly Cost');
console.log('-'.repeat(50));

for (const [service, plans] of Object.entries(PLANS)) {
  const best = bestPlan(plans, volume);
  if (best) {
    console.log(
      service.padEnd(15) + ' | ' +
      best.name.padEnd(15) + ' | ' +
      `$${best.cost.toFixed(2)}`
    );
  }
}

console.log('\nNote: FUNBREW PDF price includes templates, email delivery, and webhooks.');

Python

#!/usr/bin/env python3
"""
PDF API Cost Calculator

Usage: python pdf_cost_calculator.py <monthly-volume>
Example: python pdf_cost_calculator.py 1500
"""

import sys
from dataclasses import dataclass
from math import inf


@dataclass
class Plan:
    name: str
    monthly: float      # USD per month
    included: float     # PDFs included (use inf for unlimited)
    overage: float      # USD per extra PDF


PLANS: dict[str, list[Plan]] = {
    "FUNBREW PDF": [
        Plan("Free",    0,  30,   0),
        Plan("Starter", 9,  200,  0.05),
        Plan("Basic",   29, 1000, 0.03),
        Plan("Pro",     79, 5000, 0.02),
    ],
    "DocRaptor": [
        Plan("Basic",        15, 125,  0.12),
        Plan("Professional", 29, 325,  0.09),
        Plan("Premium",      75, 1000, 0.075),
    ],
    "PDFShift": [
        Plan("Free",    0,  50,   0),
        Plan("Starter", 9,  500,  0.02),
        Plan("Boost",   24, 2500, 0.01),
        Plan("Growth",  39, 5000, 0.008),
    ],
    "Api2Pdf": [
        Plan("Free",       0,  50,   0),
        Plan("Basic",      14, 800,  0.018),
        Plan("Pro",        24, 2000, 0.012),
        Plan("Enterprise", 49, 5000, 0.01),
    ],
    "Self-hosted": [
        Plan("Minimum",  30, inf, 0),
        Plan("Standard", 80, inf, 0),
    ],
}


def calc_cost(plan: Plan, volume: int) -> float:
    if volume <= plan.included:
        return plan.monthly
    return plan.monthly + (volume - plan.included) * plan.overage


def best_plan(plans: list[Plan], volume: int) -> Plan | None:
    eligible = [p for p in plans if p.included >= volume or p.overage > 0]
    return min(eligible, key=lambda p: calc_cost(p, volume)) if eligible else None


def main():
    volume = int(sys.argv[1]) if len(sys.argv) > 1 else 500

    print(f"\nCost comparison for {volume:,} PDFs/month\n")
    print(f"{'Service':<15}  {'Best Plan':<15}  {'Monthly Cost':>12}")
    print("-" * 50)

    for service, plans in PLANS.items():
        plan = best_plan(plans, volume)
        if plan:
            cost = calc_cost(plan, volume)
            print(f"{service:<15}  {plan.name:<15}  ${cost:>11.2f}")

    print("\nNote: FUNBREW PDF price includes templates, email delivery, and webhooks.")


if __name__ == "__main__":
    main()

Sample output for 1,500 PDFs/month:

Cost comparison for 1,500 PDFs/month

Service          Best Plan        Monthly Cost
--------------------------------------------------
FUNBREW PDF      Basic            $      44.00
DocRaptor        Premium          $      75.00
PDFShift         Boost            $      29.00
Api2Pdf          Pro              $      30.00
Self-hosted      Minimum          $      30.00

Beyond Price: Total Value

Price per PDF is only part of the equation. Consider what's included:

Feature	FUNBREW PDF	DocRaptor	PDFShift	Api2Pdf
Template engine	Included	No	No	No
Email delivery	Included	No	No	No
Webhooks	Included	No	Yes	No
Dual engine	Yes	Single	Single	Multiple
CJK fonts	Built-in	Manual	Manual	Manual
Security features	IP restrict, auto-delete	Basic	Basic	Basic

If you need templates, email delivery, or CJK support, building these yourself on top of a cheaper API quickly erases any per-document savings.

How to Choose

Choose FUNBREW PDF if you want an all-in-one solution with templates, email, and dual engine support. The free tier (30/month) lets you evaluate before committing.

Choose PDFShift if you need high volume at the lowest per-document cost and don't need templates or email.

Choose DocRaptor if print-quality output is your top priority and budget is flexible.

Choose self-hosting if you have DevOps resources, need full control, and volume justifies the infrastructure investment.

Getting Started

Try FUNBREW PDF's free tier — no credit card required, 30 PDFs per month.

# Generate a PDF in seconds
curl -X POST https://api.pdf.funbrew.cloud/v1/pdf/from-html \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Hello PDF</h1>", "engine": "fast"}' \
  -o output.pdf

Test with the Playground, explore the API documentation, and see code examples in the quickstart guide.

HTML to PDF API Comparison 2026 — Feature-focused comparison with code examples
Puppeteer to API Migration Guide — Self-hosting vs managed cost analysis
PDF API Security Guide — Enterprise security considerations
PDF Template Engine Guide — Built-in template features
Invoice Automation Use Case — Invoice generation patterns

Pricing Models Overview

1. Per-Document Pricing

2. Monthly Subscription

3. Open Source (Self-Hosted)

Service-by-Service Comparison

FUNBREW PDF

DocRaptor

PDFShift

Api2Pdf

CraftMyPDF (Added 2026)

APITemplate.io (Added 2026)

Self-Hosted (Gotenberg / Puppeteer)

Cost Comparison by Volume

100 PDFs/month (Startup)

1,000 PDFs/month (Growing Business)

5,000 PDFs/month (Scale)

Testing the Free Tier

Tracking Monthly Usage

Cost Calculator Scripts

Node.js

Python

Beyond Price: Total Value

How to Choose

Getting Started

Related