canonical: https://jentic.com/apis/docsautomator.co/docsautomator

# DocsAutomator API

The DocsAutomator API generates documents programmatically from templates, manages the automations that drive them, and runs e-signature workflows. A single create-document call merges data into a template and returns a job that can be polled to completion, while automations can be created, updated, duplicated, and deleted, and template placeholders listed so the right fields are filled. For signing, it lists and inspects e-signature sessions, returns their signing links and audit trail, and can cancel a session or resend an invitation to a specific signer.

## For AI agents

Generate documents from templates, manage the automations that drive them, and run e-signature workflows. Polls generation jobs and inspects signing sessions, links, and audit trails across 18 endpoints.

## Scope

Does not store your source data, build the templates themselves, or handle payments. Use for generating documents from templates and running e-signature workflows only.

## Capabilities

- Generate a document from a template in one call and poll the generation job to completion
- Create, update, duplicate, and delete the document automations that drive generation
- List a template's placeholders and duplicate a Google Doc template
- Track document generation queue statistics and individual job status
- List and inspect e-signature signing sessions, their signing links, and audit trail
- Cancel a signing session and resend a signing invitation to a specific signer
- Send a test email for an automation before putting it live

## Use cases

### An Agent Generating Documents on Demand

An AI agent connected to DocsAutomator through Jentic can produce a finished document from a template by calling create-document with the data to merge, then poll the returned job until it completes. This turns document production, such as a contract, invoice, or report, into a single tool call the agent can run as part of a larger workflow.

Example prompt: Create a document from a named template with a JSON payload of field values, then poll the job id until the document is ready

### Template Placeholder Discovery and Merge

Before generating, an agent can list a template's placeholders so it knows exactly which fields to supply, and it can duplicate a Google Doc template to spin up a variant. This keeps generation reliable, because the merge payload is built from the template's real placeholder names rather than guesswork.

Example prompt: List the placeholders for a template, build a matching data payload, and generate the document

### E-Signature Session Management

For documents that need signing, DocsAutomator exposes the signing sessions: list them, read one session's details and signing links, pull its audit trail, cancel a session, and resend an invitation to a specific signer by index. An agent can shepherd a signature request from sent to signed and keep a verifiable audit record.

Example prompt: Read a signing session's details and links, pull its audit trail, and resend the invitation to the signer who has not signed

### Automation Management

DocsAutomator's automations define how documents get generated, and the API manages them end to end: list automations, read one, create, update, duplicate, and delete them, and send a test email to check an automation before it goes live. This lets an operator or agent keep the generation pipeline configured without the dashboard.

Example prompt: Create a document automation, send a test email to verify its output, then update its configuration

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/createDocument` | Generate a document from a template |
| GET | `/job/{jobId}` | Get the status of a generation job |
| GET | `/automations` | List document automations |
| POST | `/createAutomation` | Create a document automation |
| GET | `/listPlaceholdersV2` | List a template's placeholders |
| GET | `/esign/sessions/{sessionId}/audit` | Get a signing session's audit trail |
| POST | `/esign/sessions/{sessionId}/cancel` | Cancel a signing session |
| POST | `/esign/sessions/{sessionId}/resend/{signerIndex}` | Resend a signing invitation to a signer |

## Key resources

- **Documents** — Generate documents from templates and track generation jobs and queue statistics
- **Automations** — List, create, update, duplicate, delete automations and send test emails
- **Templates** — List template placeholders and duplicate a Google Doc template
- **E-Signature** — List and inspect signing sessions, links, and audit trails, cancel sessions, and resend invitations

## 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:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 71 / 100
  - Developer Experience & Jentic Compatibility: 65 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 81 / 100
- **View full report:** https://jentic.com/apis/docsautomator.co/docsautomator/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 DocsAutomator by hand means handling its bearer API-key auth (sent as an Authorization Bearer or X-API-Key header), polling the generation job queue for completion, and managing automations and e-sign sessions yourself. Through Jentic you install once, import DocsAutomator from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** DocsAutomator takes automation ids in the request body or query and e-sign session ids in the URL path, so the cleanest bound is by operation: a rule can let your agent generate documents and read automations and signing sessions while deleting automations and cancelling or resending signing invitations stay out of its reach. You choose the operations it may call, so nothing destructive runs unless you add it.
- **Credential handling:** Your DocsAutomator 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 'generate a document from a template' or 'get a signing session's status', and Jentic returns the matching DocsAutomator operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **PandaDoc API** — Document automation with built-in e-signature and templates, versus DocsAutomator's Google Docs-based generation.
- **PDFMonkey API** — Template-based PDF generation from structured data, versus DocsAutomator's document plus e-signature workflow.
- **BoldSign API** — Dedicated e-signature workflows, complementing DocsAutomator's document generation.
- **PDF.co API** — PDF parsing, conversion, and manipulation, complementing DocsAutomator's generation output.

## FAQ

### Is there a DocsAutomator MCP server?

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

### Can I limit what my agent is allowed to do with DocsAutomator?

Yes. Write a rule that allows the create-document and list-automation operations but not automation deletion or signing-session cancellation, so the agent can produce documents and read signing status while changes to your automations and live signatures stay with you, and every call it makes is logged.

### What authentication does the DocsAutomator API use?

Per its OpenAPI spec, the DocsAutomator API uses a bearer API key from your workspace settings, passed either as an Authorization Bearer header or an X-API-Key header. Through Jentic the key is stored encrypted by your own Jentic One instance and injected only at call time, so it never sits in the agent's prompt or logs.

### Can I generate a document from a template with the DocsAutomator API?

Yes. The create-document operation merges your data into a template and returns a job, and the job-status operation reports when the generated document is ready. You can list a template's placeholders first so the data payload matches the fields the template expects.

### What are the rate limits for the DocsAutomator API?

The OpenAPI spec does not specify request-rate limits; generation runs through a queue, and the queue-statistics operation reports its current state so you can pace batch jobs. Check docsautomator.co for current limits and plan details.

### How do I generate a document with the DocsAutomator API through Jentic?

List the template's placeholders, build the matching data payload, call create-document, and poll the job id until the document is ready. In Jentic, search for 'generate a document from a template', store your API key once, and the agent runs the sequence. To run it on your own infrastructure, install Jentic One from its GitHub repo.