Dynamic Document API documentation for AI agents. The index of all pages is llms.txt, every page in one file is llms-full.txt. Every documentation page is available as Markdown by appending /index.md to its URL or by requesting the page with the header Accept: text/markdown.

DynamicDocumentAPI

SDKs and integrations

The TypeScript and Python SDKs, what is planned for other languages, the CLI and no-code platforms, the MCP server, and how to use the REST API directly.

View as Markdown

The REST API is the product: everything the dashboard does, you can do over HTTP. Client libraries and platform integrations are being built on top of it, and this page is an honest status list so you can plan around it.

Status

ToolStatus
REST API at https://api-eu.dynamicdocumentapi.com/v1Available
OpenAPI 3.1 description at https://api-eu.dynamicdocumentapi.com/v1/openapi.json and the API referenceAvailable
TypeScript and JavaScript SDK (@dynamic-document-api/sdk)Available
Python SDK (dynamic-document-api)Available
PHP SDK (dynamic-document-api/dynamic-document-api-php)Planned
Ruby, Go, Java and C# SDKsPlanned, after PHP
Command-line interfacePlanned
n8n community nodes (@dynamic-document-api/n8n-nodes-dynamic-document-api)Available, verified by n8n (n8n Cloud and self-hosted)
Zapier app, in the Zapier app directoryAvailable
Make appIn Make's review; available by invite link until then
Integrately integration, built and maintained by IntegratelyAvailable
BubblePlanned
MCP server at https://mcp.dynamicdocumentapi.com/mcp, also as a plugin in ChatGPT's plugin directoryAvailable
Power Automate, Pipedream, Activepieces, Airtable, Google Sheets, WordPress and WooCommerce, ShopifyPlanned

Planned means designed and on the roadmap, not available yet. Until an SDK ships for your language, call the API directly: it is a small surface, and the quickstart has working examples in cURL, TypeScript and Python.

TypeScript and JavaScript

npm install @dynamic-document-api/sdk

The SDK runs on Node.js 18 and later, Deno, Bun and edge runtimes, and has no dependencies. It covers the whole public API: renders, batches, PDF tools, e-invoices, templates, email delivery, storage destinations, webhook endpoints and signed links.

import { DynamicDocumentApi } from "@dynamic-document-api/sdk";

const dda = new DynamicDocumentApi(); // reads DYNAMIC_DOCUMENT_API_KEY

const render = await dda.pdf.fromTemplate({
  templateId: "tpl_…",
  data: { number: "2026-0042", customer: { name: "Ada Lovelace" } },
});

console.log(render.files?.[0]?.url);

The package page on npm documents every resource, the configuration and the error classes. Keep your API key on the server; don't use the SDK in browser code.

Python

pip install dynamic-document-api

The SDK runs on Python 3.9 and later and depends only on httpx. DynamicDocumentApi is the synchronous client, and AsyncDynamicDocumentApi has the same methods for asyncio. Keyword arguments carry the API's own names, and responses are the API's JSON as dicts with type hints.

from dynamic_document_api import DynamicDocumentApi

dda = DynamicDocumentApi()  # reads DYNAMIC_DOCUMENT_API_KEY

render = dda.pdf.from_template(
    template_id="tpl_…",
    data={"number": "2026-0042", "customer": {"name": "Ada Lovelace"}},
)

print(render["files"][0]["url"])

The package page on PyPI documents every resource, the configuration and the error classes.

What the SDKs provide

The SDKs' types are generated from the same OpenAPI description as the API reference, so they stay in step with the API. The TypeScript and Python SDKs offer all of the following, and the other languages will too:

  • A configurable base URL (the EU host by default), with the API key read from the DYNAMIC_DOCUMENT_API_KEY environment variable
  • Automatic retries for 429, 5xx and network errors, with exponential backoff and jitter, honouring Retry-After
  • Automatically generated idempotency keys for POST requests, which you can override
  • A timeout above the longest synchronous wait (130 seconds), so a slow render answers 202 instead of being cut off
  • Typed errors per error code, carrying the request_id
  • Pagination iterators for list endpoints
  • Helpers: wait for a render to finish, download a file as bytes or a stream, verify webhook signatures, and sign signed-link URLs locally
  • A User-Agent with the SDK name and version, which you can turn off

The TypeScript SDK runs on Node.js 18 and later, Deno, Bun and edge runtimes, and the Python SDK on Python 3.9 and later. Planned runtimes for the others are PHP 8.1 and later, Ruby 3.1 and later, Go 1.22 and later, Java 11 and later, and .NET 8.

Using the REST API today

Any HTTP client works. A few practical notes:

  • Set your client's timeout above your plan's sync timeout so you receive the 202 response instead of dropping the connection.
  • Send an Idempotency-Key header on every POST request and reuse it on retries.
  • Implement the small retry policy described in Errors.
  • For long renders, use mode: "async" plus webhooks, which includes copy-paste verification code for Node.js and Python.
  • Postman, Bruno and Insomnia can import the OpenAPI description directly.

No-code platforms

The n8n nodes, the Zapier app and the Make app render from your templates with fields built from each template's schema, run the PDF tools, and start workflows from webhook events (render.succeeded, render.failed, batch.completed, template.published). The Make app is in Make's review; until Make lists it, write to support@dynamicdocumentapi.com for an invite link. A Bubble plugin is planned.

Integrately has its own Dynamic Document API integration, which Integrately built and maintains. It starts automations from the same four webhook events and creates PDFs from templates, HTML, URLs and Markdown, images from templates, e-invoices and batches, merges and protects PDFs, and signs image URLs.

Other platforms can call the API with their generic HTTP modules:

  • Authenticate with the X-API-Key header, which is easier than a bearer token in some builders.
  • Use the flat convenience endpoints, for example POST /v1/pdf/from-template with template_id, data and filename.
  • Most platforms abort a step after 25 to 40 seconds. Keep requests inside that budget, or submit with mode: "async" and continue from a webhook.
  • GET /v1/templates and GET /v1/templates/{id}/schema give you template lists and field definitions for dropdowns and mappings.

MCP server

The remote MCP server at https://mcp.dynamicdocumentapi.com/mcp lets AI agents and assistants list templates, read their schemas and generate PDFs, images and e-invoices. Clients sign in with OAuth 2.1, you choose the workspace at consent, and renders stay in test mode until the agent asks for the final document. Setup for Claude, ChatGPT, Cursor and VS Code is in MCP server.

Building your own integration

If you distribute an integration to other workspaces:

  • Send the X-Dynamic-Document-Api-Source header with a short, stable identifier for your platform, and put your integration's name and version in the User-Agent. Renders are then attributable to your integration in the dashboard's render list and usage breakdown.
  • Use GET /v1/account as a connection test: it returns the workspace name and plan, which makes a good connection label.
  • Build input fields from GET /v1/templates/{id}/schema rather than asking users for raw JSON, and offer a raw JSON mode as a fallback.
  • Send an Idempotency-Key for every render so that a retried automation step doesn't produce duplicate documents.
  • Let users set the API host, rather than hard-coding one.
  • Ask users for a key with the narrowest scopes your integration needs, and support test keys.

The Zapier and Make apps and the MCP server sign users in with OAuth, so nobody pastes an API key. OAuth clients are registered by us: if you build an integration for other workspaces and want users to connect the same way, write to support@dynamicdocumentapi.com.

On this page