DEV Community: TemplateMaster

Generate Invoices as PDFs via API in C# (Step by Step)

TemplateMaster — Wed, 04 Feb 2026 13:02:57 +0000

Yet in many C# applications, generating a clean and reliable invoice PDF still feels harder than it should be.

Between PDF libraries, HTML-to-PDF tools, layout bugs, and infrastructure issues, what looks like a simple feature often turns into a maintenance nightmare.

In this article, I’ll show you how to generate invoice PDFs in C# using an API-first approach, with:

HTML templates
dynamic JSON data
no PDF logic in your backend

Why invoice PDF generation is still painful in .NET

If you’ve worked on invoice generation before, this probably sounds familiar:

Layout breaks when data grows
PDF libraries tightly coupled to business logic
Headless browsers crashing in production
Every layout change requires a redeploy
Only developers can edit templates

Invoices evolve constantly: branding, legal mentions, taxes, languages.
Embedding all of that directly inside your backend does not scale.

That’s why treating document generation as a separate service makes a huge difference.

The API-first approach

Instead of generating PDFs inside your C# application, we’ll:
(using a document generation API like TemplateMaster)

Create an HTML invoice template
Store and version it in TemplateMaster
Send invoice data as JSON
Let the API generate the PDF
Receive a ready-to-use file

Your backend focuses on business logic.
The document layer becomes external, reusable, and maintainable.

Step 1 – Create an invoice HTML template

Here’s a simplified invoice template example:

<h1>Invoice #{{invoiceNumber}}</h1>

<p>
  <strong>Customer</strong><br />
  {{customer.name}}<br />
  {{customer.address}}
</p>

<table width="100%" border="1" cellspacing="0" cellpadding="8">
  <thead>
    <tr>
      <th>Description</th>
      <th>Qty</th>
      <th>Unit price</th>
      <th>Total</th>
    </tr>
  </thead>
  <tbody>
    {{#each items}}
    <tr>
      <td>{{description}}</td>
      <td>{{quantity}}</td>
      <td>{{price}} €</td>
      <td>{{total}} €</td>
    </tr>
    {{/each}}
  </tbody>
</table>

<p>
  <strong>Total amount:</strong> {{totalAmount}} €
</p>

This template:

is readable
supports loops
can be edited by non-developers
doesn’t require any C# change when updated

Step 2 – Upload the template to TemplateMaster

Once uploaded to TemplateMaster:

the template is versioned
editable via a visual editor
reusable across environments

Each template has a unique identifier, for example:

813a5147-a68c-4c37-b194-124100368efa

This identifier will be used by your backend when generating PDFs.

Step 3 – Prepare invoice data in C#

Now let’s build the invoice payload in C#:

var invoiceData ={
    "templateCode": "813a5147-a68c-4c37-b194-124100368efa",
    "version": 0,
    "data": {
        "name": "John Doe",
        "address": "1234 Main St, Anytown, AN 12345",
        "items": [
            {
                "description": "Product 1",
                "quantity": 2,
                "price": 30.00
            },
            {
                "description": "Product 2",
                "quantity": 1,
                "price": 15.50
            }
        ],
        "total": 75.50,
        "date": "2023-07-30",
        "metadata": {
            "title": "Service Agreement",
            "author": "TemplateMaster",
            "subject": "Commercial agreement between TemplateMaster and ABC Company",
            "keywords": ["contract", "services", "TemplateMaster", "ABC Company"],
            "creator": "TemplateMaster API",
            "producer": "TemplateMaster PDF Engine",
            "createdAt": "2025-10-14T10:30:00Z",
            "modifiedAt": "2025-10-14T10:31:00Z"
        },
        "indexes":[
            { "DocumentType": "Facture" },
            { "InvoiceNumber":  "F2025-00123" },
            { "CreatedBy": "TemplateMaster" }
        ]
    }
};

This object matches the variables used in the HTML template.

No formatting logic.
No PDF concerns.
Just data.

Step 4 – Call the PDF generation API

Now we send the template ID and data to TemplateMaster.

using var client = new HttpClient();

var request = new
{
    templateId = "invoice-default",
    data = invoiceData
};

var response = await client.PostAsJsonAsync(
    "https://api.templatemaster.io/pdf/generate",
    request
);

var pdfBytes = await response.Content.ReadAsByteArrayAsync();
File.WriteAllBytes("invoice.pdf", pdfBytes);

That’s all it takes.

No PDF engine.
No headless browser.
No rendering logic in your backend.

Step 5 – Use the PDF anywhere

Once generated, the PDF can be:

emailed to customers
stored for accounting
archived for compliance
exposed via an API

When the invoice layout changes?

Update the template
No backend redeploy
No code change

Why this approach scales better
Approach Problems
PDF libraries Tight coupling, hard to evolve
HTML-to-PDF in backend Infra heavy, unstable
API-based generation Clean, scalable, maintainable

This pattern works especially well when:

invoices evolve frequently
multiple teams collaborate
you run a SaaS or multi-tenant system

Final thoughts

Invoice PDF generation shouldn’t slow your team down.

By externalizing document generation behind an API, you:

reduce complexity
move faster
keep your backend clean

If you’re building a serious C# application, this is a pattern worth adopting early.

Try it locally

If you want to experiment with this approach, I’m using

TemplateMaster to manage templates and generate PDFs via API.

You can try it without changing your C# setup or PDF stack.

Automate Shopify Order Emails & PDF Invoices Using TemplateMaster API + Webhooks

TemplateMaster — Tue, 09 Dec 2025 15:16:59 +0000

When a new order is created in Shopify, many merchants want to automatically:

Generate a PDF invoice
Send a confirmation email
Store or archive the document
Trigger backend processes

But doing this manually — or building your own PDF generation engine — is complex and time-consuming.

In this article, I’ll show you how to integrate Shopify Webhooks with the TemplateMaster API to automatically send invoices and emails whenever a new order is created.

This works with any backend language (C#, Node.js, Python, PHP…).

🧩 What is TemplateMaster?

TemplateMaster is a SaaS designed for developers and businesses who need:

📝 HTML/CSS template editor
📄 PDF generation via API
✉️ Email sending API
🔐 API key protection
🧩 JSON-based dynamic rendering
🗂️ Storage + versioning of templates

It is perfect for invoices, receipts, order confirmations, shipping docs, etc.

👉 Try it here: https://templatemaster.fr

📦 Shopify Webhook + TemplateMaster Workflow

Customer places an order ⬇️
Shopify triggers the orders/create webhook ⬇️
Your server receives the webhook ⬇️
Your server calls TemplateMaster API to:

Generate a PDF invoice
Send an email to the customer (with PDF attached)

⬇️

Shopify customer receives your customized invoice

1. Configure the Shopify Webhook

In Shopify Admin:

Settings → Notifications → Webhooks → Create Webhook

Event: Order creation (orders/create)
Format: JSON
URL: Your API endpoint (e.g. https://your-server.com/webhooks/shopify/order-created)

Shopify will POST the full order JSON to your server.

2. Example of Webhook Receiver (Node.js)

This endpoint receives the Shopify order JSON and generates a PDF invoice through TemplateMaster.

import express from "express";
import axios from "axios";

const app = express();
app.use(express.json());

app.post("/webhooks/shopify/order-created", async (req, res) => {
  const order = req.body;

  try {
    // Call TemplateMaster to generate a PDF + send email
    await axios.post(
      "https://api.templatemaster.fr/generate/pdf-email",
      {
        templateId: "your-invoice-template-id",
        data: order, // You can remap fields if needed
        email: {
          to: order.email,
          subject: `Invoice for Order #${order.name}`
        }
      },
      {
        headers: {
          "X-API-KEY": process.env.TM_API_KEY
        }
      }
    );

    res.status(200).send("OK");
  } catch (err) {
    console.error(err);
    res.status(500).send("Error");
  }
});

app.listen(3000, () => console.log("Server running"));

3. Example in C# (.NET)

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

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-KEY", "YOUR_API_KEY");

app.MapPost("/webhooks/shopify/order-created", async (Order order) =>
{
    var requestBody = new
    {
        templateId = "your-invoice-template-id",
        data = order,
        email = new
        {
            to = order.email,
            subject = $"Invoice for Order {order.name}"
        }
    };

    var json = System.Text.Json.JsonSerializer.Serialize(requestBody);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    await client.PostAsync("https://api.templatemaster.fr/generate/pdf-email", content);

    return Results.Ok();
});

4. Template Structure (Invoice Example)

Inside your TemplateMaster HTML template, simply use JSON placeholders:

<h1>Invoice – Order {{name}}</h1>

<p>Date: {{created_at}}</p>
<p>Customer: {{customer.first_name}} {{customer.last_name}}</p>

<table>
  <tr>
    <th>Item</th>
    <th>Qty</th>
    <th>Price</th>
  </tr>

  {{#each line_items}}
  <tr>
    <td>{{title}}</td>
    <td>{{quantity}}</td>
    <td>{{price}}</td>
  </tr>
  {{/each}}
</table>

<p>Total: {{total_price}} {{currency}}</p>

TemplateMaster automatically applies your CSS and returns a beautiful PDF.

5. Bonus Features You Can Add

✔️ Send emails to the store owner
✔️ Send packing slips to warehouse staff
✔️ Add customer notes, discount codes, fulfillment info
✔️ Save PDFs to your storage (S3, Azure, etc.)
✔️ Use multiple templates depending on order type

🎉 Conclusion

With just a few lines of code, you can fully automate:

PDF invoice generation
Order confirmation emails
Document storage
Multi-store workflows

Using Shopify Webhooks + TemplateMaster API is a powerful way to build scalable, automated document flows without maintaining your own rendering engine.

👉 Try it now: https://templatemaster.fr

How to Generate PDFs via API in C# (using TemplateMaster)

TemplateMaster — Tue, 09 Dec 2025 15:07:39 +0000

✨ Introduction

Generating PDFs dynamically in a C# application is a common need: invoices, quotes, certificates, contracts…
But implementing your own PDF engine is painful — libraries are heavy, HTML rendering is inconsistent, and templates are hard to maintain.

That's why I built TemplateMaster, a simple API-based service that lets you generate PDF documents from templates using clean JSON data.

In this article, I’ll show you how to generate a PDF from C# in just a few lines of code.

🔧 Step 1 — Add your configuration in appsettings.json

{
  "TemplateMaster": {
    "ApiKey": "YOUR_API_KEY_HERE",
    "BaseUrl": "https://api.templatemaster.fr"
  }
}

🔨 Step 2 — Create a TemplateMaster API client

public class TemplateMasterClient
{
    private readonly HttpClient _http;
    private readonly string _apiKey;

    public TemplateMasterClient(HttpClient http, IConfiguration config)
    {
        _http = http;
        _apiKey = config["TemplateMaster:ApiKey"];

        _http.BaseAddress = new Uri(config["TemplateMaster:BaseUrl"]);
        _http.DefaultRequestHeaders.Add("X-API-KEY", _apiKey);
    }
}

This client automatically injects the API key into every request.

📄 Step 3 — Generate a PDF

Endpoint used:
POST /documents/generate

C# method:

public async Task<byte[]> GenerateDocument(string templateId, object model)
{
    var request = new
    {
        TemplateId = templateId,
        Data = model
    };

    var response = await _http.PostAsJsonAsync("/documents/generate", request);
    response.EnsureSuccessStatusCode();

    var result = await response.Content.ReadFromJsonAsync<Dictionary<string, string>>();
    var fileUrl = result["FileUrl"];

    return await _http.GetByteArrayAsync(fileUrl);
}

▶️ Usage example
var pdf = await _templateMaster.GenerateDocument("invoice-template", new {
    Customer = "John Doe",
    Amount = 120.50,
    Date = DateTime.Now.ToString("yyyy-MM-dd")
});

await File.WriteAllBytesAsync("invoice.pdf", pdf);

🚀 Try TemplateMaster

You can test the API for free here:
👉 TemplateMaster

Automate Document & Email Generation in Your Apps with TemplateMaster

TemplateMaster — Sat, 08 Nov 2025 09:48:58 +0000

Introduction
Creating, sending, and managing documents and emails is often repetitive and error-prone, especially when working with multiple templates and formats. TemplateMaster is a SaaS platform that allows developers and teams to automate document and email generation using a simple API and an intuitive editor.

Why TemplateMaster?
With TemplateMaster, you can:

Create dynamic templates with HTML/CSS and a live PDF preview.

Automate email sending directly from your templates or via APIs.

Store documents securely, or integrate with external storage like AWS S3 or Cloudflare R2.

Add metadata and document indexes for advanced search or document management (GED).
Advanced Features

SMTP Configuration: Connect multiple SMTP servers and define a default one.

Webhooks: Automatically send generated documents to external applications or storage.

Metadata & Indexing: Add PDF metadata and structured indexes for enterprise document management.

Conclusion
TemplateMaster simplifies the repetitive parts of document and email handling for developers. By integrating the API, you can focus on your core application logic while ensuring reliable, professional documents and emails.

Try it today: https://templatemaster.fr

GitHub Repository: [https://github.com/Moukouk/TemplateMaster)