DEV Community: TemplateMaster

Give Your AI Agent the Power to Generate PDFs and Send Emails with an MCP Server

TemplateMaster — Mon, 05 Oct 2026 12:49:40 +0000

What if your AI assistant could look up an invoice template, fill it with data, generate the PDF and email it to a customer, all from a single prompt?

TemplateMaster exposes a Model Context Protocol (MCP) server. Any MCP-compatible agent (a desktop assistant, an IDE agent, or your own) can search your templates, generate documents and send emails, under the same rules as the REST API: permissions, quotas and strict per-organization data isolation.

In this article we'll connect an agent to it, walk through the permission model, and look at what a typical document-generation run looks like.

📚 Source: official documentation — MCP Server

🔌 Connection details


Server URL	`https://mcp.templatemaster.fr/mcp`
Transport	Streamable HTTP
Authentication	`X-API-KEY: <API_KEY>` header

🔑 Header gotcha: send your API key in the X-API-KEY header on every request, exactly like the REST API. Authorization: Bearer is not accepted for API keys; a key sent that way is rejected with a 401.

⚙️ Setup in 5 steps

1. Create an API key

In TemplateMaster, open Settings → API Keys and click Generate New Key. The same key can serve both the REST API and MCP.

2. Enable the key's MCP permissions

On the key's row, click MCP permissions and tick only the capabilities the agent needs. MCP access is disabled by default: a key without any MCP permission is refused by the server.

3. Configure your MCP client

Declare a remote MCP server using the Streamable HTTP transport, the URL above and the X-API-KEY header:

{
  "mcpServers": {
    "templatemaster": {
      "type": "http",
      "url": "https://mcp.templatemaster.fr/mcp",
      "headers": {
        "X-API-KEY": "YOUR_API_KEY"
      }
    }
  }
}

The exact config format depends on your MCP client and version, so check its docs for the remote HTTP server syntax. And never commit your API key to a repository.

4. Discover the tools

Once connected, your client lists the available tools. Only the tools allowed by the key's permissions appear.

5. Make a first request

Ask your agent to list your document templates. It calls list_templates and displays the result.

⚠️ Signed requests: if Signed requests required is enabled for your organization (Settings → API Keys), MCP access is refused, because MCP clients can't HMAC-sign every request. Use the standard API Key only mode to use MCP.

🛡️ Permissions: least privilege by design

Each API key has its own MCP permissions. Deletions are never available to agents.

Permission	Scope	Allows
Read templates	`mcp.templates.read`	`list_templates`, `get_template` and template resources
Read documents	`mcp.documents.read`	`get_document`, `list_documents`
Generate documents	`mcp.documents.generate`	`generate_document` (counts toward the monthly document quota)
Read email status	`mcp.emails.read`	`get_email_status`
Send emails (sensitive)	`mcp.emails.send`	`send_email`: real emails to external recipients (counts toward the email quota)

My practical advice: create a dedicated key per agent, and don't grant mcp.emails.send unless that agent truly needs it. An agent that can only read templates and generate PDFs can't email anything to anyone, whatever a prompt tells it.

🧰 The tools

Tools always act on the organization that owns the API key. An agent can never reach another organization's data.

Tool	Description
`list_templates`	Search your organization's document and email templates (search, type, pagination)
`get_template`	Template details: type, versions and expected data variables
`generate_document`	Generate a PDF from a document template and JSON data. Asynchronous: returns a `documentId`
`get_document`	Document status (`pending`, `retrying`, `generated`, `failed`) and a temporary download link once generated
`list_documents`	List your organization's documents (search, type, period, pagination)
`send_email`	Send an email from an email template (HTML or MJML) to one or more recipients, with optional attachments
`get_email_status`	Processing status of an email (`pending`, `retrying`, `sent`, `failed`)

The server also exposes read-only resources, templatemaster://templates and templatemaster://templates/CODE, with your template catalog.

🚶 A typical run

To generate a document, an agent chains these tools. You can do the same by hand in an MCP test client:

list_templates: find the template and copy its code.
get_template: read the variables list to build the data object (a dot means nesting: customer.name).
generate_document: send templateCode and data, and keep the returned documentId.
get_document: call it until the status is generated, then open temporaryDownloadUrl.

Here's what the generate_document arguments look like:

{
  "templateCode": "3f2a9c1e-5b7d-4c21-9e0a-7d6b8f1c2a44",
  "data": {
    "invoice_number": "INV-10023",
    "customer": { "name": "John Doe" },
    "items": [
      { "label": "T-shirt", "price": "19.90" }
    ]
  },
  "fileName": "INV-10023.pdf"
}

Two things to remember:

⏱️ Everything is asynchronous. generate_document and send_email answer immediately with an identifier. Poll get_document / get_email_status for the outcome.
🔗 Download links are short-lived (about 60 seconds). Call get_document again to get a fresh one.

💬 What it feels like

Once connected, you can simply say:

"Generate invoice INV-10023 for John Doe, one T-shirt at 19.90, and give me the PDF."

The agent finds the invoice template, reads its variables, builds the JSON above, generates the document, waits for it, and hands you the link. Add the mcp.emails.send permission and "…then email it to john@example.com" works too, which is exactly why that permission is flagged as sensitive.

🧯 Error handling

Tool errors come back as a message starting with a stable code, for example TEMPLATE_NOT_FOUND: .... No internal detail is leaked; unexpected errors include a correlation ID for support.

Code	Meaning
`UNAUTHORIZED`	Missing/invalid/inactive key, key without MCP permission, or key not sent in `X-API-KEY`
`FORBIDDEN`	The key lacks the permission required by this tool
`TEMPLATE_NOT_FOUND`	Unknown, deleted, or belonging to another organization
`DOCUMENT_NOT_FOUND`	Unknown document, or belonging to another organization
`INVALID_INPUT`	Invalid argument (type, format, size, email address…)
`QUOTA_EXCEEDED`	Your plan's monthly limit is reached
`GENERATION_FAILED`	The document couldn't be generated
`EMAIL_FAILED`	The email couldn't be queued
`INTERNAL_ERROR`	Unexpected error: contact support with the correlation ID

Because the codes are stable, an agent (or your own code) can react to them reliably, for instance by telling the user "quota reached" instead of retrying forever.

🔒 Security model

The organization comes from the API key only. No tool accepts an organization ID.
Another organization's resources are reported exactly like nonexistent ones, so nothing leaks through error messages.
Inputs are validated and bounded (data size, number of recipients and attachments, pagination), and requests are rate-limited per key.
Every tool call is logged and audited (MCP source), without logging the data you send.
Monthly quotas apply exactly as for the REST API.

OAuth 2.1 (optional)

On deployments where it's enabled, the MCP server also accepts OAuth 2.1 access tokens issued by your organization's authorization server, in addition to API keys. Tokens go in Authorization: Bearer; API keys always stay in X-API-KEY. Contact the TemplateMaster team to enable it.

🎯 Wrapping up

The MCP server turns document generation into something an agent can do safely: scoped keys, no delete access, strict isolation, quotas, auditing. Start with a read-only key to let the agent explore your templates, then add generate once you trust the workflow, and keep send for last.

Related docs: API key configuration and the .NET integration if you'd rather call TemplateMaster from C# code.

👉 Full documentation: templatemaster.fr/fr/documentation/mcp-server

Are you already giving agents access to business tools? What guardrails do you put in place? Let me know in the comments! 👇

Generate PDFs and Emails in ASP.NET Core with the TemplateMaster NuGet Package

TemplateMaster — Mon, 05 Oct 2026 12:47:44 +0000

If your ASP.NET Core app needs to produce invoices, contracts or transactional emails, you usually end up choosing between a PDF library you template by hand and a separate SaaS you call over HTTP. TemplateMaster offers a third option: a NuGet package, TemplateMaster.AspNetCore, that embeds a visual template editor, its API and a C# service inside your own application.

Your users stay your users, your data stays in your database, and generating a PDF becomes a method call instead of an HTTP request.

📚 Source: official documentation — .NET Integration (NuGet)

🧭 What you get


Package	`TemplateMaster.AspNetCore`
Platform	.NET 8 · ASP.NET Core
Editor	Visual template editor served under `/templatemaster` (UI bundled, no Node.js needed)
C# API	`ITemplateMaster` — generate PDFs and send emails straight from your code
Auth	Reuses your app's authentication — there's no separate TemplateMaster login

📦 Prerequisites

.NET 8 and an ASP.NET Core application
SQL Server 2019+: a dedicated database for TemplateMaster (created automatically in development)
RabbitMQ in production (in development, UseInMemoryMessaging() is enough)
Cookie-based authentication in your app (Identity, OpenID Connect, cookie…). TemplateMaster maps your signed-in users to its own users; it doesn't ship its own sign-in page.

1️⃣ Install the package

dotnet add package TemplateMaster.AspNetCore

That's the only package to reference. The whole TemplateMaster layer is included; only third-party dependencies (EF Core, MassTransit, PuppeteerSharp…) are pulled from nuget.org.

2️⃣ Configure `appsettings.json`

TemplateMaster reads its settings from a dedicated TemplateMaster section and never touches your other keys.

{
  "ConnectionStrings": {
    "TemplateMaster": "Server=localhost;Database=TemplateMaster;Trusted_Connection=True;TrustServerCertificate=True"
  },
  "RabbitMq": {
    "Host": "localhost",
    "Username": "guest",
    "Password": "guest"
  },
  "TemplateMaster": {
    "LicenseKey": "<your license key - keep it in user secrets / environment variables>",
    "PathRoot": "D:/templatemaster/files",
    "EmailSettings": {
      "SMTPSetting": { "Host": "smtp.example.com" },
      "Port": 587,
      "UserName": "noreply@example.com"
    }
  }
}

PathRoot is where generated documents are stored on disk (it's printed at startup).

3️⃣ Wire it up in `Program.cs`

using TemplateMaster;

var builder = WebApplication.CreateBuilder(args);

// Your application's own authentication (cookie, Identity, OpenID Connect...)
builder.Services.AddAuthentication(/* ... */);
builder.Services.AddAuthorization(options =>
    options.AddPolicy("TemplateMasterAdmin", policy => policy.RequireRole("Admin")));

builder.Services
    .AddTemplateMaster(options =>
    {
        options.BasePath = "/templatemaster";
        options.Database.AutoCreate = builder.Environment.IsDevelopment();
    })
    .UseSqlServer(builder.Configuration.GetConnectionString("TemplateMaster")!)
    .UseRabbitMq(options =>
    {
        options.Host = builder.Configuration["RabbitMq:Host"]!;
        options.Username = builder.Configuration["RabbitMq:Username"]!;
        options.Password = builder.Configuration["RabbitMq:Password"]!;
    })
    .AddLicenseKey(licenseKey: builder.Configuration["TemplateMaster:LicenseKey"]);

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// TemplateMaster editor + API, reserved to your administrators
app.MapTemplateMaster("/templatemaster")
   .RequireAuthorization("TemplateMasterAdmin");

app.Run();

Three things worth understanding here:

Database.AutoCreate creates the database on first run. Keep it for development only; in production, deploy the schema with the SQL scripts.
The dashboard always requires a signed-in user. RequireAuthorization(...) lets you add your own rules on top, like the Admin role policy above.
Messaging: UseRabbitMq is for production. For local development, UseInMemoryMessaging() saves you from running a broker.

4️⃣ Activate your license

Without a license, generated PDFs and emails carry a watermark and the free-plan limits apply: 10 documents and 10 emails per month. That's plenty to try everything out.

The key goes through AddLicenseKey, matching the TemplateMaster:LicenseKey entry of your configuration. Since it's a secret, keep it out of source control:

# Development: user secrets
dotnet user-secrets set "TemplateMaster:LicenseKey" "<your-key>"

# Production: environment variable
TemplateMaster__LicenseKey=<your-key>

At startup, the result is written to your logs:

info: TemplateMaster.License[0]
      TemplateMaster license: VALID - client acme, issued 2026-10-03, expires 2027-10-03.

If the key is rejected, the log explains why, but an invalid key never prevents your app from starting.

5️⃣ Open the editor

Run the app, sign in with your application's login, and go to /templatemaster. A default invoice template and a default email template are already created for you.

👥 Users and organizations

There's no TemplateMaster login screen. A user signed in to your app is automatically matched (by email) to a TemplateMaster user and organization, created on their first visit. Two models:

One organization (default): all your users share the same templates.
One organization per customer (Tenancy.Mode = HostManaged + TenantKeySelector): each customer of your app gets isolated templates and documents, exactly like on the SaaS platform. Perfect for B2B multi-tenant apps.

6️⃣ Generate PDFs and emails from C

Inject ITemplateMaster into your services. Every call applies the same rules as the REST API: validation, per-organization isolation, plan limits and document history. No HTTP call involved.

Method	Purpose
`GetTemplatesAsync(type?)`	List the organization's templates (code, name, type)
`RenderHtmlAsync(code, model)`	Render a template to HTML with your data, without saving anything
`GeneratePdfAsync(code, model, fileName?)`	Generate a PDF immediately and add it to the document history
`QueueDocumentAsync(code, model)`	Queue a PDF generation, processed in the background
`SendEmailAsync(email)`	Send an email from an email template
`ForUser(user)`	Same API, on behalf of the signed-in user (their organization, their role)
`ForTenant(tenantKey)`	Same API, for a given customer (one-organization-per-customer mode)

Here's an invoice service:

using TemplateMaster;

public sealed class InvoiceService(ITemplateMaster templateMaster)
{
    public async Task<byte[]> CreatePdfAsync(Invoice invoice, CancellationToken ct)
    {
        var template = (await templateMaster.GetTemplatesAsync(TemplateMasterTemplateType.Document, ct))
            .Single(t => t.Name == "invoice");

        return await templateMaster.GeneratePdfAsync(
            template.Code,
            new
            {
                invoice_number = invoice.Number,
                customer_name = invoice.CustomerName,
                items = invoice.Lines.Select(l => new { description = l.Label, quantity = l.Quantity })
            },
            fileName: $"{invoice.Number}.pdf",
            cancellationToken: ct);
    }
}

And expose it with a minimal API endpoint:

app.MapGet("/invoices/{id:int}/pdf", async (int id, InvoiceService invoices, CancellationToken ct) =>
{
    var pdf = await invoices.CreatePdfAsync(await LoadInvoiceAsync(id, ct), ct);
    return Results.File(pdf, "application/pdf", $"invoice-{id}.pdf");
}).RequireAuthorization();

⚠️ Model property names must match the template variables. {{invoice_number}} expects a property called invoice_number. Use an anonymous object, a dictionary, or [JsonPropertyName] to control the names. This is the #1 cause of "empty" fields in generated documents.

When a PDF takes time or you generate many at once, prefer QueueDocumentAsync: the work happens in the background through the message bus instead of blocking your request.

🚦 Before going to production

A checklist straight from the docs:

[ ] Database schema deployed with SQL scripts, Database.AutoCreate disabled
[ ] UseRabbitMq with a dedicated virtual host if the broker is shared
[ ] License and secrets (SMTP, Authentication:ClientSecret) in environment variables
[ ] PathRoot on a persistent volume (shared between instances); Redis configured if you run several instances
[ ] On Linux / Docker: Chromium installed (/usr/bin/chromium), required for PDF generation

That last point trips people up in containers: PDF rendering is browser-based (PuppeteerSharp), so a slim base image without Chromium will fail at generation time. A minimal Dockerfile addition on Debian-based images:

RUN apt-get update \
 && apt-get install -y --no-install-recommends chromium \
 && rm -rf /var/lib/apt/lists/*

🎯 Wrapping up

In a handful of lines you get a visual editor for your non-developer colleagues, a typed C# API for generating PDFs and emails, per-customer isolation if you need it, and no extra login to manage. If you want to see everything working end to end (login, PDF generation, background jobs, emails), the TemplateMaster team published a complete TemplateMasterDemo app on GitHub, linked from the docs.

Want to try it without any .NET setup first? Check out my previous post on running the whole TemplateMaster stack locally with Docker Compose.

👉 Full documentation: templatemaster.fr/fr/documentation/dotnet-integration

Are you generating PDFs in your .NET apps today? Which library are you using? Let me know in the comments! 👇

Run TemplateMaster Locally in 5 Minutes with Docker Compose (PDF & Email API)

TemplateMaster — Mon, 05 Oct 2026 12:45:26 +0000

Generating PDFs and emails from templates is something almost every business application ends up needing: invoices, contracts, notifications, statements… TemplateMaster provides a PDF & Email generation API paired with a visual template editor.

Good news: the whole stack can run locally with a single docker compose up. In this article we'll walk through the official configuration, start it, and I'll share a few tweaks to make it more robust.

📚 Source: official documentation — Run local environment

🧱 What we're going to run

The local stack is made of 5 services:

Service	Image	Role	Port(s)
`editorTemplate-front`	`templatemaster/editortemplate-front`	Web UI / visual editor	`8080`
`editorTemplate-api`	`templatemaster/editortemplate-api`	.NET API (PDF/email generation)	`5000`
`mssql`	`mcr.microsoft.com/mssql/server:2019-latest`	Database (app + Hangfire)	`1433`
`rabbitmq-service`	`rabbitmq:3-management`	Message bus for async processing	`5672`, `15672`
`smtp4dev`	`rnwood/smtp4dev:v3`	Fake SMTP server that captures emails	`9000`, `2525`

            ┌──────────────┐
  Browser   │  Front :8080 │
            └──────┬───────┘
                   │ HTTP
            ┌──────▼───────┐      ┌──────────────┐
            │  API  :5000  ├─────►│ SQL Server   │  (TemplateEditor + HangfireDb)
            └──┬────────┬──┘      └──────────────┘
               │        │
     AMQP      │        │ SMTP
 ┌─────────────▼──┐  ┌──▼──────────┐
 │ RabbitMQ       │  │ smtp4dev    │  → email UI on :9000
 └────────────────┘  └─────────────┘

It's a classic .NET architecture: Hangfire for scheduled jobs, RabbitMQ for the message queue, and smtp4dev to intercept every email without ever sending anything outside. Perfect for development.

⚠️ Before you start: no encryption locally

In production, TemplateMaster encrypts sensitive data in the database. Locally, this encryption is disabled to make debugging easier. Bottom line: never use this environment with real or sensitive data.

📦 Prerequisites

Docker Desktop (Docker Compose is included)
These ports must be free: 5000, 8080, 1433, 5672, 15672, 9000 (and 2525 for SMTP)

A handy way to check whether a port is already in use:

# Linux / macOS
lsof -i :1433

# Windows (PowerShell)
netstat -ano | findstr :1433

💡 Already running SQL Server on your machine? It's probably holding port 1433. Just change the mapping to "14330:1433".

🗂️ Project structure

Two files are all you need:

/
├─ docker-compose.yaml
└─ .env

`docker-compose.yaml`

version: "3"
services:
  smtp4dev:
    image: rnwood/smtp4dev:v3
    container_name: smtp4dev
    restart: always
    ports:
      - "9000:80"
      - "2525:25"

  mssql:
    image: mcr.microsoft.com/mssql/server:2019-latest
    container_name: mssql
    environment:
      SA_PASSWORD: "YourStrong!Passw0rd"
      ACCEPT_EULA: "Y"
    ports:
      - "1433:1433"

  rabbitmq-service:
    image: rabbitmq:3-management
    container_name: rabbitmq_service
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      RABBITMQ_DEFAULT_USER: "${RABBIT_MQ_USER_NAME}"
      RABBITMQ_DEFAULT_PASS: "${RABBIT_MQ_USER_PASSWORD}"

  editorTemplate-api:
    image: templatemaster/editortemplate-api:latest
    container_name: editorTemplate-api
    ports:
      - "5000:8080"
    volumes:
      - "C:/EditorTemplate:/app/EditeurDoc"
      #- /home/EditorTemplate:/app/EditeurDoc
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      ConnectionStrings__EditeurBdd: "${EDITEUR_BDD}"
      ConnectionStrings__HangfireDb: "${HANGFIRE_BDD}"
      EmailSettings__SMTPSetting__Host: "smtp4dev"
      EmailSettings__Port: "${EDITEUR_EMAIL_PORT}"
      EmailSettings__UserName: "${EDITEUR_EMAIL_USER_NAME}"
      EmailSettings__Password: "${EDITEUR_EMAIL_PASSWORD}"
      RabbitMQ__HostName: "rabbitmq://rabbitmq-service"
      RabbitMQ__UserName: "${RABBIT_MQ_USER_NAME}"
      RabbitMQ__Password: "${RABBIT_MQ_USER_PASSWORD}"
      contactEmail: "${CONTACT_EMAIL}"
      Authentication__Issuer: "${ATHENTICATION_ISSUER}"
      Authentication__Audience: "${ATHENTICATION_AUDIENCE}"
      Authentication__ClientSecret: "${ATHENTICATION_CLIENT_SECRET}"
      BaseUrl: "${BASE_URL_API}"
      BaseUrlFront: "${BASE_URL_FRONT}"
      adminEmail: "${ADMIN_EMAIL}"
      adminPassword: "${ADMIN_PASSWORD}"
      LICENSE_KEY: "${LICENSE_KEY}"
    depends_on:
      - rabbitmq-service
      - smtp4dev
      - mssql

  editorTemplate-front:
    image: templatemaster/editortemplate-front:latest
    container_name: editortemplate-front
    ports:
      - "8080:80"
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      BASE_URL: "${BASE_URL_API}"

A few things worth noting:

Variables like ConnectionStrings__EditeurBdd or RabbitMQ__HostName follow the ASP.NET Core convention: the double underscore __ maps to the : separator in appsettings.json. So RabbitMQ__HostName overrides RabbitMQ:HostName.
Services talk to each other by name on the Docker network: the API reaches the database via Server=mssql, SMTP via smtp4dev (internal port 25) and RabbitMQ via rabbitmq-service.
The volume C:/EditorTemplate:/app/EditeurDoc persists generated files on the host. On Linux/macOS, uncomment the /home/EditorTemplate:/app/EditeurDoc line (and comment out the Windows one).

`.env`

EDITEUR_BDD='Server=mssql;Database=TemplateEditor;Trusted_Connection=False;TrustServerCertificate=True;User id=sa;Password=YourStrong!Passw0rd;'
HANGFIRE_BDD='Server=mssql;Database=HangfireDb;Trusted_Connection=False;TrustServerCertificate=True;User id=sa;Password=YourStrong!Passw0rd;'

EDITEUR_EMAIL_HOST='smtp4dev'
EDITEUR_EMAIL_PORT=25
EDITEUR_EMAIL_USER_NAME='contact@templatemaster.fr'
EDITEUR_EMAIL_PASSWORD=''

BASE_URL_API='http://localhost:5000/api/v1'
BASE_URL_FRONT='http://localhost:8080/'

RABBIT_MQ_USER_NAME='editorTemplate'
RABBIT_MQ_USER_PASSWORD='editorTemplatePassword'

ADMIN_EMAIL='admin@templatemaster.fr'
ADMIN_PASSWORD='admin'
CONTACT_EMAIL='admin@gmail.com'

ATHENTICATION_ISSUER='templatemaster.fr'
ATHENTICATION_AUDIENCE='account'
ATHENTICATION_CLIENT_SECRET='<generate-your-own-secret>'

LICENSE_KEY=''

⚠️ Watch the spelling: the variables really are named ATHENTICATION_* (no "U"). Don't "fix" them in .env without also fixing docker-compose.yaml, or the API will start with empty values.

For the authentication secret, rather than copying a value found online, generate your own:

openssl rand -hex 32

🚀 Start it up

Put both files in the same folder, then run:

docker compose up -d

docker compose (with a space) is the Compose v2 syntax bundled with Docker Desktop. The legacy docker-compose command works too.

Once the containers are up:

URL	What
http://localhost:8080/signin	🌐 TemplateMaster UI
http://localhost:9000	📬 smtp4dev — every email sent by the app
http://localhost:15672	📨 RabbitMQ management console (credentials from `.env`)
https://webhook.site	🌍 To test your outgoing webhooks

🔑 First login

On first startup, an admin account is created automatically from ADMIN_EMAIL and ADMIN_PASSWORD. With the .env above:

Email:    admin@templatemaster.fr
Password: admin

Head over to http://localhost:8080/signin… and start building your first template! Send a test email: it will show up instantly in smtp4dev.

🛠️ Everyday commands

# Follow the API logs
docker compose logs -f editorTemplate-api

# Check that .env variables are interpolated correctly
docker compose config

# Stop the stack
docker compose down

# Update the TemplateMaster images (:latest tag)
docker compose pull && docker compose up -d

💡 The official docs mention docker compose up -d --build. Since every service uses a prebuilt image (no build: section), --build has no effect here. To get a new version, run docker compose pull.

🧠 Going further: making the stack more robust

The official configuration works, but it has a classic pitfall: depends_on waits for the SQL Server container to start, not for it to be *ready. SQL Server often takes 10–30 seconds before accepting connections, and the API can crash on startup. The docs actually hint at this: *make sure the database is initialized before the API starts.

The fix: add healthchecks and make the API wait for them.

services:
  mssql:
    image: mcr.microsoft.com/mssql/server:2019-latest
    environment:
      MSSQL_SA_PASSWORD: "${SA_PASSWORD}"
      ACCEPT_EULA: "Y"
    ports:
      - "1433:1433"
    volumes:
      - mssql-data:/var/opt/mssql
    healthcheck:
      test: >
        /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P "$${MSSQL_SA_PASSWORD}" -Q "SELECT 1"
        || /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P "$${MSSQL_SA_PASSWORD}" -Q "SELECT 1"
      interval: 10s
      timeout: 5s
      retries: 10
      start_period: 20s

  rabbitmq-service:
    image: rabbitmq:3-management
    # ...
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  editorTemplate-api:
    # ...
    restart: unless-stopped
    depends_on:
      mssql:
        condition: service_healthy
      rabbitmq-service:
        condition: service_healthy
      smtp4dev:
        condition: service_started

volumes:
  mssql-data:

What changes:

✅ Healthchecks on SQL Server and RabbitMQ → the API only starts once its dependencies actually respond.
✅ Named volume mssql-data → your templates survive a docker compose down (without -v).
✅ SA password in .env (SA_PASSWORD=...) instead of hardcoded in the compose file. Remember to update it in EDITEUR_BDD and HANGFIRE_BDD too.
✅ MSSQL_SA_PASSWORD is the variable name Microsoft currently recommends (SA_PASSWORD is deprecated).
✅ The version: "3" line can be removed: Compose v2 ignores it.

The double sqlcmd in the healthcheck covers both possible tool locations depending on the image version (mssql-tools18 on recent images, mssql-tools on older ones).

🩺 Quick troubleshooting

Symptom	Likely cause	Fix
`Bind for 0.0.0.0:1433 failed: port is already allocated`	A local SQL Server is already running	Change the host port (`14330:1433`)
The API keeps restarting on first launch	SQL Server isn't ready yet	Healthcheck + `condition: service_healthy` (see above)
The `mssql` container exits immediately	SA password too weak	8+ chars with upper/lowercase, digits and symbols
Empty variables in the API	Typo / `.env` not in the right folder	`docker compose config` to see resolved values
No email received	That's expected! They're captured	Open http://localhost:9000
Volume error on Linux/macOS	Windows `C:/...` path	Use `/home/EditorTemplate:/app/EditeurDoc`

🎯 Wrapping up

With two files and one command, you get a complete environment to try TemplateMaster: visual editor, PDF/email generation API, SQL Server database, RabbitMQ bus and email capture. Great for prototyping templates or validating an integration (for example via the .NET NuGet package) before going to production.

Security reminder: this environment is for development only — no database encryption, default credentials (admin/admin), well-known SA password. Never expose it to the Internet.

👉 Full documentation: templatemaster.fr/fr/documentation

Have you tried it? Tell me in the comments what kind of templates you're generating! 👇

I Got Tired of Maintaining HTML, PDF and Email Templates in Code, So I Built a Better Solution

TemplateMaster — Fri, 26 Jun 2026 07:30:29 +0000

If you've ever worked on a business application, you've probably faced this problem.

You need to generate:

invoices
quotes
contracts
reports
receipts
transactional emails

At first, everything seems simple.

You create an HTML template, generate a PDF, and move on.

A few weeks later, the customer asks for small changes.

"Can you move the logo?"

"Can we change the footer?"

"Can you add a barcode?"

"Can we have a different template for another customer?"

Now you're editing HTML inside your source code.

A new deployment is required for every tiny change.

Eventually, you end up with dozens of template files, duplicated code, and no version history.

The Problems I Kept Seeing

After working on several enterprise applications, I noticed the same issues over and over:

HTML templates stored inside the application
No visual editor
Every modification required a deployment
No template versioning
Difficult collaboration between developers and business teams
Email templates managed separately from document templates
No centralized API

It quickly became difficult to maintain.

What I Wanted

I wanted a platform where users could:

create templates visually
manage all templates in one place
generate PDFs from JSON
generate HTML emails
expose everything through a REST API
keep a complete history of every template

Without touching the application code.

Building TemplateMaster

That's why I built TemplateMaster.

The idea is simple.

Instead of storing templates inside your application, they're managed in a dedicated platform.

The application only sends JSON.

Everything else is handled automatically.

Features

✅ Visual HTML editor

✅ PDF generation

✅ Email template generation

✅ JSON preview

✅ REST API

✅ Template versioning

✅ Document history

✅ Generated document archive

✅ Email sending

Versioning Was a Game Changer

One feature I didn't initially plan became one of my favorites.

Every template modification automatically creates a new version.

You can:

compare versions
restore previous versions
see who modified a template
never lose your work

No more copying files like:

invoice_v2_final.html
invoice_v3_final_final.html
invoice_v7_really_final.html

We've all been there 😄

Typical Workflow

Create a template visually.
Connect sample JSON data.
Preview the generated document.
Publish the template.
Call the REST API from your application.
Generate PDFs or emails on demand.

No redeployment required.

Example API

POST /api/v1/document/generate

{
  "templateCode": "invoice",
  "data": {
    "customer": {
      "name": "John Doe"
    },
    "invoice": {
      "number": "INV-2026-001"
    }
  }
}

The API returns the generated PDF.

Simple.

Lessons Learned

Building a document generation platform is much more than rendering HTML.

You also need:

version management
storage
permissions
preview
email generation
PDF rendering
asset management
API security
template history

Those parts usually become harder than the rendering itself.

I'm Looking for Feedback

I'm currently improving TemplateMaster and adding new features.

I'd love to hear how you're currently managing:

PDF generation
email templates
document versioning

What tools are you using today?

What do you wish they did better?

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)

DEV Community: TemplateMaster

Give Your AI Agent the Power to Generate PDFs and Send Emails with an MCP Server

🔌 Connection details

⚙️ Setup in 5 steps

1. Create an API key

2. Enable the key's MCP permissions

3. Configure your MCP client

4. Discover the tools

5. Make a first request

🛡️ Permissions: least privilege by design

🧰 The tools

🚶 A typical run

💬 What it feels like

🧯 Error handling

🔒 Security model

OAuth 2.1 (optional)

🎯 Wrapping up

Generate PDFs and Emails in ASP.NET Core with the TemplateMaster NuGet Package

🧭 What you get

📦 Prerequisites

1️⃣ Install the package

2️⃣ Configure appsettings.json

3️⃣ Wire it up in Program.cs

4️⃣ Activate your license

5️⃣ Open the editor

👥 Users and organizations

6️⃣ Generate PDFs and emails from C

🚦 Before going to production

🎯 Wrapping up

Run TemplateMaster Locally in 5 Minutes with Docker Compose (PDF & Email API)

🧱 What we're going to run

⚠️ Before you start: no encryption locally

📦 Prerequisites

🗂️ Project structure

docker-compose.yaml

.env

🚀 Start it up

🔑 First login

🛠️ Everyday commands

🧠 Going further: making the stack more robust

🩺 Quick troubleshooting

🎯 Wrapping up

I Got Tired of Maintaining HTML, PDF and Email Templates in Code, So I Built a Better Solution

The Problems I Kept Seeing

What I Wanted

Building TemplateMaster

Features

Versioning Was a Game Changer

Typical Workflow

Example API

Lessons Learned

I'm Looking for Feedback

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

Try it locally

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

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

Automate Document & Email Generation in Your Apps with TemplateMaster

2️⃣ Configure `appsettings.json`

3️⃣ Wire it up in `Program.cs`

`docker-compose.yaml`

`.env`