DEV Community: Ethan from reportgen.io

Reportgen.io vs Html2pdf.app - Which PDF API Should You Use in 2025? ⚔️

Ethan from reportgen.io — Wed, 04 Jun 2025 06:46:26 +0000

Before we dive into the details, here’s the TL;DR: Reportgen.io is
purpose-built for dynamic PDF generation with multiple templating engines,
pay-per-use pricing, and a developer-centric dashboard, while Html2pdf.app
shines as a lightweight, credit-based service for straight-forward
raw-HTML-to-PDF jobs. If you need highly-customized, data-driven documents,
Reportgen.io is likely the better fit; if you just want to turn single pages
into PDFs on a tight budget, Html2pdf.app may suffice.

🔍 Overview

Reportgen.io: An API that lets you feed templated HTML (EJS, Handlebars, GoTempl, or raw) plus JSON data and returns a PDF, either synchronously or via an async job queue. It offers a generous free tier (150 PDFs/month) and simple $0.0025 per-report, pay-as-you-go billing.
Html2pdf.app: A credit-based service that converts raw HTML or a public URL into a PDF. It supports synchronous calls and an asynchronous callback mode, with 100 free credits/month (1 MB max per file) and paid plans starting at $9 for 1 000 credits.

📊 Feature Comparison

Feature	Reportgen.io	Html2pdf.app
Templating Engines	EJS, Handlebars, GoTempl, Raw HTML	Raw HTML only
Sync & Async	Both, no concurrency ceiling	Both; parallel jobs limited by plan
Built-in Storage/CDN	Cloudflare R2 for 1-year retention	❌ File is streamed back; you store it yourself
Dashboard UI	Full usage analytics & logs	Simple credit counter + usage chart
Dynamic Data Insertion	JSON payload populates templates	❌ Not supported (no templating)
Styling Support	Any modern CSS + JS (e.g., Tailwind, Chart.js)	Modern CSS & JS via browser engine
Code Samples	cURL, JS/TS, Python, Go	cURL, PHP, Node, Python, Ruby, Java, Go
Free Tier	150 PDFs/month	100 credits/month (1 MB/file)
Pricing	$0.0025 per PDF (pay-per-use)	From $9/mo (1 000 credits)
Encryption	AES-256 optional	AES-128 optional

🧑‍💻 Developer Experience

Reportgen.io feels like a developer tool: multiple templating engines,
signed URLs, verbose error payloads, and an observability-first dashboard with
per-job logs.

Html2pdf.app keeps things minimal. You post HTML, poll (or await a callback)
and get a PDF. A lightweight dashboard shows remaining credits, and a new chart
on the Credits tab helps you track usage at a glance.

🎨 Customization & Integration

Reportgen.io lets you mix Tailwind, Chart.js, or any client-side library inside your templates, so invoices, dashboards, or contracts can be fully branded.
Html2pdf.app renders modern CSS & JS thanks to a headless browser engine, but without a server-side templating step you must generate your HTML string yourself.

⚙️ Performance, Scalability & Security

Reportgen.io processes unlimited PDFs async out-of-the-box and scales horizontally; PDFs up to 189 MB have been reported in production.
Html2pdf.app allows “unlimited PDF size” on paid plans, but each 5 MB chunk costs 1 credit, so a 15 MB document burns 3 credits.
Both services offer encrypted PDFs. Reportgen.io supports AES-256, while Html2pdf.app documents note AES-128.

💰 Pricing Breakdown

	Free Tier	Pay-as-you-go / Subscription
Reportgen.io	150 PDFs/mo	$0.0025 per PDF, no minimum
Html2pdf.app	100 credits (1 MB cap)	Startup: $9/mo → 1 000 credits; larger plans scale up with more parallel jobs

Tip: Html2pdf.app’s credit model means very large files may exhaust your
quota quickly, whereas Reportgen.io’s flat rate is size-agnostic.

🧠 Who Should Use What?

Choose Reportgen.io if you need…
- Dynamic PDFs powered by templating and JSON data.
- Pay-per-document pricing without monthly lock-ins.
- A dashboard with logs, usage analytics, and signed download URLs.
Choose Html2pdf.app if you need…
- Quick, no-frills conversion of single-page raw HTML.
- A low-cost entry point (100 free credits) for small files.
- Language-agnostic code snippets in six major languages out-of-the-box.

✅ Conclusion

Both APIs turn HTML into PDFs, but Reportgen.io excels when documents are
dynamic, large, or part of a mission-critical workflow, while Html2pdf.app
remains attractive for lightweight, occasional jobs that fit neatly into its
credit-based model. Match the tool to the complexity of your output and the
predictability of your volume.

Ready to build?

🆓 Get 150 free reports/month – no credit card required
📖 Read the Docs

Your PDFs deserve better. Let’s build them right. 🔥

If you're doing PDF in your app, check this one out

Ethan from reportgen.io — Thu, 29 May 2025 08:02:22 +0000

🚫 Ditch Puppeteer: 5 Painful Lessons Learned Building PDFs at Scale

Ethan from reportgen.io ・ May 28

🚫 Ditch Puppeteer: 5 Painful Lessons Learned Building PDFs at Scale

Ethan from reportgen.io — Wed, 28 May 2025 19:45:52 +0000

We thought Puppeteer was “good enough.” Turns out, “good enough” breaks at scale. Here’s what nobody tells you about building PDF pipelines with headless browsers.

🪓 The Cold, Hard Truth About Puppeteer PDF Generation

If you’ve ever Googled “generate PDF from HTML in Node.js,” you’ve probably landed on Puppeteer. It’s fast, works for MVPs, and it’s open source. But when our app started generating thousands of PDFs a day, we learned some hard lessons. The kind of lessons that don’t show up in the docs.

Here’s what went wrong (and what I wish I knew sooner):

1. Zombie Chrome Processes Will Haunt You

Remember that “just use headless Chrome in Docker” tip? Works fine - until it doesn’t.

Puppeteer spawns Chrome processes for each PDF job. But when things go wrong - timeouts, crashes, or OS bugs - it leaks those processes. Suddenly, your servers are chewing through memory and “OOM killed” becomes your favorite Slack notification.

Lesson:
Managing Chrome at scale is a game of whack-a-mole. You’ll burn time on process cleanup instead of shipping features.

2. Performance Bottlenecks Sneak Up Fast

Need to generate PDFs in parallel? Say hello to the bottleneck monster.

Each Puppeteer instance uses 100MB+ RAM and spawns its own Chromium process. Try spinning up 10, 20, or 50 at once. You’ll hit resource limits fast, especially on smaller VMs or containers.

Lesson:
Scaling horizontally gets expensive. For bursty workloads, expect weird delays, timeouts, and server crashes unless you invest in orchestration.

3. Docker Nightmares & OS Compatibility

Works on my machine. Fails in prod. Welcome to container hell.

Dockerizing Puppeteer means juggling fonts, dependencies, glibc versions, missing libraries, and obscure startup flags. “Error: failed to launch Chromium” is the bane of your CI/CD pipeline.

Lesson:
Upgrading Chrome? Be ready for surprise production outages and dependency chaos.

4. Debugging Is a Time Sink

Your beautiful HTML works in the browser… but your PDF is a hot mess.

Headless Chrome renders differently from your desktop browser: think missing fonts, broken CSS, and no animations. Debugging means endless screenshotting, CSS tweaking, rerunning jobs, and a healthy dose of frustration.

Lesson:
Expect to lose hours chasing rendering quirks and “why is my chart missing?” mysteries.

5. Security & Maintenance Are Never “Done”

Running browsers on your backend? Prepare for patch marathons.

Chromium ships security patches almost weekly. Falling behind means risking exploits and stability issues. You’ll end up maintaining a mini browser farm just to keep up.

Lesson:
Security and compliance become ongoing headaches, especially if you handle sensitive data.

🚀 What Actually Works at Scale?

After all this pain, we created a PDF-as-a-Service model called Reportgen.io:

No more Chrome orchestration: Just send HTML & data, get a PDF back.
Async & scalable: Handles spikes and queues without server bottlenecks.
Simple REST API: Integrates with any stack (Go, Node.js, Python, etc.).
Secure & auto-updating: Someone else worries about browser patches and exploits.

Bonus:
We got back days of engineering time and no more server babysitting or “Chromium upgrade Fridays.”

⚡ TL;DR

Puppeteer is fine for hobby projects.
At scale? It’ll break your infrastructure and your sanity.
Consider a dedicated PDF API and let someone else handle the mess.

Curious? Try Reportgen.io for free. Skip the Puppeteer pain and focus on shipping.

Want more technical war stories or a step-by-step migration guide? Drop a comment below! 👇

[Boost]

Ethan from reportgen.io — Wed, 21 May 2025 09:47:14 +0000

Ethan from reportgen.io

May 21 '25

Stop Wasting Hours on PDF Generation: A Fast, Clean JavaScript Setup with reportgen.io

#javascript #programming #backend #tutorial

Comments

4 min read

Stop Wasting Hours on PDF Generation: A Fast, Clean JavaScript Setup with reportgen.io

Ethan from reportgen.io — Wed, 21 May 2025 05:45:53 +0000

Generating PDFs in a JS app used to mean fragile Puppeteer scripts, bloated code, or expensive third-party services. We hated it. So we built reportgen.io. A faster, simpler way to generate dynamic documents with real templates and real data.

Whether you’re building invoicing software, generating reports, or creating marketing materials, reportgen.io makes it easy to create dynamic, high-quality PDFs.

Before You Begin

To follow along, make sure you have:

A JavaScript or TypeScript project set up.
An Access key from reportgen.io.
Basic familiarity with REST APIs and how to make HTTP requests.
Node.js installed on your system.

You can also use tools like Postman or curl to test the API before diving into code. Postman is a powerful API testing tool that simplifies debugging. Download Postman to get started.

In this guide for dynamic PDF generation with Javascript, we will be using the EJS templating engine. EJS is a simple templating language that lets you generate HTML markup with plain JavaScript. If you’re new to EJS, you can learn more about it in the official documentation.
There are other templating engines like Handlebars, GoTempl and Raw that you can use with reportgen.io. Learn more about templating engines.

Step 1: Set Up Your Project and Install Dependencies

First, create a folder structure for your project. Here’s a suggested layout:

/project-root
    /templates
        invoice.ejs
    /src
        reportgen.js
    index.js
    package.json

Initialize Your Project and Install Dependencies

Run the following command to initialize your project:

npm init -y

Install Required Dependencies

npm install node-fetch

Step 2: Create your dynamic HTML template

Create an HTML template in the /templates folder. For example, name it invoice.ejs and include:

<!DOCTYPE html>
<html>
<head>
  <title>Invoice</title>
</head>
<body>
  <h1>Invoice for <%= Name %></h1>
  <p>Total Due: $<%= Total %></p>
</body>
</html>

Save this file as invoice.ejs. This template will be processed server-side by reportgen.io using the EJS templating engine.

Step 3: Integrate with the reportgen.io API

Create a new file in the /src directory, e.g., reportgen.js. Add the following code which will interact with reportgen API (the core function that you will call across your project):

import { readFileSync } from "fs";
import path from "path";
import fetch from "node-fetch";

export const generatePDF = async (templateKey, data) => {
    const apiUrl = "https://reportgen.io/api/v1/generate-pdf-sync";
    const accessKey = process.env.REPORTGEN_ACCESS_KEY;

    // Load the HTML template
    const htmlTemplate = readFileSync(
        path.resolve("templates", `${templateKey}.ejs`),
        "utf8"
    );

    const payload = {
        html_template: htmlTemplate,
        data: data,
        engine: "ejs", // Also supports "handlebars, gotempl and raw"
    };

    try {
        const response = await fetch(apiUrl, {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "X-API-Key": accessKey,
            },
            body: JSON.stringify(payload),
        });

        if (!response.ok) {
            const error = await response.json();
            throw new Error(`API error: ${error.message}`);
        }

        const pdfBuffer = await response.arrayBuffer();

        return pdfBuffer;
    } catch (err) {
        throw new Error(`Error generating PDF: ${err}`);
    }
};

Explanation of the Code:

File Read: The fs module reads your template file.
Payload: Prepares the payload for the API request.
Fetch API: Makes an HTTP POST request to the reportgen.io endpoint.
Error Handling: Outputs helpful messages if something goes wrong.

Step 4: Prepare the last pieces for your integration

Set your access key in the environment

Usually you would have .env file in the project root directory. Add your access key to the .env file like this:

REPORTGEN_ACCESS_KEY=your_access_key_here

But you can also simply set the environment variable in your terminal with export:

export REPORTGEN_ACCESS_KEY=your_access_key

Create the main file that will call the function

Create an index.js file where you'll call the new function:

import { generatePDF } from "./src/reportgen.js";
import fs from "fs";

const data = {
    Name: "John Doe",
    Total: 120,
}

generatePDF("invoice", data)
    .then((pdfArrayBuffer) => {
        fs.writeFileSync("invoice_for_john.pdf", Buffer.from(pdfArrayBuffer));
        console.log('PDF successfully generated and saved as invoice_for_john.pdf');
    })
    .catch((err) => {
        console.log(`Error generating PDF: ${err}`);
    });

Explanation of the Code:

Data Object: Contains the "dynamic" data to be injected into the template.
Function Call: Invokes the generatePDF function with the template key and data.
Write PDF: Saves the generated PDF to a file.
Console Log: Displays a success message or error.

Step 5: Test your integration ✅

Run your script:

node index.js

Upon success, the console will display a message that the PDF has been generated and saved. You can find the freshly generated PDF in your project directory under the name invoice_for_john.pdf.

Extra: Testing with tools like Postman

Before coding, you can use testing tools like Postman to validate your API calls:

Set the method to POST and the URL to https://reportgen.io/api/v1/generate-pdf-sync.
Add the X-API-Key header with your access key.
In the body, set the payload as raw JSON:

{
  "html_template": "<h1>Hello <%= Name %></h1>",
  "data": { "Name": "John Doe" },
  "engine": "ejs"
}

Check the response for errors or success.

Learn more about using Postman in their documentation.

Next Steps

Ready to stop wasting time on document generation? Sign up at reportgen.io and create your first PDF in under 5 minutes.

💻 Source code: On GitHub, plus a lot more examples.
👉 Create an Account: Sign up if you haven’t already.

👥 Have a better way to write this code? Drop it in the comments below. I always love a good code review!

[Boost]

Ethan from reportgen.io — Wed, 14 May 2025 04:33:42 +0000

Ethan from reportgen.io

May 14 '25

How to generate dynamic invoices for SaaS applications in Python 💸

#webdev #programming #python #tutorial

Comments

4 min read

How to generate dynamic invoices for SaaS applications in Python 💸

Ethan from reportgen.io — Wed, 14 May 2025 04:28:19 +0000

Invoice generation in SaaS applications doesn’t have to be tedious. With reportgen.io, you can automate the entire process, offering dynamic, scalable, and secure solutions. Whether you're working on a single invoice or handling bulk generation, reportgen.io’s modern API is built to make developers’ lives easier.

This guide walks you through the steps of integrating reportgen.io into your SaaS application for dynamic invoice generation, complete with advanced templating and efficient API calls.

Step 1: Define a Dynamic Template with Conditional Logic

Invoices are more than just a list of numbers; they must reflect accurate calculations, dynamic line items, and conditional elements like VAT. With reportgen.io, you can use templating engines such as EJS to create powerful, flexible templates.

Here’s an example template that:

Iterates through line items dynamically.
Calculates VAT conditionally based on the input percentage.
Includes subtotals and totals.

EJS Template Example

<html>
  <body>
    <h1>Invoice for <%= CustomerName %></h1>
    <table border="1" style="border-collapse: collapse; width: 100%;">
      <thead>
        <tr>
          <th>Description</th>
          <th>Quantity</th>
          <th>Price</th>
          <th>Subtotal</th>
        </tr>
      </thead>
      <tbody>
        <% LineItems.forEach(item => { %>
          <tr>
            <td><%= item.description %></td>
            <td><%= item.quantity %></td>
            <td><%= item.price.toFixed(2) %></td>
            <td><%= (item.quantity * item.price).toFixed(2) %></td>
          </tr>
        <% }); %>
      </tbody>
    </table>
    <p>Subtotal: $<%= Subtotal.toFixed(2) %></p>
    <% if (VATPercentage > 0) { %>
      <p>VAT (<%= (VATPercentage * 100).toFixed(1) %>%): $<%= (Subtotal * VATPercentage).toFixed(2) %></p>
    <% } %>
    <p><strong>Total: $<%= Total.toFixed(2) %></strong></p>
  </body>
</html>

This template ensures flexibility and clarity, allowing you to dynamically populate all values, including VAT percentages and line items.

Step 2: Write Python Functions

To make the implementation reusable and scalable, we’ll create functions that:

Dynamically calculate invoice data.
Handle synchronous PDF generation for immediate needs.
Use asynchronous generation for bulk operations.

Step 2.1: A Function to Generate Dynamic Data

This function calculates the subtotal, VAT, and total dynamically based on the provided line items and VAT percentage.

def generate_invoice_data(customer_name, line_items, vat_percentage):
    subtotal = sum(item['quantity'] * item['price'] for item in line_items)
    vat_amount = subtotal * vat_percentage
    total = subtotal + vat_amount
    return {
        "CustomerName": customer_name,
        "LineItems": line_items,
        "Subtotal": subtotal,
        "VATPercentage": vat_percentage,
        "Total": total
    }

Step 2.2: A Function for Synchronous PDF Generation

Synchronous generation is best for smaller workloads or when you need the invoice immediately. This function sends the request and saves the PDF locally.

import requests

def generate_pdf_sync(api_key, template, data):
    url = "https://reportgen.io/api/v1/generate-pdf-sync"
    headers = {"X-API-Key": f"{api_key}", "Content-Type": "application/json"}
    payload = {"html_template": template, "data": data, "engine": "ejs"}

    response = requests.post(url, json=payload, headers=headers)
    if response.status_code == 200:
        with open("invoice_sync.pdf", "wb") as file:
            file.write(response.content)
        print("Invoice generated successfully as 'invoice_sync.pdf'.")
    else:
        print(f"Failed to generate PDF: {response.status_code} - {response.text}")

Step 2.3: A Function for Asynchronous PDF Generation

Asynchronous generation is ideal for handling bulk operations or when the task isn’t time-sensitive. This function queues the PDF generation and returns a report_id for tracking.

def generate_pdf_async(api_key, template, data):
    url = "https://reportgen.io/api/v1/generate-pdf-async"
    headers = {"X-API-Key": f"{api_key}", "Content-Type": "application/json"}
    payload = {"html_template": template, "data": data, "engine": "ejs"}

    response = requests.post(url, json=payload, headers=headers)
    if response.status_code == 200:
        report_id = response.json().get("report_id")
        print(f"Invoice queued successfully. Report ID: {report_id}")
        return report_id
    else:
        print(f"Failed to queue PDF generation: {response.status_code} - {response.text}")

Step 3: Usage

Example Input

Here’s an example of how to call the functions with dynamic data, but it doesn't include the functions. You can simply copy them over.

api_key = "YOUR_API_KEY"
template = """
<html>
  <body>
    <h1>Invoice for <%= CustomerName %></h1>
    <table border="1" style="border-collapse: collapse; width: 100%;">
      <thead>
        <tr>
          <th>Description</th>
          <th>Quantity</th>
          <th>Price</th>
          <th>Subtotal</th>
        </tr>
      </thead>
      <tbody>
        <% LineItems.forEach(item => { %>
          <tr>
            <td><%= item.description %></td>
            <td><%= item.quantity %></td>
            <td><%= item.price.toFixed(2) %></td>
            <td><%= (item.quantity * item.price).toFixed(2) %></td>
          </tr>
        <% }); %>
      </tbody>
    </table>
    <p>Subtotal: $<%= Subtotal.toFixed(2) %></p>
    <% if (VATPercentage > 0) { %>
      <p>VAT (<%= (VATPercentage * 100).toFixed(1) %>%): $<%= (Subtotal * VATPercentage).toFixed(2) %></p>
    <% } %>
    <p><strong>Total: $<%= Total.toFixed(2) %></strong></p>
  </body>
</html>
"""
line_items = [
    {"description": "DevOps monthly", "quantity": 1, "price": 5000.0},
    {"description": "SysAdmin hours", "quantity": 10, "price": 35.0},
]
vat_percentage = 0.22  # Dynamic VAT percentage
customer_name = "John Doe"

data = generate_invoice_data(customer_name, line_items, vat_percentage)

# Sync
generate_pdf_sync(api_key, template, data)

# Or async:
report_id = generate_pdf_async(api_key, template, data)
print(f"Track your report status using this ID: {report_id}")

Why Choose reportgen.io?

Dynamic Powerhouse: Unlike competitors, reportgen.io empowers you to generate complex documents with dynamic data, conditional logic, and flexibility in templates.
Built for Scalability: Handle large volumes of PDF generation asynchronously without performance bottlenecks.
Developer-Centric: We prioritize ease of use, robust documentation, and advanced templating options like EJS and Handlebars.
Secure & Modern: With Cloudflare-backed security and data privacy, reportgen.io ensures your sensitive data is always protected.
Competitive Edge: reportgen.io offers simplicity without compromising on advanced features and flexibility, giving you the best of both worlds.

Next Steps

Implement integrations with services like Novu.co for automated invoice emailing.
Attach payment links using Stripe or PayPal APIs for seamless transactions.
Enhance workflows by incorporating invoice tracking and CRM updates with HubSpot or Salesforce.

Start leveraging reportgen.io to elevate your SaaS application's automation game today! 🚀

💻 Source code can be found on GitHub

👉 Ready to make your PDFs not suck? Try it free at reportgen.io
You get 150 reports for free each month, no credit card required.

👥 Have a better way to write this code? Drop it in the comments below. I always love a good code review!

Level Up Your PDF Game: From 1998 to Stunning in 15 Minutes

Ethan from reportgen.io — Wed, 07 May 2025 07:07:09 +0000

You're shipping reports, invoices, or data exports as PDFs. And they look like they were built in 1998. That might fly internally, but the moment you're sending them to clients, investors, or partners, it reflects directly on your brand.

Bad design isn't neutral. It kills trust.

With reportgen.io, you can generate stunning PDFs using modern CSS, Tailwind, and Chart.js - without turning your dev team into a design agency.

Here's how to go from "ugh" to "damn" in 15 minutes.

🚧 Step 1: Basic CSS – Full Control, Old School

If you want tight control and don't mind some manual work, you can write vanilla CSS. Think of this like hand-coding an HTML email.

<!-- sample invoice template -->
<style>
  body { font-family: Arial; padding: 20px; }
  .invoice { max-width: 600px; margin: auto; border: 1px solid #ccc; padding: 20px; }
</style>
<div class="invoice">
  <h1>Invoice</h1>
  <table>...</table>
</div>

Pros:

No dependencies.
Predictable rendering.

Cons:

Verbose.
No design system or utility classes.

⚡ Step 2: Tailwind – Fast, Consistent Styling

Already using Tailwind in your app? Great! Carry that system into your PDFs. Just inline the CDN or use a local build.

<script src="https://cdn.tailwindcss.com"></script>
<div class="max-w-xl mx-auto bg-white p-6 rounded shadow">
  <h1 class="text-2xl font-bold mb-4">Invoice</h1>
  <table class="w-full text-sm">...</table>
</div>

Pros:

Speed. Utility-first styling is fast.
Reusability. Copy-paste styles from your app.

Caveat:
Tailwind must be inlined as external network calls won't work in the PDF engine.

📊 Step 3: Add Dynamic Charts with Chart.js

Static reports are fine. But data-driven PDFs with live charts? That's next-level.

<canvas id="myChart"></canvas>
<script>
  new Chart(document.getElementById('myChart').getContext('2d'), {
    type: 'bar',
    data: { labels: [...], datasets: [...] }
  });
</script>

Yes, this renders directly into your PDF. No screenshotting, no hacks.

Want to make it dynamic? Use EJS (or any template engine):

<script>
  const data = <%- JSON.stringify(myData) %>;
</script>

Then inject your data via the reportgen.io API.

{
  "html_template": "...",
  "data": { "myData": [100, 200, 300] },
  "engine": "ejs"
}

📄 Learn More: Read the Full Guide →

🧰 Docs & GitHub reference

Full Docs: docs.reportgen.io
Code examples: github.com/reportgenio/examples

Final Take

You built a great product. Don't let your PDFs be the weakest link.

With reportgen.io, you can generate client-ready, visually impressive, dynamic PDFs in minutes, not days.

Make your output match your quality.

👉 Ready to make your PDFs not suck? Try it free at reportgen.io
You get 150 reports for free each month, no credit card required.

[Boost]

Ethan from reportgen.io — Wed, 30 Apr 2025 06:52:52 +0000

Ethan from reportgen.io

Apr 30 '25

From HTML to PDF at Scale - Without Subscriptions, Limits, or Pain

Comments

3 min read

[Boost]

Ethan from reportgen.io — Wed, 30 Apr 2025 06:12:54 +0000

From HTML to PDF at Scale - Without Subscriptions, Limits, or Pain

Ethan from reportgen.io ・ Apr 30

From HTML to PDF at Scale - Without Subscriptions, Limits, or Pain

Ethan from reportgen.io — Wed, 30 Apr 2025 05:49:59 +0000

Generating PDFs should be simple.

But if you've tried to do it inside a SaaS product, you already know it's anything but. Most APIs lock you into rigid templates, slow render speeds, or bloated subscription plans for what should be a basic developer utility.

We hit this wall ourselves while building internal tools. We didn’t want to manage Chromium headless rendering ourselves. But every "PDF as a Service" option we found came with restrictions that made no sense:

Subscriptions even if you're only rendering a few reports a month.
Hard limits on parallel processing or file sizes.
Poor templating support.
No async API for high-volume or background batch jobs.

So we built Reportgen.io - a simple, scalable, and affordable HTML-to-PDF API with pay-per-use pricing, unlimited parallelism, and built-in storage/CDN.

What Makes Reportgen Different

Most PDF APIs are priced like they're serving Fortune 500s. We're not.

With Reportgen, you get:

150 free reports/month
Just $0.0025 per PDF after that
No subscriptions
Unlimited parallel jobs
Unlimited file size
Built-in Cloudflare CDN & R2 storage (1-year retention)
Async and sync APIs
Templating support for EJS, Handlebars, Go templates, and raw HTML

We focused on developer ergonomics and performance at scale. Whether you're rendering one-off invoices or 10,000 reports per day, it just works.

How It Works

Here’s a basic example using the sync API and Handlebars:

const fetch = require('node-fetch');
const fs = require('fs');

// Define the Handlebars template
const htmlTemplate = `
<html>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Order Confirmation</title>
  </head>
  <body>
    <h1>Order Confirmation</h1>
    <p>Thank you for your order!</p>
    <p>Order ID: {{orderId}}</p>
    <p>Date: {{orderDate}}</p>
    <p>Your order will be shipped soon.</p>
  </body>
</html>`;

// Define the dynamic data for the Handlebars template
const templateData = {
  orderId: '123456789',
  orderDate: 'October 7, 2024'
};

// Define the payload for the request
const requestData = {
  html_template: htmlTemplate,
  data: templateData,
  engine: 'handlebars'
};

// API Key
const apiKey = 'YOUR_API_KEY';

// Function to generate PDF using the Fetch API
async function generatePDF() {
  try {
    const response = await fetch('https://reportgen.io/api/v1/generate-pdf-sync', {
      method: 'POST',
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(requestData),
    });

    if (!response.ok) {
      throw new Error(`Error generating PDF: ${response.statusText}`);
    }

    const pdfBuffer = await response.buffer();
    fs.writeFileSync('order_confirmation.pdf', pdfBuffer);
    console.log('PDF successfully generated and saved as order_confirmation.pdf');
  } catch (error) {
    console.error('Error generating PDF:', error.message);
  }
}

generatePDF();

You can pass raw HTML or use placeholders to inject dynamic data using your preferred engine. Our API supports both sync (fast, simple) and async (long-running, high-volume) operations.

Use Cases We See A Lot

SaaS platforms generating client invoices, reports, and dashboards
Marketing teams automating branded proposals
Backend systems that need contract rendering at scale
Platforms offering document downloads directly to end users

Basically, if you’re building an app and need a reliable, zero-maintenance way to generate and host PDFs, you’ll probably love this.

Trade-Offs (Yes, We Have Some)

No sandbox/test mode yet - we recommend using a separate dev account during early integration
Billing model is new - we’re tracking feedback closely, but the pay-per-use is here to stay

We believe in being transparent. We’d rather earn your trust by showing you where we’re still improving.

Try It Free (No Credit Card Needed)

We built this because we were sick of the subscription tax on basic developer tools. If you are too, come try it out and tell us what breaks.

Questions, feature requests, edge cases? Drop them in the comments or ping us on Twitter.

Happy rendering.