Certificate Generation API
One template, every participant. Each name in your list comes back as a print-ready certificate PDF and a shareable image — in one run, from your own application.
A certificate generation API turns a list of participants into finished certificate files. You design one template with your seal, signature and layout; your application sends each name, course and date as JSON, and the API returns a print-ready PDF and a shareable image for every entry — one at a time or a whole cohort at once.
Not the other kind of certificate. This page is about certificates people receive and hang on a wall: course completion, diplomas, attendance, awards. X.509 certificates for TLS, code signing or device identity are a different field, and nothing here issues them. The same page also answers to certificate generator API — same thing, different wording.
| Endpoints | POST https://api.dynamicdocumentapi.com/v1/pdf/from-template for the PDF, /v1/images/from-template for the image |
|---|---|
| Input | Participant data as JSON, or a CSV export of your cohort |
| Output | PDF for printing and PNG or JPG for sharing, from the same template |
| Layout | A4, Letter or a custom size, portrait or landscape; your fonts, seals, signature images and background artwork |
| Codes | QR codes and 16 barcode types, rendered as vector graphics |
| Bulk | Batches from a JSON list or a CSV file, async with a signed webhook when the run is finished (paid plans) |
| Render time | Median 216 ms, p95 516 ms per certificate1 |
| Price | Free: 50 renders/month. Paid from €15/month (billed annually) for 3,000 renders, auto top-ups from €6 per 1,000 — a PDF and an image count as two |
1. Measured over 1,664 successful renders on engine 2026.4.
total_ms = time in the queue plus processing in the worker, excluding API
overhead and network transfer. A cohort of 250 certificates is processed as a batch, so
the wall-clock time for the run depends on your plan's concurrency, not on a single
render.
Store the design once as a template — background, seal, signature, the line where the name goes — then send one call per participant. Landscape A4 is the usual choice; every field in the example comes from your own records. To change the design itself, you edit the certificate template in HTML and CSS and keep every version.
curl https://api.dynamicdocumentapi.com/v1/pdf/from-template \
-H "Authorization: Bearer $DYNAMIC_DOCUMENT_API_KEY" \
-H "Idempotency-Key: CERT-2026-0481" \
-H "Content-Type: application/json" \
-d '{
"template_id": "tpl_certificate",
"data": {
"recipient": "Ada Lovelace",
"course": "Data Engineering 101",
"completed_on": "2026-09-25",
"hours": 24,
"certificate_id": "CERT-2026-0481",
"verify_url": "https://academy.example.com/verify/CERT-2026-0481",
"signed_by": "Dr. Erin Cole, Head of Academy"
},
"pdf": {
"paper": { "format": "A4" },
"orientation": "landscape",
"margin": { "top": "0mm", "right": "0mm", "bottom": "0mm", "left": "0mm" },
"metadata": { "title": "Certificate — Ada Lovelace" }
},
"filename": "CERT-2026-0481.pdf"
}'// Node.js 18+: one participant → certificate PDF + shareable PNG
const API = "https://api.dynamicdocumentapi.com/v1";
async function render(path, body, key) {
const res = await fetch(API + path, {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.DYNAMIC_DOCUMENT_API_KEY}`,
"Idempotency-Key": key,
"Content-Type": "application/json",
},
body: JSON.stringify(body),
});
if (!res.ok) throw new Error(await res.text());
return (await res.json()).files[0].url;
}
export async function issueCertificate(data) {
const base = { template_id: "tpl_certificate", data };
const [pdf, image] = await Promise.all([
render("/pdf/from-template", { ...base,
pdf: { paper: { format: "A4" }, orientation: "landscape" },
}, data.certificate_id + "-pdf"),
render("/images/from-template", { ...base,
image: { format: "png", viewport: { width: 1600, height: 1131 }, scale: 2 },
}, data.certificate_id + "-png"),
]);
return { pdf, image };
}import csv, os
import requests
API = "https://api.dynamicdocumentapi.com/v1"
AUTH = {"Authorization": f"Bearer {os.environ['DYNAMIC_DOCUMENT_API_KEY']}"}
def issue_certificate(row: dict) -> str:
"""One participant → one certificate PDF. Returns a signed link."""
res = requests.post(
f"{API}/pdf/from-template",
headers={**AUTH, "Idempotency-Key": row["certificate_id"]},
json={
"template_id": "tpl_certificate",
"data": row,
"pdf": {"paper": {"format": "A4"}, "orientation": "landscape"},
"filename": f"{row['certificate_id']}.pdf",
},
timeout=60,
)
res.raise_for_status()
return res.json()["files"][0]["url"]
with open("cohort.csv") as f:
for row in csv.DictReader(f):
print(row["recipient"], issue_certificate(row))<?php
function issueCertificate(array $participant): string
{
$ch = curl_init('https://api.dynamicdocumentapi.com/v1/pdf/from-template');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'Authorization: Bearer ' . getenv('DYNAMIC_DOCUMENT_API_KEY'),
'Idempotency-Key: ' . $participant['certificate_id'],
'Content-Type: application/json',
],
CURLOPT_POSTFIELDS => json_encode([
'template_id' => 'tpl_certificate',
'data' => $participant,
'pdf' => [
'paper' => ['format' => 'A4'],
'orientation' => 'landscape',
],
'delivery' => 'binary', // attach it to the completion email
]),
]);
return curl_exec($ch); // PDF bytes
}The certificate ID doubles as the idempotency key. If a course platform fires its completion webhook twice, the participant still gets exactly one certificate: the second call returns the first render, for 24 hours. Test keys let you run the whole flow against watermarked output without touching your quota.
A certificate has two lives. One is the file people print or attach to an application; the other is the picture they post the same evening. Both come from the same template, so the design is maintained once.
Landscape A4 or Letter, zero margins for a full-bleed background, vector text that stays
crisp at any zoom. Add metadata so the file shows a proper title in a PDF
reader, and protect if the file should not be edited.
"paper": { "format": "A4" },
"orientation": "landscape",
"margin": { "top": "0mm", "right": "0mm",
"bottom": "0mm", "left": "0mm" }The same template through the image generation API
gives you a picture for the completion email, the profile page or a social post. Pick the
viewport, then scale 1 to 3 for a retina-sharp file.
"image": { "format": "png", "scale": 2,
"viewport": { "width": 1600, "height": 1131 } }Upload the script font, the signature scan, the seal and the background as template assets, or load a web font through the proxy. The engine waits for fonts and image decoding before it captures, so nothing is ever half-drawn.
Accents, Greek, Cyrillic, Arabic and CJK names render with the right glyphs as long as the font carries them. Dates follow the participant's locale through Unicode CLDR, so “25 September 2026” and “2026年9月25日” come from the same template.
Certificates arrive in bursts: a course ends, a conference closes, a quarter finishes. Three parts of the API are built for that shape of work.
A batch takes a JSON array or a CSV export straight from your LMS: one row per participant, each with its own name, date and certificate ID.
The run is async, so your request returns immediately. Every certificate gets its own filename, and failures are reported per row instead of failing the whole batch.
A signed webhook fires when the batch is done. Take the signed links, or merge the PDFs into one file for the printer.
Webhooks are signed with HMAC-SHA256 following the Standard Webhooks specification, and a
delivery your server rejects is retried up to eight times over about 28 hours. Batches are
available on paid plans. Files live as long as you set with retention_days,
and you can delete them at any time — useful when a certificate carries a participant's
full name.
A certificate is worth what a stranger can check. The API renders the code; the answer comes from your system, because that is where the records are.
You generate a unique, hard-to-guess certificate ID, build the URL of your verification page and pass it with the data. The template turns it into a sharp vector QR code, next to the ID in readable text for anyone who types it in.
{{ verify_url | qrcode(size="24mm", ecc="Q") }}
{{ certificate_id }}
→ https://academy.example.com/verify/CERT-2026-0481That URL shows a page with the recipient, the course, the date and the current status. It is a handful of lines in the app that already knows who completed what — and it keeps the source of truth with you, rather than with a document service.
We do not host a public verification registry, issue open badges, manage recipient profiles or revoke credentials after the fact. If you need those, a credential platform is the right tool, and the comparison below says so plainly. Sixteen barcode types are available too, when a scanner in a hall expects something other than a QR code.
The completion event already exists in your product. One call later the learner has a certificate in the dashboard and an image in the congratulations email.
Attendance certificates and CPD records for everyone who checked in, generated the evening the event ends instead of by hand the week after.
Proof that a technician passed the annual refresher: a fixed layout, a certificate ID, an expiry date on the document and a copy in your audit trail.
The same mechanism prints a card instead of a certificate: a custom paper size, a photo, a valid-until date and a scannable code.
Both are reasonable choices, and they solve different halves of the problem. Here is the honest split.
| Question | Credential platform | Dynamic Document API |
|---|---|---|
| Design freedom | Their editor and themes | Your own HTML and CSS, any layout you can build for print |
| Hosted verification page | Included | No — the QR code points at a page in your product |
| Revoking a credential | Built in | Your database decides; the file itself is just a file |
| Open badges, wallets, recipient profiles | Built in | Not offered |
| Where the recipient data lives | On the platform | In your system; we only receive what a render needs |
| Image for social sharing | Usually a fixed format | Any size, from the same template |
| Cost at 5,000 certificates | Typically per credential | About €0.0031 per render on the Growth plan |
| Best when | Credentials must be verifiable and revocable by a third party | Your product owns the records and needs beautiful files at scale |
A render is one returned file (up to 50 pages, or one image size), so a participant who gets both a PDF and an image uses two. At 15,000 renders the Growth plan is €47 billed annually, about €0.0031 each — roughly €0.006 per participant with both files. See the cost per certificate on every plan.
FAQ
No. This API generates documents people receive: course completion certificates, diplomas, award and attendance certificates, as PDF and image files. X.509 certificates for TLS, code signing or device identity are a different field entirely and are not issued here.
Yes. Send a batch from a JSON list or a CSV export of your cohort on paid plans: one row per participant, one certificate per row. Large runs go async, and a signed webhook tells your system when the batch is finished, so nothing waits on an open connection.
Yes. Templates render QR codes and 16 barcode types as sharp vector graphics. You generate a unique certificate ID, build a URL to your own verification page and pass it to the template. The page that answers “is this real?” stays in your product, where the records live.
Yes. The same template renders through the PDF endpoint for a print-ready file and through the image endpoint for a PNG or JPG. Set the viewport and a scale of 1 to 3 for the image, so the same design serves both printing and social sharing.
Yes. Upload fonts, signature scans, seals and background artwork as template assets, or load a web font through the font proxy. The engine waits for fonts and image decoding before it captures, so a signature is never missing from the first render.
Any system that can make an HTTP request can call the API — usually the same code that already marks a course as completed. There is no prebuilt LMS plugin: you map the completion event to certificate data and call the endpoint from your backend or your automation tool.
Credential platforms such as Certifier or Accredible host the credential: a public verification page, revocation, recipient profiles, wallets and open badges. This API generates the files. If you need revocable credentials with a hosted registry, use a platform. If your product already has the records and you need beautiful certificates at scale, use the API.
50 renders a month on the free plan, no credit card, auto top-ups on paid plans.
Start free