Turn an HTML report into a PDF
Convert a monthly summary or a dashboard snapshot that already exists as a web page into a PDF you can email, archive or hand to a client, with page breaks that avoid splitting tables and headers on every page. You pay per report, 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.
paginated
When a web page is not enough
Many internal tools already show a perfectly good report on screen: a monthly summary, a dashboard snapshot, an analytics breakdown. But a web page is not something you attach to an email, file for an audit or hand to a client who wants a document rather than a link that might change tomorrow. This tool takes the report you already produce as a web page and turns it into a fixed, paginated and portable PDF that keeps your styling, so the version people receive is the version that stays on file.
What changes on paper, and where it fits
A printed report needs things a screen does not. Page breaks are placed so a table is not cut in half when that can be avoided, margins stay consistent, and headers or footers repeat so readers always know which section a page belongs to. Typical uses are weekly dashboard snapshots for stakeholders, monthly performance summaries sent to each client, period reports kept for audit, and a summary attached to the notice that a job has finished. If a conversion fails, it is retried three times and you are not charged. Report content is deleted after the retention period and never used for training.
A webpage and a report are not the same artifact
Plenty of internal tools already render a perfectly good HTML view of a report — a monthly summary, a dashboard snapshot, an analytics breakdown — but a webpage isn't something you attach to an email, archive for compliance, or hand to a client who wants a document, not a link that might change tomorrow. The generate pdf report api exists to convert what you already render as HTML into something that behaves like a finished report: fixed, paginated, and portable.
Pricing and how report data is handled
A failed conversion is never charged; we retry three times before returning a clear error. Report content is deleted after the retention window and never used for training.
What you can do with it
Weekly dashboard snapshots
A BI tool exports its live dashboard as HTML and converts it to a paginated PDF every week so stakeholders get a fixed, archivable record.
Client-facing performance summaries
An agency renders a monthly performance report as HTML internally and converts it to a branded PDF to send to each client.
Compliance and audit archives
An internal system converts a rendered analytics report to PDF each period so there's a fixed, unchangeable document on file for audit purposes.
Automated end-of-run summaries
A data pipeline renders an HTML summary when a job finishes and converts it to a PDF that gets attached to the completion notification.
FAQ
Does it handle page breaks properly, or does content get cut off?
The service paginates content with sensible page breaks and consistent margins, avoiding awkward cuts through tables or blocks wherever the layout allows.
Can I include headers, footers, or page numbers?
Yes. Repeating headers and footers are supported so each page identifies its section, which is what makes a long report navigable instead of a wall of pages.
What happens if the conversion fails?
A failed task is never charged. We retry three times and return a clear error rather than a silent failure or an unexpected charge.
How long can I access the generated report?
After the retention window it's deleted and never used for training.
Why turn a web report into a PDF instead of sending a link?
A link can change tomorrow, while a PDF stays fixed. That matters when a client wants a document, when a report goes into a compliance archive or when it has to travel as an email attachment.
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/report \
-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/report", {
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/report",
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/report", 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/report", 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.report",
"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. |
413 | input_too_large | The file exceeds the size limit. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |
Technical notes
The PDF Report API takes an HTML document — a dashboard export, a data summary, a formatted analysis — and paginates it into a proper PDF with headers, page breaks, and consistent margins. It's for the reports your systems already know how to render as a webpage but need to hand someone as a file.
What happens to your HTML
You send the HTML content — either inline markup or a reference the service can retrieve — and it's rendered and paginated into a PDF that respects your styling while adding what a printed report actually needs: sensible page breaks that don't cut a table in half if avoidable, consistent margins, and repeating headers or footers so a reader can tell which page belongs to which section without scrolling back to page one.
How the conversion and delivery work
Call POST /pdf/report with your HTML and you get a task_id back immediately, no open connection required while pagination runs. The PDF is built asynchronously on our global edge, and once it's finished you're notified by a signed webhook — well suited to a reporting pipeline that emails or archives the file automatically — or by a signed link valid for 24 hours when someone just needs to open one report.
Where this fits in a reporting pipeline
This is meant to sit at the end of whatever already produces your HTML: a business-intelligence tool exporting a weekly dashboard snapshot, an internal system compiling a client-facing performance summary, an analytics job rendering a monthly breakdown that needs to be archived as a fixed record. Because it takes HTML as input, you keep using whatever templating or charting you already have — the endpoint's job is turning that rendered page into a document with real pagination, not re-authoring your report.
Pricing and how report data is handled
Billing is $0.040 per request plus $0.001 per page, a published rate with no tokens and no invented credits — a longer report costs more precisely because it has more pages, nothing hidden in between. Access requires prepaid balance, with no free tier or trial, which keeps the endpoint fast and abuse-free; requests without balance get a 402.
Technical questions
How do I generate a PDF report with an API?
Send your HTML report to POST /pdf/report and you get a task_id back. The generate pdf report api paginates and renders the document asynchronously, delivering 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.
How is a long report priced?
You pay $0.040 per request plus $0.001 per page, so cost scales directly with the number of pages your report actually produces.
Can I convert reports in bulk on a schedule?
Yes. The endpoint is asynchronous and each call returns its own task_id, which fits a scheduled job that renders and converts a batch of reports on a recurring cadence.