JetPageDesign
Design a template in JetPage's visual builder: drag text, tables, images; every setting lives in the Inspector panel, with no curly braces and no HTML.
Visual PDF builder · render API for developers
Design PDFs visually Generate them in milliseconds
JetPage is a visual PDF builder: drag and drop a template, fill in your data, and download finished invoices, statements, contracts, and reports right in the app. There is no template syntax to learn and no code in the document. JetPage renders on a real typesetting engine, not a hidden web browser, so every document is ready in milliseconds and identical on every run. And for developers, the same templates work through the render API.
- JetPage typesets a document in tens of milliseconds. That adds up to thousands of PDFs per second at scale.
- JetPage's preview is the final PDF: same engine, same fonts, guaranteed by visual regression tests.
- JetPage produces tagged, accessible PDFs by default on every plan, not as a paid add-on.
MS, not secJetPage typesets one document in tens of milliseconds on a real typesetting engine.
1000s / secJetPage generates thousands of PDFs per second. A billing run finishes over coffee.
0 bracesJetPage templates contain zero template syntax: no
{{tags}}, no HTML.10 localesJetPage formats currency, numbers, and dates per locale, from en-US to de-DE to pt-BR.
How it works
From blank page to production PDFs
in three steps
Add data
Fill in the data a JetPage template expects (customer, items, totals) right in the app; sample data lights up every field instantly, and every render is validated against the schema.
Generate
Click Generate and download the finished PDF right in the app. Want to automate? Send { templateId, data } to the JetPage render API and receive a link to the finished PDF in the same response.
POST /v1/renders
→ 200 { "pdf": { "url": "..." } }Why JetPage
What sets JetPage apart
A real typesetting engine, not a browser in disguise
Most PDF APIs load each document into a hidden web browser and "print" the page. That takes seconds per document, and none of the major competitors disclose their engine at all. JetPage renders each PDF in tens of milliseconds on a professional typesetting engine, the same class of technology used to produce books, and scales to thousands of documents per second.
Proof: own dataThe same JetPage template and data always produce the identical PDF, byte for byte. Published render-time benchmarks and methodology are on the way at /benchmarks.
A monthly billing run that takes an overnight batch on a browser-based service finishes with JetPage over coffee.
Typical single-document render time (illustrative). Measured benchmarks to be published at /benchmarks.
The preview is the PDF
The classic template-builder failure: the editor shows one thing, the downloaded PDF wraps a line differently or substitutes a font. JetPage's preview is produced by the same engine, fonts, and layout logic as the final document, so what appears on screen is what the customer receives.
Proof: original methodologyJetPage protects preview fidelity with automated visual regression tests, so fidelity cannot silently drift over time.
Teams using JetPage never ship a template whose output surprised them.
Overlay diff: 0 pixels
No curly braces, no template code
Competing tools require {{d.customer.name}}, Liquid tags, or raw HTML. One misplaced brace breaks the render, and non-developers are locked out. JetPage templates contain zero template syntax: data, formulas, and logic live in the Inspector panel, never inside the document.
ProofA formula in JetPage is just
price * qty, with the live result shown beneath the input as = £29.97. And the "Insert field..." and "Insert function..." pickers mean nobody has to remember a field name.Anyone who can use a spreadsheet can build a production JetPage template.
Elsewhere{% for item in items %}
{{ item.price | money }} × {{ item.qty }}
{% endfor %}
{{ item.price | money }} × {{ item.qty }}
{% endfor %}
In JetPage's Inspectorprice * qty
= £29.97 live, as you type
= £29.97 live, as you type
Accessible PDFs by default, ready for the European Accessibility Act
The European Accessibility Act applies to digital documents since June 2025, and enforcement has begun across the EU. Competing services either ignore accessibility entirely or sell it as a gated add-on from higher tiers. JetPage produces tagged, screen-reader-navigable PDFs by default on every plan. Accessibility is the output, not an API flag to remember or a tier to buy.
ProofJetPage requires alt text on every image at design time, making an inaccessible document impossible to ship by accident. PDF/A and PDF/UA are supported by the JetPage engine and ready to be switched on.
Companies generating invoices and statements with JetPage are EAA-ready on the cheapest plan, with zero engineering effort.
Tagged PDF · every plan
Money math that is always exact
Standard floating-point arithmetic makes 0.1 + 0.2 = 0.30000000000000004; on an invoice that is a wrong total. JetPage's formula engine uses exact decimal arithmetic, so every subtotal, tax line, and grand total adds up the way an accountant expects.
0.1 + 0.2 = 0.30000000000000004 0.3, every time
One template, many faces
Every element in a JetPage template (text, image, table column, even a page break) carries a "Visible when" condition. A "PAID IN FULL" stamp appears only at zero balance; a discount column shows up only when a discount exists.
Visible when: balance_due == 0
Templates that never change behind your back
JetPage freezes every published template as an immutable numbered version, so a PDF generated today is reproducible next year. Drafts, rollback, branching, and portable export bundles (design, sample data, images, fonts in one file) are built in.
v1v2v3 · livedraft
Reliability plumbing included
JetPage ships the infrastructure features teams normally build themselves, so a network retry never creates a duplicate invoice and a traffic spike never collapses the service.
- Idempotent rendering: retries return the same PDF once
- Graceful overload backpressure ("busy, retry in N seconds")
- Runaway-template protection and fair multi-tenancy
- Render data privacy-scrubbed shortly after each job
For developers
When you're ready to automate: one request in, finished PDF out
Everything you build and generate in the app is also available through the render API. JetPage validates every request against the template's declared data schema and returns field-by-field errors, so a broken payload never produces a half-broken PDF.
- Structured, specific errors: which field failed and why
- Scoped API keys: render-only, authoring, or admin
- Storage to Google Cloud Storage, Amazon S3, or filesystem: your bucket, your naming scheme, expiring links
- Staging vs. final render switch for post-processing pipelines
# One call. The PDF link comes back in the same response. curl -X POST https://api.jetpage.example/v1/renders \ -H "Authorization: Bearer $JETPAGE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "templateId": "tpl_invoice", "data": { "customer_name": "Acme GmbH", "items": [ { "description": "Design work", "qty": 12, "price": 90 } ] } }' # → 200 { "pdf": { "url": "https://.../invoice-1042.pdf" } }
const res = await fetch("https://api.jetpage.example/v1/renders", { method: "POST", headers: { Authorization: `Bearer ${process.env.JETPAGE_API_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ templateId: "tpl_invoice", data }), }); // Link to the finished PDF, same response, no polling const { pdf } = await res.json(); console.log(pdf.url);
import os, requests res = requests.post( "https://api.jetpage.example/v1/renders", headers={"Authorization": f"Bearer {os.environ['JETPAGE_API_KEY']}"}, json={"templateId": "tpl_invoice", "data": data}, ) # Link to the finished PDF, same response, no polling print(res.json()["pdf"]["url"])
Use cases
What teams generate with JetPage
Invoices
JetPage renders line items, exact-decimal totals, and locale-correct currency on one template that adapts to any customer.
Explore →Statements
JetPage turns a monthly statement run of thousands of documents into a job that finishes in minutes, not overnight.
Explore →Policies
JetPage keeps every published insurance-policy template immutable and reproducible: the version issued is the version on file.
Explore →Contracts & quotes
JetPage shows or hides clauses, columns, and page breaks from data, so one contract template replaces a folder of variants.
Explore →E-commerce
JetPage generates order confirmations and packing slips at checkout speed: tens of milliseconds per document, idempotent on retries.
Explore →Reports & certificates
JetPage typesets long, paginated reports with repeating headers, footers, and page numbers, with print-grade typography included.
Explore →Security & compliance
Built for teams that answer to auditors
GDPR-conscious by design
JetPage scrubs render data shortly after each job completes, so customers' personal data does not linger in queues.
Scoped keys, stored as hashes
JetPage API keys are limited to rendering, authoring, or admin; shown once, stored only as hashes, revocable at any time.
Isolated workspaces & roles
JetPage separates teams, brands, and clients into fully isolated workspaces with owner, editor, and viewer roles, plus a font-licensing gate for compliant embedding.
Pricing
One document = one credit,
on every plan
JetPage counts one generated document as one credit regardless of page count, and the JetPage free plan is permanent: no credit card, API included.
Free
€0 / month, forever
- Full builder + render API
- Tagged, accessible PDFs included
- No credit card required
Team
€ TBA / month · placeholder
- Everything in Free, more credits
- Workspaces, roles & custom fonts
- Your own S3 / GCS storage
Scale
Custom · volume pricing
- Thousands of documents per second
- Idempotency, backpressure, metering
- SLA & DPA
FAQ
Questions, answered
What is JetPage?
JetPage is a visual PDF builder: design a template, fill in your data, and generate finished PDFs right in the app in tens of milliseconds each. For developers, a render API turns the same templates plus JSON data into documents at scale.
How is JetPage different from HTML-to-PDF APIs?
JetPage renders on a professional typesetting engine instead of a headless browser: milliseconds instead of seconds per document, byte-identical output on every run, print-grade typography.
Do I need to write template code?
No. JetPage templates contain no curly braces or markup; formulas and data bindings are entered in the Inspector panel with live results shown as you type.
Are JetPage PDFs accessible?
Yes, by default on every plan: JetPage generates tagged PDFs and requires alt text on images, supporting European Accessibility Act compliance without configuration.
How fast is JetPage at scale?
JetPage generates thousands of PDFs per second; a single document typesets in tens of milliseconds. Benchmark methodology and measured numbers will be published at /benchmarks.
What does JetPage cost?
JetPage plans start free (permanent, no credit card); one document costs one credit regardless of page count.
What doesn't JetPage do yet?
JetPage is flow-based (no free-form overlapping layout), does not yet render barcodes/QR codes or right-to-left scripts, and renders synchronously. Webhooks, async polling, and batch rendering are planned but not yet exposed.
Generate the first PDF with JetPage in five minutes
JetPage is free to try without a credit card, and the first template, from design to data to a finished PDF downloaded right in the app, takes about five minutes.