Complete API reference.

List the templates of your organisation.

Cursor-paginated, 25 per page (`page_size` up to 200), newest first. `?search=` matches name and description.

Upload a new PDF as a template.

Page previews are generated in the background. `previews_ready` flips to `true` when they're done.

Retrieve a template with its labels and page previews.

Propose the fields the PDF seems to ask for, without saving them.

Reads the form fields the PDF already has, the boxes, cells and lines it draws, and leaders such as `Name ______`. Returns `{ fields, pages, complete }`: each field has `page`, `x`, `y`, `width`, `height`, `field_type`, `layout`, `box_count`, `line_count`, `font_size`, `description` and `source`. Keep the right ones and save them with `bulk-upsert`. `complete` is `false` when the reading stopped before the last page. At most 30 calls an hour.

Delete the template and its files.

Refused with `409 template_in_use` while compilations, batches or share links still reference it.

Replace the labels, groups and signers of a template in one call, and its requested attachments and consents when sent.

Required attachments, or ones assigned to a signer, need Pro or above; how many attachments each signer can be asked for depends on the plan (3 on Starter, 10 from Pro).

Upload the PDF a consent points at, such as the general terms.

The document never changes: a new version is a new document, with its own fingerprint. Returns `id`, `file_name`, `size`, `sha256`.

Create a compilation and render it.

{
  "template": "3f0e4b2a-21c2-4d34-9c8d-9b0a5d6b3f11",
  "name": "NDA — Acme Corp",
  "values": {
    "full_name": "Jordan Rivera",
    "effective_date": "2026-06-01",
    "agrees_to_terms": true
  }
}

HTTP/1.1 201 Created
{
  "id": "c2a1...e9",
  "name": "NDA — Acme Corp",
  "template": "3f0e4b2a-21c2-4d34-9c8d-9b0a5d6b3f11",
  "values": { "full_name": "Jordan Rivera", "effective_date": "2026-06-01", "agrees_to_terms": true },
  "store_values": true,
  "status": "done",
  "download_url": "https://…",
  "output_sha256": "9b1c…4e",
  "is_signed": false,
  "signature_request": null,
  "attachments_count": 0,
  "consents_count": 0,
  "error": "",
  "expires_at": null,
  "created_at": "2026-09-30T10:13:51Z",
  "updated_at": "2026-09-30T10:13:52Z"
}

Statuses: `done`, `failed`, `pending` (only while a share-link submission is being rendered) and `expired` once the retention period has deleted the PDF. `download_url` is a pre-signed link valid for up to 30 minutes: fetch a fresh one with `GET` when you need it. `GET` also fills in `expires_at`, when the retention deletes the PDF (`null` if it never does). `signature_request` is `{ id, status, signed, total }` for a document sent to several signers. Values that can't be printed in their field return `400` with code `unprintable` or `does_not_fit`.

List compilations.

Filters: `?status=`, `?template=`, `?search=` (name), `?expiring=1` (PDFs the retention deletes within 14 days).

Retrieve a compilation, with a fresh `download_url`.

Re-render with new values, or rename the compilation.

Sending `values` re-renders inside the request, returns `200` and uses one PDF of quota. Sending only `name` is free. `store_values` can go with either; left out, the current choice stays. A signed compilation can't be changed (`409 signed`), nor can one with consents (`409 has_consents`).

Render a PNG preview of one page with your values, without using quota.

Permanently delete the compilation, its rendered PDF and its attachments.

A signed compilation, or one with consents, can't be deleted with an API key: `403 admin_required`. An owner or administrator deletes it from the dashboard, confirming with `confirm=ELIMINA` (otherwise `400 confirmation_required`). For a signed document the fingerprints, the issuer's name and the dates are kept, so the verification page reports it as signed and then deleted.

Submit up to 5,000 rows of values inline.

HTTP/1.1 202 Accepted
{
  "id": "b1f2...77",
  "source": "json",
  "status": "pending",
  "total": 0,
  "expected_total": 2,
  "succeeded": 0,
  "failed": 0
}

Webhook precedence: saved endpoint → inline URL → org default endpoint. If none is configured, the batch runs without notification.

Submit a CSV or XLSX file (up to 20 MB).

Poll a batch.

Statuses: `pending → running → done | failed`, then `expired` after retention. When `done`, `succeeded + failed` equal `expected_total` and `download_url` points at the zip. A batch that fails as a whole ends as `failed`, with no zip.

Create a single share request.

Automatic reminders (`reminders: true`): the same link, same token, at most twice per recipient. The first goes 3 days after the invitation, if more than 24 hours are left before the expiry; the last within the 24 hours before the expiry, skipped if that person received a message in the previous 24 hours. They go out only Monday to Saturday, 09:00–18:59 Italian time, and never once the link is completed, revoked or expired. Every link carries `reminders_enabled`, `reminder_count` (automatic reminders sent), `last_reminded_at` (the latest message after the invitation, automatic or resent by you), `resend_count` and `first_opened_at`, the first time the recipient opened the link.

Create a batch of links from a list of recipients.

Rows with an invalid email are skipped and counted in `failed`.

Create a batch of links from a file.

List share requests.

Filters: `?status=pending|completed|expired|revoked`, `?batch=`, `?q=` (recipient email). Without `?batch=` only the links created one by one come back; the links of a batch with `?batch=<id>`. Completed links carry the `compilation` and its `compilation_download_url`. To know what to follow up: `?expiring_within=N` returns the links still open that expire within N days, `?expired_within=N` those that expired unanswered in the last N days (completed and revoked ones excluded); N from 1 to 90, otherwise `400`. Without `?batch=` these two include the links of batches too.

List the batches of links.

Filters: `?q=` (batch or template name), `?status=open|done`. Each batch carries `id`, `name`, `source`, `template`, `template_name`, `total`, `sent`, `completed`, `failed` and `created_at`; `GET /share-requests/batches/{id}/` reads one, with `open_links` (links still open), `open_with_recipient` (those of them with a recipient) and `remindable_links` (those a reminder reaches right now), which the list leaves `null`.

Send the invitation again to every recipient of a batch still to answer.

No body. Every open link with a recipient gets the same link again, under the rules of `resend`: once every 24 hours (automatic reminders count too) and 5 times at most per link. Returns `200` with `{"sent": n, "skipped": n, "reasons": {"no_recipient": n, "cooldown": n, "limit": n}}`. Completed, revoked and expired links are left alone. Same permissions as the other batch endpoints.

Revoke every link of a batch still open.

No body. Returns `200` with `{"revoked": n}`; their codes and signing drafts stop working with them. Completed, expired or already revoked links stay as they are.

Download the links of a batch as CSV.

UTF-8 with BOM and `;` as separator, so Excel opens it in columns; dates in Italian time. Columns: recipient (who signed, when known), email, status, invitation sent, first opened, completed, expires, reminders sent (automatic and by hand). Cells starting with `=`, `+`, `-`, `@`, a tab or a carriage return get a leading `'`, so no spreadsheet runs them as formulas. Headers follow `Accept-Language`.

Revoke a link: it stops working immediately.

Issue a fresh link with the same settings and send a new invitation.

Send the invitation again, with the same link.

No body. Returns `200` with the link. `409 not_pending` when the link is no longer open, `409 no_recipient` when it has no recipient. `429 resend_cooldown` within 24 hours of the latest message to that person (reminder or resend), with `Retry-After`, or after 5 resends in all.

Extend the expiry of an open link.

Returns `200` with the updated link; `400` when `days` is not valid. `409 not_open` when the link is completed, revoked or expired: an expired one is issued again with `recreate`. After an extension the last reminder can go again before the new expiry. Same permissions as revoke.

Fill and freeze the document to sign.

The response carries `id`, `sha256`, `pdf_url` and `pages` to show the document, `signature_labels` and `consent_text`, the declaration the signer accepts. The draft lasts 24 hours.

Get a link for the signer's own device.

Returns `{ url, expires_at }`: a link valid for 30 minutes. The signer opens it, reviews the document and signs there; the record shows the `handoff` method with your API key.

Check whether the draft has been signed.

Returns `{ id, finalized, compilation }`. Or listen for `compilation.signed`.

Send a signature collected by your integration.

{
  "document_sha256": "<sha256>",
  "signer_name": "Mario Rossi",
  "consent": true,
  "signatures": { "signature": "data:image/png;base64,iVBORw0KGgo..." }
}

Returns the signed compilation. The record shows the `api` method with the name of your API key, and so does the audit page.

Read the signature records of a compilation.

Method (`remote`, `in_person`, `handoff`, `api`), signer, email and code verification, IP, device, `api_key_label` and the SHA-256 fingerprints of the document and of each signature.

Create a request and invite who signs first.

{
  "template": "3f0e4b2a-21c2-4d34-9c8d-9b0a5d6b3f11",
  "order": "sequential",
  "fill_mode": "sender",
  "values": { "full_name": "Jordan Rivera" },
  "signers": [
    { "role": "client", "name": "Jordan Rivera", "email": "[email protected]" },
    { "role": "guarantor", "name": "Sasha Park", "email": "[email protected]" }
  ]
}

Returns `201` with every signer's `status` (`waiting`, `invited`, `signed`) and their personal `url` while they can sign. With `sender` the document is rendered and one PDF of quota used now; with `first_signer`, when the first signer submits. Creating the request also counts one signed document of your plan, given back if the request closes with no signature. With `reminders: true` the reminders follow the rules of share links and, in sequence, go only to the signer whose turn it is; in parallel, to everyone still to sign. The request carries `reminders_enabled`; every signer `reminder_count`, `last_reminded_at` and `first_opened_at`.

List signature requests.

Filters: `?status=open|completed|expired|revoked`, `?template=`, `?q=` (signer email), `?expiring_within=N` (open requests expiring within N days), `?expired_within=N` (expired unsigned in the last N days); N from 1 to 90.

Where the request stands: signers, compilation and, once completed, `download_url`.

Close the request: the links stop working and the compilation is marked failed.

Send the invitation again to a signer whose turn it is (at most once a minute).

Extend the expiry of an open request.

Returns `200` with the updated request; `400` when `days` is not valid, `409 not_open` when it is completed, revoked or expired. After an extension the last reminder can go again before the new expiry. Same permissions as revoke.

List your organisation's attachments.

Filters: `?compilation=`, `?share_request=`, `?signature_request=`. Each attachment carries `id`, `requirement`, `title`, `signer_role`, `file_name`, `content_type`, `size`, `sha256`, `uploaded_at` and `download_url`.

The attachments of a compilation.

Download the file of an attachment.

This is the attachments' `download_url`: it needs your API key and returns the file as a download, under its file name.

Download the complete file: one ZIP with the PDF and its attachments.

List the consent answers of your organisation.

Filters: `?compilation=`, `?share_request=`, `?signature_request=`. Each answer carries `requirement`, `text`, `required`, `signer_role`, `accepted`, `answered_at`, `document_name`, `document_sha256`, `ip` and `user_agent`.

The consent answers of a compilation.

Register a new endpoint. The response includes the `secret` once — store it.

List your endpoints.

Update an endpoint, disable it (`is_active`) or make it the default for batches (`is_default`).

Issue a new secret, returned once. The old one stops working immediately.

Send a `test.ping` and return the target's answer: `{ ok, response_status, delivery }`.

Inspect recent deliveries: status code, attempt count, response body.

Network errors, `5xx` and `429` are retried, up to 6 attempts, waiting 30 s and doubling each time. Redirects aren't followed and private addresses are refused.