API Reference

curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com" },
    "format": "pdf",
    "options": {
      "page":   { "size": "A4", "margin": "15mm" },
      "render": { "printBackground": true }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output document.pdf

$payload = json_encode([
    'source'   => ['url' => 'https://example.com'],
    'format'   => 'pdf',
    'options'  => [
        'page'   => ['size' => 'A4', 'margin' => '15mm'],
        'render' => ['printBackground' => true],
    ],
    'delivery' => ['returnType' => 'json', 'fileName' => 'my-document'],
]);

$ch = curl_init('https://pdfrender.io/api/generate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
]);

$result = json_decode(curl_exec($ch), true);
curl_close($ch);

echo $result['conversion_id'];
echo $result['cdn_url'];

const response = await fetch('https://pdfrender.io/api/generate', {
  method:  'POST',
  headers: {
    Authorization:  'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    source:   { url: 'https://example.com' },
    format:   'pdf',
    options:  {
      page:   { size: 'A4', margin: '15mm' },
      render: { printBackground: true },
    },
    delivery: { returnType: 'json', fileName: 'my-document' },
  }),
});

const data = await response.json();
console.log(data.conversion_id);
console.log(data.cdn_url);

require 'net/http'
require 'json'

uri     = URI('https://pdfrender.io/api/generate')
payload = {
  source:   { url: 'https://example.com' },
  format:   'pdf',
  options:  { page: { size: 'A4', margin: '15mm' }, render: { printBackground: true } },
  delivery: { returnType: 'json', fileName: 'my-document' }
}

req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Content-Type']  = 'application/json'
req.body             = payload.to_json

res  = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
data = JSON.parse(res.body)

puts data['conversion_id']
puts data['cdn_url']

using System.Net.Http;
using System.Text;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var payload = new {
    source   = new { url = "https://example.com" },
    format   = "pdf",
    options  = new { page = new { size = "A4", margin = "15mm" }, render = new { printBackground = true } },
    delivery = new { returnType = "json", fileName = "my-document" }
};

var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
var res     = await client.PostAsync("https://pdfrender.io/api/generate", content);
var json    = await res.Content.ReadAsStringAsync();
var data    = JsonSerializer.Deserialize<JsonDocument>(json);

curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com" },
    "format": "pdf",
    "options": {
      "page": { "size": "A4", "margin": "15mm" },
      "watermark": {
        "enabled":   true,
        "text":      "CONFIDENTIAL",
        "placement": "diagonal-full"
      }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output watermarked.pdf

curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com/payslip/123" },
    "format": "pdf",
    "options": {
      "page": { "size": "A4", "margin": "15mm" },
      "security": {
        "password":      "employee123",
        "ownerPassword": "admin-secret"
      }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output payslip.pdf

# Full page PNG screenshot
curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com" },
    "format": "png",
    "options": {
      "screenshot": { "fullPage": true, "width": 1440 }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output screenshot.png

# Social / og:image (1200x630 viewport)
curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com/blog/my-post" },
    "format": "png",
    "options": {
      "screenshot": { "fullPage": false, "width": 1200, "height": 630 }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output og-image.png

# Raw HTML with variable injection
curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "html": "<html><body style=\"font-family:Arial;padding:40px\"><h1>Invoice for {{customer_name}}</h1><p>Amount: {{amount}}</p></body></html>",
      "data": {
        "customer_name": "Joe Blogs",
        "amount":        "$499.00"
      }
    },
    "format": "pdf",
    "options": {
      "page":   { "size": "A4", "margin": "20mm" },
      "render": { "printBackground": true }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output invoice.pdf

# Wait for a CSS selector before capturing
# Useful for pages with JavaScript-rendered content

curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": { "url": "https://example.com/dashboard" },
    "format": "pdf",
    "options": {
      "page": { "size": "A4", "margin": "15mm" },
      "render": {
        "printBackground": true,
        "waitFor":         "#chart-ready",
        "timeout":         15000
      }
    },
    "delivery": { "returnType": "binary" }
  }' \
  --output dashboard.pdf

# The API waits for #chart-ready to appear in the DOM
# before capturing the page. If the selector does not
# appear within timeout ms, capture proceeds anyway.

# Factur-X / ZUGFeRD hybrid PDF — EN 16931 compliant
# Requires: Large plan or above
# The API auto-generates the XML from your source.data

curl -X POST \
  https://pdfrender.io/api/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "template_id": 1,
      "data": {
        "invoice_number":   "INV-2026-001",
        "invoice_date":     "2026-04-05",
        "payment_due_date": "2026-05-05",
        "currency":         "GBP",
        "tax_rate":         20,

        "seller_name":      "Acme Ltd",
        "seller_address":   "123 Main Street",
        "seller_city":      "London",
        "seller_postcode":  "EC1A 1BB",
        "seller_country":   "GB",
        "seller_vat":       "GB123456789",
        "seller_email":     "billing@acme.com",
        "iban":             "GB29NWBK60161331926819",
        "bic":              "NWBKGB2L",

        "buyer_name":       "Customer Corp",
        "buyer_address":    "456 High Street",
        "buyer_city":       "Manchester",
        "buyer_postcode":   "M1 1AA",
        "buyer_country":    "GB",
        "buyer_vat":        "GB987654321",

        "lines": [
          { "description": "Product A", "quantity": 10, "unit_price": 49.99 },
          { "description": "Service B", "quantity": 2,  "unit_price": 150.00 }
        ],
        "notes": "Payment due within 30 days. Thank you for your business."
      }
    },
    "format": "pdf",
    "options": {
      "page": { "size": "A4", "margin": "15mm" },
      "render": { "printBackground": true },
      "compliance": {
        "mode": "en16931"
      }
    },
    "delivery": {
      "returnType": "binary",
      "fileName":   "INV-2026-001"
    }
  }' \
  --output invoice-facturx.pdf

# Verify the XML is embedded in the output PDF:
# strings invoice-facturx.pdf | grep -i factur

$body      = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_PDFRENDER_SIGNATURE'] ?? '';
$expected  = 'sha256=' . hash_hmac('sha256', $body, 'your-signing-secret');

if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid signature']);
    exit;
}

$data = json_decode($body, true);
// PDF is ready at: $data['cdn_url']

const crypto = require('crypto');

// Use express.raw() to get the raw body for signature verification
app.post('/pdf-ready', express.raw({ type: 'application/json' }), (req, res) => {
    const sig      = req.headers['x-pdfrender-signature'];
    const expected = 'sha256=' + crypto
        .createHmac('sha256', process.env.WEBHOOK_SECRET)
        .update(req.body)
        .digest('hex');

    if (!crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
        return res.status(401).json({ error: 'Invalid signature' });
    }

    const data = JSON.parse(req.body);
    // PDF is ready at: data.cdn_url
    res.json({ ok: true });
});

import hmac, hashlib
from flask import Flask, request, jsonify

app = Flask(__name__)
WEBHOOK_SECRET = 'your-signing-secret'

@app.route('/pdf-ready', methods=['POST'])
def pdf_ready():
    body      = request.get_data()
    signature = request.headers.get('X-PDFRender-Signature', '')
    expected  = 'sha256=' + hmac.new(
        WEBHOOK_SECRET.encode(), body, hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        return jsonify({'error': 'Invalid signature'}), 401

    data = request.get_json(force=True)
    # PDF is ready at: data['cdn_url']
    return jsonify({'ok': True})