> ## 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. # Crea voce blocklist API: allowlist e blocklist Didit > Aggiungi una voce (volto, documento, IP, wallet, email, telefono) a una blocklist o allowlist Didit. Controlli antifrode programmatici via API. Prompt API per creare una voce di lista Copia il prompt negli appunti \

\`Add an entry to a Didit list (blocklist, allowlist, or custom) through the Management API.

Endpoint:
POST https://verification.didit.me/v3/lists/{list_uuid}/entries/

Authentication:
Use the x-api-key header with my Didit API key. A scoped API key needs workflows: write.

Goal:
\- Insert a single entry into a list. Three add modes are supported:
1\. By value: pass value matching the list's entry_type.
2\. From a verification session: pass reference_session_id and Didit reads the value from the session's most recent record of the list's entry_type (face, document, phone, email, ip_address, device_fingerprint) and links the entry to the session.
3\. With a source reference: pass value plus reference_object_uuid and metadata.reference_type so the console links the entry back to the transaction, user or business it came from.

Path parameter:
\- list_uuid: list UUID from GET /v3/lists/. For a face without a session, use POST /v3/lists/{list_uuid}/entries/face-upload/ instead.

Request body (application/json):
\{
"value": "string",                  // required unless reference_session_id is sent
"reference_session_id": "uuid",     // optional: read the value from this session of my application
"reference_object_uuid": "uuid",    // optional: transaction UUID, or didit_internal_id of a user or business
"face_image_source": "liveness" | "front_image_camera_front" | "back_image_camera_front", // optional, system face blocklist + reference_session_id only; default liveness
"reference_node_id": "string",      // optional, with a document-capture face_image_source: which ID verification node's selfie to use
"display_label": "string",          // optional, at most 512 characters
"comment": "string",                // optional, reason or note
"metadata": {                       // optional, free-form; reference_image_url and front_image_url are ignored
"reference_type": "transaction" | "vendor_user" | "vendor_business",
"reference_id": "uuid"
}
}

Value validation by entry_type:
\- email: valid email address.
\- phone: valid international phone number (stored in E.164).
\- ip_address: IP address or CIDR range (e.g. 10.0.0.0/8).
\- device_fingerprint: at least 8 characters among letters, digits, -, _, : and . (a blocklist refuses a fingerprint that several distinct devices have reported).
\- country: ISO 3166-1 alpha-2 or alpha-3 (stored as alpha-3).
\- user, business: the vendor_data to block.
\- face, document, wallet_address, bank_account, key: any non-empty string.
Values are case-insensitive: country codes are stored in upper case, phone numbers in E.164, everything else in lower case.
A list holds each value once: adding a value that is already there returns 400.

Adding from a session, what Didit does:
\- Looks up the session (it must belong to the same application).
\- Reads the value from the session's most recent record of the list's entry_type:
\- face: the liveness face (value is the face UUID). With face_image_source = front_image_camera_front / back_image_camera_front, the face from the selfie the front camera took while the user photographed the front / back of their document instead (system face blocklist only, leave value empty).
\- document: the document number; full_name, issuing_state, document_type, region and document_number go into metadata.
\- phone / email: the phone number / email address.
\- ip_address: the session's IP address.
\- device_fingerprint: a fingerprint that identifies one device. On a blocklist, Didit refuses a session that only has a device-class fingerprint or was completed on more than one device; pass the exact fingerprint as value in that case.
\- Links the entry to the session (reference_session_id) and to that record (reference_object_uuid).
\- If I also send value, Didit stores my value but still links the most recent record. To list a value from an earlier record, add it by value without reference_session_id.

Example calls:
\# By value
curl -X POST "https://verification.didit.me/v3/lists/{list_uuid}/entries/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"value": "+14155552671", "comment": "Reported fraud"}'

\# From a session
curl -X POST "https://verification.didit.me/v3/lists/{list_uuid}/entries/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"reference_session_id": "33333333-4444-5555-6666-777777777777"}'

\# The face from the selfie taken during document capture (system face blocklist)
curl -X POST "https://verification.didit.me/v3/lists/{list_uuid}/entries/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"reference_session_id": "33333333-4444-5555-6666-777777777777", "face_image_source": "front_image_camera_front"}'

\# From a transaction
curl -X POST "https://verification.didit.me/v3/lists/{list_uuid}/entries/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"value": "0x52908400098527886E0F7030069857D2E4169EE7", "reference_object_uuid": "55555555-6666-7777-8888-999999999999", "metadata": {"reference_type": "transaction"}}'

Failure modes:
\- 400: value fails the entry_type validator or is already in the list, neither value nor reference_session_id was sent, reference_session_id is not a session of this application, or the session has no data of the list's entry_type.
\- 400 (face_image_source): the list is not the system face blocklist, value was sent, the session has no image for that source, no clear face was found in that selfie, or that selfie is already in the blocklist.
\- 401: the API key has expired.
\- 403: missing x-api-key (a wrong, revoked or expired key gets 401) ({ "detail": "You do not have permission to perform this action." }), or a scoped key without workflows: write.
\- 404: list not found in this application ({ "detail": "List not found." }).
\- 503 (face_image_source): face analysis is temporarily unavailable; nothing was added, retry later.
\- 429: rate limited (see /integration/rate-limiting); back off and retry.

Side effects:
\- System face, document, phone and email blocklists: a record read from a session is flagged as blocklisted at once, and new sessions that match it are declined.
\- System user and business blocklists: users or businesses of the application whose vendor_data equals value (or whose UUID equals reference_object_uuid) are set to BLOCKED.
\- Sessions and transactions that already finished are not changed.

For the full integration shape, see /integration/integration-prompt.`

\
Incolla in Aggiunge una voce a una lista. Il valore viene validato in base al tipo di voce della lista:* **email**: un indirizzo email valido * **telefono**: un numero di telefono internazionale valido, memorizzato in formato E.164 (ad esempio `+14155552671`) * **ip\_address**: un indirizzo IP valido o un intervallo CIDR (ad esempio `192.168.1.1` o `10.0.0.0/8`) * **device\_fingerprint**: almeno 8 caratteri tra lettere, cifre, `-`, `_`, `:` e `.`. Una blocklist rifiuta un fingerprint che più dispositivi distinti hanno segnalato, perché bloccarlo bloccherebbe persone non collegate * **paese**: un [codice paese ISO 3166-1 alpha-3](https://docs.didit.me/it/core-technology/id-verification/supported-documents-id-verification.md) valido (ad esempio `USA`, `GBR`, `ESP`). I codici alpha-2 (ad esempio `US`) sono accettati e convertiti automaticamente in alpha-3 * **utente**, **azienda**: il `vendor_data` dell'utente o dell'azienda * **volto**, **documento**, **wallet\_address**, **bank\_account**, **chiave**: qualsiasi stringa non vuota> [!NOTE] > > Tutti i valori delle voci sono **senza distinzione tra maiuscole e minuscole**. I valori inviati vengono normalizzati alla memorizzazione (numeri di telefono in E.164, codici paese in maiuscolo, tutto il resto in minuscolo) e confrontati senza distinzione tra maiuscole e minuscole durante la verifica. Ad esempio, bloccando `User@Example.COM` verrà intercettato anche `user@example.com`. Una lista contiene ogni valore una sola volta: l'aggiunta di un valore già presente nella lista restituisce `400`.Per un volto, usa [Carica volto](https://docs.didit.me/it/management-api/lists/upload-face.md) quando hai solo un'immagine, oppure invia un `reference_session_id` per prendere il volto di una sessione esistente. Una voce di tipo volto richiede un volto memorizzato con cui confrontarsi, che un `value` digitato non fornisce.## Aggiunta da una sessioneQuando fornisci un `reference_session_id`, Didit:1) Cerca la sessione (deve appartenere alla stessa applicazione) 2) Legge il valore dal record **più recente** della sessione relativo al tipo di voce della lista: * **volto**: il volto del selfie di prova di vitalità; `value` è l'UUID del volto * **documento**: il numero del documento; il nome completo, lo stato di emissione, il tipo di documento, la regione e il numero del documento vengono memorizzati in `metadata`, e `display_label` è impostato per default con il nome del titolare e il numero del documento * **telefono**: il numero di telefono * **email**: l'indirizzo email * **ip\_address**: l'indirizzo IP della sessione * **device\_fingerprint**: un fingerprint che identifica un dispositivo, con preferenza per un dispositivo che ha completato un passaggio di verifica. In una blocklist, Didit rifiuta una sessione che ha solo un fingerprint di classe dispositivo, oppure uno completato su più di un dispositivo: in tal caso invia il fingerprint esatto come `value` 3) Collega la voce alla sessione (`reference_session_id`) e al record (`reference_object_uuid`) per la tracciabilitàNelle blocklist di sistema per volto, documento, telefono ed email, il record viene anche contrassegnato come in blocklist, quindi le nuove sessioni che corrispondono vengono rifiutate. Per qualsiasi altro tipo di voce, invia anche `value`.Restituisce `400` se la sessione non viene trovata o non contiene dati per il tipo di voce richiesto.### Volti dal selfie della cattura del documentoMentre l'utente fotografa il documento, la fotocamera frontale può scattare un selfie (le immagini `front_image_camera_front` e `back_image_camera_front` del [report di verifica dell'identità](https://docs.didit.me/it/core-technology/id-verification/report-id-verification.md)). Quel volto può essere aggiunto anche alla blocklist dei volti, oltre al volto della prova di vitalità: passa `face_image_source` con l'immagine che desideri.```json theme={null} { "reference_session_id": "33333333-4444-5555-6666-777777777777", "face_image_source": "front_image_camera_front" } ```- La voce viene creata solo nella **blocklist dei volti** di sistema, e `value` deve essere lasciato vuoto: Didit prende il volto dal selfie della sessione. - Il selfie deve contenere un solo volto ben visibile. In caso contrario la richiesta restituisce `400` e non viene aggiunto nulla. - Ogni selfie può essere aggiunto una sola volta. `metadata.face_image_source` e `metadata.reference_node_id` della voce indicano da quale selfie proviene. - In un workflow con più di un passaggio di verifica dell'identità, `reference_node_id` sceglie il passaggio di cui usare il selfie. Per default Didit usa la verifica dell'identità più recente che ha quel selfie. - Da quel momento il volto viene controllato come qualsiasi altro volto in blocklist: contro il selfie di prova di vitalità di ogni nuova sessione e contro ogni nuovo selfie della cattura del documento (vedi [`FRONT_CAMERA_FACE_IN_BLOCKLIST`](https://docs.didit.me/it/core-technology/id-verification/warnings-id-verification)). - Eliminare la voce rimuove il volto dalla blocklist e il volto non verrà più confrontato con le nuove sessioni.### Sessioni con più record dello stesso tipoUna sessione può contenere più record di un tipo, ad esempio due numeri di telefono da un workflow in più passaggi. Didit legge sempre quello **più recente**. Se invii `value` insieme a `reference_session_id`, la voce memorizza il tuo `value` ma resta collegata a quel record più recente, e in una blocklist di sistema è quel record a essere contrassegnato.Per inserire in lista un valore da un record precedente, aggiungilo solo tramite `value`, senza `reference_session_id`:```json theme={null} { "value": "+34612345678", "comment": "First phone number of session 42" } ```## Riferimenti a transazioni, utenti e aziendeQuando aggiungi alla blocklist dati di una transazione o di un utente o di un'azienda del fornitore, passa l'UUID dell'entità come `reference_object_uuid` e indica il tipo di origine in `metadata`:```json theme={null} { "value": "0x52908400098527886E0F7030069857D2E4169EE7", "reference_object_uuid": "55555555-6666-7777-8888-999999999999", "metadata": { "reference_type": "transaction", "reference_id": "55555555-6666-7777-8888-999999999999" } } ```Questo ti permette di risalire dalla voce della blocklist alla transazione, all'utente o all'azienda originale nella console. Didit memorizza le chiavi di `metadata` che invii, tranne `reference_image_url` e `front_image_url`, che imposta solo Didit. Per una voce letta da una sessione, Didit aggiunge le proprie chiavi alle tue, e le sue chiavi prevalgono.| Entità di origine | `reference_object_uuid` | `metadata.reference_type` | | - | - | - | | Sessione di verifica | Impostato da Didit (il record del volto, del documento, del telefono o dell'email) | Non necessario: usa `reference_session_id` | | Transazione | UUID della transazione | `"transaction"` | | Utente del fornitore | `didit_internal_id` | `"vendor_user"` | | Azienda del fornitore | `didit_internal_id` | `"vendor_business"` |Nelle blocklist di sistema **Utenti** e **Aziende**, Didit imposta anche gli utenti o le aziende corrispondenti su `BLOCKED`: quelli il cui `vendor_data` è uguale a `value`, oppure il cui `didit_internal_id` è uguale a `reference_object_uuid`. Vedi [blocklist degli utenti](https://docs.didit.me/it/entities/users/blocklist.md) e [blocklist delle aziende](https://docs.didit.me/it/entities/businesses/blocklist.md). ## OpenAPI ````yaml it/openapi-25.json POST /v3/lists/{list_uuid}/entries/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API di verifica dell'identità. Autenticati con l'intestazione x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/lists/{list_uuid}/entries/: post: tags: - Lists summary: Crea una voce nella lista description: >- Aggiunge una voce a una lista in uno dei tre modi seguenti: tramite `value`; da una sessione di verifica con `reference_session_id`, dove Didit legge il valore dal record più recente della sessione per il tipo di voce della lista e vi collega la voce; oppure tramite `value` con un `reference_object_uuid` e `metadata.reference_type` che rimandano a una transazione, un utente o un'azienda. Nelle blocklist di sistema per volti, documenti, telefoni ed email, anche il record letto dalla sessione viene contrassegnato come inserito in blocklist, quindi le nuove sessioni corrispondenti vengono rifiutate; nelle blocklist di sistema per utenti e aziende, gli utenti o le aziende corrispondenti vengono impostati su `BLOCKED`. Le sessioni e le transazioni già completate non vengono modificate. Una chiave API con ambito limitato richiede `workflows: write`. Consulta [Crea una voce della lista](https://docs.didit.me/it/management-api/lists/create-entry) per ciascuna modalità. operationId: create_list_entry parameters: - name: list_uuid in: path required: true description: >- UUID della lista a cui aggiungere l'elemento. Per un volto disponibile solo come immagine, usa invece Upload a face to a list. schema: type: string format: uuid example: 11111111-2222-3333-4444-555555555555 requestBody: required: true content: application/json: schema: type: object description: >- Invia `value`, `reference_session_id` o entrambi. I campi applicabili dipendono dall'`entry_type` della lista. properties: value: type: string description: >- Il valore da inserire nell'elenco, validato rispetto all'`entry_type` della lista: `email` un indirizzo email valido; `phone` un numero internazionale valido, memorizzato in formato E.164; `ip_address` un indirizzo IP o un intervallo CIDR (ad esempio `10.0.0.0/8`); `device_fingerprint` almeno 8 caratteri tra lettere, cifre, `-`, `_`, `:` e `.` (una blocklist rifiuta un'impronta segnalata da diversi dispositivi distinti); `country` un codice ISO 3166-1 alpha-2 o alpha-3, memorizzato come alpha-3; `user` e `business` il `vendor_data`; qualsiasi altro tipo una stringa non vuota. Memorizzato in minuscolo tranne i numeri di telefono e i codici paese, e una lista contiene ciascun valore una sola volta (senza distinzione tra maiuscole e minuscole). Obbligatorio a meno che non venga inviato `reference_session_id`; deve essere lasciato vuoto con un `face_image_source` di acquisizione del documento. reference_session_id: type: string format: uuid description: >- Una sessione di verifica di una persona o di un'azienda della tua applicazione da cui acquisire il valore. Didit legge il record più recente della sessione corrispondente al tipo di voce della lista (`face`, `document`, `phone`, `email`, `ip_address` o `device_fingerprint`), collega la voce alla sessione e a quel record e compila `display_label` e `metadata` per i documenti. Per una blocklist di tipo `device_fingerprint`, una sessione che dispone solo di un'impronta di classe dispositivo, o che è stata completata su più dispositivi, viene rifiutata: invia l'impronta esatta come `value`. Per altri tipi di voce, o quando la sessione non contiene tale record, invia anche `value`; in tal caso, il tuo `value` viene memorizzato e la voce rimane comunque collegata alla sessione. reference_object_uuid: type: string format: uuid description: >- UUID del record rappresentato dalla voce quando non proviene da una sessione: un UUID di transazione oppure il `didit_internal_id` di un utente o di un'azienda. Abbinalo a `metadata.reference_type`. Sostituito dal record della sessione quando `reference_session_id` ne fornisce uno. face_image_source: type: string enum: - liveness - front_image_camera_front - back_image_camera_front default: liveness description: >- Elenchi di volti con `reference_session_id`: da quale delle immagini della sessione viene estratto il volto. `liveness` (impostazione predefinita) è il selfie di rilevamento della vitalità. `front_image_camera_front` e `back_image_camera_front` sono i selfie scattati dalla fotocamera anteriore mentre l'utente fotografava il fronte o il retro del proprio documento: accettati solo sulla blocklist di volti di sistema, con `reference_session_id` e un `value` vuoto. Ciascun selfie può essere aggiunto una sola volta e deve mostrare un unico volto ben visibile. reference_node_id: type: string nullable: true maxLength: 100 description: >- Con un `face_image_source` di acquisizione del documento: il nodo di verifica dell'identità di cui usare il selfie, per i workflow che ne contengono più di uno. Il valore predefinito è la verifica dell'identità più recente contenente tale immagine. Rifiutato con `liveness`. display_label: type: string maxLength: 512 description: >- Etichetta di facile lettura. Se vuota, Didit ne ricava una dalla sessione ove possibile (ad esempio il nome del titolare e il numero del documento). comment: type: string description: >- Nota in formato testo libero, ad esempio il motivo dell'inclusione nella lista. metadata: type: object additionalProperties: true description: >- JSON a struttura libera memorizzato con la voce e restituito così come memorizzato. Usa `reference_type` e `reference_id` affinché la console rimandi alla fonte. `reference_image_url` e `front_image_url` sono impostati esclusivamente da Didit e vengono rimossi se li invii. Per una voce letta da una sessione, le chiavi di Didit vengono unite alle tue. properties: reference_type: type: string enum: - transaction - vendor_user - vendor_business description: A cosa punta `reference_object_uuid`. reference_id: type: string description: Identificatore del record di origine. examples: By value: value: value: '+14155552671' comment: Reported fraud From a session: value: reference_session_id: 33333333-4444-5555-6666-777777777777 Face from a document-capture selfie: value: reference_session_id: 33333333-4444-5555-6666-777777777777 face_image_source: front_image_camera_front From a transaction: value: value: '0x52908400098527886E0F7030069857D2E4169EE7' reference_object_uuid: 55555555-6666-7777-8888-999999999999 comment: Linked to a chargeback metadata: reference_type: transaction reference_id: 55555555-6666-7777-8888-999999999999 Country: value: value: PRK comment: Sanctioned jurisdiction responses: '201': description: La voce è stata creata. content: application/json: schema: $ref: '#/components/schemas/ComplianceListEntry' examples: By value: value: uuid: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee value: '+14155552671' display_label: '' comment: Reported fraud added_by: api reference_session_id: null reference_session_number: null reference_session_type: null reference_object_uuid: null metadata: null created_at: '2026-10-12T10:04:51.220391Z' Document from a session: value: uuid: bbbbbbbb-cccc-dddd-eeee-ffffffffffff value: X1234567 display_label: Jane Doe - X1234567 comment: '' added_by: api reference_session_id: 33333333-4444-5555-6666-777777777777 reference_session_number: 1042 reference_session_type: kyc reference_object_uuid: 66666666-7777-8888-9999-000000000000 metadata: full_name: Jane Doe issuing_state: ESP document_type: ID region: '' document_number: X1234567 created_at: '2026-10-12T10:06:12.774915Z' From a transaction: value: uuid: dddddddd-eeee-ffff-0000-111111111111 value: '0x52908400098527886e0f7030069857d2e4169ee7' display_label: '' comment: Linked to a chargeback added_by: api reference_session_id: null reference_session_number: null reference_session_type: null reference_object_uuid: 55555555-6666-7777-8888-999999999999 metadata: reference_type: transaction reference_id: 55555555-6666-7777-8888-999999999999 created_at: '2026-10-12T10:20:40.117062Z' '400': description: >- Il corpo non è valido, il valore è già presente nella lista o la sessione non può fornire il valore. content: application/json: examples: Nothing to list: value: value: - >- Either 'value' or 'reference_session_id' must be provided. Duplicate value: value: value: - An entry with this value already exists in this list. Invalid phone: value: value: - >- Invalid phone number. Provide a valid international number (e.g. +1234567890). Invalid IP: value: value: - >- Invalid IP address or CIDR range (e.g. 192.168.1.1 or 10.0.0.0/24). Invalid country: value: value: - >- Invalid country code: XX. Provide a valid ISO 3166-1 alpha-2 or alpha-3 country code. Device-class fingerprint: value: value: - >- This value is a device-class fingerprint: several distinct devices have reported it, so blocklisting it would decline unrelated people. Block the user by document, face, email or phone instead. Unknown session: value: reference_session_id: - >- Session not found or does not belong to this application. No data in session: value: value: - >- Either provide a 'value' or ensure the session contains data for this entry type. Selfie on another list: value: face_image_source: - >- A document-capture selfie can only be added to the face blocklist. No clear face in selfie: value: face_image_source: - >- No clear face was found in this selfie, so it cannot be blocklisted. Selfie already listed: value: face_image_source: - This selfie is already in the blocklist. '401': description: >- La chiave API con ambito è scaduta. Altri errori di autenticazione restituiscono `403`. content: application/json: examples: Expired API key: value: detail: This API key has expired. '403': description: >- L'intestazione `x-api-key` è mancante (una chiave errata, revocata o scaduta riceve `401`), oppure una chiave API con ambito limitato non dispone di `workflows: write` o viene utilizzata da un indirizzo IP non presente nella sua allowlist. content: application/json: examples: Missing or invalid API key: value: detail: You do not have permission to perform this action. Scoped key without workflows access: value: detail: This API key has no write access to workflows. '404': description: >- Nessuna lista con questo UUID esiste nell'applicazione della chiave API, oppure è stata eliminata. content: application/json: examples: Not found: value: detail: List not found. '429': $ref: '#/components/responses/RateLimitedWrite' '503': description: >- L'analisi facciale di un selfie acquisito durante l'acquisizione del documento è temporaneamente non disponibile. Non è stato aggiunto nulla; riprova più tardi. content: application/json: examples: Unavailable: value: detail: Service temporarily unavailable. Please try again later. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: >- curl -X POST 'https://verification.didit.me/v3/lists/11111111-2222-3333-4444-555555555555/entries/' \ -H 'x-api-key: YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{"value": "+14155552671", "comment": "Reported fraud"}' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.lists.entries.create( "11111111-2222-3333-4444-555555555555", value="+14155552671", comment="Reported fraud", ) print(result) - lang: javascript label: Node.js source: >- import Didit from "@didit-protocol/sdk-node"; // Reads DIDIT_API_KEY. const didit = new Didit(); const result = await didit.lists.entries.create("11111111-2222-3333-4444-555555555555", { value: "+14155552671", comment: "Reported fraud", }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Lists.Entries.Create(ctx, \"11111111-2222-3333-4444-555555555555\", didit.ListsEntriesCreateParams{\n\tValue: didit.String(\"+14155552671\"),\n\tComment: didit.String(\"Reported fraud\"),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: >- import me.didit.Didit; import me.didit.types.ListsEntriesCreateParams; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.lists().entries().create("11111111-2222-3333-4444-555555555555", ListsEntriesCreateParams.builder() .value("+14155552671") .comment("Reported fraud") .build()); System.out.println(result); - lang: php label: PHP source: >- lists->entries->create('11111111-2222-3333-4444-555555555555', [ 'value' => '+14155552671', 'comment' => 'Reported fraud', ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.lists.entries.create( "11111111-2222-3333-4444-555555555555", value: "+14155552671", comment: "Reported fraud" ) puts result.to_h - lang: csharp label: .NET source: >- using System; using System.Text.Json; using Didit; // Reads DIDIT_API_KEY. using var client = new DiditClient(); var result = await client.Lists.Entries.CreateAsync("11111111-2222-3333-4444-555555555555", new ListsEntriesCreateParams { Value = "+14155552671", Comment = "Reported fraud", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: ComplianceListEntry: type: object description: Un singolo valore in una lista. required: - uuid - value - display_label - comment - added_by - reference_session_id - reference_session_number - reference_session_type - reference_object_uuid - metadata - created_at properties: uuid: type: string format: uuid description: >- Identificatore della voce. Utilizzalo come `entry_uuid` in Elimina una voce dell'elenco. value: type: string description: >- Il valore inserito in lista: un numero di telefono in formato E.164, un indirizzo email, un numero di documento, un indirizzo IP o un intervallo CIDR, un'impronta digitale del dispositivo, un indirizzo del wallet, un conto bancario, un codice paese ISO 3166-1 alpha-3, un `vendor_data`, qualsiasi stringa su una lista `key`, oppure l'UUID del volto memorizzato su una lista di volti. I valori inviati vengono memorizzati in minuscolo, ad eccezione dei numeri di telefono e dei codici paese. La corrispondenza non fa distinzione tra maiuscole e minuscole. display_label: type: string nullable: true maxLength: 512 description: >- Etichetta di facile lettura. Didit la compila per le voci estratte da una sessione (ad esempio il nome del titolare e il numero del documento) quando non ne invii nessuna. comment: type: string description: Nota in formato testo libero. Stringa vuota se non impostata. added_by: type: string nullable: true description: >- Chi ha aggiunto la voce: `api` (una chiave API), l'indirizzo email di un utente della console o `console`, `system` o `migration` (voci create da Didit), oppure `rule` (un'azione di una regola di transazione o monitoraggio). reference_session_id: type: string format: uuid nullable: true description: >- Sessione di verifica da cui è stata estratta la voce. `null` quando la voce è stata aggiunta per valore. reference_session_number: type: integer nullable: true description: >- Numero della sessione con ambito limitato all'applicazione, come mostrato nella console. reference_session_type: type: string nullable: true enum: - kyc - kyb - null description: >- `kyc` per una sessione di verifica di una persona fisica, `kyb` per una sessione di verifica aziendale, `null` quando non è presente alcuna sessione. reference_object_uuid: type: string format: uuid nullable: true description: >- Il record rappresentato dalla voce: il record del volto, del documento, del telefono o dell'email letto da una sessione, il volto creato tramite Upload a face to a list, o l'UUID inviato (ad esempio l'UUID di una transazione o il `didit_internal_id` di un utente). metadata: type: object nullable: true additionalProperties: true description: >- Contesto aggiuntivo. Contiene le chiavi impostate da Didit (elencate qui) unite a qualsiasi `metadata` inviato durante la creazione della voce, restituite così come memorizzate. `null` se non è presente alcuno. properties: reference_image_url: type: string description: >- Voci del volto: URL firmato di breve durata, emesso nuovamente a ogni chiamata; `null` per una chiave API con ambito senza `media: read`. Assente quando nessuna immagine appartiene alla voce. front_image_url: type: string description: >- Voci del documento contenenti l'immagine frontale del documento: URL firmato di breve durata, riemesso a ogni chiamata; `null` per una chiave API con ambito priva di `media: read`. full_name: type: string description: >- Voci del documento estratte da una sessione: nome completo del titolare. issuing_state: type: string description: >- Voci del documento estratte da una sessione: paese di emissione ISO 3166-1 alpha-3. document_type: type: string description: >- Voci del documento estratte da una sessione: codice del tipo di documento, ad esempio `P`, `ID` o `DL`. region: type: string description: >- Voci del documento estratte da una sessione: stato o provincia di emissione per un documento emesso a livello regionale, vuoto se non applicabile. Non impostato da Aggiungi elementi della sessione alla blocklist. document_number: type: string description: >- Voci del documento estratte da una sessione: il numero del documento. face_image_source: type: string enum: - front_image_camera_front - back_image_camera_front description: >- Voci facciali tratte da un selfie acquisito durante l'acquisizione del documento: quale selfie. Assente per i volti del rilevamento della vitalità. reference_node_id: type: string nullable: true description: >- Voci facciali tratte da un selfie acquisito durante l'acquisizione del documento: il nodo di verifica dell'identità da cui proviene il selfie. fingerprint_tier: type: string nullable: true enum: - persistent_id - composite_hash - legacy_fp - unknown - null description: >- Voci del fingerprint del dispositivo acquisite da una sessione: come è stato ricavato il fingerprint. `persistent_id` identifica un singolo dispositivo; `composite_hash` e `legacy_fp` possono essere condivisi da dispositivi dello stesso modello. sandbox: type: boolean description: >- `true` su una voce del volto caricata in un'applicazione sandbox; tale voce non produce alcuna corrispondenza. reference_type: type: string enum: - transaction - vendor_user - vendor_business description: >- Impostato da te: cosa indica `reference_object_uuid`, in modo che la console crei un collegamento di ritorno verso di esso. reference_id: type: string description: 'Impostato da te: identificativo del record di origine.' created_at: type: string format: date-time description: Data e ora di aggiunta della voce. responses: RateLimitedWrite: description: >- Il limite di scrittura condiviso di 300 richieste al minuto per chiave API è stato superato. Rispetta `Retry-After` prima di riprovare. content: application/json: schema: type: object required: - detail properties: detail: type: string example: detail: >- Write request rate limit exceeded. You can make up to 300 requests per minute. securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- La chiave API della tua applicazione, da Developers -> API keys nella Business Console. La chiave primaria ha accesso completo. Una chiave con nome può avere un ambito definito: nessuno, lettura o scrittura per risorsa, limitata ad alcuni workflow o a sessioni approvate, a un elenco di indirizzi IP e a una data di scadenza. 401 indica che la chiave è errata, revocata o scaduta; 403 indica che non è stata inviata alcuna chiave, che la chiave non ha accesso a questa risorsa o azione, oppure che la richiesta proviene da un indirizzo non incluso nel suo elenco IP; 404 su una route di sessione indica che la sessione non rientra nei workflow o negli stati previsti dalla chiave. Una chiave senza accesso ai media riceve gli URL di immagini, video e PDF come null, e una chiave senza permessi di scrittura sulle sessioni riceve link e token di sessione come null. Consulta https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.