> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# API di firma elettronica: firma documenti dopo il KYC

> Con Didit la persona verificata o i rappresentanti di un'azienda firmano documenti PDF e Word nel flusso di verifica, a livello semplice o avanzato (AES).

La Firma elettronica consente a una persona di firmare i tuoi documenti all'interno dello stesso flusso. L'utente esamina ciascun documento, aggiunge la propria firma, le iniziali e tutti i dati richiesti e, al livello della firma Avanzata (AES), conferma tramite un codice monouso inviato all'indirizzo email o al numero di telefono verificato in precedenza. Didit restituisce ciascun documento firmato, oltre a un PDF probatorio che registra chi ha firmato e con quali modalità.La Firma elettronica prevede tre livelli. **Semplice** è l'impostazione predefinita e non richiede alcuna verifica dell'identità, email o telefono. **Avanzata (AES)** richiede una verifica dell'identità approvata e un'email o un telefono verificati, associando la firma all'identità verificata. **Qualificata (QES)** è una funzionalità aggiuntiva non ancora disponibile. Consulta [Livelli di firma](#livelli-di-firma).Funziona per la Verifica degli utenti (KYC), in cui la persona verificata firma, e per la Verifica aziendale (KYB), in cui i rappresentanti legali dell'azienda o le persone chiave firmano per suo conto.

Prompt per l'integrazione della firma elettronica
        Copia il prompt negli appunti



      
      

\<pre>

\`Goal:
Add Didit E-signature to a verification workflow: the verified person (KYC) or a company's representatives (KYB) sign PDF or Word documents inside the Didit flow, and your backend receives the signed PDFs and the evidence.

Delivery mode:
E-signature is a workflow step (feature SIGNATURE). There is no standalone signing API: the signer signs inside the hosted Didit flow, the Web SDK or a native SDK.

Prerequisites in the workflow (Advanced (AES) level only; the default Simple level needs no earlier step and no code):
\- KYC: an ID Verification step before the signature step (the signer's identity must be Approved), plus Email Verification (email codes, the default) or Phone Verification (SMS codes) so the code goes to a verified contact. If the workflow has Liveness, it must be Approved too.
\- KYB: a Key People step whose people complete their own KYC with the same prerequisites. signature_signer "legal_representative" picks the key people with the role representative or authorized_signatory; "key_people" picks every eligible key person (1 to 20 signers). For these KYB signers always set signature_level to "aes": "simple" is refused with signature_simple_requires_verified_person, so the workflow cannot be saved.

Steps:
1\. Add the E-signature step to the workflow in the Business Console (or POST /v3/workflows/ with {"feature": "SIGNATURE", "config": {...}}). Upload the documents in the console, or set signature_documents_source to "session" (or "both") to send them per session.
2\. Optional: place fields on each document: signature, initials, full_name, date_signed, text, checkbox, email and read-only data. Workflow documents get their fields in the console's template editor. Session documents carry them in sign.documents[].fields, placed by page and position or by anchor text. Every field has a key; a field with prefill "api.<key>" takes its value from sign.field_values.
3\. Create a session. For per-session documents, send sign.documents with base64 content:

curl -X POST 'https://verification.didit.me/v3/session/' \
-H 'x-api-key: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"workflow_id": "YOUR_WORKFLOW_ID",
"vendor_data": "user-1234",
"sign": {
  "documents": [
    \{
      "title": "Account agreement",
      "file_name": "agreement.pdf",
      "content_base64": "<base64 of the PDF>",
      "fields": [
        \{ "key": "signature", "type": "signature", "page": 3, "x": 0.09, "y": 0.62, "width": 0.36, "height": 0.085 },
        \{ "key": "credit_limit", "type": "data", "page": 1, "x": 0.34, "y": 0.31, "width": 0.3, "height": 0.03, "prefill": "api.credit_limit" }
      ]
    }
  ],
  "field_values": { "credit_limit": "3,000 EUR" }
}
}'

4\. Send the user to session.url (or open it with the Web or native SDK). Documents with fields need a native SDK release that supports fields; the hosted page and the Web SDK always do.
5\. Wait for the status.updated webhook, then GET /v3/session/{session_id}/decision/.

Decision surface:
signatures[] (one item per signer and signature step). Read:
\- status: the signing stage (intro, review, code, signing, signed, declined).
\- verdict: Not Finished | Approved | In Review | Declined.
\- level ("simple" or "aes"), format ("pdf" for simple, "pades" for aes), profile ("PAdES-B-LT" once an aes step is signed, otherwise null).
\- signer, identity_used, confirmation, certificate, timestamp, adopted_signature, electronic_signature_consent_at.
\- documents[]: mode ("fields" or "read_and_agree"), sha256_original, sha256_signed, status, signed_file (download path), source_format, conversion, fields[] (key, type, value, display_value, value_source, filled_at, image_url).
\- evidence_file (download path), warnings[] ({code, node_id}).

Downloads (x-api-key works):
\- GET /v3/session/{session_id}/signatures/{node_id}/documents/{document_id}/file/ -> signed PDF
\- GET /v3/session/{session_id}/signatures/{node_id}/evidence/?signature_id={id} -> evidence PDF
\- GET /v3/session/{session_id}/signatures/{node_id}/fields/{field_id}/image/ -> applied signature or initials (PNG); use the image_url of the field
\- POST /v3/session/{session_id}/signatures/{node_id}/validate/ -> re-checks the stored signatures

Warnings:
SIGNATURE_DECLINED (default REVIEW), SIGNATURE_OTP_FAILED, SIGNATURE_NAME_MISMATCH, SIGNATURE_IDENTITY_NOT_VERIFIED, SIGNATURE_DOCUMENT_CHANGED (default DECLINE). Each maps to a signature_*_action setting.

Rules:
\- Level: "simple" (default) or "aes". "qes" is an add-on that is not available yet and saving it returns 400 qes_not_available. While signature_availability.aes is false on the workflow, saving a new "aes" step returns 400 aes_not_available.
\- PDF: up to 20 MB and 100 pages each, no password, scripts or attachments. Up to 20 documents and 50 MB per signer.
\- Word: .docx only (.doc, .docm, .odt and .rtf are refused with unsupported_type), up to 20 MB, converted to PDF while the upload or create-session request runs. Fields refer to the converted pages. Macros, tracked changes, external links and embedded objects are refused with signature_document_not_supported; a file that can't be converted returns signature_document_conversion_failed. Both carry a reason.
\- Fields: key matches ^[a-z][a-z0-9_]{0,63}$ and is unique in its document; role defaults to the step's signer; up to 200 fields per document and 500 per signer. Every role with fields on a document needs a signature or initials field. There is no date picker type: use text.
\- Never show success until status is "signed". That is the check at every level. For an aes signature a null certificate, timestamp or signed_file also means "not signed"; a signed simple signature has a signed_file but a null certificate and timestamp.

See also:
\- /core-technology/electronic-signature/report-electronic-signature
\- /core-technology/electronic-signature/warnings-electronic-signature
\- /management-api/workflows/feature-configs#e-signature`

\</pre>



      
      

Incolla in

## Livelli di firma| Livello | Requisiti | Descrizione |
| - | - | - |
| **Semplice** | Predefinito. Nessuna verifica dell'identità, email o telefono | La persona firma tramite il link di sessione senza alcuna verifica dell'identità, email, telefono o codice. Se la sessione include già un nome verificato, viene utilizzato quest'ultimo; in caso contrario, l'utente digita il proprio nome, e la firma e il report indicano che il nome è stato digitato e non verificato. Chiunque sia in possesso del link di sessione può firmare, pertanto è consigliabile scegliere Semplice per accordi a basso rischio; per contratti regolamentati o di valore elevato è opportuno utilizzare Avanzata (AES). Il file firmato è un PDF dotato di una pagina probatoria e non contiene alcuna firma digitale, sigillo o timestamp. Didit conserva l'hash SHA-256 del record e di ciascun file firmato, in modo da rendere rilevabile qualsiasi modifica successiva. |
| **Avanzata (AES)**, firma elettronica avanzata | Una verifica dell'identità approvata e un indirizzo email o un numero di telefono verificati nella stessa sessione | Ciascun documento viene firmato in formato PAdES, il formato di firma per PDF, con un profilo di convalida a lungo termine (`PAdES-B-LT`): la firma include un timestamp RFC 3161 emesso da Didit e i dati di revoca necessari per convalidarla in un secondo momento. È collegata in modo univoco al firmatario tramite la sua identità verificata e il codice monouso confermato, e qualsiasi modifica apportata al documento dopo la firma la invalida. |
| **Qualificata (QES)**, firma elettronica qualificata | Funzionalità aggiuntiva, non ancora disponibile | Verrebbe firmata con un certificato qualificato rilasciato al firmatario. La console mostra l'opzione come **Prossimamente** e il salvataggio di `signature_level: "qes"` tramite API restituisce `400` con `qes_not_available`. Non viene mai sostituita in modo silenzioso da AES. |La firma Avanzata (AES) viene apposta esclusivamente in formato PAdES. I valori `signature_format` `xades` e `cades` vengono rifiutati per AES con `signature_format_not_supported`. Verifica `signature_availability` sul workflow prima di salvare un passaggio AES: finché `aes` è `false`, il salvataggio di un nuovo passaggio restituisce `400` con `aes_not_available`.## Come funziona**1. Per il livello Avanzato (AES), il workflow verifica prima il firmatario**Al livello della firma Avanzata (AES), il passaggio di firma viene eseguito dopo i passaggi che accertano l'identità del firmatario: Verifica dell'identità e Verifica email o telefonica per il recapito a cui viene inviato il codice. Consulta [Prima di iniziare](#prima-di-iniziare). Il livello Semplice non richiede alcun passaggio precedente.**2. Didit prepara i documenti**Quando il firmatario raggiunge il passaggio, Didit copia i documenti e i relativi campi nella sessione e registra l'hash SHA-256 di ciascun documento. Le eventuali modifiche successive al workflow non possono alterare ciò che questo firmatario visualizza.**3. Il firmatario esamina ciascun documento**Per i documenti che contengono campi, il firmatario viene guidato da un campo all'altro. Il firmatario appone la firma una sola volta e questa viene applicata a ogni campo per firma e iniziali, compilando inoltre i campi di testo e le caselle di controllo. I valori che Didit recupera dall'identità verificata, dalla sessione o dal tuo sistema sono già presenti sulla pagina. Per i documenti senza campi, l'utente li legge e li approva.**4. Per Avanzata (AES), il firmatario conferma con un codice**Se un documento contiene campi, il firmatario accetta innanzitutto di firmare i documenti elettronicamente. Al livello della firma Avanzata (AES), Didit invia quindi un codice a sei cifre all'indirizzo email o al numero di telefono verificato in precedenza nella sessione; l'inserimento di tale codice autorizza la firma su tutti i documenti del passaggio. Al livello Semplice non è previsto alcun codice: l'accettazione è sufficiente per autorizzare la firma.**5. Didit firma e appone il sigillo**Didit inserisce la data di firma, applica il valore di ciascun campo in ogni PDF e allega la pagina probatoria. Al livello della firma Avanzata (AES), applica successivamente la firma PAdES e il timestamp, in modo che la firma copra l'intero contenuto della pagina. Al livello Semplice, il file è un PDF con la pagina probatoria, privo di firma digitale, sigillo o timestamp.**6. Ricevi i risultati**I webhook di decisione e di sessione contengono `signatures[]` con i dati del firmatario, la conferma, il certificato, il timestamp, gli hash di ciascun documento e il valore di ogni campo. Puoi scaricare i PDF firmati e il PDF probatorio, e Didit può inviare una copia via email al firmatario.## Prima di iniziareAl livello Avanzato (AES), il firmatario deve essere verificato prima di poter firmare. Didit ricava il suo nome e i suoi recapiti dai record verificati della sessione stessa, mai da ciò che tu o il firmatario inserite digitando. Il livello Semplice non richiede nulla di tutto questo: non prevede alcuna verifica dell'identità, email, telefono o codice, e viene rifiutato per i firmatari KYB.**Per la Verifica degli utenti (KYC)**, inserisci questi passaggi prima di Firma elettronica nel workflow:- **Verifica dell'identità**, approvata, con un nome leggibile. Senza di essa, il passaggio registra `SIGNATURE_IDENTITY_NOT_VERIFIED`.
- **Verifica email** quando il codice viene inviato via email (l'opzione predefinita), oppure **Verifica telefonica** quando viene inviato tramite SMS. Il codice viene inviato solo a un recapito verificato nella stessa sessione.
- Se il workflow include anche **Rilevamento della vitalità**, questo deve essere approvato.Per inviare via email al firmatario una copia dei documenti firmati, la sessione necessita anche di un'email verificata, anche quando il codice viene inviato tramite SMS.**Per la Verifica aziendale (KYB)**, i firmatari sono le persone chiave dell'azienda, ciascuna con il proprio KYC approvato:| `signature_signer` | Chi firma |
| - | - |
| `legal_representative` | Ogni persona chiave con il ruolo `representative` o `authorized_signatory` |
| `key_people` | Ogni singola persona chiave con una sessione KYC |Un passaggio KYB ha tra 1 e 20 firmatari, e ciascuno necessita di un KYC approvato prima di firmare. Ognuno firma la propria copia dei documenti e conferma con un codice inviato al recapito verificato nella propria sessione KYC. Il nome dichiarato per la persona chiave deve corrispondere al suo nome verificato, senza distinzione tra maiuscole e minuscole e tra gli spazi, altrimenti il passaggio registra `SIGNATURE_NAME_MISMATCH`. Il passaggio si conclude quando ogni firmatario ha firmato o rifiutato.## Documenti### Da dove provengono i documenti`signature_documents_source` imposta da dove un passaggio ottiene i propri documenti:| Valore | Documenti |
| - | - |
| `workflow` (predefinito) | I documenti caricati nel workflow nella console. Ogni sessione firma gli stessi. |
| `session` | I documenti che invii in `sign.documents` quando [crei la sessione](https://docs.didit.me/it/sessions-api/create-session.md#documenti-di-firma-elettronica). Ciascuna sessione firma i propri. |
| `both` | Prima i documenti del workflow, poi i documenti della sessione. |I documenti per sessione sono il modo per far firmare a una persona un contratto con il proprio nome, importo o clausole già compilati dal tuo sistema.### File supportati| | Limite |
| - | - |
| PDF | Fino a 20 MB e 100 pagine ciascuno. Nessuna password, script o file allegato. |
| Word (`.docx`) | Fino a 20 MB. Viene convertito in PDF quando lo carichi o quando crei la sessione, e il PDF convertito ha gli stessi limiti di un PDF. I file `.doc`, `.docm`, `.odt` e `.rtf` vengono rifiutati con `unsupported_type`. |
| Per firmatario | Fino a 20 documenti e 50 MB in totale. |Quando carichi un documento Word, Didit lo converte in PDF durante il caricamento, in un massimo di 60 secondi. Le pagine convertite corrispondono a ciò che il firmatario vede e firma, quindi controllale prima di posizionare i campi: le interruzioni di riga possono differire leggermente rispetto a Word. Il file Word e il relativo PDF appartengono allo stesso documento e vengono eliminati insieme ad esso. Il PDF delle evidenze registra la conversione e l'hash SHA-256 di entrambi i file.Didit rifiuta un file Word con `signature_document_not_supported` e un `reason` quando ciò che verrebbe firmato risulta ambiguo: contiene macro (`macros`), revisioni non accettate (`tracked_changes`), link a contenuti esterni (`external_links`) o oggetti incorporati (`embedded_objects`). Accetta o rifiuta le revisioni prima del caricamento, affinché il PDF mostri il testo concordato.Un file che non può essere convertito viene rifiutato con `signature_document_conversion_failed` e uno dei seguenti motivi:| `reason` | Cosa è andato storto |
| - | - |
| `docx_password_protected` | Il file è protetto da password. Rimuovila e caricalo di nuovo. |
| `docx_unreadable` | Il file non è un documento Word leggibile. |
| `docx_too_many_pages` | Il PDF convertito ha più di 100 pagine. |
| `docx_too_large` | Il file è troppo grande per essere convertito. |
| `conversion_timeout` | La conversione ha richiesto troppo tempo. Riprova oppure carica il documento in formato PDF. |### Campi sul documentoI campi trasformano un documento in un modello che il firmatario compila, proprio come prepareresti una busta in uno strumento di firma desktop. Un documento senza campi mantiene il flusso più semplice: il firmatario lo legge e acconsente.| Tipo | Cosa fa il firmatario | Valore |
| - | - | - |
| `signature` | Lo tocca per applicare la firma adottata. Il primo campo di firma o sigla apre il passaggio in cui la si adotta. | `true` una volta applicata |
| `initials` | Lo tocca per applicare la sigla adottata. | `true` una volta applicata |
| `text` | Digita un valore, verificato rispetto alla [validazione](#validazione) del campo. Può essere precompilato. | Stringa |
| `checkbox` | La spunta o la deseleziona. Una casella obbligatoria deve essere spuntata. | Booleano |
| `email` | Nulla se la sessione ha un'email verificata, che viene inserita nel campo in sola lettura. Altrimenti la digita. | Stringa |
| `full_name` | Nulla: Didit compila il nome completo verificato, in sola lettura. | Stringa |
| `date_signed` | Nulla: Didit compila la data in cui i documenti vengono firmati. | Stringa |
| `data` | Nulla: Didit compila un valore ricavato dall'identità verificata, dalla sessione o dal tuo sistema, in sola lettura. Imposta la sua origine in `prefill`. | Stringa |In questa versione non è disponibile un selettore di data. Usa un campo `text` per una data inserita dal firmatario.Un campo ha le seguenti proprietà:| Proprietà | Regole |
| - | - |
| `id` | Impostato da Didit. |
| `key` | Assegna un nome al campo nei risultati e in `sign.field_values`. Lettere minuscole, cifre e trattini bassi, che iniziano con una lettera, fino a 64 caratteri (`^[a-z][a-z0-9_]{0,63}$`), e univoco all'interno del documento. |
| `type` | Uno dei tipi sopra indicati. |
| `role` | Chi lo compila, con i valori di `signature_signer`: `verified_person`, `legal_representative` o `key_people`. Su un documento di sessione corrisponde per impostazione predefinita al firmatario del passaggio. |
| `page` | Da 1 al numero totale di pagine del documento. Per un documento Word, una pagina del PDF convertito. |
| `x`, `y`, `width`, `height` | Frazioni della pagina così come viene visualizzata (da `0` a `1`), misurate dall'angolo in alto a sinistra e arrotondate a 4 decimali. Il campo deve rientrare nella pagina. È largo almeno `0.02` e alto almeno `0.012`, e una firma almeno `0.12` per `0.035`. |
| `required` | `signature` e `initials` sono obbligatori se non sono impostati su `false`. `full_name`, `date_signed` e `data` sono sempre obbligatori. |
| `label` | Da 1 a 80 caratteri, mostrato al firmatario e nei risultati. |
| `placeholder` | Solo per `text` ed `email`. Fino a 80 caratteri. |
| `position` | L'ordine con cui il firmatario viene guidato, a partire da `0`. Didit lo imposta in base alla posizione del campo: per pagina, poi dall'alto verso il basso e da sinistra a destra. |
| `validation` | Solo per `text`. Vedi [Validazione](#validazione). |
| `prefill` | Da dove proviene il valore. Vedi [Valori precompilati](#valori-precompilati). |
| `editable_when_prefilled` | Solo per `text` ed `email`: il firmatario può modificare un valore precompilato. Valore predefinito `false`. |
| `checked_by_default` | Solo per `checkbox`: la casella parte spuntata. |
| `date_format` | Solo per `date_signed`: `DD/MM/YYYY` (predefinito), `MM/DD/YYYY`, `YYYY-MM-DD` o `D MMMM YYYY`. |```json theme={null}
{
  "id": "6a2f1c0e-4d8b-4f5e-9a51-0c7b2e9d3f10",
  "key": "occupation",
  "type": "text",
  "role": "verified_person",
  "page": 1,
  "x": 0.34,
  "y": 0.4618,
  "width": 0.57,
  "height": 0.0325,
  "required": true,
  "label": "Occupation",
  "placeholder": "For example, nurse",
  "position": 5,
  "validation": { "kind": "any", "min_length": 0, "max_length": 80, "pattern": null, "message": null },
  "prefill": null,
  "editable_when_prefilled": false,
  "checked_by_default": false,
  "date_format": null
}
```Un documento accetta fino a 200 campi e un singolo firmatario fino a 500 in tutti i suoi documenti.Un passaggio compila e appone il timbro solo sui campi del proprio firmatario. Un documento può contenere campi per diversi ruoli solo quando più passaggi di firma del workflow lo utilizzano: ciascun passaggio compila i campi del proprio ruolo e lascia vuoti gli altri sulla propria copia. Un campo destinato a un ruolo che nessun passaggio di firma del workflow utilizza viene rifiutato con `role_not_used`. Ogni ruolo che dispone di campi su un documento deve avere almeno un campo `signature` o `initials` su di esso, altrimenti la versione del workflow non può essere pubblicata (`signature_field_missing`).#### Validazione`validation` si applica ai campi `text`:```json theme={null}
{ "kind": "any", "min_length": 0, "max_length": 80, "pattern": null, "message": null }
```- `kind`: `any`; `letters` (lettere in qualsiasi sistema di scrittura, spazi, trattini e apostrofi); `number` (cifre con un separatore decimale opzionale); `email`; o `pattern`.
- `min_length`: da `0` fino a `max_length`.
- `max_length`: da `1` a `500`. Valore predefinito `120`.
- `pattern`: obbligatorio con `kind: "pattern"`. Un'espressione regolare fino a 200 caratteri a cui l'intero valore deve corrispondere. Lookaround e backreference non sono supportati.
- `message`: fino a 120 caratteri, mostrato al posto dell'errore predefinito.L'anteprima della console, il flusso di firma e l'API applicano le stesse regole.#### Valori precompilati`prefill` indica l'origine del valore di un campo:| `prefill` | Valore |
| - | - |
| `identity.full_name`, `identity.first_name`, `identity.last_name` | Il nome riportato sul documento d'identità verificato del firmatario. |
| `identity.date_of_birth` | Dal documento d'identità verificato, come `DD/MM/YYYY`. |
| `identity.nationality`, `identity.document_number`, `identity.document_type`, `identity.issuing_country` | Dal documento d'identità verificato. |
| `identity.address` | L'indirizzo formattato dal documento d'identità verificato, oppure da una prova di residenza nella stessa sessione. |
| `contact.email`, `contact.phone` | L'email o il telefono verificati del firmatario. |
| `company.name`, `company.registration_number`, `company.address`, `company.country` | L'azienda verificata, per KYB. |
| `session.vendor_data` | I `vendor_data` della sessione. |
| `metadata.<key>` | Il valore di `<key>` nei `metadata` della sessione, come stringa. |
| `api.<key>` | Il valore di `<key>` in `sign.field_values`, inviato quando [crei la sessione](https://docs.didit.me/it/sessions-api/create-session.md#valori-dei-campi). |Un campo `data` deve avere un `prefill`. Un campo `full_name` usa sempre `identity.full_name` e un campo `email` usa `contact.email`; anche un campo `text` può averne uno. I valori dei campi `data`, `full_name` e dei campi `email` verificati vengono fissati quando il firmatario avvia la firma: modifiche successive alla sessione non li cambiano. Un campo `text` o `email` precompilato è di sola lettura a meno che non imposti `editable_when_prefilled`.Quando l'origine di un campo obbligatorio non ha alcun valore in quel momento, ad esempio una sessione priva di indirizzo, il campo rimane vuoto e il firmatario può comunque firmare. Non viene generato alcun avviso, e `value_unavailable_reason` nel [report](https://docs.didit.me/it/core-technology/electronic-signature/report-electronic-signature.md) ne spiega il motivo.## Configuralo nella console1) Vai su **Workflow**, apri un workflow e aggiungi il passaggio **Firma elettronica** dopo i passaggi che verificano il firmatario.
2) In **Documenti**, seleziona **Carica** per aggiungere file PDF o Word, e trascinali nell'ordine in cui li vedrà il firmatario. I file Word vengono convertiti in PDF: controlla le pagine convertite prima di posizionare i campi. **Sostituisci** sostituisce il file di un documento mantenendone i campi, a eccezione di quelli presenti sulle pagine che il nuovo file non contiene più.
3) Sotto **Posiziona i campi sui documenti**, seleziona **Apri l'editor**. Trascina un campo dalla tavolozza sulla pagina, oppure selezionalo e fai clic nel punto in cui deve andare, quindi spostalo e ridimensionalo. Per ogni campo, imposta **Chi lo compila**, la sua etichetta, se è **Obbligatorio**, cosa accetta, da dove proviene il suo valore e la sua **Chiave API** (la `key` del campo). **Anteprima come firmatario** mostra il documento così come lo vede il firmatario su smartphone o desktop. L'editor salva man mano che procedi (**Salvato come bozza**) ed elenca cosa correggere prima di selezionare **Fatto**.
4) Sempre in **Documenti**, scegli l'origine dei documenti: **Questo workflow**, **Ogni sessione** o **Entrambe**. Per i documenti senza campi, scegli se il firmatario deve **Leggere fino alla fine prima di firmare** e se deve dare **Un consenso per documento**.
5) In **Firma**, scegli il **Firmatario**, il **Livello** (**Semplice**, l'impostazione predefinita, o **Avanzato (AES)**; **Qualificato (QES)** è contrassegnato come **Prossimamente**), il **Formato** e dove inviare il codice (**Codice monouso via**).
6) In **Regole**, imposta l'effetto di ogni [avviso](https://docs.didit.me/it/core-technology/electronic-signature/warnings-electronic-signature.md) sul verdetto.
7) In **Avanzate**, scegli se **Invia la copia firmata via e-mail** e **Aggiungi una pagina delle evidenze**, e per quanti giorni il link di firma rimane valido. Puoi anche aggiungere regole di stato personalizzate.
8) Salva il workflow.Per configurare lo stesso passaggio tramite l'API, consulta [Configurazioni delle funzionalità del workflow](https://docs.didit.me/it/management-api/workflows/feature-configs.md#e-signature). I documenti del workflow e i relativi campi si gestiscono nella console; tramite l'API, invia documenti e campi per sessione.## L'esperienza di firmaIl passaggio di firma viene eseguito nella pagina di verifica ospitata, nel [Web SDK](https://docs.didit.me/it/integration/web-sdks/overview.md) e negli [SDK nativi](https://docs.didit.me/it/integration/native-sdks/overview.md), su desktop e su telefoni. Non è necessario sviluppare alcuna interfaccia di firma.1) **Introduzione.** Il firmatario visualizza i documenti che sta per firmare.
2) **Ciascun documento, in ordine.** Per un documento contenente campi, il firmatario viene guidato attraverso i relativi campi nell'ordine di `position`. Il primo campo per la firma o le iniziali apre un pannello in cui [adottare una firma](#adozione-di-una-firma). I campi facoltativi sono contrassegnati come **Facoltativo**. I valori precompilati da Didit appaiono sulla pagina con un lucchetto e non costituiscono passaggi separati. Toccando un campo sulla pagina ci si sposta direttamente su di esso. Su telefono, viene mostrato un campo alla volta all'interno di un pannello che rimane al di sopra della tastiera. Su schermi di larghezza pari ad almeno 1200 px, la pagina è affiancata all'elenco dei campi. Se si conclude un documento lasciando vuoto un campo obbligatorio, viene mostrato quanti ne mancano e si viene reindirizzati al primo di essi. Un documento senza campi viene letto e accettato, in base alla configurazione impostata.
3) **Riepilogo.** Il firmatario visualizza nuovamente i documenti e, se qualcuno di essi contiene campi, acconsente a firmarli elettronicamente.
4) **Codice (solo Advanced (AES)).** Il firmatario richiede il proprio codice. È valido per 5 minuti, ne può essere inviato uno nuovo dopo 60 secondi e ogni firmatario ha a disposizione fino a 5 codici e 3 tentativi errati. L'esaurimento dei codici o dei tentativi errati registra `SIGNATURE_OTP_FAILED`. Al livello Simple non è previsto alcun codice: il firmatario passa direttamente dal riepilogo alla firma.
5) **Firmato.** Dopo la firma, il firmatario può scaricare i propri documenti firmati. Se l'opzione è stata abilitata, Didit invia loro anche una copia via email.
6) **Rifiuto.** Il firmatario può rifiutare invece di firmare. Questa azione registra `SIGNATURE_DECLINED`. Un rifiuto può essere riaperto finché il link di firma rimane valido, consentendo al firmatario di firmare comunque se cambia idea.Il flusso avvisa il firmatario nel caso in cui il codice sia scaduto, un documento sia stato modificato, la firma sia fallita o il link di firma sia scaduto.Il link di firma rimane valido per `signature_link_validity_days` (da 1 a 30, predefinito 7), calcolati a partire dalla creazione della sessione. La sessione rimane aperta almeno per tale durata.> [!NOTE]
>
> Gli SDK nativi mostrano il passaggio di firma a partire dalla release che ne introduce il supporto, indicata nella [panoramica degli SDK nativi](https://docs.didit.me/it/integration/native-sdks/overview.md) al momento del rilascio. I documenti con campi richiedono una versione che supporti i campi: una release precedente non è in grado di mostrarli e il passaggio visualizzerà un errore. I documenti senza campi funzionano in qualsiasi release che includa il passaggio di firma. Fino a quando la tua applicazione non adotta una release compatibile con le funzionalità utilizzate dal tuo workflow, indirizza gli utenti verso la pagina ospitata o il Web SDK.### Adozione di una firmaIl firmatario adotta la propria firma e le iniziali una sola volta, in un unico pannello, la prima volta che un documento richiede l'una o le altre:- **Digitata**: il proprio nome verificato con lo stile calligrafico scelto, contrassegnato come **Dal tuo documento**. Non è possibile digitare un nome diverso. Le iniziali digitate corrispondono alle prime lettere di tale nome.
- **Disegnata**: tracciate con il dito o con il mouse, sia per la firma sia per le iniziali.Ogni successivo campo per la firma o le iniziali si applica con un solo tocco; toccando nuovamente un campo a cui è stata applicata una firma o delle iniziali, queste vengono rimosse.## RisultatiIl risultato di ciascun firmatario è un elemento di `signatures[]` nella [decisione della sessione](https://docs.didit.me/it/sessions-api/retrieve-session.md) e nel campo `decision` dei [webhook della sessione](https://docs.didit.me/it/integration/webhooks.md). Non esiste un webhook separato per la firma: l'evento `status.updated` della sessione segnala quando recuperare la decisione.Riceverai il PDF firmato di ciascun documento, un PDF probatorio per ogni firmatario e l'hash SHA-256 di ogni file originale e firmato, per poter dimostrare in seguito che nulla è stato alterato. Per i documenti con campi, otterrai anche il valore di ciascun campo, la sua origine e l'orario di compilazione, oltre alla firma adottata e al momento esatto in cui il firmatario ha acconsentito alla firma elettronica. Consulta il [report di Firma elettronica](https://docs.didit.me/it/core-technology/electronic-signature/report-electronic-signature.md) per l'elenco completo dei campi, i download e le modalità di riconvalida di una firma.Nella console, la scheda **Firma** della sessione mostra i documenti, seguiti da un blocco **Campi** con l'anteprima di ogni pagina, la firma e le iniziali adottate, nonché il valore, l'orario e l'origine di ciascun campo. Il [report PDF](https://docs.didit.me/it/sessions-api/generate-pdf.md) include una sezione dedicata alla firma e una pagina **Firma elettronica · campi** quando i documenti contengono campi.## PrezziLa firma elettronica costa \$0.10 per sessione firmata, inclusa nel credito gratuito, a prescindere dal numero di documenti inclusi in una singola firma e dal livello scelto, Simple o Advanced (AES). Una firma rifiutata, fallita o scaduta non viene addebitata. Qualified (QES) è un modulo aggiuntivo non ancora disponibile e il cui prezzo non è ancora definito.## Eliminazione dei dati di firmaQuando si [elimina una sessione](https://docs.didit.me/it/sessions-api/delete-session.md), i relativi dati di firma vengono eliminati contestualmente: i documenti inviati con la sessione e i rispettivi file Word originali, le copie predisposte per ciascun firmatario, i PDF firmati, i PDF probatori, le immagini della firma e delle iniziali adottate e il valore di ciascun campo. I relativi link di download smettono di funzionare. Lo stesso avviene quando una sessione viene eliminata al termine del periodo di conservazione dei dati. L'eliminazione non può essere annullata, pertanto scarica preventivamente tutto ciò che è necessario conservare.- I documenti firmati di una Verifica aziendale (KYB) appartengono alla sessione dell'azienda. Eliminando tale sessione verranno eliminati anche i documenti.
- Rimuovere un documento da un workflow comporta la sua eliminazione, assieme ai relativi campi e al file Word originale. Un firmatario che ha già avviato la firma mantiene la copia visualizzata, all'interno della propria sessione, fino a quando tale sessione non viene eliminata. Rimuovi documenti solo da workflow che non hanno sessioni in attesa di firma.
- L'eventuale copia che Didit ha già inviato via email al firmatario si trova nella sua casella di posta e non viene toccata.## Correlati- [Report di Firma elettronica](https://docs.didit.me/it/core-technology/electronic-signature/report-electronic-signature.md): `signatures[]`, il PDF firmato, il PDF probatorio e i download.
- [Avvisi di Firma elettronica](https://docs.didit.me/it/core-technology/electronic-signature/warnings-electronic-signature.md): tutti gli avvisi e la regola che li gestisce.
- [Crea sessione](https://docs.didit.me/it/sessions-api/create-session.md#documenti-di-firma-elettronica): invio di documenti, campi e valori dei campi per sessione.
- [Configurazioni delle funzionalità del workflow](https://docs.didit.me/it/management-api/workflows/feature-configs.md#e-signature): tutte le impostazioni del passaggio.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.