> ## 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 de assinatura eletrônica após o KYC > A assinatura eletrônica da Didit permite que a pessoa verificada, ou os representantes de uma empresa, assinem PDFs e documentos Word no fluxo de verificação. A assinatura eletrônica da Didit permite que a pessoa que você acabou de verificar assine os seus documentos no mesmo fluxo. Ela percorre cada documento, adiciona a assinatura, as iniciais e os dados que você pedir, e confirma com um código de uso único enviado ao e-mail ou ao telefone que verificou antes. A Didit devolve cada documento assinado com uma assinatura eletrônica avançada (AES), além de um PDF de evidências que vincula a assinatura à identidade verificada.Ela funciona na verificação de usuários (KYC), em que a pessoa verificada assina, e na verificação de empresas (KYB), em que os representantes legais ou pessoas-chave da empresa assinam em nome dela. Prompt de integração da assinatura eletrônica Copy prompt to clipboard \

\`Goal:
Add Didit Electronic 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:
Electronic 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:
\- 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).

Steps:
1\. Add the Electronic 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." 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": "",
      "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 ("aes"), format ("pades"), profile ("PAdES-B-LT" once signed).
\- 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), SIGNATURE_FIELD_DATA_MISSING (default REVIEW). Each maps to a signature_*_action setting.

Rules:
\- Level: "aes" only. "qes" is coming soon and saving it returns 400 qes_provider_not_configured.
\- 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.
\- Treat a null certificate, timestamp or signed_file as "not signed". Never show success until status is "signed".

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

\
Paste into ## Níveis de assinatura| Nível | Disponibilidade | O que é | | - | - | - | | **AES**, assinatura eletrônica avançada | Disponível | Cada documento é assinado em PAdES, o formato de assinatura de PDF, com um perfil de validação de longo prazo (`PAdES-B-LT`): a assinatura traz um carimbo de tempo confiável e os dados de revogação necessários para validá-la depois. Ela fica vinculada de forma exclusiva ao signatário por meio da identidade verificada e do código de uso único que ele confirmou, e qualquer alteração no documento após a assinatura a invalida. | | **QES**, assinatura eletrônica qualificada | Em breve | Assinada com um certificado qualificado emitido ao signatário. O console mostra a opção como **Em breve**, e salvar `signature_level: "qes"` pela API devolve `400` com `qes_provider_not_configured`. |A AES assina somente em PAdES. Os valores `xades` e `cades` de `signature_format` são recusados para a AES com `signature_format_not_supported`.## Como funciona**1. O fluxo verifica primeiro o signatário**A etapa de assinatura é executada depois das etapas que estabelecem quem está assinando: verificação de identidade e verificação de e-mail ou de telefone, para o contato que recebe o código. Veja [Antes de começar](#antes-de-começar).**2. A Didit prepara os documentos**Quando o signatário chega à etapa, a Didit copia os documentos e seus campos para a sessão e registra o SHA-256 de cada documento. Alterações posteriores no fluxo não mudam o que este signatário vê.**3. O signatário percorre cada documento**Em um documento com campos, o signatário é guiado de campo em campo. Ele adota uma assinatura uma única vez, que é aplicada a todos os campos de assinatura e de iniciais, e preenche os campos de texto e de caixa de seleção. Os valores que a Didit obtém da identidade verificada, da sessão ou do seu sistema já estão na página. Em um documento sem campos, ele lê e concorda.**4. O signatário confirma com um código**Quando algum documento tem campos, o signatário primeiro concorda em assinar os documentos eletronicamente. A Didit então envia um código de seis dígitos ao e-mail ou ao telefone que ele verificou antes na sessão. Digitá-lo autoriza a assinatura em todos os documentos da etapa.**5. A Didit assina e sela**A Didit preenche a data da assinatura, carimba o valor de cada campo em cada PDF, anexa a página de evidências e então aplica a assinatura PAdES e o carimbo de tempo, de modo que a assinatura cobre tudo o que está na página.**6. Você recebe os resultados**A decisão e os webhooks da sessão trazem `signatures[]` com o signatário, a confirmação, o certificado, o carimbo de tempo, os hashes de cada documento e o valor de cada campo. Você baixa os PDFs assinados e o PDF de evidências, e a Didit pode enviar uma cópia por e-mail ao signatário.## Antes de começarO signatário precisa estar verificado antes de poder assinar. A Didit obtém o nome e o contato dele dos registros verificados da própria sessão, nunca do que você ou o signatário digitam.**Para a verificação de usuários (KYC)**, coloque estas etapas antes da assinatura eletrônica no fluxo:- **Verificação de identidade**, aprovada, com um nome legível. Sem ela, a etapa registra `SIGNATURE_IDENTITY_NOT_VERIFIED`. - **Verificação de e-mail** quando o código vai por e-mail (o padrão) ou **verificação de telefone** quando vai por SMS. O código só é enviado a um contato verificado na mesma sessão. - Se o fluxo também tem **prova de vida**, ela deve estar aprovada.Para enviar ao signatário uma cópia dos documentos assinados por e-mail, a sessão também precisa de um e-mail verificado, mesmo quando o código vai por SMS.**Para a verificação de empresas (KYB)**, os signatários são as pessoas-chave da empresa, cada uma com o próprio KYC aprovado:| `signature_signer` | Quem assina | | - | - | | `legal_representative` | Toda pessoa-chave com o papel `representative` ou `authorized_signatory` | | `key_people` | Toda pessoa-chave física com uma sessão de KYC |Uma etapa de KYB tem de 1 a 20 signatários, e cada um precisa ter um KYC aprovado no momento de assinar. Cada um assina a própria cópia dos documentos e confirma com um código enviado ao contato verificado na sua própria sessão de KYC. O nome declarado para a pessoa-chave deve corresponder ao nome verificado dela, sem diferenciar maiúsculas de minúsculas nem espaçamento, ou a etapa registra `SIGNATURE_NAME_MISMATCH`. A etapa termina quando todos os signatários assinaram ou recusaram.## Documentos### De onde vêm os documentos`signature_documents_source` define de onde uma etapa obtém seus documentos:| Valor | Documentos | | - | - | | `workflow` (padrão) | Os documentos que você enviou ao fluxo no console. Todas as sessões assinam os mesmos. | | `session` | Os documentos que você envia em `sign.documents` ao [criar a sessão](https://docs.didit.me/sessions-api/create-session.md#electronic-signature-documents). Cada sessão assina os seus. | | `both` | Primeiro os documentos do fluxo, depois os da sessão. |Os documentos por sessão são a forma de fazer uma pessoa assinar um contrato com o próprio nome, valor ou condições já preenchidos pelo seu sistema.### Arquivos compatíveis| | Limite | | - | - | | PDF | Até 20 MB e 100 páginas cada. Sem senha, scripts nem arquivos anexados. | | Word (`.docx`) | Até 20 MB. Convertido em PDF ao enviá-lo ou ao criar a sessão, e o PDF convertido tem os mesmos limites de um PDF. Arquivos `.doc`, `.docm`, `.odt` e `.rtf` são recusados com `unsupported_type`. | | Por signatário | Até 20 documentos e 50 MB no total. |Quando você envia um documento Word, a Didit o converte em PDF durante o envio, em no máximo 60 segundos. As páginas convertidas são o que o signatário vê e assina, então confira-as antes de posicionar os campos: as quebras de linha podem diferir um pouco do Word. O arquivo Word e o seu PDF pertencem ao mesmo documento e são excluídos com ele. O PDF de evidências registra a conversão e o SHA-256 dos dois arquivos.A Didit recusa um arquivo Word com `signature_document_not_supported` e um `reason` quando o que seria assinado é ambíguo: ele tem macros (`macros`), alterações controladas não aceitas (`tracked_changes`), links para conteúdo externo (`external_links`) ou objetos incorporados (`embedded_objects`). Aceite ou rejeite as alterações controladas antes de enviar, para que o PDF mostre o texto com o qual você concordou.Um arquivo que não pode ser convertido é recusado com `signature_document_conversion_failed` e um destes motivos:| `reason` | O que deu errado | | - | - | | `docx_password_protected` | O arquivo tem senha. Remova-a e envie de novo. | | `docx_unreadable` | O arquivo não é um documento Word legível. | | `docx_too_many_pages` | O PDF convertido tem mais de 100 páginas. | | `docx_too_large` | O arquivo é grande demais para converter. | | `conversion_timeout` | A conversão demorou demais. Tente de novo ou envie o documento como PDF. |### Campos no documentoOs campos transformam um documento em um modelo que o signatário preenche, como você prepararia um envelope em uma ferramenta de assinatura de desktop. Um documento sem campos mantém o fluxo mais simples: o signatário lê e concorda.| Tipo | O que o signatário faz | Valor | | - | - | - | | `signature` | Toca nele para aplicar a assinatura que adotou. O primeiro campo de assinatura ou de iniciais abre a etapa em que ele a adota. | `true` depois de aplicado | | `initials` | Toca nele para aplicar as iniciais que adotou. | `true` depois de aplicado | | `text` | Digita um valor, conferido com a [validação](#validação) do campo. Pode vir preenchido. | String | | `checkbox` | Marca ou desmarca. Uma caixa de seleção obrigatória deve estar marcada. | Booleano | | `email` | Nada, quando a sessão tem um e-mail verificado, que o preenche somente para leitura. Caso contrário, digita. | String | | `full_name` | Nada: a Didit preenche o nome verificado, somente para leitura. | String | | `date_signed` | Nada: a Didit preenche a data em que os documentos são assinados. | String | | `data` | Nada: a Didit preenche, somente para leitura, um valor da identidade verificada, da sessão ou do seu sistema. Defina a origem em `prefill`. | String |Nesta versão não há seletor de data. Use um campo `text` para uma data que o signatário informa.Um campo tem estas propriedades:| Propriedade | Regras | | - | - | | `id` | Definido pela Didit. | | `key` | Nomeia o campo nos resultados e em `sign.field_values`. Letras minúsculas, dígitos e sublinhados, começando por uma letra, até 64 caracteres (`^[a-z][a-z0-9_]{0,63}$`), e único dentro do documento. | | `type` | Um dos tipos acima. | | `role` | Quem o preenche, com os valores de `signature_signer`: `verified_person`, `legal_representative` ou `key_people`. Em um documento de sessão, o padrão é o signatário da etapa. | | `page` | De 1 até o número de páginas do documento. Em um documento Word, uma página do PDF convertido. | | `x`, `y`, `width`, `height` | Frações da página como é exibida (de `0` a `1`), medidas a partir do canto superior esquerdo e arredondadas em 4 casas decimais. O campo deve caber dentro da página. Tem no mínimo `0.02` de largura e `0.012` de altura, e uma assinatura, no mínimo `0.12` por `0.035`. | | `required` | `signature` e `initials` são obrigatórios, a menos que você defina `false`. `full_name`, `date_signed` e `data` são sempre obrigatórios. | | `label` | De 1 a 80 caracteres, exibido ao signatário e nos resultados. | | `placeholder` | Somente `text` e `email`. Até 80 caracteres. | | `position` | A ordem em que o signatário é guiado, a partir de `0`. A Didit a define pela posição do campo: por página, depois de cima para baixo, depois da esquerda para a direita. | | `validation` | Somente `text`. Veja [Validação](#validação). | | `prefill` | De onde vem o valor. Veja [Valores pré-preenchidos](#valores-pré-preenchidos). | | `editable_when_prefilled` | Somente `text` e `email`: o signatário pode alterar um valor pré-preenchido. Padrão `false`. | | `checked_by_default` | Somente `checkbox`: a caixa já começa marcada. | | `date_format` | Somente `date_signed`: `DD/MM/YYYY` (padrão), `MM/DD/YYYY`, `YYYY-MM-DD` ou `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 } ```Um documento aceita até 200 campos, e um signatário até 500 entre os seus documentos.Uma etapa preenche e carimba apenas os campos do seu próprio signatário. Um documento só pode ter campos de vários papéis quando várias etapas de assinatura do fluxo o usam: cada etapa preenche os campos do seu próprio papel e deixa os demais vazios na sua cópia. Um campo de um papel que nenhuma etapa de assinatura do fluxo usa é recusado com `role_not_used`. Todo papel que tem campos em um documento precisa de pelo menos um campo `signature` ou `initials` nele, ou a versão do fluxo não pode ser publicada (`signature_field_missing`).#### Validação`validation` se aplica aos campos `text`:```json theme={null} { "kind": "any", "min_length": 0, "max_length": 80, "pattern": null, "message": null } ```- `kind`: `any`; `letters` (letras de qualquer alfabeto, espaços, hífens e apóstrofos); `number` (dígitos com separador decimal opcional); `email`; ou `pattern`. - `min_length`: de `0` até `max_length`. - `max_length`: de `1` a `500`. Padrão `120`. - `pattern`: obrigatório com `kind: "pattern"`. Uma expressão regular de até 200 caracteres que o valor inteiro deve atender. Lookarounds e backreferences não são compatíveis. - `message`: até 120 caracteres, exibida no lugar do erro padrão.A prévia do console, o fluxo de assinatura e a API aplicam as mesmas regras.#### Valores pré-preenchidos`prefill` indica a origem do valor de um campo:| `prefill` | Valor | | - | - | | `identity.full_name`, `identity.first_name`, `identity.last_name` | O nome como consta no documento de identidade verificado do signatário. | | `identity.date_of_birth` | Do documento de identidade verificado, como `DD/MM/YYYY`. | | `identity.nationality`, `identity.document_number`, `identity.document_type`, `identity.issuing_country` | Do documento de identidade verificado. | | `identity.address` | O endereço formatado do documento de identidade verificado, ou de um comprovante de endereço na mesma sessão. | | `contact.email`, `contact.phone` | O e-mail ou o telefone verificado do signatário. | | `company.name`, `company.registration_number`, `company.address`, `company.country` | A empresa verificada, no KYB. | | `session.vendor_data` | O `vendor_data` da sessão. | | `metadata.` | O valor de `` no `metadata` da sessão, como string. | | `api.` | O valor de `` em `sign.field_values`, enviado ao [criar a sessão](https://docs.didit.me/sessions-api/create-session.md#field-values). |Um campo `data` deve ter um `prefill`. Um campo `full_name` sempre usa `identity.full_name` e um campo `email` usa `contact.email`, e um campo `text` também pode ter um. Os valores dos campos `data`, `full_name` e `email` verificado são fixados quando o signatário começa a assinar: alterações posteriores na sessão não os mudam. Um campo `text` ou `email` pré-preenchido é somente leitura, a menos que você defina `editable_when_prefilled`.Quando a origem do valor de um campo obrigatório não tem valor naquele momento, por exemplo uma sessão sem endereço, o campo não é exibido vazio. A etapa gera [`SIGNATURE_FIELD_DATA_MISSING`](https://docs.didit.me/core-technology/electronic-signature/warnings-electronic-signature) e aplica `signature_field_data_missing_action` (padrão `REVIEW`). Com `NO_ACTION`, o signatário ainda pode assinar e o campo fica vazio.## Configure no console1) Vá até **Fluxos de trabalho**, abra um fluxo e adicione a etapa **Assinatura eletrônica** depois das etapas que verificam o signatário. 2) Em **Documentos**, selecione **Enviar** para adicionar arquivos PDF ou Word e arraste-os na ordem em que o signatário os vê. Os arquivos Word são convertidos em PDF: confira as páginas convertidas antes de posicionar os campos. **Substituir** troca o arquivo de um documento e mantém os campos dele, exceto os de páginas que o novo arquivo não tem mais. 3) Em **Posicione campos nos documentos**, selecione **Abrir o editor**. Arraste um campo da paleta até a página, ou selecione-o e clique onde ele deve ficar, depois mova e redimensione. Para cada campo, defina **Quem preenche**, o rótulo, se é **Obrigatório**, o que ele aceita, de onde vem o valor e a **Chave na API** (o `key` do campo). **Visualizar como signatário** mostra o documento como o signatário o vê em um celular ou no desktop. O editor salva conforme você avança (**Salvo no rascunho**) e lista o que corrigir antes de você selecionar **Concluído**. 4) Ainda em **Documentos**, escolha de onde vêm os documentos: **Este fluxo de trabalho**, **Cada sessão** ou **Ambas**. Para documentos sem campos, escolha se o signatário deve **Ler até o final antes de assinar** e dê **Um consentimento por documento**. 5) Em **Assinatura**, escolha o **Signatário**, o **Nível** (**Avançada (AES)**), o **Formato** e para onde vai o código (**Código de uso único por**). 6) Em **Regras**, defina o que cada [aviso](https://docs.didit.me/core-technology/electronic-signature/warnings-electronic-signature.md) faz com o veredito. 7) Em **Avançado**, escolha se deve **Enviar a cópia assinada por e-mail** e **Adicionar uma página de evidências**, e por quantos dias o link de assinatura permanece válido. Você também pode adicionar regras de status personalizadas. 8) Salve o fluxo.Para configurar a mesma etapa pela API, veja [Configurações de recursos do fluxo](https://docs.didit.me/management-api/workflows/feature-configs.md#electronic-signature). Os documentos do fluxo e seus campos são gerenciados no console; pela API, envie documentos e campos por sessão.## A experiência de assinaturaA etapa de assinatura é executada na página de verificação hospedada, no [SDK Web](https://docs.didit.me/pt-br/integration/web-sdks/overview.md) e nos [SDKs nativos](https://docs.didit.me/pt-br/integration/native-sdks/overview.md), no desktop e em celulares. Você não precisa criar nenhuma interface de assinatura.1) **Introdução.** O signatário vê os documentos que está prestes a assinar. 2) **Cada documento, em ordem.** Em um documento com campos, o signatário é guiado pelos campos na ordem de `position`. O primeiro campo de assinatura ou de iniciais abre uma janela em que ele [adota uma assinatura](#adotar-uma-assinatura). Os campos opcionais são marcados como **Opcional**. Os valores que a Didit preencheu aparecem na página com um cadeado e não são etapas. Tocar em um campo na página leva até ele. Em um celular, um campo por vez aparece em um painel que fica acima do teclado. Em uma tela com pelo menos 1200 px de largura, a página fica ao lado da lista de campos. Ao terminar um documento com um campo obrigatório ainda vazio, é mostrado quantos faltam e o fluxo salta para o primeiro. Um documento sem campos é lido e aceito, conforme você configurou. 3) **Revisão.** O signatário vê os documentos novamente e, quando algum deles tem campos, concorda em assiná-los eletronicamente. 4) **Código.** O signatário pede o código. Ele vale por 5 minutos, um novo pode ser enviado após 60 segundos, e o signatário recebe até 5 códigos e tem 3 tentativas erradas. Esgotá-los registra `SIGNATURE_OTP_FAILED`. 5) **Assinado.** Depois de assinar, o signatário pode baixar os documentos assinados. Se você habilitou, a Didit também envia uma cópia por e-mail. 6) **Recusa.** O signatário pode recusar em vez de assinar. Isso registra `SIGNATURE_DECLINED`. Uma recusa pode ser reaberta enquanto o link de assinatura for válido, então o signatário ainda pode assinar se mudar de ideia.O fluxo avisa o signatário quando o código expirou, um documento mudou, a assinatura falhou ou o link de assinatura expirou.O link de assinatura permanece válido por `signature_link_validity_days` (de 1 a 30, padrão 7), contados a partir da criação da sessão. A sessão permanece aberta pelo menos por esse tempo.> [!NOTE] > > Os SDKs nativos mostram a etapa de assinatura a partir da versão que a inclui, listada na [visão geral dos SDKs nativos](https://docs.didit.me/pt-br/integration/native-sdks/overview.md) quando for lançada. Documentos com campos exigem uma versão que ofereça suporte a campos: uma versão mais antiga não consegue exibi-los, e a etapa mostra um erro. Documentos sem campos funcionam em todas as versões com a etapa de assinatura. Até que o seu aplicativo execute uma versão compatível com o que o seu fluxo usa, direcione as pessoas à página hospedada ou ao SDK Web.### Adotar uma assinaturaO signatário adota a assinatura e as iniciais uma única vez, em uma janela, na primeira vez que um documento pede qualquer uma delas:- **Digitada**: o nome verificado dele em um estilo de letra manuscrita à sua escolha, marcado como **Do seu documento**. Ele não pode digitar outro nome. As iniciais digitadas são as primeiras letras desse nome. - **Desenhada**: desenhada com o dedo ou o mouse, tanto a assinatura quanto as iniciais.Todo campo de assinatura ou de iniciais seguinte é aplicado com um toque, e tocar em um já aplicado o remove de novo.## ResultadosO resultado de cada signatário é um item de `signatures[]` na [decisão da sessão](https://docs.didit.me/sessions-api/retrieve-session.md) e no `decision` dos [webhooks da sessão](https://docs.didit.me/integration/webhooks.md). Não há um webhook de assinatura separado: o evento `status.updated` da sessão avisa quando buscar a decisão.Você recebe o PDF assinado de cada documento, um PDF de evidências para cada signatário e o SHA-256 de cada arquivo original e assinado, para poder provar depois que nada mudou. Em documentos com campos, você também recebe o valor de cada campo, de onde veio e quando foi preenchido, além da assinatura adotada e de quando o signatário concordou em assinar eletronicamente. Veja o [relatório da assinatura eletrônica](https://docs.didit.me/core-technology/electronic-signature/report-electronic-signature.md) para cada campo, os downloads e como validar uma assinatura novamente.No console, a aba **Assinatura** da sessão mostra os documentos e depois um bloco **Campos** com uma prévia de cada página, a assinatura e as iniciais adotadas e o valor, o horário e a origem de cada campo. O [relatório em PDF](https://docs.didit.me/sessions-api/generate-pdf.md) inclui uma seção de assinatura e uma página **Assinatura eletrônica · campos** quando os documentos têm campos.## PreçosA assinatura eletrônica é cobrada uma vez por sessão assinada, qualquer que seja o número de documentos, signatários ou etapas de assinatura. Uma assinatura recusada, que falha ou que expira não é cobrada.## Exclusão dos dados de assinaturaQuando você [exclui uma sessão](https://docs.didit.me/sessions-api/delete-session.md), os dados de assinatura dela são excluídos junto: os documentos enviados com a sessão e seus arquivos Word originais, as cópias preparadas para cada signatário, os PDFs assinados, os PDFs de evidências, as imagens da assinatura e das iniciais adotadas e o valor de cada campo. Os links de download deixam de funcionar. O mesmo acontece quando uma sessão é excluída no fim do seu período de retenção de dados. A exclusão não pode ser desfeita, então baixe antes tudo o que precisar guardar.- Os documentos assinados de uma verificação de empresas pertencem à sessão da empresa. Excluir essa sessão os exclui. - Remover um documento de um fluxo o exclui, com seus campos e seu arquivo Word original. Um signatário que já começou a assinar mantém a cópia que lhe foi mostrada, como parte da sua sessão, até que você exclua essa sessão. Remova documentos somente de fluxos sem sessões aguardando assinatura. - Uma cópia que a Didit já enviou por e-mail ao signatário está na caixa de entrada dele e não é afetada.## Relacionados- [Relatório da assinatura eletrônica](https://docs.didit.me/core-technology/electronic-signature/report-electronic-signature.md): `signatures[]`, o PDF assinado, o PDF de evidências e os downloads. - [Avisos da assinatura eletrônica](https://docs.didit.me/core-technology/electronic-signature/warnings-electronic-signature.md): cada aviso e a regra que o controla. - [Criar sessão](https://docs.didit.me/sessions-api/create-session.md#electronic-signature-documents): envie documentos, campos e valores de campos por sessão. - [Configurações de recursos do fluxo](https://docs.didit.me/management-api/workflows/feature-configs.md#electronic-signature): cada configuração da etapa. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.