Reference API completa.

Elenca i template della tua organizzazione.

Paginazione a cursore, 25 per pagina (`page_size` fino a 200), dai più recenti. `?search=` cerca in nome e descrizione.

Carica un nuovo PDF come template.

Le anteprime delle pagine vengono generate in background. `previews_ready` passa a `true` quando sono pronte.

Recupera un template con le sue label e le anteprime delle pagine.

Propone i campi che il PDF sembra chiedere, senza salvarli.

Legge i campi modulo che il PDF ha già, le caselle, le celle e le righe che disegna, e i tratteggi come `Nome ______`. Restituisce `{ fields, pages, complete }`: ogni campo ha `page`, `x`, `y`, `width`, `height`, `field_type`, `layout`, `box_count`, `line_count`, `font_size`, `description` e `source`. Tieni quelli giusti e salvali con `bulk-upsert`. `complete` è `false` se la lettura si è fermata prima dell'ultima pagina. Al massimo 30 chiamate l'ora.

Elimina il template e i suoi file.

Rifiutato con `409 template_in_use` finché compilazioni, batch o link share lo usano.

Sostituisce in una chiamata i campi, le sezioni e i firmatari di un template, e gli allegati e i consensi richiesti quando li invii.

Gli allegati obbligatori o assegnati a un firmatario richiedono Pro o superiore; il numero di allegati per firmatario dipende dal piano (3 su Starter, 10 da Pro).

Carica il PDF a cui un consenso rimanda, per esempio le condizioni generali.

Il documento non si modifica più: una nuova versione è un nuovo documento, con la sua impronta. Restituisce `id`, `file_name`, `size`, `sha256`.

Crea una compilazione e la renderizza.

{
  "template": "3f0e4b2a-21c2-4d34-9c8d-9b0a5d6b3f11",
  "name": "NDA — Acme S.r.l.",
  "values": {
    "nome_completo": "Giulia Rossi",
    "data_efficacia": "2026-06-01",
    "accetta_condizioni": true
  }
}

HTTP/1.1 201 Created
{
  "id": "c2a1...e9",
  "name": "NDA — Acme S.r.l.",
  "template": "3f0e4b2a-21c2-4d34-9c8d-9b0a5d6b3f11",
  "values": { "nome_completo": "Giulia Rossi", "data_efficacia": "2026-06-01", "accetta_condizioni": 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"
}

Status: `done`, `failed`, `pending` (solo mentre viene renderizzato l'invio di un link share) ed `expired` quando la retention ha cancellato il PDF. `download_url` è un link pre-firmato valido fino a 30 minuti: se ti serve dopo, prendine uno nuovo con `GET`. `GET` riporta anche `expires_at`, quando la retention cancellerà il PDF (`null` se non succede mai). `signature_request` è `{ id, status, signed, total }` per un documento inviato a più firmatari. I valori che non si possono stampare nel loro campo restituiscono `400` con codice `unprintable` o `does_not_fit`.

Elenca le compilazioni.

Filtri: `?status=`, `?template=`, `?search=` (nome), `?expiring=1` (PDF che la retention cancella entro 14 giorni).

Recupera una compilazione, con un `download_url` nuovo.

Ri-renderizza con nuovi valori, o rinomina la compilazione.

Inviare `values` ri-renderizza dentro la richiesta, restituisce `200` e consuma un PDF di quota. Inviare solo `name` è gratuito. `store_values` può accompagnare l'uno o l'altro; se omesso, la scelta attuale resta. Una compilazione firmata non si può modificare (`409 signed`), e nemmeno una con consensi (`409 has_consents`).

Renderizza un'anteprima PNG di una pagina con i tuoi valori, senza consumare quota.

Elimina definitivamente la compilazione, il PDF renderizzato e i suoi allegati.

Una compilazione firmata, o con consensi, non si può eliminare con una API key: `403 admin_required`. La elimina il titolare o un amministratore dalla dashboard, confermando con `confirm=ELIMINA` (altrimenti `400 confirmation_required`). Di un documento firmato restano le impronte, il nome di chi l'ha emesso e le date, così la pagina di verifica lo indica come firmato e poi eliminato.

Invia fino a 5.000 righe di valori inline.

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

Precedenza webhook: endpoint salvato → URL inline → endpoint di default dell'org. Senza configurazione, il batch parte comunque senza notifica.

Invia un file CSV o XLSX (fino a 20 MB).

Polling su un batch.

Status: `pending → running → done | failed`, poi `expired` dopo la retention. A `done`, `succeeded + failed` sono pari a `expected_total` e `download_url` punta allo zip. Un batch che fallisce per intero finisce `failed`, senza zip.

Crea una share request singola.

Promemoria automatici (`reminders: true`): lo stesso link, con lo stesso token, al massimo due volte per destinatario. Il primo parte 3 giorni dopo l'invito, se mancano più di 24 ore alla scadenza; l'ultimo nelle 24 ore prima della scadenza, saltato se quella persona ha ricevuto un messaggio nelle 24 ore precedenti. Partono solo dal lunedì al sabato, 09:00–18:59 ora italiana, e mai dopo che il link è stato completato, revocato o è scaduto. Ogni link riporta `reminders_enabled`, `reminder_count` (promemoria automatici inviati), `last_reminded_at` (l'ultimo messaggio dopo l'invito, automatico o reinviato da te), `resend_count` e `first_opened_at`, la prima volta che il destinatario ha aperto il link.

Crea un batch di link da una lista di destinatari.

Le righe con un'email non valida vengono saltate e contate in `failed`.

Crea un batch di link da un file.

Elenca le share request.

Filtri: `?status=pending|completed|expired|revoked`, `?batch=`, `?q=` (email del destinatario). Senza `?batch=` tornano solo i link creati uno per uno; quelli di un batch con `?batch=<id>`. I link completati riportano la `compilation` e il suo `compilation_download_url`. Per sapere cosa seguire: `?expiring_within=N` restituisce i link ancora aperti che scadono entro N giorni, `?expired_within=N` quelli scaduti senza risposta negli ultimi N giorni (completati e revocati esclusi); N da 1 a 90, altrimenti `400`. Senza `?batch=` questi due comprendono anche i link dei batch.

Elenca i batch di link.

Filtri: `?q=` (nome del batch o del template), `?status=open|done`. Ogni batch riporta `id`, `name`, `source`, `template`, `template_name`, `total`, `sent`, `completed`, `failed` e `created_at`; `GET /share-requests/batches/{id}/` ne legge uno, con `open_links` (link ancora aperti), `open_with_recipient` (quelli con un destinatario) e `remindable_links` (quelli che un promemoria raggiunge adesso), che nella lista restano `null`.

Invia di nuovo l'invito a ogni destinatario di un batch che non ha ancora risposto.

Nessun body. Ogni link aperto con un destinatario riceve di nuovo lo stesso link, con le regole di `resend`: una volta ogni 24 ore (contando anche i promemoria automatici) e al massimo 5 volte per link. Risponde `200` con `{"sent": n, "skipped": n, "reasons": {"no_recipient": n, "cooldown": n, "limit": n}}`. I link completati, revocati o scaduti restano esclusi. Stessi permessi degli altri endpoint dei batch.

Revoca tutti i link di un batch ancora aperti.

Nessun body. Risponde `200` con `{"revoked": n}`; con i link smettono di funzionare anche i loro codici e le bozze di firma. I link completati, scaduti o già revocati restano come sono.

Scarica i link di un batch in CSV.

UTF-8 con BOM e `;` come separatore, così Excel lo apre in colonne; date in ora italiana. Colonne: destinatario (chi ha firmato, se noto), email, stato, invito inviato, prima apertura, completamento, scadenza, promemoria inviati (automatici e a mano). Le celle che iniziano con `=`, `+`, `-`, `@`, una tabulazione o un ritorno a capo sono precedute da `'`, così nessun foglio di calcolo le esegue come formule. Le intestazioni seguono `Accept-Language`.

Revoca un link: smette di funzionare subito.

Emette un nuovo link con le stesse impostazioni e invia un nuovo invito.

Reinvia l'invito, con lo stesso link.

Senza corpo. Restituisce `200` con il link. `409 not_pending` se il link non è più aperto, `409 no_recipient` se non ha un destinatario. `429 resend_cooldown` entro 24 ore dall'ultimo messaggio a quella persona (promemoria o reinvio), con `Retry-After`, oppure dopo 5 reinvii in tutto.

Proroga la scadenza di un link aperto.

Restituisce `200` con il link aggiornato; `400` se `days` non è valido. `409 not_open` se il link è completato, revocato o scaduto: uno scaduto si emette di nuovo con `recreate`. Dopo una proroga l'ultimo promemoria può ripartire prima della nuova scadenza. Stessi permessi della revoca.

Compila e congela il documento da firmare.

La risposta contiene `id`, `sha256`, `pdf_url` e `pages` per mostrare il documento, `signature_labels` e `consent_text`, la dichiarazione che il firmatario accetta. La bozza vale 24 ore.

Ottieni un link per il dispositivo del firmatario.

Restituisce `{ url, expires_at }`: un link valido 30 minuti. Il firmatario lo apre, rivede il documento e firma lì; il registro riporta il metodo `handoff` con la tua API key.

Controlla se la bozza è stata firmata.

Restituisce `{ id, finalized, compilation }`. Oppure ascolta `compilation.signed`.

Invia una firma raccolta dalla tua integrazione.

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

Restituisce la compilazione firmata. Il registro riporta il metodo `api` con il nome della tua API key, e così la pagina di registro.

Leggi il registro firme di una compilazione.

Metodo (`remote`, `in_person`, `handoff`, `api`), firmatario, email e verifica del codice, IP, dispositivo, `api_key_label` e impronte SHA-256 del documento e di ogni firma.

Crea una richiesta e invita chi firma per primo.

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

Restituisce `201` con lo `status` di ogni firmatario (`waiting`, `invited`, `signed`) e il suo `url` personale finché può firmare. Con `sender` il documento viene renderizzato e un PDF di quota consumato subito; con `first_signer`, quando il primo firmatario invia. Creare la richiesta conta anche un documento firmato del piano, restituito se la richiesta si chiude senza nessuna firma. Con `reminders: true` i promemoria seguono le regole dei link share e, in sequenza, vanno solo al firmatario di turno; in parallelo, a chi deve ancora firmare. La richiesta riporta `reminders_enabled`; ogni firmatario `reminder_count`, `last_reminded_at` e `first_opened_at`.

Elenca le richieste di firma.

Filtri: `?status=open|completed|expired|revoked`, `?template=`, `?q=` (email del firmatario), `?expiring_within=N` (richieste aperte che scadono entro N giorni), `?expired_within=N` (scadute senza firma negli ultimi N giorni); N da 1 a 90.

A che punto è la richiesta: firmatari, compilazione e, a completamento, `download_url`.

Chiude la richiesta: i link smettono di funzionare e la compilazione risulta fallita.

Reinvia l'invito a un firmatario di turno (al massimo una volta al minuto).

Proroga la scadenza di una richiesta aperta.

Restituisce `200` con la richiesta aggiornata; `400` se `days` non è valido, `409 not_open` se è completata, revocata o scaduta. Dopo una proroga l'ultimo promemoria può ripartire prima della nuova scadenza. Stessi permessi della revoca.

Elenca gli allegati della tua organizzazione.

Filtri: `?compilation=`, `?share_request=`, `?signature_request=`. Ogni allegato riporta `id`, `requirement`, `title`, `signer_role`, `file_name`, `content_type`, `size`, `sha256`, `uploaded_at` e `download_url`.

Gli allegati di una compilazione.

Scarica il file di un allegato.

È il `download_url` degli allegati: richiede la tua API key e restituisce il file come allegato, con il suo nome.

Scarica la pratica completa: uno ZIP con il PDF e i suoi allegati.

Elenca le risposte ai consensi della tua organizzazione.

Filtri: `?compilation=`, `?share_request=`, `?signature_request=`. Ogni risposta riporta `requirement`, `text`, `required`, `signer_role`, `accepted`, `answered_at`, `document_name`, `document_sha256`, `ip` e `user_agent`.

Le risposte ai consensi di una compilazione.

Registra un nuovo endpoint. La risposta include il `secret` una sola volta — conservalo.

Elenca i tuoi endpoint.

Aggiorna un endpoint, lo disattiva (`is_active`) o lo rende quello di default per i batch (`is_default`).

Emette un nuovo secret, restituito una sola volta. Il vecchio smette di funzionare subito.

Invia un `test.ping` e restituisce la risposta del target: `{ ok, response_status, delivery }`.

Ispeziona le consegne recenti: status code, numero di tentativi, response body.

Errori di rete, `5xx` e `429` vengono ritentati, fino a 6 tentativi, aspettando 30 s e raddoppiando ogni volta. I redirect non vengono seguiti e gli indirizzi privati sono rifiutati.