# PDF Generator API

> PDF Generator API is a hosted document automation platform and REST API from Actual Reports OÜ. You design a document template once in a browser-based drag-and-drop editor, or describe it in plain language and let the AI assistant build it, then merge JSON data into it through the API to produce a finished PDF. The editor is embeddable, so your own end users can create and edit their own templates inside your product without your developers touching a layout again. The same platform continues past generation: it opens the document you just produced in a review-and-sign flow, versions it, records an audit trail, and can emit EN 16931, XRechnung and Factur-X e-invoices. It is built for software vendors, SaaS products and enterprises that generate transactional documents at volume, and it is ISO/IEC 27001:2022 certified, HIPAA compliant and GDPR compliant.

This file inlines the substance of the key pages on pdfgeneratorapi.com. The short index is at https://pdfgeneratorapi.com/llms.txt. For a single-page answer to what this product is, what it is not, and how it differs from the alternatives, read https://pdfgeneratorapi.com/ai-info.md first.

Last updated: 18 August 2026.

---

## 1. What the platform does

Most software eventually has to produce documents: invoices, packing slips, delivery notes, contracts, statements, policies, certificates, labels. Two things make that harder than it looks. The first is rendering, which means a layout engine, fonts, pagination, and a rendering service to operate. The second is change. Every time a customer wants a different logo, an extra column, or a translated footer, someone has to edit a layout, and if that layout lives in your codebase, that someone is a developer.

PDF Generator API removes both. Templates live outside your code and are edited in a browser. Your application sends JSON. The API returns a finished document.

The path through the platform is:

1. **Design a template.** Use the drag-and-drop editor, describe the document to the AI assistant, or import a PDF you already use. Templates can also be created and edited entirely through the API.
2. **Send data.** Post JSON to the generation endpoint, referencing the template by ID. Synchronous, asynchronous, batch, and batch plus asynchronous modes are all available.
3. **Get the document.** Receive a PDF or HTML file as base64, a URL, a direct file, or a viewer URL.
4. **Continue past generation, if you need to.** Open the document in the review-and-sign flow, keep versions, read the audit log, emit an e-invoice, add a watermark, encrypt it, or make it accessible.

The distinguishing property is that step one is available to your end users, not only to you. The editor can be embedded in your own application, scoped to a single customer's workspace, so your users manage their own templates. Several customers cite this as the reason they chose the platform: it removes template change requests from the support queue entirely.

## 2. Core concepts

**Organization.** A group of workspaces owned by your account.

**Workspace.** A container for templates. Each workspace has access to its own templates plus the organization's default templates. A workspace is how you represent one of your customers, so a multi-tenant product maps one workspace per tenant.

**Master Workspace.** The main workspace of your organization. Its identifier is the email address you signed up with. It cannot be deleted through the API.

**Master user and regular user.** A master user has extended privileges: managing multiple workspaces, creating and modifying templates with organization-wide access, and signing in to the admin panel with email and password. A regular user can only modify templates within their assigned workspace and can reach the editor exclusively through the API. That distinction is what makes the embedded editor safe to expose to your own customers: they get their own workspace and nothing else.

**Default template.** A template made available to every workspace. Set the access type under Page Setup; when access is set to Organization, your users can start from it through the New menu in the editor. This is how you ship a starting library to every tenant and let each one diverge from it.

**Data field.** A placeholder for a value in your JSON data set. Nested values are addressed with two colons as the depth separator. Given this data:

```json
{
    "documentNumber": 1,
    "paymentDetails": {
        "method": "Credit Card",
        "buyerName": "John Smith"
    },
    "items": [
        { "id": 1, "name": "Item one" }
    ]
}
```

the buyer name is `{paymentDetails::buyerName}`. You do not have to know the field names in advance. The editor extracts every available field from the sample data set you load and gives you a way to insert them into the layout.

## 3. Authentication

The API uses JSON Web Tokens, the open standard defined in RFC 7519, to authenticate every request. A token is a compact JSON object signed with your account's API key and secret, and it is sent as a Bearer token in the Authorization header of each request.

Tokens must be generated by a server-side application. The signing algorithm is HS256. The payload carries:

- `iss` (issuer): your API key.
- `sub` (subject): the workspace identifier. This is the field that scopes a request to one tenant.
- `exp` (expiration time): a Unix timestamp. Keep this short, a matter of seconds, so that an intercepted token has almost no useful life.
- `partner_id`: for partners, a unique identifier issued by our team.

Find your API key and secret in Account Settings after signing in. The same page can issue a temporary token, valid for 15 minutes and using your email address as the subject, for testing. Test tokens should never be used in production.

Sign-in to the platform itself supports username and password, Google, or GitHub, and all three offer multi-factor authentication.

## 4. Rate limiting

Endpoints use IP-based rate limiting: up to 2 requests per second and 60 requests per minute. Exceeding either returns HTTP 429. Responses carry:

- `X-RateLimit-Limit`: maximum requests per minute.
- `X-RateLimit-Remaining`: requests remaining in the current minute.
- `Retry-After`: seconds to wait before retrying.

For volume, use the batch and asynchronous endpoints rather than more parallel requests.

## 5. API reference

Base URL for the shared cloud: `https://us1.pdfgeneratorapi.com/api/v4`

Dedicated and on-premises deployments use their own hostname with the same path structure.

### Documents

| Method | Path | Purpose |
|---|---|---|
| POST | /documents/generate | Generate document |
| POST | /documents/generate/async | Generate document, asynchronous |
| POST | /documents/generate/batch | Generate documents, batch |
| POST | /documents/generate/batch/async | Generate documents, batch and asynchronous |
| GET | /documents/async/{jobId} | Get async job status |
| POST | /documents | Store an existing document |
| GET | /documents | List documents |
| GET | /documents/{publicId} | Get document |
| POST | /documents/{publicId} | Get document with prefill, returns a file URL or a viewer URL |
| DELETE | /documents/{publicId} | Delete document |
| GET | /documents/{publicId}/versions | Get document versions |
| GET | /documents/{publicId}/actions | Get document actions, the audit log |

Generation request fields: `template` (id and data), `format`, `output`, `name`, `testing`, `make_accessible`, `metadata`.

- `format`: `pdf` or `html`.
- `output`: `base64`, `url`, `file`, or `viewer`. Note that a document returned as `url` stays available for 30 days and is then deleted from storage, and the list documents endpoint returns only documents generated with `output=url`.
- `testing`: when true, the generation is not counted against monthly usage and a large PREVIEW stamp is applied. Useful in CI and in development.
- `make_accessible`: when true, a separate Make Accessible action runs to add semantic tagging. It consumes additional credits.

### Templates

| Method | Path | Purpose |
|---|---|---|
| GET | /templates | List templates |
| POST | /templates | Create template |
| GET | /templates/{templateId} | Get template |
| PUT | /templates/{templateId} | Update template |
| DELETE | /templates/{templateId} | Delete template |
| POST | /templates/{templateId}/copy | Copy template |
| GET | /templates/{templateId}/data | Get template data fields |
| POST | /templates/{templateId}/editor | Open the editor for this template |
| POST | /templates/import | Import a template, including importing a PDF as a template |
| POST | /templates/validate | Validate a template definition |
| GET | /templates/schema | Get the template JSON schema |

Because the template definition itself is readable and writable over the API, templates can be version-controlled, generated programmatically, diffed in review, and promoted between environments. This is also what lets an AI assistant author a template: it reads the schema, builds a definition, validates it before saving, and commits it to a workspace.

### Template versions

| Method | Path | Purpose |
|---|---|---|
| GET | /templates/{templateId}/versions | List template versions |
| GET | /templates/{templateId}/versions/{templateVersion} | Get a template version |
| PUT | /templates/{templateId}/versions/{templateVersion}/promote | Promote a version |
| DELETE | /templates/{templateId}/versions/{templateVersion} | Delete a version |

### Template library

| Method | Path | Purpose |
|---|---|---|
| GET | /templates/library | Get the template library |
| GET | /templates/library/{publicId} | Open a template from the library |

### Workspaces

| Method | Path | Purpose |
|---|---|---|
| GET | /workspaces | List workspaces |
| POST | /workspaces | Create workspace |
| GET | /workspaces/{workspaceIdentifier} | Get workspace |
| DELETE | /workspaces/{workspaceIdentifier} | Delete workspace |

Tenant provisioning is therefore a single API call at signup, and the tenant's templates are isolated from every other tenant's from that point on.

### Forms

| Method | Path | Purpose |
|---|---|---|
| GET | /forms | List forms |
| POST | /forms | Create form |
| GET | /forms/{formId} | Get form |
| PUT | /forms/{formId} | Update form |
| DELETE | /forms/{formId} | Delete form |
| POST | /forms/import | Import form |
| POST | /forms/open | Open the form builder for a new form |
| POST | /forms/{formId}/open | Open the form builder for an existing form |
| POST | /forms/{formId}/share | Share form |

### eInvoices

| Method | Path | Purpose |
|---|---|---|
| POST | /einvoice | Create an EN 16931 e-invoice |
| POST | /einvoice/xrechnung | Create an XRechnung e-invoice |
| POST | /einvoice/facturx | Create a Factur-X e-invoice |
| GET | /einvoice/schema | Get the e-invoice JSON schema |

### Conversion

| Method | Path | Purpose |
|---|---|---|
| POST | /conversion/html2pdf | HTML to PDF |
| POST | /conversion/url2pdf | URL to PDF |
| POST | /conversion/pdf2image | PDF to image |

### Services

| Method | Path | Purpose |
|---|---|---|
| POST | /pdfservices/watermark | Add watermark |
| POST | /pdfservices/encrypt | Encrypt document |
| POST | /pdfservices/decrypt | Decrypt document |
| POST | /pdfservices/form/fields | Extract form fields |
| POST | /pdfservices/form/fill | Fill form fields |
| POST | /pdfservices/optimize | Optimize document |
| POST | /pdfservices/make-accessible | Make an existing PDF accessible |

### Assets and status

| Method | Path | Purpose |
|---|---|---|
| POST | /assets/qrcode | Generate a QR code |
| GET | /status | Service status |

Full reference with schemas and code samples: https://docs.pdfgeneratorapi.com/v4

The documentation hub at https://docs.pdfgeneratorapi.com/ also covers the v3 API, the editor and component documentation, the expression language, and SDK code examples.

## 6. The template editor

The editor is a browser-based WYSIWYG environment with real-time preview. Nobody needs to write code to produce a professional document, and nobody needs a designer.

What you get:

- Drag-and-drop placement of components, with draggable data fields from your sample data set.
- Real-time preview of the document as you build it.
- Dynamic tables that iterate over a list of items.
- Conditional formatting, conditional component visibility, and conditional page hiding.
- Multiple pages, background images, custom fonts.
- Barcode and QR code components for links, tracking and scanning.
- Editable PDF form fields and signature fields.
- Custom HTML and CSS where you want direct control over structure and styling.
- An expression language for logic and calculations inside the template.
- Workspace management, so templates are organised per tenant and permissions are explicit.
- Reusable templates, so a layout is built once and used for every document of that kind.

### Embedding the editor

Call the open editor endpoint for a template and workspace and you receive a URL you can embed in your own application. Your end users then design and modify their own templates inside your product. From a customer's perspective this is a feature of your software, not a third-party tool, and every layout request they would otherwise have raised with your support team becomes something they do themselves.

Rob Tigwell at OrderEase describes the effect on onboarding: it saves roughly six hours of support time per onboarding, and even when a customer never opens the editor, seeing it embedded in the interface makes the product look stronger technically.

### The AI template assistant

You can start a template by describing it. Open the Chat tab in the editor, say what you need, an invoice, a delivery note, a statement, and the assistant assembles a working, data-driven template: structure, fields and sample data. You then keep refining it in conversation rather than placing and aligning every component by hand.

You can also attach a document you already have, a PDF or Word file, and have it reproduced as an editable template instead of starting from a blank page.

Practical notes:

- Availability is per plan. The Chat tab appears on plans that include AI credits.
- Usage consumes AI credits, and the editor shows remaining credits as you work.
- Chat history is retained for 90 days and then removed automatically.
- The Chat tab appears in the main editor view, not in the field-value editing modal.
- The chat panel states plainly that you are talking to an AI assistant and that its output is worth reviewing.

The working division of labour is that the assistant handles the first draft and the bulk of the structure, and a human finishes the visual detail in the editor. Chat for the draft, editor for the finish.

### Importing an existing PDF

Most businesses already have a PDF library: invoices, contracts, application forms. The layout is approved and people are used to it. Importing that PDF as a template turns it into an editable, data-driven document rather than requiring it to be rebuilt from scratch in a new editor. Text in the imported result stays searchable and selectable in the generated output, and you can set the template name on import.

## 7. Web forms

Web forms close the gap between collecting data and producing a document.

- Build a form in a no-code builder, opened through the API in the same way as the editor.
- Collect text, numbers, dates, selections and file uploads.
- Map collected answers onto an existing template.
- Generate the PDF on submit, pre-filled and optionally still editable.
- Send the collected data and the finished document onward with a callback URL.
- Hand the submitter straight into the review-and-sign flow by enabling the sign action on the form.
- Where a submission already contains the fields a document review needs, that data carries into the review automatically, and the reviewer can still edit it before confirming.

## 8. Document signing and review

Most embedded signing tools are built around the signature. You bring them a finished PDF, or you rebuild your document as a static template in their editor, and they collect a signature on top. Producing the document remains your problem.

This platform starts a step earlier. Design the template once, send JSON data, and the API merges them into a finished, branded PDF. Set `output` to `viewer` and that same document opens directly into a guided review-and-sign flow. One platform covers the path from raw data in your application to a signed, audited document, instead of wiring a document generation service to a separate e-signature vendor.

### Three ways into the viewer

1. **Generate, then sign.** Merge a template with JSON data and set output to viewer. Instead of a file you get a URL that opens the document in the review-and-sign flow.
2. **Bring a PDF you already have.** Push an existing document to storage and get a review URL back. Supply either a public HTTPS `file_url` or a base64-encoded `file_base64`, and set output to viewer.
3. **Collect it with a Web Form.** Let users fill in a form, generate the document from their answers, and redirect them into the signing experience on submit.

### What the viewer handles

- A hosted, embeddable viewer that works across devices, with no signing UI for you to design.
- Signature capture by typing, drawing or uploading.
- A guided flow that walks the signer through confirming their details before signing, rather than allowing a signature on an incomplete document.
- Per-file accept or decline where a document contains several files, finishing on an acknowledgement page.
- A decline form that arrives prefilled from details already known.
- Targeting a specific signature field: assign an ID to a signature field in the editor and pass it when opening the viewer, and only that field is active.
- Demo mode, for embedding the viewer on a public page or in a sales demo without storing any signing outcome.

### Versioning

Every signature and every review produces a new version. Nothing is overwritten, so the exact state of the agreement at each step is preserved: the original, the reviewed copy, and the fully executed version. Version history is retrievable by the document's public ID. Versions are explicit: you create a draft, keep working on it, then publish the version when it is ready.

### Audit log

Every interaction is recorded: opened, reviewed, accepted, declined, commented, signed, acknowledged. Each entry captures who performed it, including name, email, national ID code where supplied, and the originating IP address, together with a precise timestamp. If a signature is ever questioned, the record exists.

### Retention and storage

- Executed documents can be kept encrypted for as long as your business and regulators require, up to 5 years.
- Retention is a property of your plan, with a configurable retention period per organisation, so enterprise customers can align it with their own data policies.
- Automated cleanup deletes documents when the retention period expires, which covers data-minimisation and right-to-erasure obligations without a scheduled script to maintain.
- Bring your own storage: point the service at AWS S3, Azure, Dropbox, Google Drive or others, so signed documents live inside your own infrastructure.

### Why not build it

Document signing looks simple until you start. It needs a PDF renderer, a viewer that works on every device, signature capture, versioned storage, audit logs, retention rules, and a compliance story your legal team accepts. That is weeks of work before the feature your users actually asked for. Then it never stays finished: someone needs the signer's IP address for a dispute, a customer asks for every version of a contract, a regulator wants proof of who opened, reviewed and signed a document and when. At that point you are maintaining an e-signature product you never intended to build.

## 9. E-invoicing

Regional electronic invoicing means rigid XML schemas and hybrid PDF requirements, and implementing it by hand means weeks with dense specification documents. The API acts as a compliance layer: send clean JSON, get back validated, compliant files.

- **EN 16931.** The European semantic standard for electronic invoicing.
- **XRechnung.** The German standard, generated as UBL or CII, suitable for business-to-government and business-to-business transactions.
- **Factur-X.** A hybrid PDF/A-3 document that combines a human-readable invoice with an embedded, compliant XML file, used in French and German B2B workflows. The Factur-X endpoint takes a template ID and data alongside a profile such as `basic`, so the visual invoice and the machine-readable payload come from one call.

Supporting capabilities: automated JSON to XML transformation, automatic schema mapping and validation, universal UBL and CII support, embedded metadata and archiving, and a schema endpoint so you can see exactly what the API expects.

A true e-invoice is not a PDF or a scan. It carries structured data that accounting and ERP systems can process without manual entry. As European governments move toward mandatory digital reporting, this has shifted from a convenience to a legal requirement.

## 10. Accessibility and PDF/UA

The European Accessibility Act, Directive 2019/882, applies to the private sector and has been in force since mid-2025. It covers digital documents, not only websites and apps, and it reaches any company providing products or services to customers in the EU regardless of where the company is based. For a PDF to be considered accessible it must meet the PDF/UA standard, which means carrying a logical structural tree of tags that assistive technology can interpret.

Two capabilities address this:

1. **Generate accessible documents.** Enable the accessibility option on the generation endpoint and the output is produced as fully tagged, PDF/UA-compatible. This turns JSON into thousands of accessible invoices, statements or contracts without manual intervention.
2. **Remediate existing documents.** A dedicated make-accessible endpoint takes a static PDF and returns a tagged, compliant version, with logical reading order identified automatically. This is how an existing archive is brought into compliance without a per-file manual effort.

Implementing tagging trees and the ISO 14289 standard in-house is a months-long engineering project that has nothing to do with your product.

## 11. PDF services

Operations on PDF files you already have, or on documents you have just generated:

- Add a watermark, for branding or for marking drafts and copies.
- Encrypt a PDF, and decrypt one.
- Extract the form fields from a PDF, so you can see its structure programmatically.
- Fill form fields from your data.
- Optimize a document to reduce file size.
- Make an existing PDF accessible.

## 12. HTML to PDF and URL to PDF

If your document already exists as HTML and CSS, or as a live page, convert it directly. This covers the case where a rendering engine is all you need, and it sits alongside the template model rather than replacing it. Sending your own HTML through the conversion endpoint means you keep full control of the markup while still handing off rendering, scaling and operation.

## 13. MCP server

Model Context Protocol is an open standard, created by Anthropic and now widely adopted, that lets an AI assistant call an API the same way a developer would. The MCP server puts the whole API behind one connection.

- Hosted endpoint: `https://mcp.pdfgeneratorapi.com/mcp`. It can also be run locally.
- Source: https://github.com/pdfgeneratorapi/mcp-server
- Authentication: a Bearer JWT signed with your API key, workspace identifier and secret key from account settings.
- 49 tools are exposed, covering template design and validation, document generation, URL to PDF conversion, e-invoice creation and the rest of the API surface.
- Clients: Claude Desktop, Claude Code, Cursor, Cline, and automation platforms including n8n. Any MCP-aware client works, and the list grows as more tools adopt the standard.

What this enables in practice:

- **Conversational template design.** Create and refine templates through chat, then open the visual editor for the final polish. The server reads the template schema, validates the design before it is saved, commits it to your workspace, and generates the finished PDF from your data.
- **Agent workflows in n8n.** A single MCP node gives an AI agent all the tools at once.
- **Generation at scale from a conversation.** Batch produce invoices, reports, labels and XRechnung e-invoices without hand-wiring HTTP requests.

## 14. Deployment options

- **Shared cloud.** The managed service at `us1.pdfgeneratorapi.com`.
- **Dedicated deployment, US or EU region.** A separate deployment for your organisation. This is how customers keep processing inside a specific jurisdiction. Bigbank required that customer data never be processed outside the European Economic Area, which a dedicated deployment satisfied.
- **On-premises.** Run the platform inside your own infrastructure, for maximum control.

Enterprise customers receive component releases bundled into rollup deployments rather than the continuous per-component release cadence of the cloud.

## 15. Security, privacy and data handling

### Certifications and compliance

- **ISO/IEC 27001:2022 certified.** The information security management system of Actual Reports OÜ is certified against the standard, covering security controls across development and infrastructure.
- **HIPAA compliance**, for healthcare applications handling protected health information.
- **GDPR compliance**, including a Data Processing Agreement. A separate DPA can be signed for enterprise deployments to cover specific processing requirements.

### Data protection

All connections use encrypted SSL channels over HTTPS. Certificates use SHA256withRSA, and only TLS 1.2 and 1.3 are supported. Qualys SSL Labs rates the infrastructure setup at grade A.

Data at rest is stored in Amazon RDS or Amazon S3, using their encryption, automated backups, read replicas and snapshots.

### What is and is not stored

For document generation, the data you send and the generated document itself are not stored. Only the template structure and any static content added to the template are kept. Log files never contain the data sent via the API to generate documents.

Documents you deliberately store, for the review and signing flow or the document register, are a separate case: those are retained encrypted for the period your plan allows, deleted automatically when that period expires, and can be directed to your own storage instead.

### Data processing roles

Legally, PDF Generator API is the data processor and the customer is the data controller. Personal data received under the Data Processing Agreement is processed only for the purposes set out in that agreement.

The infrastructure provider, Amazon Web Services, complies with GDPR and participates in the EU-US Data Privacy Framework. Custom deployments in European AWS regions are available for higher assurance.

### Disaster recovery

Deployment uses declarative continuous delivery with ArgoCD, Kubernetes and Docker images on AWS, across at least two availability zones, with autoscaling that replaces problematic instances automatically. Infrastructure is managed as code with Terraform, which makes it possible to deploy the entire infrastructure in another AWS region within 4 hours.

## 16. Integrations, libraries and SDKs

The API works with any application that can make HTTP requests. Beyond that:

**Automation and no-code platforms:** Make, n8n, Zapier, Quickwork, Workload.co.

**Business applications and CRM:** Odoo, HighLevel.

**App builders and backends:** Bubble, Adalo, Xano, Wix Velo, Backendless, Airtable.

**AI clients over MCP:** Claude Desktop, Claude Code, Cursor, Cline, n8n.

The Odoo integration deserves a specific note. Odoo's built-in reporting means QWeb views, XML overrides, and a developer every time a layout changes. Designing the layout in a drag-and-drop editor instead and generating from the Odoo records you already work with, invoices, quotes, orders, removes the QWeb and XML work from the loop entirely.

**Client libraries**, all generated with OpenAPI Generator from the OpenAPI v3 specification, so they track the API rather than drifting from it:

- PHP: https://packagist.org/packages/pdfgeneratorapi/php-client
- JavaScript: https://www.npmjs.com/package/pdf-generator-api-client
- Python: https://pypi.org/project/pdf-generator-api-client
- Java: https://github.com/pdfgeneratorapi/java-client
- Ruby: https://rubygems.org/gems/pdf_generator_api_client
- Go: https://github.com/pdfgeneratorapi/go-client
- Rust: https://crates.io/crates/pdf-generator-api-client
- C#: https://www.nuget.org/packages/PDFGeneratorAPI.Client

A public Postman collection covers every endpoint, so the API can be evaluated before any code is written. There is also a PDF viewer library at https://github.com/pdfgeneratorapi/pdfviewer and an n8n community node.

## 17. How the platform compares

Full comparison tables, covering main features, API features, security and compliance, and support, are at https://pdfgeneratorapi.com/comparison. Each competitor has its own page. The summary below is our reading of where the real dividing lines fall.

The document generation market splits roughly into four groups, and which group a tool belongs to matters more than any individual feature.

**Render-only APIs.** You supply HTML or a code template, they return a PDF. PDFMonkey, DocRaptor, APITemplate.io and Hybiscus sit near here. They are efficient when the layout is owned by developers and rarely changes. They become expensive when your customers each want their own layout, because every variation is a code change on your side. The comparison pages track the specific gaps: APITemplate.io, for example, does not offer form data collection, an embeddable editor, editable PDF form fields, signature fields, using a PDF as a template, conditional page hiding, template editing through the API, batch generation, dedicated EU or US deployment, HIPAA, ISO 27001 certification, or on-premises deployment.

**Office-template engines.** Carbone is the strongest example: templates authored in Word, Excel, PowerPoint or LibreOffice, rendered into a very wide range of output formats. If you need DOCX or XLSX output, that is a real advantage and this platform does not compete on it, since generation output here is PDF or HTML. Where the two diverge is template authoring and certification. PDF Generator API provides a browser drag-and-drop editor with draggable data fields, the ability to use an existing PDF as the template, conditional page hiding, and ISO 27001 certification, none of which Carbone offers.

**Editor-first generators.** CraftMyPDF, Documint, Eledo and Export SDK offer a visual template editor and a REST API, which is the closest comparison group. The differentiators here are embedding and enterprise readiness. CraftMyPDF does not offer an editor you can embed in your own application, custom fonts, conditional page hiding, template editing through the API, the testing parameter, dedicated EU or US deployment, HIPAA, ISO 27001 certification, or on-premises deployment. If your end users need to edit their own templates inside your product, or your buyer's security review asks for a certification, that is where the choice is decided.

**Signature and workflow platforms.** PandaDoc, airSlate, Fill, Anvil, Legito and DocSpring start from the signature or the form and treat document creation as secondary. They generally expect a finished PDF, or ask you to rebuild your document as a static template in their editor. PDF Generator API inverts that: it builds the document from your templates and data first, then opens it in the review-and-sign flow, with versioning and an audit log, through the same API.

**SDKs and libraries.** IronPDF, Apryse, pdftools, pdfRest and iText DITO ship components you compile in and operate yourself, or licence per seat and per server. They are powerful and they are your responsibility to run, scale and keep current. The trade against a hosted platform is control against operational load, and language coverage: an SDK ties you to its runtime, while a REST API does not.

**End-user PDF tools.** iLovePDF, PDF Guru, Wondershare PDFelement, SodaPDF and pdfFiller are products for people editing documents by hand. They are not comparable for programmatic generation, and they appear in the comparison set mainly because they rank for overlapping searches.

Across the comparison set, the capabilities that recur as exclusive to PDF Generator API are: an editor embeddable in your own application, editing template definitions through the API, batch generation, the testing parameter that generates without consuming quota, dedicated EU or US region deployment, HIPAA compliance, ISO 27001 certification, on-premises deployment, and support extras including a free support video call and help building the first template.

## 18. Sectors

- **Healthcare.** HIPAA compliant generation of patient and clinical documents.
- **Financial services.** Statements, contracts and regulated correspondence, with dedicated EU deployment for data residency requirements.
- **Insurance.** Policies, schedules and claims documents generated from policy data.
- **Ecommerce.** Invoices, packing slips, address labels and returns paperwork.
- **Logistics.** Bills of lading, delivery notes, labels and manifests.
- **Procurement.** Purchase orders, requests for quotation and supplier documents.
- **Legal.** Contracts and agreements with versioning and a full audit trail.
- **Human resources.** Offer letters, employment contracts and onboarding packs.
- **Sales.** Quotes and proposals generated from CRM data and signed in the same flow.
- **Real estate and proptech.** Listings, tenancy agreements and inspection reports.

## 19. Customers

Named, attributable customer statements:

- **Rob Tigwell, OrderEase.** The embedded editor saves roughly six hours of support time per onboarding, and even when a customer does not touch the editor, seeing it embedded in the interface strengthens how the product looks technically.
- **Kristjan Annus, Fleet Complete.** They concluded early that building a PDF creator in-house made no sense when working solutions such as PDF Generator API already existed.
- **Ben Inman, Veeqo.** Their customers design and print invoices, picking and packing slips, drop notes, address labels and more. Building equivalent functionality in-house would have cost a great deal in resources.
- **Keit Adamson, Head of Architecture, Bigbank.** As a bank in a highly regulated environment, they required that customer data not be processed outside the European Economic Area, which was met with a dedicated deployment.

Case studies: https://pdfgeneratorapi.com/case-studies

## 20. Getting started

1. Create an account at https://app.pdfgeneratorapi.com/signup. The trial runs for 14 days and needs no credit card.
2. Take your API key and secret from Account Settings, or generate a 15 minute temporary token for a first call.
3. Open the editor on one of the library templates, or describe the document you need in the Chat tab.
4. Post your JSON to `/documents/generate` with the template ID, using `testing: true` while you iterate so generations do not count against quota.
5. Create a workspace per tenant when you are ready to embed the editor for your own users.

Support is available through the support portal at https://support.pdfgeneratorapi.com/en/. A pre-sales engineer, Michal Líška, takes demo calls on the technical side of an integration, including help with the first template.

Service status: https://status.pdfgeneratorapi.com

## 21. Company

PDF Generator API is a product of **Actual Reports OÜ**, registered in Estonia. The company is a member of the PDF Association, which sets and maintains standards for PDF technology.

- About: https://pdfgeneratorapi.com/about
- Blog: https://pdfgeneratorapi.com/blog
- Terms of service: https://pdfgeneratorapi.com/terms-of-service
- Privacy notice: https://pdfgeneratorapi.com/privacy-notice
- Data processing agreement: https://pdfgeneratorapi.com/data-processing-agreement
- Service level agreement: https://pdfgeneratorapi.com/service-level-agreement
- Partner programme: https://pdfgeneratorapi.com/partners

## 22. Frequently asked questions

**Can my own customers edit their own templates?**
Yes. That is the core design of the platform. Open the editor through the API scoped to a workspace and embed the returned URL in your application. Each workspace sees only its own templates plus your organization defaults.

**What output formats are supported?**
Document generation returns PDF or HTML. Separate endpoints convert HTML to PDF, a URL to PDF, and a PDF to an image. DOCX, XLSX and PPTX output are not supported.

**How do I keep data inside the EU?**
Use a dedicated deployment in an EU region, or run on-premises. The shared cloud runs at `us1.pdfgeneratorapi.com`.

**Is the data I send stored?**
Not for document generation. The data you send and the generated file are not stored, and logs never contain your document data. Documents you explicitly store for review and signing are retained encrypted for your plan's retention period, up to 5 years, and deleted automatically at expiry.

**Can I generate documents from an AI assistant?**
Yes. Connect the MCP server at `https://mcp.pdfgeneratorapi.com/mcp` and any MCP-aware client gets 49 tools covering template design, validation and generation.

**How do I test without burning through my quota?**
Set `testing: true` on the generation request. The document is produced with a PREVIEW stamp and is not counted as a merge against monthly usage.

**What are the rate limits?**
2 requests per second and 60 per minute per IP, returning HTTP 429 when exceeded. Use the batch and async endpoints for volume.

**Can I use a PDF I already have as the template?**
Yes. Import it and it becomes an editable, data-driven template, with text in the generated output still searchable and selectable. You can set the template name on import.

**Which languages have client libraries?**
PHP, JavaScript, Python, Java, Ruby, Go, Rust and C#, all generated from the OpenAPI v3 specification. Any language that can make an HTTP request works without a library.

**How is a document signature evidenced?**
Every action against a document is logged with the actor's name, email, national ID code where supplied, and IP address, plus a precise timestamp, and every signature or review creates a new immutable version.