canonical: https://jentic.com/apis/pdfs.build/pdfs

# pdfs.build API

The pdfs.build API renders PDFs from templates you create and publish, validating the data you send against each template's schema before compiling it. The v2 routes address templates by an external id you control inside an organization, and support synchronous renders, background renders with job polling, and batch renders against one pinned template version. Around rendering it exposes render logs, signed webhook endpoints with secret rotation and delivery history, a gallery of ready-made designs, embedded editor sessions for your own users, and delegated connect tickets with scoped grants. Legacy v1 routes remain for existing integrations and are marked deprecated.

## For AI agents

Create, publish, and render PDF templates by external id, run background and batch renders, read render logs, manage signed webhooks, and issue embedded editor sessions or delegated grants for your own tenants.

## Scope

Does not convert arbitrary web pages or HTML strings to PDF, collect e-signatures, or edit existing PDF files. Use for rendering, publishing, and managing pdfs.build templates only.

## Capabilities

- Render a published template to a PDF by externalId with JSON data validated against the template's schema, optionally pinned to a version
- Queue a batch of renders against one template and version through the batches endpoint and track it by batchId
- Run a render in the background with async set to true, poll the render job, and download the finished PDF
- Create a template with externalId, name, and code, then publish or unpublish it
- Register webhook endpoints, send a test event, rotate the signing secret, and list recent deliveries
- Open an embedded editor session for an externalTenantId and externalUserId, or revoke it
- Mint a delegated connect ticket limited to scopePrefixes and allowedTools, and list or revoke the resulting grants

## Use cases

### Agent document rendering through Jentic

An agent that prepares invoices or certificates finds the pdfs.build render operation through Jentic, sends the record as data to a published template's externalId, and returns the PDF. pdfs.build validates data against the template schema first, so a missing field comes back as a validation error rather than a broken document. Jentic injects the bearer key at call time, so the agent never sees the prs_ key.

Example prompt: Call POST `/v2/organizations/{organizationId}/templates/invoice/render` with data containing company 'Acme Corp', items with name 'Consulting', qty 3, price 150, and due_date '2026-06-01', then return the PDF

### Bulk certificates and statements

For a run of documents from one design, the batches endpoint takes an items list, up to 500 entries, against one template and one version resolved at submission, so a mid-batch template change does not mix versions. Progress is read from GET `/v2/organizations/{organizationId}/batches/{batchId}`, and on plans with webhooks a single batch completion event replaces per-item callbacks.

Example prompt: POST `/v2/organizations/{organizationId}/templates/certificate/batches` with an items list of attendee data, then poll GET `/v2/organizations/{organizationId}/batches/{batchId}` until it completes

### Background renders with signed webhooks

Set async to true on a render to get a job handle instead of waiting, then poll the job or listen for render.completed and render.failed events. Webhook endpoints are managed per organization, a test event confirms the receiver works, rotate-secret replaces the signing secret, and the deliveries list shows recent attempts. webhookIds on a render limits which endpoints receive its events.

Example prompt: Call the render operation with async true and webhookIds containing one endpoint id, then GET `/v2/organizations/{organizationId}/renders/{jobId}` and download GET `/v2/organizations/{organizationId}/renders/{jobId}/pdf` when it finishes

### Template editing inside your own product

SaaS products can let their customers edit document designs without a pdfs.build account. POST `/v2/organizations/{organizationId}/templates/{externalId}/embed-sessions` creates an editor session for an externalTenantId and externalUserId, with an optional expiresInSeconds, and the session can be revoked at any time. PATCH on a template sets its scopePath for tenant scoping.

Example prompt: Create an embed session for template 'invoice' with externalTenantId 'tenant_42' and externalUserId 'user_7', return the session to the frontend, and revoke it with DELETE `/v2/organizations/{organizationId}/embed-sessions/{sessionId}` when done

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v2/organizations/{organizationId}/templates/{externalId}/render` | Render a PDF from a published template |
| POST | `/v2/organizations/{organizationId}/templates/{externalId}/batches` | Render a batch |
| GET | `/v2/organizations/{organizationId}/renders/{jobId}` | Get render job status |
| POST | `/v2/organizations/{organizationId}/templates` | Create a template |
| POST | `/v2/organizations/{organizationId}/templates/{externalId}/publish` | Publish a template |
| GET | `/v2/organizations/{organizationId}/logs` | List render logs |
| POST | `/v2/organizations/{organizationId}/webhooks` | Create a webhook endpoint |

## Key resources

- **Templates** — Create, read, rename, scope, publish, and unpublish templates addressed by external id
- **Rendering** — Synchronous, async, and batch renders, with job status and PDF download
- **Render logs** — List and read render logs per organization or template
- **Webhooks** — Create, update, delete, test, and rotate secrets for webhook endpoints, and list deliveries
- **Embedded editor and delegated agents** — Editor sessions for your tenants, and connect tickets with revocable delegated grants
- **Template gallery** — Browse and preview ready-made designs and add them to the organization

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 65 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 68 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 51 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 74 / 100
- **View full report:** https://jentic.com/apis/pdfs.build/pdfs/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring pdfs.build by hand means sending its prs_ bearer key, matching the organization id in every v2 URL to the key, and handling async jobs and batches yourself. Through Jentic you install once, import pdfs.build from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** pdfs.build puts the organization id and the template's external id in the URL path (`/v2/organizations/{organizationId}/templates/{externalId}/...`), so a rule can pin your agent to one template and the operations you pick. You choose the operations it may call, so actions like unpublishing templates, deleting webhook endpoints, or minting delegated tickets are not included unless you add them.
- **Credential handling:** Your pdfs.build API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'render a PDF from a template' or 'check a render job', and Jentic returns the matching pdfs.build operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **PDFBolt API** — HTML, URL, and Handlebars template PDF generation with webhook delivery
- **PDFMonkey API** — Template-based document generation from JSON payloads
- **CraftMyPDF API** — Generates PDFs and images from visually designed templates
- **BoldSign API** — Sends documents for e-signature and tracks signing status

## FAQ

### What authentication does the pdfs.build API use?

Per its OpenAPI spec, pdfs.build authenticates with an organization-scoped API key that starts with `prs_`, sent as an HTTP bearer token in the Authorization header. The organization in a v2 URL must match the key's organization, otherwise the request fails with organization_scope_mismatch. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time.

### What is the difference between the v2 and v1 routes?

The v2 routes live under `/v2/organizations/{organizationId}` and address templates by an external id you control. The v1 routes identify templates by their generated internal id, are marked deprecated in the spec, and remain for existing integrations, so new work should use v2.

### How do I render a PDF with pdfs.build through Jentic?

Search Jentic for 'render a PDF from a template', load the schema for the v2 render operation, and pass your organization id, the template's externalId, and the document data. The template must be published first. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### What are the rate limits for the pdfs.build API?

The OpenAPI spec does not state a per-second rate limit. It describes a monthly render quota tied to your plan, with batches admitted in full or rejected with a 429. Check https://pdfs.build/docs/ for current plan limits.

### Is there a pdfs.build MCP server?

You don't need an MCP server to give your agent the pdfs.build API. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent calls it. Operations are discovered on demand, so no extra tool definitions sit in the agent's context.

### Can I limit what my agent is allowed to do with the pdfs.build API?

Yes. For example, write a rule that allows only the render operation on the 'invoice' template plus the two render job reads (job status and PDF download), so the agent can produce and fetch invoices from that one template and cannot publish templates, delete webhooks, or mint delegated tickets. Every call it makes is logged by your Jentic One instance.