Create certificates
A cohort of a thousand learners needs a thousand certificates, each with the right name: enter the name, the course or achievement and the date, and get a formal, print-quality PDF for each person. You pay per certificate, with no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
diplomas at scale
From one template to a stack of named certificates
A certificate becomes real only once a specific name is on it, and that is exactly where manual work breaks down. A design tool can produce one handsome template, but turning it into five hundred individually named documents is a mail-merge chore nobody enjoys. Here the layout stays the same while the recipient, the achievement and the date change for each person, and every result follows the conventions people expect from a diploma: a centred title, the recipient's name given prominence and a clear statement of what was earned and when.
Where certificates are issued in bulk
Conference and workshop organisers send an attendance certificate to every registered participant in one batch as soon as the event ends. HR teams issue a dated completion certificate to each employee who finishes mandatory training, which serves both the employee and the compliance record. Certification bodies produce a certificate for every candidate who passes an exam, matching the score record without manual document work. Recipient data is deleted after the retention window and is never used for training.
From classroom tradition to automated issuance
Certificates of completion trace back to a simple idea: a formal, presentable record that something was learned or achieved, meant to be kept and shown. Online courses, workshops, internal training programs, and certification exams inherited that tradition but multiplied the volume — a cohort of a thousand learners finishing at once needs a thousand individually correct documents, not one template shared around.
Pricing and how the data is treated
Failed generations are never charged; we retry three times and return a clear error rather than a silent failure. Recipient data is deleted after the retention window and never used for training.
What you can do with it
Workshop and event attendance
A conference or workshop organizer generates attendance certificates for every registered participant in a single batch right after the event ends.
Internal training compliance
An HR system issues a completion certificate for each employee finishing mandatory training, giving both the employee and the compliance record a dated document.
Certification exam results
A certification body generates an official certificate for every candidate who passes an exam, matching their score record without manual document work.
FAQ
What happens if a certificate fails to generate?
A failed task is never charged. We retry three times before returning a clear error, so you never pay for a document that wasn't produced.
Can I reissue a single certificate without regenerating the whole batch?
Yes. Each certificate is its own independent request, so correcting or reissuing one person's document never requires touching anyone else's.
How long can I access the generated certificate?
After the retention window it's deleted and never used for training.
What goes on each certificate?
The recipient's name, the course, program or achievement being recognised, the completion date, and any signatory or issuing-organisation details you want printed. The layout follows diploma conventions: a centred title, the name given prominence and a clear statement of what was earned and when.
Can I issue certificates for a whole event at once?
Yes. Organisers generate attendance certificates for every registered participant in a single batch right after the event ends, and each document carries that person's own name rather than a shared template.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/pdf/certificate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com"}'const res = await fetch("https://api.kit.forhosting.com/pdf/certificate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/pdf/certificate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/pdf/certificate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/pdf/certificate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"url": "https://example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "pdf.certificate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 25 |
max_pages | 200 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |
Technical notes
The Certificate Generator API produces a finished, print-quality diploma or certificate PDF from a recipient's name, a course or achievement, and a date — one call per person, however many people you have. It's the piece that turns 'everyone who finished the course' into a stack of individually named documents without anyone opening a design tool.
One template, hundreds of unique documents
A certificate only becomes real once it has a specific name on it, and that's exactly where manual workflows break down: a design tool can produce one beautiful template, but turning it into five hundred individually named PDFs is a mail-merge chore nobody enjoys. The certificate generator api is built to close that gap — the layout stays consistent, the recipient, achievement, and date change per call, and the result is a properly formatted document every time.
What you send and what comes back
The service lays this out as a formal certificate PDF, respecting the visual conventions people expect from a diploma — centered title, recipient name given prominence, a clear statement of what was earned and when. The request carries the recipient's name, the title of the course, program or achievement being recognized, the date of completion, and any signatory or issuing-organization details you want printed.
The mechanics of generation and delivery
You call POST /pdf/certificate and receive a task_id right away, with no connection left waiting on the render. Generation happens asynchronously on our global edge, and once the certificate is ready you're notified through a signed webhook — ideal for a learning platform that wants to email the diploma the moment a course is marked complete — or through a signed link valid for 24 hours when someone just needs to download a single copy.
From classroom tradition to automated issuance
Because each call is independent, a course platform can trigger certificate generation the instant a learner crosses the completion threshold, batch a whole cohort at graduation, or reissue a single corrected certificate without touching anyone else's.
Pricing and how the data is treated
The rate is $0.040 per request plus $0.001 per document, published and predictable, with no tokens or invented credits. Access requires prepaid balance — no free tier, no trial — which keeps the endpoint fast and abuse-free; requests without balance return 402.
Integration use cases
Course completion diplomas
An online learning platform issues a personalized certificate the moment a student finishes the final module, emailed automatically via webhook.
Technical questions
How do I generate a certificate PDF with an API?
Send JSON with the recipient's name, the achievement, and the date to POST /pdf/certificate and you get a task_id back. The certificate generator api builds the document asynchronously and delivers it by signed webhook or a signed link valid for 24 hours.
Is this API free?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
Can I issue certificates for an entire cohort at once?
Yes. Because the endpoint is asynchronous and returns an independent task_id per call, you can fire off a request for every learner in a cohort and generate them all in parallel.
Can I include a signature or issuing organization?
Yes. The payload accepts signatory names and issuing-organization details so the certificate reads as officially issued rather than generic.
What formats or layouts are supported?
The endpoint returns a formal, print-ready certificate PDF following standard diploma conventions; the specific fields you provide control the title, recipient, achievement, and date shown.