> ## 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 Crea transazione: invio KYT > Invia una transazione a Didit KYT per punteggio di rischio, screening e Travel Rule. 1,000 transazioni al mese incluse, poi $0.001 ciascuna. Prompt API per creare una transazione Copia il prompt negli appunti \

\`Submit a transaction for Didit monitoring through the Management API.

Endpoint:
POST https://verification.didit.me/v3/transactions/

Authentication:
Use the x-api-key header with my Didit API key.

Goal:
\- Submit a transaction for KYT (transaction monitoring). Didit runs the configured rules engine, blockchain analytics, and AML screening synchronously and returns the verdict in the response. The full detail (parties, rule runs, provider results, remediation links) is also returned.
\- A Travel Rule transfer is stored in the same call, but Didit contacts the counterparty after the response: travel_rule.status comes back AWAITING_COUNTERPARTY (or NOT_APPLICABLE, UNCONFIRMED_OWNERSHIP, or COMPLETED for your own verified wallet) with travel_rule.protocol null, and every later status change, including COUNTERPARTY_VASP_NOT_FOUND, arrives as a travel_rule.status.updated webhook. Your rules run again when the rail or the status changes.

When to call:
\- At payment authorization, before fanning out funds, to decide allow / hold / decline based on status, score, severity.
\- On post-trade events (gambling bets, audit-trail events, KYC events) for long-running monitoring without a per-transaction decision.
\- On crypto deposits / withdrawals — set transaction_details.currency_kind = "crypto" and provide the relevant wallet address in payment_method.account_id.
\- For Travel Rule, set transaction_category = "travel_rule" and include travel_rule_details (alias travelRule).
travel_rule_details.status is required (400 if missing); when Travel Rule is enabled, Didit runs the exchange and ignores the status you send, and otherwise Didit records the transfer passively with that status.
When the subject is a user with an approved Didit KYC verification and Travel Rule is on, Didit replaces the originator_data fields the verification holds with the verified values (metadata.originator_provenance says which); otherwise it sends originator_data as you provide it, so build it from the identity you verified.
beneficiary_data carries the beneficiary (name, wallet_address, chain) and any routing hints (travel_address, counterparty_vasp_lei, counterparty_vasp_name, counterparty_vasp_email).
If beneficiary_data.chain is empty, Didit takes transaction_details.crypto_params.crypto_chain, else custom_properties.crypto_chain, else the currency, uppercases it, and sets it only when it is a chain Didit recognises (for example ETH or BTC).
\- Chain shapes: on XRP, XLM, EOS, ATOM and HBAR send the destination tag or memo as payment_method.memo (or beneficiary_data.memo); on BTC, LTC, BCH and DOGE send the transaction's inputs and outputs as travel_rule_details.utxo; on bitcoin or Lightning, payment_method.account_id may be a Lightning payment request or Lightning Address. What Didit resolved is on travel_rule.chain_details (see /transaction-monitoring/travel-rule#chain-shapes).

Identifiers:
\- transaction_id (alias txnId) is YOUR identifier (max 128 chars), unique per application.
It becomes txn_id on subsequent calls.
Reusing a transaction_id that already exists returns 400 {"transaction_id": ["A transaction with this transaction_id already exists."]}, and when two identical requests race each other the loser gets 409.
Neither response returns the existing transaction, so to retry safely, treat a 400 or 409 for a duplicate id as already created and look the transaction up instead of resubmitting: GET /v3/transactions/{uuid}/ with the Didit uuid from the first response, or with the transaction_id (the Didit uuid) that the transaction.created webhook carries next to your txn_id.
GET does not accept your txn_id. Sandbox applications do not receive transaction.created or transaction.status.updated, so save the Didit uuid from the create response. Sandbox Travel Rule exchanges do emit travel_rule.status.updated with environment: sandbox.
\- The returned uuid is Didit's stable identifier — use it in GET /v3/transactions/{transaction_id}/.

Linking to entities:
\- subject.vendor_data (and optionally counterparty.vendor_data) are your internal user/business identifiers. They link the transaction to the long-lived User / Business entity assembled from prior verification sessions. Use the SAME vendor_data you supplied when creating the KYC session.

Minimum request body (application/json):
\{
"transaction_id": "your-txn-2026-05-17-001",
"transaction_category": "finance",   // finance | kyc | travel_rule | user_event | audit_trail_event | gambling_bet | gambling_limit_change | gambling_bonus_change
"transaction_details": {
"direction": "outbound",            // "inbound" | "outbound"
"amount": 1500,                     // number or decimal string, up to 18 decimal places (string for exact precision); never negative, because direction carries the sign
"currency": "EUR",                  // any ISO 4217 code (EUR, USD, NGN, ...) or a crypto symbol
"currency_kind": "fiat",            // "fiat" | "crypto" (optional)
"action_type": "withdrawal"         // optional, e.g. deposit/withdrawal/transfer
},
"subject": {                          // APPLICANT party
"entity_type": "individual",        // "individual" | "company"
"vendor_data": "user-12345",        // required
"full_name": "Maria Garcia",        // required
"address": { "country": "ESP" }     // optional
},
"counterparty": { ... },              // optional COUNTERPARTY party (same shape as subject)
"transaction_at": "2026-05-17T08:42:00Z",  // optional, defaults to now
"travel_rule_details": { "status": "AWAITING_COUNTERPARTY", ... }   // optional, for crypto Travel Rule; status is required inside it
}

Currency codes:
\- currency has no enum. Any ISO 4217 alphabetic code (EUR, USD, NGN, ...) and any crypto asset symbol (BTC, ETH, ...) are accepted and stored exactly as you send them, up to 10 characters.
\- Prefer a currently-circulating code. Not every accepted code has an exchange rate: withdrawn currencies and accounting units such as XDR are often still quoted, but when Didit has no rate for the code you send (for example the ISO accounting unit XSU, or a crypto symbol Didit does not price), automatic conversion to your base currency fails and preferred_currency_amount comes back null. A pre-converted amount_in_default_currency is always used as sent when present, so supply it for any code you are not sure has a rate.
\- Set currency_kind = "crypto" for on-chain amounts. The kind gates the transaction's own crypto AML screening: without currency_kind = "crypto" that regular screening step is skipped and no screening fee is estimated or charged for it, even with monitoring enabled or include_crypto_screening = true. Travel Rule attribution is a separate path: on a production application with Travel Rule and VASP attribution enabled, an outbound transaction_category = "travel_rule" request whose beneficiary wallet and chain cannot be reached over any rail triggers a VASP attribution wallet screening, and that screening is billed at the wallet screening price whatever currency_kind is or is not set. The kind does not change the stored decimal scale: up to 18 decimal places are kept either way, but only when amount arrives as a decimal string ("0.123456789012345678"). A JSON number is parsed as a binary float first, so anything beyond about 15 significant digits is rounded before it is stored (0.123456789012345678 is stored as 0.12345678901234568). The kind also decides how the amount is rendered in the transaction PDF. Crypto amounts render with up to 8 decimal places, fiat amounts with their ISO 4217 minor unit (2 for most currencies). Without the kind, RON, MNT and GEL are rendered as fiat because each is both a token and an ISO 4217 currency, so a small token amount can show as 0 in the report.
The VASP attribution screening is skipped when the transaction's own crypto screening already screened that wallet: Didit reuses that result and charges nothing extra.

Example call:
curl -X POST "https://verification.didit.me/v3/transactions/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{
"transaction_id": "your-txn-2026-05-17-001",
"transaction_category": "finance",
"transaction_details": {"direction":"outbound","amount":1500,"currency":"EUR","action_type":"withdrawal"},
"subject": {"entity_type":"individual","vendor_data":"user-12345","full_name":"Maria Garcia"}
}'

What to read from the response:
\- uuid — Didit transaction id, use for GET /v3/transactions/{transaction_id}/.
\- status - APPROVED | IN_REVIEW | DECLINED | AWAITING_USER (live verdict; at creation, AWAITING_USER comes from a rule action).
\- score (0–100, higher = riskier) and severity (LOW | MEDIUM | HIGH | CRITICAL).
\- decision_reason_code / decision_reason_label — machine + human verdict reason.
\- parties (role APPLICANT for the subject, COUNTERPARTY for the counterparty; kind USER, BUSINESS or EXTERNAL), cost_breakdown, rule_runs, provider_results (crypto screening results) and network_snapshot.
\- travel_rule - the Travel Rule transfer (status, protocol, required, originator_data, beneficiary_data, direction, rail, counterparty_vasp, delivery, discovery, reason, next_actions), or null; action_required - a pending wallet-ownership or verification step, or null.
reason and next_actions say why a COUNTERPARTY_VASP_NOT_FOUND or COUNTERPARTY_VASP_NOT_REACHABLE transfer is stuck and what moves it on (for example email_undeliverable: update_compliance_email, then resend); they are "" and [] for any other status.

Webhooks:
\- transaction.created fires after this call succeeds.
\- For a travel_rule transaction, travel_rule.status.updated fires for each Travel Rule transition, after transaction.created. Each webhook is delivered and retried on its own, so key on transaction_id rather than on arrival order.
\- transaction.status.updated fires whenever the verdict changes (manual review, async screening, rule re-runs). Subscribe a destination via POST /v3/webhook/destinations/.

Failure modes:
\- 400 - duplicate transaction_id, missing required field (including travel_rule_details.status), an unknown travel_rule_details.status ("Invalid travel rule status: ..."), invalid direction/category enum, or malformed party object.
\- 409 - a concurrent request with the same transaction_id was created first.
\- 403 - missing x-api-key (a wrong, revoked or expired key gets 401), or a key without permission for this action; the body is a { "detail": "..." } envelope.
\- 403 - the organization's balance cannot cover the fees this request would charge: { "detail": "...", "code": "insufficient_credits" }, and nothing is created.
\- 429 - more than 600 ingestion requests per minute for this API key (transaction and event ingestion share this budget, apart from the 300 of every other write); wait Retry-After seconds and retry.

Side effects:
\- Creates the transaction record and runs the synchronous rules + screening pipeline.
\- Links the transaction to the User / Business entity that shares the subject.vendor_data.
\- An outbound travel_rule transaction is billed once, at creation, on one line. It pays the Travel Rule fee ($0.02) when Travel Rule is on and Didit starts an exchange for it (amount at or above threshold_amount, including a transfer to a self-hosted wallet or to the user's own verified wallet). Otherwise it is billed as transaction monitoring (included in the plan's monthly transaction allowance, $0.001 each beyond it): below threshold_amount, a Lightning payment the Travel Rule does not apply to, or data recorded while Travel Rule is disabled. A resend never charges again.
\- An inbound travel_rule transaction pays no base fee, an application that joined Travel Rule free pays none on outbound transactions until it turns outbound billing on, and sandbox applications are never charged.
\- Crypto screening, when it runs, adds the Wallet Verification & Screening charge.

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

\
Incolla in ## OpenAPI ````yaml it/openapi-25.json POST /v3/transactions/ 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/transactions/: post: tags: - Transactions summary: Crea transazione description: >- Invia una transazione per il monitoraggio sincrono AML/del rischio. La transazione viene creata come `APPROVED`, poi le tue regole (e lo screening crypto, se applicabile) vengono eseguite inline e possono modificare lo `status` restituito in `IN_REVIEW` o `DECLINED`. **`transaction_id` è la tua chiave di idempotenza** (max 128 caratteri, univoca per app); riutilizzarla restituisce 400. Un webhook `transaction.created` viene inviato in caso di esito positivo per le applicazioni in produzione. Le applicazioni in sandbox non vengono fatturate e non emettono webhook `transaction.created` o `transaction.status.updated`. Gli scambi Travel Rule in sandbox emettono invece webhook `travel_rule.status.updated` con `environment: sandbox`. Un trasferimento Travel Rule viene memorizzato e restituito prima che qualsiasi controparte venga contattata: `travel_rule.status` restituisce `AWAITING_COUNTERPARTY` (o `NOT_APPLICABLE` sotto la tua soglia, `UNCONFIRMED_OWNERSHIP` per un wallet in autocustodia dichiarato, `COMPLETED` quando l'altro wallet è il tuo wallet verificato) e `travel_rule.protocol` è null. Didit sceglie quindi il canale e invia lo scambio, e ogni successiva modifica di stato del trasferimento, incluso `COUNTERPARTY_VASP_NOT_FOUND` quando nessun canale raggiunge la controparte, arriva come webhook `travel_rule.status.updated`. Le tue regole vengono eseguite nuovamente quando cambiano il canale o lo stato. operationId: createTransaction requestBody: required: true content: application/json: schema: type: object properties: transaction_id: type: string description: >- Il tuo identificatore univoco per questa transazione (massimo 128 caratteri). example: your-txn-2026-05-17-001 transaction_at: type: string format: date-time description: >- Quando è avvenuta la transazione. Se omesso, il valore predefinito è adesso. time_zone: type: string description: Identificatore di fuso orario IANA, ad es. `Europe/Madrid`. transaction_category: type: string description: >- Categoria della transazione. Sono accettati anche alias CamelCase (`travelRule`, `userPlatformEvent`, `gamblingBet`, …); il valore memorizzato/restituito è in camelCase per le categorie composte da più parole. example: finance enum: - finance - kyc - travel_rule - user_event - audit_trail_event - gambling_bet - gambling_limit_change - gambling_bonus_change - travelRule transaction_details: type: object description: Dettagli finanziari principali della transazione. required: - direction - amount - currency properties: direction: type: string description: >- Direzione della transazione rispetto al soggetto. Non fa distinzione tra maiuscole e minuscole; `in`/`out` sono accettati come alias. Restituito in maiuscolo (`INBOUND`/`OUTBOUND`). example: outbound enum: - inbound - outbound - in - out amount: type: number description: >- Importo della transazione (fino a 18 cifre decimali). Invialo come stringa decimale (es. `"0.123456789012345678"`) quando la precisione esatta è fondamentale: un numero JSON viene prima analizzato come float binario, quindi le cifre oltre circa 15 cifre significative vengono arrotondate prima che l'importo venga memorizzato. Deve essere pari o superiore a zero: la direzione determina il segno, e un importo negativo restituisce `400`. example: 1500 currency: type: string description: >- Codice valuta. Viene accettato qualsiasi codice alfabetico ISO 4217 (ad es. `EUR`, `USD`, `NGN`), così come il simbolo di un asset crypto (ad es. `BTC`). È preferibile utilizzare un codice attualmente in circolazione. Non tutti i codici accettati hanno un tasso di cambio: quando non ne è disponibile alcuno per il codice (ad esempio l'unità di conto ISO `XSU` o un simbolo crypto di cui Didit non calcola il prezzo), la conversione automatica non riesce e `preferred_currency_amount` viene restituito null a meno che la richiesta non abbia fornito un `amount_in_default_currency` pre-convertito. example: EUR currency_kind: type: string description: Indica se la valuta è `fiat` o `crypto`. amount_in_default_currency: type: number nullable: true description: >- Importo pre-convertito nella valuta predefinita. Se omesso, viene tentata la conversione valutaria automatica. Deve essere maggiore o uguale a zero. default_currency: type: string description: >- Il codice valuta predefinito per l'importo convertito. Qualsiasi codice ISO 4217 attualmente in circolazione. payment_details: type: string nullable: true description: >- Riferimento di pagamento o promemoria in formato testo libero. payment_reference_id: type: string nullable: true description: >- Riferimento del sistema di pagamento esterno. Per lo screening AML crypto basato su hash di transazione, invia l'hash della transazione blockchain e fornisci anche `subject.payment_method.account_id` con l'indirizzo correlato. action_type: type: string nullable: true description: >- Sottotipo della transazione, ad es. `deposit`, `withdrawal`, `transfer`. crypto_params: type: object description: >- Selezione della rete crypto, separata dalla valuta (il simbolo dell'asset). La registrazione di un simbolo di token personalizzato non garantisce la copertura dell'hash della transazione per il relativo smart contract. properties: crypto_chain: type: string description: >- Rete effettiva utilizzata per lo screening. Lo screening gestito supporta BTC, ETH, LTC, XRP, BCH, DOGE, TRX, SOL, MATIC, BNB, BASE (Base), OP (Optimism), ARB (Arbitrum One), AVAX (Avalanche C-Chain), ADA (Cardano), XLM (Stellar) e HBAR (Hedera). Sono accettati anche i nomi comuni delle reti, ad esempio POLYGON o POL per MATIC, BSC per BNB e TRON per TRX. Specificalo sempre per i token multi-rete. Quando non è presente per USDT, USDC o ETH inviati con un hash di transazione 0x, Didit cerca l'hash su Ethereum, BNB Chain, Polygon, Base, Arbitrum e Optimism ed esegue lo screening sulla rete in cui viene trovato; se nessuna rete lo contiene, la transazione non viene sottoposta a screening e custom_values.aml_screening_status è impostato su FAILED con il motivo in custom_values.aml_screening_error. Quando non è presente per USDT o USDC sottoposti a screening tramite wallet (senza hash di transazione), un indirizzo Tron viene esaminato su Tron, un indirizzo Solana su Solana e un indirizzo 0x sulla prima di queste sei reti in cui ha inviato una transazione o detiene il token, oppure su Ethereum se non è attivo su nessuna di esse. La copertura dei provider connessi varia; LIGHTNING richiede un provider connesso supportato. example: BASE subject: type: object description: Il soggetto (richiedente) della transazione. required: - vendor_data - full_name properties: entity_type: type: string description: 'Tipo di entità: `individual` o `company`.' vendor_data: type: string description: Il tuo identificatore interno utente/azienda. example: user-12345 full_name: type: string description: Nome completo del soggetto. example: Maria Garcia first_name: type: string description: Nome del soggetto. last_name: type: string description: Cognome del soggetto. date_of_birth: type: string format: date description: Data di nascita (YYYY-MM-DD). address: type: object description: Oggetto indirizzo. properties: country: type: string description: >- Codice del paese (consigliato ISO 3166-1 alpha-3). Copiato nel `country_code` della parte. town: type: string state: type: string street: type: string post_code: type: string institution_details: type: object description: Dati dell'istituto (per soggetti istituzionali). properties: name: type: string code: type: string address: type: object device_context: type: object description: >- Contesto del dispositivo acquisito al momento della transazione. browser_family e platform devono essere inviati come chiavi esplicite di primo livello: non sono ricavati da user_agent. Nella richiesta è accettato anche l'alias in camelCase device. properties: fingerprint: type: string description: Impronta digitale univoca del dispositivo. persistent_device_id: type: string description: >- Identificatore stabile del dispositivo tra sessioni diverse (schema di fingerprint v2). user_agent: type: string description: >- Stringa user agent del browser o dell'app. Alias in CamelCase: userAgent. browser_family: type: string description: >- Famiglia del browser (es. Chrome, Firefox, Safari). Deve essere inviata esplicitamente — non è derivata da user_agent. Alias in CamelCase: browserFamily. browser_version: type: string description: >- Stringa della versione del browser. Deve essere inviata esplicitamente. Alias in CamelCase: browserVersion. platform: type: string description: >- Identificatore della piattaforma (web, ios, android, macos, windows, linux). Deve essere inviato esplicitamente — non viene derivato da user_agent. os_family: type: string description: >- Famiglia del sistema operativo (ad es. iOS, Android, Windows). Alias CamelCase: osFamily. os_version: type: string description: >- Stringa della versione del sistema operativo. Alias CamelCase: osVersion. accept_language: type: string description: >- Valore dell'intestazione Accept-Language. Alias camelCase: acceptLang. session_id: type: string description: >- Identificatore di sessione della sessione corrente dell'utente. Memorizzato nei metadati. Alias camelCase: sessionId. session_age_ms: type: number description: >- Età della sessione utente in millisecondi al momento della transazione. Alias CamelCase: sessionAgeMs. network_context: type: object description: >- Contesto di rete con indirizzo IP e geolocalizzazione. Anche un blocco ipInfo di livello principale è incluso in questo oggetto. properties: ip_address: type: string description: 'Indirizzo IP del client. Alias CamelCase: ip.' ip_country_code: type: string description: >- Paese geolocalizzato dell'IP (ISO 3166-1 alpha-3). Alias CamelCase: countryCode3. latitude: type: number description: >- Latitudine geografica dell'IP. Alias CamelCase: lat. longitude: type: number description: >- Longitudine geografica dell'IP. Alias CamelCase: lon. payment_method: type: object description: Metodo di pagamento usato dal soggetto. properties: method_type: type: string description: >- Tipo di metodo di pagamento: `bank_card`, `bank_account`, `crypto_wallet`, `ewallet`, `unhosted_wallet`, `other`. account_id: type: string description: >- Identificativo dell'account (ad es. IBAN, indirizzo). Per lo screening delle criptovalute, questo campo deve contenere l'indirizzo per questo partecipante. Lo screening dell'hash della transazione in entrata richiede l'indirizzo di deposito del servizio/cliente del soggetto. Lo screening in uscita utilizza il wallet di destinazione della controparte. Su un trasferimento crypto su bitcoin o Lightning può essere una richiesta di pagamento Lightning (fattura BOLT11, offerta BOLT12, LNURL) o un Lightning Address: Didit memorizza il beneficiario indicato come account ("" quando non ne indica alcuno) e il contenuto della richiesta in `chain_details.lightning` del trasferimento Travel Rule. Massimo 255 caratteri una volta memorizzato. Su un trasferimento crypto su bitcoin o Lightning può essere una richiesta di pagamento Lightning (fattura BOLT11, offerta BOLT12, LNURL) o un Lightning Address: Didit memorizza il beneficiario indicato come account ("" quando non ne indica alcuno) e il contenuto della richiesta in `chain_details.lightning` del trasferimento Travel Rule. Massimo 255 caratteri una volta memorizzato. memo: type: string maxLength: 256 description: >- Il destination tag o memo che fa parte del wallet su una rete con memo (XRP, XLM, EOS, ATOM, HBAR). Su un unico indirizzo di exchange condiviso, ciascun memo costituisce un metodo di pagamento a sé stante. XRP: un destination tag, un numero intero da 0 a 4294967295 (è accettato un numero JSON). XLM: un memo di testo fino a 28 byte, un ID a 64 bit o un hash a 32 byte in formato esadecimale. EOS: fino a 256 byte. ATOM: fino a 256 caratteri. HBAR: fino a 100 byte. I wallet Bitcoin, EVM, Solana, Tron, Litecoin, Bitcoin Cash, Dogecoin e Lightning non accettano alcun memo: specificarne uno restituisce un errore `400`. Alias: `destinationTag` o `destination_tag`. issuing_country: type: string description: Codice paese ISO 3166-1 alpha-3 dell'emittente. counterparty: type: object description: La controparte della transazione (opzionale). properties: entity_type: type: string description: 'Tipo di entità: `individual` o `company`.' vendor_data: type: string description: Il tuo identificatore interno per la controparte. full_name: type: string description: Nome completo della controparte. first_name: type: string last_name: type: string date_of_birth: type: string format: date address: type: object description: Oggetto indirizzo con `country` (ISO 3166-1 alpha-3). institution_details: type: object device_context: type: object description: >- Contesto del dispositivo per la controparte. browser_family e platform devono essere inviati come chiavi esplicite di primo livello — non sono derivati da user_agent. properties: fingerprint: type: string description: Impronta digitale univoca del dispositivo. persistent_device_id: type: string description: >- Identificatore stabile del dispositivo tra sessioni diverse (schema di fingerprint v2). user_agent: type: string description: >- Stringa user agent del browser o dell'app. Alias in CamelCase: userAgent. browser_family: type: string description: >- Famiglia del browser (es. Chrome, Firefox, Safari). Deve essere inviata esplicitamente — non è derivata da user_agent. Alias in CamelCase: browserFamily. browser_version: type: string description: >- Stringa della versione del browser. Deve essere inviata esplicitamente. Alias in CamelCase: browserVersion. platform: type: string description: >- Identificatore della piattaforma (web, ios, android, macos, windows, linux). Deve essere inviato esplicitamente — non viene derivato da user_agent. os_family: type: string description: >- Famiglia del sistema operativo (ad es. iOS, Android, Windows). Alias CamelCase: osFamily. os_version: type: string description: >- Stringa della versione del sistema operativo. Alias CamelCase: osVersion. accept_language: type: string description: >- Valore dell'intestazione Accept-Language. Alias camelCase: acceptLang. session_id: type: string description: >- Identificatore di sessione per la sessione della controparte. Memorizzato nei metadati. Alias camelCase: sessionId. session_age_ms: type: number description: >- Età della sessione utente in millisecondi al momento della transazione. Alias CamelCase: sessionAgeMs. network_context: type: object description: >- Contesto di rete con indirizzo IP e geolocalizzazione. Anche un blocco ipInfo di livello principale è incluso in questo oggetto. properties: ip_address: type: string description: 'Indirizzo IP del client. Alias CamelCase: ip.' ip_country_code: type: string description: >- Paese geolocalizzato dell'IP (ISO 3166-1 alpha-3). Alias CamelCase: countryCode3. latitude: type: number description: >- Latitudine geografica dell'IP. Alias CamelCase: lat. longitude: type: number description: >- Longitudine geografica dell'IP. Alias CamelCase: lon. payment_method: type: object description: >- Metodo di pagamento usato dalla controparte. Nelle transazioni travelRule, `method_type: "unhosted_wallet"` dichiara il wallet della controparte come in autocustodia: il trasferimento salta l'instradamento verso il VASP della controparte, viene creato direttamente in `UNCONFIRMED_OWNERSHIP` e (quando `auto_wallet_verification` è abilitato) viene generata automaticamente una sessione del widget di proprietà del wallet restituita nel blocco `action_required` della transazione. properties: method_type: type: string description: >- Tipo di metodo di pagamento: `bank_card`, `bank_account`, `crypto_wallet`, `ewallet`, `unhosted_wallet`, `other`. Usa `unhosted_wallet` per dichiarare un wallet in autocustodia per la Travel Rule. account_id: type: string description: >- Identificativo dell'account (ad es. IBAN o indirizzo). In un trasferimento di criptovaluta su Bitcoin o Lightning può essere una richiesta di pagamento Lightning (fattura BOLT11, offerta BOLT12, LNURL) o un Lightning Address: Didit memorizza il beneficiario indicato come account ("" quando non ne indica alcuno) e il contenuto della richiesta in `chain_details.lightning` del trasferimento Travel Rule. Massimo 255 caratteri una volta memorizzato. In un trasferimento di criptovaluta su Bitcoin o Lightning può essere una richiesta di pagamento Lightning (fattura BOLT11, offerta BOLT12, LNURL) o un Lightning Address: Didit memorizza il beneficiario indicato come account ("" quando non ne indica alcuno) e il contenuto della richiesta in `chain_details.lightning` del trasferimento Travel Rule. Massimo 255 caratteri una volta memorizzato. memo: type: string maxLength: 256 description: >- Il destination tag o memo che fa parte del wallet su una rete con memo (XRP, XLM, EOS, ATOM, HBAR). Su un unico indirizzo di exchange condiviso, ciascun memo costituisce un metodo di pagamento a sé stante. XRP: un destination tag, un numero intero da 0 a 4294967295 (è accettato un numero JSON). XLM: un memo di testo fino a 28 byte, un ID a 64 bit o un hash a 32 byte in formato esadecimale. EOS: fino a 256 byte. ATOM: fino a 256 caratteri. HBAR: fino a 100 byte. I wallet Bitcoin, EVM, Solana, Tron, Litecoin, Bitcoin Cash, Dogecoin e Lightning non accettano alcun memo: specificarne uno restituisce un errore `400`. Alias: `destinationTag` o `destination_tag`. issuing_country: type: string custom_properties: type: object description: >- Coppie chiave-valore arbitrarie allegate alla transazione. Ciascuna chiave può essere richiamata nelle condizioni delle regole con il percorso di campo `custom_values.`. additionalProperties: true example: merchant_id: test bank_name: test_2 travel_rule_details: type: object description: >- Dati Travel Rule. Quando Travel Rule è abilitata e transaction_category è travel_rule, Didit gestisce lo scambio direttamente: ignora status, protocol, required e obligations_count e utilizza originator_data, beneficiary_data e metadata. Altrimenti Didit memorizza questi valori come record Travel Rule passivo. Quando Travel Rule è attiva, un trasferimento in uscita pari o superiore alla soglia deve includere quanto richiesto dal relativo regime (TFR UE o Raccomandazione 16 del GAFI), verificato sulle parti inviate: un campo mancante restituisce 400 sotto `travel_rule_details.originator_data` o `travel_rule_details.beneficiary_data`, ad esempio "Il TFR UE richiede il nome dell'ordinante." required: - status properties: status: type: string description: >- Obbligatorio ogni volta che si invia travel_rule_details. Uno degli stati del trasferimento Travel Rule (ad esempio AWAITING_COUNTERPARTY, COMPLETED, NOT_APPLICABLE); sono accettate e mappate anche le grafie minuscole e camelCase nonché i valori legacy UNKNOWN, COMPLIANT, PENDING_ACTION, PENDING_COUNTERPARTY, FAILED ed EXEMPT. Qualsiasi altro valore restituisce 400. protocol: type: string required: type: boolean obligations_count: type: integer originator_data: type: object description: >- Soggetto ordinante, come campi piatti o come una singola persona IVMS 101. Per il tuo utente con una verifica KYC approvata, Didit sostituisce i campi contenuti nella verifica con i valori verificati (vedi `metadata.originator_provenance`). Deve essere un oggetto: qualsiasi altro valore restituisce un `400`. Su una rete basata su memo, la chiave `memo` indica il memo o il tag del wallet dell'ordinante. beneficiary_data: type: object description: >- Parte beneficiaria, come campi piatti o una singola persona IVMS 101. Deve essere un oggetto: qualsiasi altra cosa restituisce `400`. Per instradare il trasferimento, Didit legge `wallet_address` (se vuoto viene compilato da `counterparty.payment_method.account_id`), `chain` (compilato da `transaction_details.crypto_params.crypto_chain` o da `currency` quando quest'ultima indica una chain supportata), `name` (con fallback su `counterparty.full_name`), `travel_address`, `counterparty_vasp_name`, `counterparty_vasp_lei` e `counterparty_vasp_email`. Su una rete con memo, `memo` indica il memo o il tag del wallet del beneficiario; `wallet_address` e `memo` hanno la precedenza sul metodo di pagamento della controparte. metadata: type: object utxo: allOf: - $ref: '#/components/schemas/TravelRuleUtxo' description: >- Opzionale, solo per blockchain UTXO (BTC, LTC, BCH, DOGE). Gli input e gli output della transazione, da cui Didit deduce il wallet dell'ordinante e l'output del beneficiario quando non li dichiari. originator: type: object description: >- Un blocco dell'ordinante IVMS 101: `originatorPersons` (una `naturalPerson` o `legalPerson`; una persona giuridica rende la parte un'azienda) e `accountNumber` (indirizzi del wallet). Utilizzato per `originator_data` quando tale oggetto è vuoto. Un blocco non valido risponde con 400 indicizzato dal relativo percorso, ad esempio `originator.originatorPersons`. beneficiary: type: object description: >- Un blocco del beneficiario IVMS 101: `beneficiaryPersons` (una `naturalPerson` o `legalPerson`; una persona giuridica rende la parte un'azienda) e `accountNumber` (indirizzi del wallet). Utilizzato per `beneficiary_data` quando tale oggetto è vuoto. Un blocco non valido risponde con 400 indicizzato dal relativo percorso, ad esempio `beneficiary.beneficiaryPersons`. ivms101: type: object description: >- I blocchi `originator` e `beneficiary` racchiusi in un singolo oggetto IVMS 101 (è accettato anche `IVMS101`). I blocchi di primo livello hanno la precedenza su quelli dell'involucro. network_snapshot: type: object description: Istantanea precalcolata del grafo di rete. properties: nodes: type: array items: type: object edges: type: array items: type: object metrics: type: object include_crypto_screening: type: boolean nullable: true description: >- Sostituzione per singola transazione per lo screening di analisi della blockchain crypto. Quando è `true`, lo screening crypto viene eseguito indipendentemente dal valore predefinito dell'applicazione. Quando è `false`, lo screening crypto viene saltato anche se abilitato nelle impostazioni dell'applicazione. Se omesso o `null`, viene utilizzato il valore predefinito a livello di applicazione configurato nella Console. Lo screening crypto richiede `transaction_details.direction`, `currency_kind: "crypto"`, una blockchain/valuta e l'indirizzo del wallet selezionato in base alla direzione: lo screening in entrata pre-trasferimento utilizza `counterparty.payment_method.account_id`, lo screening in entrata con hash di transazione utilizza `subject.payment_method.account_id`, e lo screening in uscita utilizza `counterparty.payment_method.account_id`. Quando `transaction_details.payment_reference_id` contiene l'hash di una transazione blockchain, Didit esegue lo screening della transazione e restituisce l'arricchimento del riepilogo della transazione quando disponibile. required: - transaction_id - transaction_category - transaction_details - subject examples: Minimal fiat withdrawal: summary: Payload minimo accettabile per un trasferimento fiat in uscita value: transaction_id: your-txn-2026-05-17-001 transaction_category: finance transaction_details: direction: outbound amount: 1500 currency: EUR action_type: withdrawal subject: entity_type: individual vendor_data: user-12345 full_name: Maria Garcia Crypto outbound with screening: summary: >- Prelievo crypto in uscita verso un wallet in autocustodia, screening opzionale value: transaction_id: your-txn-2026-05-17-002 transaction_category: finance include_crypto_screening: true transaction_details: direction: outbound amount: 0.5 currency: BTC currency_kind: crypto amount_in_default_currency: 32500 default_currency: USD action_type: withdrawal subject: entity_type: individual vendor_data: user-12345 full_name: Maria Garcia payment_method: method_type: crypto_wallet account_id: bc1qexampleexchangewalletaddressxyz issuing_country: ESP counterparty: entity_type: individual payment_method: method_type: unhosted_wallet account_id: bc1qexampleexternalwalletaddressabc Travel Rule transfer: summary: >- Trasferimento crypto in uscita con dati dell'ordinante/beneficiario per la Travel Rule value: transaction_id: your-txn-2026-05-17-003 transaction_category: travel_rule transaction_details: direction: outbound amount: 25000 currency: USDT currency_kind: crypto action_type: transfer subject: entity_type: individual vendor_data: user-12345 full_name: Maria Garcia date_of_birth: '1992-03-14' address: country: ESP town: Madrid street: Calle Mayor 1 post_code: '28013' counterparty: entity_type: individual full_name: John Beneficiary institution_details: name: Beneficiary VASP, Inc. code: BVASP-US travel_rule_details: status: AWAITING_COUNTERPARTY protocol: IVMS101 required: true originator_data: name: Maria Garcia beneficiary_data: name: John Beneficiary responses: '201': description: >- Transazione inviata e monitorata. Il corpo contiene il dettaglio completo della transazione (stessa struttura di `GET /v3/transactions/{transaction_id}/`), che riflette gli esiti delle regole già applicati. content: application/json: schema: $ref: '#/components/schemas/TransactionDetail' examples: Approved with no rule hits: value: uuid: abcdef12-3456-4890-abcd-ef1234567890 environment: live transaction_number: 4123 txn_id: your-txn-2026-05-17-001 txn_date: '2026-05-17T08:42:00Z' zone_id: Europe/Madrid transaction_type: finance action_type: withdrawal direction: OUTBOUND status: APPROVED source: LIVE amount: '1500' currency: EUR currency_type: fiat amount_in_default_currency: '1620.45' default_currency_code: USD preferred_currency_amount: '1620.45' preferred_currency_code: USD payment_details: Withdrawal to crypto wallet payment_txn_id: null score: 0 severity: null decision_reason_code: null decision_reason_label: null vendor_data: user-12345 metadata: subject: entity_type: individual vendor_data: user-12345 full_name: Maria Garcia address: {} institution_details: {} device_context: {} counterparty: {} props: {} tags: [] parties: - uuid: b1111111-2222-4333-8444-555555555555 role: APPLICANT entity_type: individual kind: USER vendor_data: user-12345 full_name: Maria Garcia first_name: null last_name: null country_code: null dob: null address: {} institution_info: {} device: {} external_party_snapshot: null payment_methods: [] documents: [] activities: - uuid: d4e5f6a7-8901-4bcd-9ef0-123456789abc activity_type: TRANSACTION_CREATED source: TRANSACTION status: APPROVED title: withdrawal description: Transaction recorded. metadata: {} occurred_at: '2026-05-17T08:42:11Z' alerts: [] rule_runs: [] provider_results: [] travel_rule: null network_snapshot: null remediation: null action_required: null cost_breakdown: null Flagged for review: value: uuid: abcdef12-3456-4890-abcd-ef1234567891 environment: live transaction_number: 4124 txn_id: your-txn-2026-05-17-002 txn_date: '2026-05-17T08:42:00Z' zone_id: Europe/Madrid transaction_type: finance action_type: withdrawal direction: OUTBOUND status: IN_REVIEW source: LIVE amount: '0.5' currency: BTC currency_type: crypto amount_in_default_currency: '32500' default_currency_code: USD preferred_currency_amount: '32500' preferred_currency_code: USD payment_details: Withdrawal to crypto wallet payment_txn_id: null score: 78 severity: HIGH decision_reason_code: WALLET_HIGH_RISK decision_reason_label: Destination wallet flagged as high risk vendor_data: user-12345 metadata: subject: entity_type: individual vendor_data: user-12345 full_name: Maria Garcia address: {} institution_details: {} device_context: {} counterparty: {} props: order_id: ord-9988 tags: [] parties: - uuid: b1111111-2222-4333-8444-555555555555 role: APPLICANT entity_type: individual kind: USER vendor_data: user-12345 full_name: Maria Garcia first_name: null last_name: null country_code: null dob: null address: {} institution_info: {} device: {} external_party_snapshot: null payment_methods: [] documents: [] activities: [] alerts: - uuid: a7b8c9d0-1234-4abc-9def-567890abcdef title: Destination wallet flagged as high risk description: Provider risk score exceeded the configured threshold. severity: HIGH status: OPEN source: RULE metadata: {} created_at: '2026-05-17T08:42:12Z' due_at: null rule_runs: - uuid: e5f6a7b8-9012-4cde-af01-23456789abcd rule: f6a7b8c9-0123-4def-b012-3456789abcde rule_title: High-risk wallet screening rule_description: null rule_category: crypto matched: true is_test: false mode: ACTIVE severity: HIGH score_delta: 78 status_target: IN_REVIEW action_summary: score +78; change_status:IN_REVIEW metadata: {} created_at: '2026-05-17T08:42:12Z' provider_results: [] travel_rule: null network_snapshot: null remediation: null action_required: null cost_breakdown: null '400': description: >- Validazione non riuscita (campi obbligatori mancanti, `transaction_id` duplicato, valore enum sconosciuto, valuta non valida, ecc.). content: application/json: examples: Missing required field: value: transaction_details: amount: - This field is required. Duplicate transaction_id: value: transaction_id: - A transaction with this transaction_id already exists. Invalid category: value: non_field_errors: - Unsupported transaction category. Missing subject identity: value: subject: - subject.vendor_data and subject.full_name are required. Blocklisted participant: value: vendor_data: - >- The individual 'user-12345' is in the blocklist and cannot participate in transactions. '403': description: >- Chiave API mancante, non valida o revocata, oppure la chiave non può inviare transazioni per questa applicazione. Una chiave mancante restituisce `403`; una chiave errata, revocata o scaduta restituisce `401`. content: application/json: examples: Forbidden: value: detail: You do not have permission to perform this action. '409': description: >- Un'altra richiesta con lo stesso `transaction_id` ha creato la transazione mentre questa era in fase di elaborazione, quindi solo uno dei due invii simultanei ha esito positivo. Leggi la transazione esistente invece di inviarla nuovamente. content: application/json: examples: Concurrent duplicate: value: detail: A transaction with this transaction_id already exists. '429': description: >- Limite di frequenza superato: le creazioni di transazioni e l'ingestione di eventi (`POST /v3/transactions/`, `POST /v3/events/`, `POST /v3/events/batch/`) condividono un budget di 600 richieste al minuto per chiave API, separato dalle 300 condivise da tutte le altre richieste di scrittura. Attendi `Retry-After` secondi, quindi riprova. headers: Retry-After: description: >- Secondi da attendere prima di riprovare, arrotondati per eccesso in modo che il nuovo tentativo rientri nella finestra successiva. schema: type: integer minimum: 1 example: 30 content: application/json: examples: Throttled: value: detail: >- Ingestion rate limit exceeded. You can make up to 600 requests per minute. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: |- curl -X POST 'https://verification.didit.me/v3/transactions/' \ -H 'x-api-key: YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{ "transaction_id": "your-txn-2026-05-17-001", "transaction_category": "finance", "transaction_details": { "direction": "outbound", "amount": 1500, "currency": "EUR", "action_type": "withdrawal" }, "subject": { "entity_type": "individual", "vendor_data": "user-12345", "full_name": "Maria Garcia" } }' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.transactions.create( transaction_id="your-txn-2026-05-17-001", transaction_category="finance", transaction_details={ "direction": "outbound", "amount": 1500.0, "currency": "EUR", "action_type": "withdrawal", }, subject={ "entity_type": "individual", "vendor_data": "user-12345", "full_name": "Maria Garcia", }, ) 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.transactions.create({ transaction_id: "your-txn-2026-05-17-001", transaction_category: "finance", transaction_details: { direction: "outbound", amount: 1500.0, currency: "EUR", action_type: "withdrawal", }, subject: { entity_type: "individual", vendor_data: "user-12345", full_name: "Maria Garcia", }, }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.Create(ctx, didit.TransactionsCreateParams{\n\tTransactionID: \"your-txn-2026-05-17-001\",\n\tTransactionCategory: \"finance\",\n\tTransactionDetails: didit.TransactionsCreateParamsTransactionDetails{\n\t\tDirection: \"outbound\",\n\t\tAmount: 1500.0,\n\t\tCurrency: \"EUR\",\n\t\tActionType: didit.String(\"withdrawal\"),\n\t},\n\tSubject: didit.TransactionsCreateParamsSubject{\n\t\tEntityType: didit.String(\"individual\"),\n\t\tVendorData: \"user-12345\",\n\t\tFullName: \"Maria Garcia\",\n\t},\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.TransactionsCreateParams; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.transactions().create(TransactionsCreateParams.builder() .transactionId("your-txn-2026-05-17-001") .transactionCategory(TransactionsCreateParams.TransactionCategory.of("finance")) .transactionDetails(TransactionsCreateParams.TransactionDetails.builder() .direction(TransactionsCreateParams.TransactionDetails.Direction.of("outbound")) .amount(1500.0) .currency("EUR") .actionType("withdrawal") .build()) .subject(TransactionsCreateParams.Subject.builder() .entityType("individual") .vendorData("user-12345") .fullName("Maria Garcia") .build()) .build()); System.out.println(result); - lang: php label: PHP source: |- transactions->create([ 'transaction_id' => 'your-txn-2026-05-17-001', 'transaction_category' => 'finance', 'transaction_details' => [ 'direction' => 'outbound', 'amount' => 1500.0, 'currency' => 'EUR', 'action_type' => 'withdrawal', ], 'subject' => [ 'entity_type' => 'individual', 'vendor_data' => 'user-12345', 'full_name' => 'Maria Garcia', ], ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.transactions.create( transaction_id: "your-txn-2026-05-17-001", transaction_category: "finance", transaction_details: { direction: "outbound", amount: 1500.0, currency: "EUR", action_type: "withdrawal", }, subject: { entity_type: "individual", vendor_data: "user-12345", full_name: "Maria Garcia", } ) 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.Transactions.CreateAsync(new TransactionsCreateParams { TransactionId = "your-txn-2026-05-17-001", TransactionCategory = "finance", TransactionDetails = new() { Direction = "outbound", Amount = 1500.0, Currency = "EUR", ActionType = "withdrawal", }, Subject = new() { EntityType = "individual", VendorData = "user-12345", FullName = "Maria Garcia", }, }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: TravelRuleUtxo: type: object description: >- Gli input e gli output di un trasferimento UTXO (BTC, LTC, BCH, DOGE). Accettati solo su queste blockchain: su qualsiasi altra blockchain restituisce `400`. Da essi Didit deduce il wallet dell'ordinante (quello dichiarato, altrimenti l'indirizzo di input che ha contribuito di più) e l'output del beneficiario (quello dichiarato, altrimenti l'unico output che non restituisce il resto a un indirizzo di input, altrimenti l'output che paga l'importo del trasferimento). Il risultato si trova in `chain_details` del trasferimento. required: - outputs properties: inputs: type: array maxItems: 1000 items: $ref: '#/components/schemas/TravelRuleUtxoEntry' description: >- Opzionale. Senza input non viene dedotto alcun ordinante e non viene riconosciuto alcun output di resto. outputs: type: array minItems: 1 maxItems: 1000 items: $ref: '#/components/schemas/TravelRuleUtxoEntry' TransactionDetail: type: object description: >- Record di monitoraggio completo per una transazione, come restituito da `GET /v3/transactions/{transaction_id}/` e `POST /v3/transactions/`. properties: uuid: type: string format: uuid description: >- Identificativo della transazione stabile di Didit. Utilizzalo come `{transaction_id}` per le chiamate successive. environment: type: string enum: - live - sandbox description: >- Ambiente dell'applicazione proprietaria della transazione. Una transazione in `sandbox` viene archiviata ma non viene mai valutata, sottoposta a screening, notificata o fatturata; pertanto, il valore vuoto di `rule_runs` indica "non valutata". transaction_number: type: integer description: >- Numero sequenziale della transazione con ambito limitato all'applicazione mostrato nella Console (es. `4123`). txn_id: type: string description: >- Il `transaction_id` fornito al momento della creazione (max 128 caratteri). Univoco per applicazione. txn_date: type: string format: date-time description: >- Quando è avvenuta la transazione (da `transaction_at`; il valore predefinito è il momento dell'invio). zone_id: type: string nullable: true description: >- Identificatore di fuso orario IANA fornito al momento della creazione. transaction_type: type: string description: >- Categoria di primo livello così come memorizzata: `finance`, `kyc`, `travelRule`, `userPlatformEvent`, `gamblingBet`, `gamblingLimitChange`, `gamblingBonusChange`, `auditTrailEvent`. Nota che i valori composti da più parole vengono restituiti in camelCase anche se inviati in snake_case. action_type: type: string description: >- Sottotipo all'interno della categoria (ad es. `deposit`, `withdrawal`, `transfer`). Se non specificato, il valore predefinito coincide con la categoria. direction: type: string enum: - INBOUND - OUTBOUND description: >- Direzione rispetto al soggetto. Memorizzato in maiuscolo indipendentemente dal formato inviato (`in`/`out`/`inbound`/`outbound` sono accettati in input). status: type: string enum: - APPROVED - IN_REVIEW - DECLINED - AWAITING_USER description: >- Verdetto di monitoraggio attuale. Le transazioni vengono create come `APPROVED`; le regole possono modificarle in `IN_REVIEW`/`DECLINED` in modo sincrono. source: type: string enum: - LIVE - IMPORTED description: >- In che modo ha avuto origine il record: `LIVE` per le transazioni inviate tramite API o SDK, `IMPORTED` per le transazioni caricate tramite l'importazione da console. amount: type: string description: >- Importo della transazione come stringa decimale senza zeri finali (es. `"1500"`, `"0.5"`, `"0.123456789012345678"`). Fino a 18 cifre decimali. currency: type: string description: >- Codice valuta di `amount`. Viene accettato qualsiasi codice alfabetico ISO 4217 (ad es. `EUR`, `USD`, `NGN`), così come il simbolo di un asset crypto (ad es. `BTC`). È preferibile utilizzare un codice attualmente in circolazione. Non tutti i codici accettati hanno un tasso di cambio: quando non ne è disponibile alcuno per il codice (ad esempio l'unità di conto ISO `XSU` o un simbolo crypto di cui Didit non calcola il prezzo), la conversione automatica non riesce e `preferred_currency_amount` viene restituito null a meno che la richiesta non abbia fornito un `amount_in_default_currency` pre-convertito. currency_type: type: string nullable: true description: '`fiat` o `crypto`, come inviato in `currency_kind`.' amount_in_default_currency: type: string nullable: true description: >- Importo pre-convertito fornito dall'utente, come stringa decimale priva di zeri finali. default_currency_code: type: string nullable: true preferred_currency_amount: type: string nullable: true description: >- `amount` convertito nella valuta preferita dell'applicazione, se disponibile. preferred_currency_code: type: string nullable: true payment_details: type: string nullable: true description: >- Riferimento di pagamento o promemoria in formato testo libero derivante dall'invio. payment_txn_id: type: string nullable: true description: >- Riferimento del sistema di pagamento esterno (ad es. hash della transazione blockchain) da `payment_reference_id`. score: type: integer description: >- Punteggio di rischio accumulato dalle regole (in genere 0–100). Più alto = più rischioso. severity: type: string nullable: true enum: - UNKNOWN - LOW - MEDIUM - HIGH - CRITICAL description: >- Gravità categoriale del rischio impostata da regole/provider (`UNKNOWN`, `LOW`, `MEDIUM`, `HIGH`, `CRITICAL`). `null` finché non viene impostata. decision_reason_code: type: string nullable: true description: Motivo leggibile dalla macchina per il `status` attuale. decision_reason_label: type: string nullable: true description: Etichetta di facile lettura per `decision_reason_code`. vendor_data: type: string nullable: true description: Copia per comodità di `vendor_data` del richiedente. metadata: type: object description: >- Istantanea dei payload di `subject` e `counterparty` così come inviati al momento della creazione. props: type: object description: >- Le `custom_properties` fornite al momento della creazione. Ciascuna chiave è accessibile nelle condizioni delle regole come `custom_values.`. tags: type: array items: type: object properties: uuid: type: string format: uuid name: type: string color: type: string description: type: string nullable: true source: type: string enum: - didit - custom description: Indica se il tag è predefinito da Didit o personalizzato. description: Tag associati alla transazione (manualmente o tramite regole). parties: type: array items: type: object properties: uuid: type: string format: uuid role: type: string enum: - APPLICANT - REMITTER - BENEFICIARY - COUNTERPARTY description: >- Ruolo della parte. L'endpoint di creazione assegna `APPLICANT` (il soggetto) e `COUNTERPARTY`. entity_type: type: string enum: - individual - company - external - unhostedWallet kind: type: string enum: - USER - BUSINESS - EXTERNAL description: >- Le parti `USER`/`BUSINESS` rimandano a un'entità di Didit tramite `vendor_data`. Le parti `EXTERNAL` non hanno alcuna entità Didit associata. vendor_data: type: string nullable: true description: Il tuo identificatore interno utente/azienda. full_name: type: string nullable: true first_name: type: string nullable: true last_name: type: string nullable: true country_code: type: string nullable: true description: >- Codice del paese ricavato dal valore `address.country` inviato (in genere ISO 3166-1 alpha-3). dob: type: string format: date nullable: true description: Data di nascita dal valore `date_of_birth` inviato. address: type: object description: Oggetto indirizzo così come inviato. `{}` se omesso. institution_info: type: object description: Dettagli dell'istituto così come inviati. `{}` se omessi. device: type: object description: >- Contesto del dispositivo normalizzato, compreso l'arricchimento IP lato server sotto network_context (geolocalizzazione, flag VPN/data center) se è stato fornito un indirizzo IP. properties: fingerprint: type: string description: Impronta digitale univoca del dispositivo. persistent_device_id: type: string description: >- Identificatore stabile del dispositivo tra sessioni diverse (schema di fingerprint v2). user_agent: type: string description: Stringa user agent del browser o dell'app. browser_family: type: string description: Famiglia del browser (es. Chrome, Firefox, Safari). browser_version: type: string description: Stringa della versione del browser. platform: type: string description: >- Identificatore della piattaforma (web, ios, android, macos, windows, linux). os_family: type: string description: >- Famiglia del sistema operativo (ad es. iOS, Android, Windows). os_version: type: string description: Stringa della versione del sistema operativo. accept_language: type: string description: Valore dell'intestazione Accept-Language. session_id: type: string description: Identificatore della sessione (archiviato nei metadati). session_age_ms: type: number description: Età della sessione in millisecondi. network_context: type: object description: Contesto di rete con indirizzo IP e geolocalizzazione. properties: ip_address: type: string description: Indirizzo IP del client. ip_country_code: type: string description: Paese geolocalizzato dell'IP (ISO 3166-1 alpha-3). latitude: type: number description: Latitudine geografica dell'IP. longitude: type: number description: Longitudine geografica dell'IP. external_party_snapshot: type: object nullable: true description: >- Copia congelata dei dati della parte per le parti `EXTERNAL`. `null` finché la parte è collegata a un utente o a un'azienda Didit. description: Parti della transazione (richiedente, controparte). payment_methods: type: array items: type: object properties: uuid: type: string format: uuid payment_method_type: type: string enum: - bank_card - bank_account - e_wallet - crypto_wallet - unhosted_wallet - other label: type: string nullable: true fingerprint: type: string nullable: true description: >- SHA-256 su `type:account_id:issuing_country` — identificatore stabile per correlare il riutilizzo dello stesso strumento. account_id: type: string nullable: true description: >- Identificativo dell'account (IBAN, indirizzo, token della carta, …). issuing_country: type: string nullable: true owner_kind: type: string enum: - USER - BUSINESS - EXTERNAL vendor_data: type: string nullable: true description: Il tuo identificatore per l'utente o l'azienda proprietari. owner_name: type: string nullable: true institution_info: type: object details: type: object description: Oggetto `payment_method` non elaborato così come inviato. external_owner_snapshot: type: object nullable: true role: type: string enum: - SOURCE - DESTINATION - FUNDING - BENEFICIARY description: >- Come è stato utilizzato questo metodo nella transazione. L'endpoint di creazione assegna `SOURCE`/`DESTINATION` in base alla direzione (in uscita: soggetto = SOURCE; in entrata: soggetto = DESTINATION). description: Metodi di pagamento collegati alla transazione. documents: type: array description: >- File allegati alla transazione dalla console. `[]` se non ce ne sono. items: type: object properties: uuid: type: string format: uuid label: type: string nullable: true note: type: string nullable: true uploaded_by: type: string nullable: true created_at: type: string format: date-time files: type: array items: type: object properties: uuid: type: string format: uuid file_url: type: string format: uri nullable: true description: >- URL di download firmato di breve durata; recuperalo quando necessario invece di memorizzarlo. original_filename: type: string nullable: true file_size: type: integer nullable: true activities: type: array items: type: object properties: uuid: type: string format: uuid activity_type: type: string description: >- Ad es. `TRANSACTION_CREATED`, `TRANSACTION_NOTE_ADDED`, `TRANSACTION_STATUS_CHANGED`. source: type: string status: type: string nullable: true title: type: string nullable: true description: type: string nullable: true metadata: type: object occurred_at: type: string format: date-time description: >- Voci del registro delle attività (creazione, note, revisioni manuali, modifiche di stato). alerts: type: array items: type: object properties: uuid: type: string format: uuid title: type: string description: type: string nullable: true severity: type: string enum: - UNKNOWN - LOW - MEDIUM - HIGH - CRITICAL status: type: string enum: - OPEN - INVESTIGATING - AWAITING_USER - PENDING_SAR - SAR_FILED - RESOLVED - DISMISSED source: type: string enum: - RULE - PROVIDER - MANUAL metadata: type: object created_at: type: string format: date-time due_at: type: string format: date-time nullable: true description: >- Attualmente sempre vuoto. Un alert aperto è una transazione con stato `IN_REVIEW` o `AWAITING_USER`. rule_runs: type: array items: type: object properties: uuid: type: string format: uuid rule: type: string format: uuid description: UUID della regola eseguita. rule_title: type: string rule_description: type: string nullable: true rule_category: type: string matched: type: boolean description: >- Indica se le condizioni della regola corrispondevano a questa transazione. L'esecuzione viene registrata solo per le regole soddisfatte, pertanto le valutazioni in tempo reale riportano sempre `true`. is_test: type: boolean description: >- True quando la regola è stata eseguita in modalità TEST (nessun effetto su stato/punteggio). mode: type: string enum: - ACTIVE - DISABLED - TEST severity: type: string nullable: true score_delta: type: integer description: Punteggio aggiunto dalle azioni `add_score` di questa regola. status_target: type: string nullable: true description: Stato impostato da un'azione `change_status`, se presente. action_summary: type: string nullable: true description: >- Riepilogo delle azioni eseguite dalla regola, unite con `; ` (ad es. `score +30; change_status:IN_REVIEW; add_tag:high_risk_country`). Componenti: `score +N`, `change_status:`, `add_tag:`, `add_note`, `add_to_list`, `open_case`. `null` quando la regola non ha eseguito alcuna azione. metadata: type: object description: >- Dettaglio di valutazione: `scope_match`, `conditions[]` e `aggregations[]`. Ogni voce di condizione include `field`, `operator`, `expected_value`, il `current_value` letto dalla transazione, `matched`, `group_index` e `group_logic`. Ogni voce di aggregazione (frequenza / conteggio / somma) include `metric`, `field`, `operator`, `expected_value`, il `computed_value` a cui è stata valutata l'aggregazione, `window`, `filters`, `matched` e `sample_references`; le aggregazioni asincrone differite hanno `computed_value: null` e `deferred: true`. Un gruppo di condizioni nidificato è una voce `conditions[]` con `operator` `any_of` o `all_of`, `field` null e i risultati dei relativi membri all'interno del proprio `conditions`. created_at: type: string format: date-time description: >- Risultati dell'esecuzione per regola: quale regola è scattata, con quale impatto sul punteggio. provider_results: type: array items: type: object properties: uuid: type: string format: uuid provider: type: string result_type: type: string enum: - FIAT_MONITORING - WALLET_SCREENING - TRANSACTION_SCREENING - TRAVEL_RULE - NETWORK_GRAPH - CUSTOM status: type: string severity: type: string nullable: true score: type: integer summary: type: string nullable: true payload: type: object description: Payload di risposta del provider non elaborato. created_at: type: string format: date-time description: >- Payload non elaborati del provider (screening AML, analisi blockchain, ecc.). travel_rule: nullable: true allOf: - $ref: '#/components/schemas/TransactionTravelRule' description: >- Trasferimento o controllo Travel Rule. Valorizzato quando `travel_rule_details` è stato inviato e anche quando Travel Rule è abilitata e la transazione è stata creata con `transaction_category: travelRule` (Didit avvia lo scambio direttamente, anche senza `travel_rule_details`). `null` quando non esiste alcun trasferimento o controllo. In un trasferimento in entrata, `originator_data` e `beneficiary_data` della controparte rimangono mascherati (`data_masked: true`) finché non viene confermato l'assetto proprietario del wallet. network_snapshot: type: object nullable: true description: >- Snapshot del grafo delle transazioni/parti correlate utilizzato dal motore di regole. È il `network_snapshot` inviato con la transazione oppure il grafo che Didit crea da uno Screening AML del wallet riuscito (che sostituisce quello inviato). `null` quando nessuno dei due è presente. properties: uuid: type: string format: uuid nodes: type: array items: type: object edges: type: array items: type: object metrics: type: object remediation: type: object nullable: true description: >- Sessione di remediation offerta all'utente quando è richiesta una nuova verifica. Sostituita da `action_required`, che costituisce il blocco canonico; mantenuta per retrocompatibilità. properties: session_id: type: string session_token: type: string url: type: string format: uri status: type: string action_required: type: object nullable: true description: >- Azione richiesta all'utente finale e ancora in sospeso per completare questa transazione, oppure null quando non ce n'è alcuna. Gli SDK di Didit avviano automaticamente l'azione per impostazione predefinita e aggiornano la transazione al termine. Due varianti, distinte da `type`: `verification_session` (una sessione di verifica ospitata creata da un'azione di una regola) e `wallet_ownership` (una sessione del widget di proprietà del wallet generata automaticamente per un trasferimento Travel Rule che richiede la prova di controllo del wallet, regolata dall'impostazione Travel Rule `auto_wallet_verification`). Quando potrebbero essere applicate entrambe, `wallet_ownership` ha la precedenza perché blocca lo scambio Travel Rule. oneOf: - $ref: '#/components/schemas/TransactionVerificationSessionAction' - $ref: '#/components/schemas/TransactionWalletOwnershipAction' discriminator: propertyName: type mapping: verification_session: '#/components/schemas/TransactionVerificationSessionAction' wallet_ownership: '#/components/schemas/TransactionWalletOwnershipAction' cost_breakdown: type: object nullable: true description: >- Costo di questa transazione: `total_price` e `items`, uno per ogni addebito, ciascuno con `usage_type`, `price`, `details` e `created_at`. Un nuovo screening della stessa transazione costituisce una nuova voce. TravelRuleUtxoEntry: type: object description: >- Un input o output di una transazione UTXO, così come registrato dalla blockchain. required: - address properties: address: type: string maxLength: 128 amount: type: string nullable: true description: >- Stringa decimale nell'unità propria della moneta (BTC, non satoshi). Facoltativo. example: '0.0125' txid: type: string maxLength: 128 description: Opzionale. La transazione utilizzata da un input. vout: type: integer nullable: true minimum: 0 description: Opzionale. L'indice di output speso da un input. TransactionTravelRule: type: object description: >- Il trasferimento Travel Rule di una transazione, come restituito da `GET /v3/transactions/{transaction_id}/`, dal `201` di `POST /v3/transactions/` e da ciascuna riga di `GET /v3/transactions/`. `direction`, `rail`, `counterparty_vasp`, `delivery`, `discovery`, `reason` e `next_actions` hanno la stessa struttura di `PATCH /v3/transactions/{transaction_id}/travel-rule/`, quindi una singola lettura di una transazione indica perché il suo trasferimento è bloccato e cosa consente di farlo avanzare. properties: uuid: type: string format: uuid status: type: string protocol: type: string nullable: true required: type: boolean obligations_count: type: integer originator_data: type: object description: >- Soggetto ordinante. Per un trasferimento in entrata, i valori della controparte sono oscurati fino alla conferma dell'assetto proprietario. beneficiary_data: type: object description: >- Parte beneficiaria. Per un trasferimento in entrata i valori della controparte sono mascherati fino a quando non viene confermato l'assetto proprietario. name_match: type: object nullable: true description: >- Il confronto dei nomi che ha determinato il trasferimento (punteggio e livello di rigore). Null fino all'esecuzione. I nomi confrontati vengono oscurati insieme alle parti. data_match: $ref: '#/components/schemas/TravelRuleDataMatch' mismatched_fields: type: array items: type: string description: >- Scorciatoia per `data_match.mismatched_fields`. Vuoto quando non ci sono differenze. data_unmasked: $ref: '#/components/schemas/TravelRuleDataUnmasked' data_masked: type: boolean description: >- True mentre i dati personali della controparte sono mascherati in questa risposta. metadata: type: object direction: type: string enum: - INBOUND - OUTBOUND description: Quale lato dello scambio rappresenta questo trasferimento. rail: type: string nullable: true description: >- Il canale (rail) utilizzato per il trasferimento: `INTERNAL`, `TRP`, `GTR`, `TRUST`, `VERIFYVASP`, `SYGNA` o `EMAIL` (`TEST_VASP` su un'applicazione sandbox, quando il Didit Test VASP ha risposto), oppure `null` finché non viene scelto un canale. counterparty_vasp: type: object nullable: true properties: name: type: string lei: type: string dd_score: type: integer description: >- Punteggio di due diligence da 0 a 100, dove un valore più alto è migliore. Stessa scala utilizzata nella directory dei VASP. dd_score_breakdown: type: object description: >- Contributi per componente a dd_score, un oggetto per componente come nella directory VASP (giurisdizione, verifica, protocollo, lei, cronologia, elementi essenziali, reattività), ciascuno con {points, max, reason, detail}. {} finché la controparte non è stata valutata. additionalProperties: type: object properties: points: type: number description: Punti assegnati per questo componente. max: type: integer description: Punti massimi che questo componente può assegnare. reason: type: string description: Codice leggibile dalla macchina dell'esito del componente. detail: type: string description: Motivo leggibile dall'utente per i punti assegnati. dd_assessed_at: type: string format: date-time nullable: true description: >- Data e ora dell'ultima esecuzione della valutazione di adeguata verifica. Null finché la controparte non è stata valutata. description: >- La voce di directory della controparte, oppure `null` se il trasferimento non ne collega alcuna. delivery: nullable: true allOf: - $ref: '#/components/schemas/TravelRuleDelivery' description: >- Il messaggio più recente che il trasferimento deve a un'altra parte. `null` quando non ne ha dovuti, ad esempio al di sotto di `threshold_amount` o per un wallet in autocustodia dichiarato. discovery: type: array description: >- Modalità con cui Didit ha cercato la controparte, una voce per ogni passaggio eseguito. Vuoto se non è stata eseguita alcuna ricerca, ad esempio per un trasferimento in entrata. items: $ref: '#/components/schemas/TravelRuleDiscoveryStep' reason: type: string description: >- Il motivo per cui un trasferimento `COUNTERPARTY_VASP_NOT_FOUND` o `COUNTERPARTY_VASP_NOT_REACHABLE` è bloccato; `""` per qualsiasi altro stato. Una consegna non riuscita lo determina per prima, solo su `COUNTERPARTY_VASP_NOT_REACHABLE`: `email_undeliverable` (il provider di posta ha rifiutato l'email di compliance e non è rimasto alcun indirizzo da provare: quando è stata inviata, in un promemoria o come bounce permanente segnalato successivamente) o `delivery_failed` (il canale che effettuava la consegna è fallito definitivamente: un canale di rete ha rifiutato il messaggio o ha esaurito i tentativi, un host di identità `TRP` non ha risposto o l'host `TRP` della controparte non ha accettato la richiesta). Altrimenti lo determina la traccia di `discovery`: `awaiting_end_user` (nessun passaggio ha indicato una controparte raggiungibile da Didit), `directory_match_no_route` (un passaggio ha indicato un VASP della directory privo di rotta), `picked_member_without_proven_wallet` (l'utente finale ha scelto un cliente Didit che non ha dimostrato il controllo del wallet) o `no_directory_match` quando la traccia non fornisce altri motivi. Un nuovo invio fa avanzare il trasferimento, quindi il motivo viene azzerato. Consulta [Perché un trasferimento è bloccato](/it/transaction-monitoring/travel-rule#perché-un-trasferimento-è-bloccato). next_actions: type: array description: >- Cosa fa procedere il trasferimento; `[]` per qualsiasi stato tranne `COUNTERPARTY_VASP_NOT_FOUND` o `COUNTERPARTY_VASP_NOT_REACHABLE`. `email_undeliverable` propone `update_compliance_email`, poi `resend`. `delivery_failed` propone `resend`. Un motivo di discovery propone `select_counterparty_vasp`, `declare_self_hosted`, `add_vasp_hint` e `resend`. items: $ref: '#/components/schemas/TravelRuleNextAction' chain_details: $ref: '#/components/schemas/TravelRuleChainDetails' TransactionVerificationSessionAction: title: Verification session type: object properties: type: type: string enum: - verification_session url: type: string format: uri description: URL di verifica ospitato da aprire per l'utente finale. session_id: type: string format: uuid description: ID della sessione di verifica. session_token: type: string description: >- Token di sessione, utilizzato dagli SDK per dispositivi mobili per avviare il flusso in modo nativo. status: type: string description: Stato della sessione di verifica. required: - type - url TransactionWalletOwnershipAction: title: Wallet ownership type: object properties: type: type: string enum: - wallet_ownership url: type: string format: uri description: >- URL del widget ospitato per la titolarità del wallet. Aprilo in una vera interfaccia browser: su mobile usa SFSafariViewController o un Chrome Custom Tab, mai una webview integrata. widget_session_id: type: string format: uuid description: ID di sessione del widget di titolarità del wallet. expires_at: type: string format: date-time description: Quando scade la sessione del widget. required: - type - url TravelRuleDataMatch: type: object nullable: true description: >- Confronto campo per campo tra i dati della parte del trasferimento e ciò che l'altra parte sa sul titolare del wallet. Riporta i nomi dei campi e i risultati, mai i valori, in modo che rimanga leggibile mentre i dati della controparte sono oscurati. Null finché non viene eseguito un confronto. properties: matched: type: boolean description: True quando nessun campo confrontato differisce. mismatched_fields: type: array items: type: string enum: - name - date_of_birth - address - account description: I campi che differiscono. fields: type: object description: >- Una voce per ciascun campo confrontato per il tipo di entità della parte (`name`, `date_of_birth`, `address`, `account`; un'azienda non ha `date_of_birth`). additionalProperties: type: object properties: result: type: string enum: - matched - mismatched - not_compared description: >- `not_compared` quando la regola è `NONE` o una delle due parti non ha un valore per il campo. strictness: type: string enum: - NONE - STRICT - CONTAINS - DEFAULT - FUZZY TravelRuleDataUnmasked: type: object nullable: true description: >- Registro di audit del momento in cui i dati della controparte sono stati smascherati. Null finché i dati sono ancora mascherati e per i trasferimenti in uscita. properties: at: type: string format: date-time reason: type: string enum: - ownership_confirmed - wallet_proof - address_book_match - own_verified_wallet - inquiry_approved - known_payment_method - travel_address description: >- Cosa ha confermato l'assetto proprietario: ownership_confirmed (la tua conferma tramite la console o l'API), wallet_proof (una prova del wallet nel widget o un trasferimento in entrata INTERNAL, impostato al momento della creazione), address_book_match (un wallet verificato nella rubrica), own_verified_wallet (il wallet verificato del tuo utente), inquiry_approved (la tua approvazione di una richiesta TRP in entrata o di un messaggio GTR o Sygna), known_payment_method (un wallet con cui il tuo utente ha già pagato) o travel_address (il Travel Address associato al wallet ha denominato il wallet). actor: type: string description: >- Chi l'ha confermata: l'email dell'utente della console o l'etichetta della chiave API. Vuoto per una decisione automatica. TravelRuleDelivery: type: object description: >- Lo stato dell'ultimo messaggio dovuto dal trasferimento alla controparte. Didit contatta la controparte dopo la restituzione della richiesta che ha creato o modificato il trasferimento, quindi questo oggetto indica se tale messaggio è andato a buon fine: in coda, in fase di invio, in attesa di un nuovo tentativo dopo un errore, consegnato o non riuscito. In caso di errore da cui la rete può ancora riprendersi (nessuna risposta in tempo, connessione non riuscita, HTTP `408`, `429` o `5xx`), viene effettuato un nuovo tentativo dopo 30 secondi, 2 minuti, 10 minuti, 30 minuti e 1 ora. Quando un primo messaggio (`kind: SEND`) fallisce definitivamente, perché la rete lo ha rifiutato o anche il sesto tentativo non è riuscito, il trasferimento passa a `COUNTERPARTY_VASP_NOT_REACHABLE` con `last_error` nella sua `timeline`; qualsiasi altro messaggio che fallisce definitivamente viene annotato nella `timeline`. Lo `status` del trasferimento rimane l'unica fonte di verità per lo scambio stesso. required: - kind - status - rail - attempts - last_error - next_attempt_at - delivered_at properties: kind: type: string enum: - SEND - ANSWER - TXID - CANCEL - POLL description: >- Cosa trasporta il messaggio. `SEND`: il primo messaggio del trasferimento verso la controparte (in uscita; il canale viene scelto al momento dell'invio). `ANSWER`: la tua accettazione o rifiuto, dovuta alla rete che ha effettuato la richiesta (in entrata). `TXID`: l'hash della transazione on-chain, dopo aver completato il trasferimento. `CANCEL`: l'annullamento, dopo averlo cancellato. `POLL`: una richiesta di stato verso una rete che la supporta, ripetuta ogni 5 minuti mentre il trasferimento è in attesa della controparte. status: type: string enum: - QUEUED - SENDING - RETRYING - DELIVERED - FAILED description: >- `QUEUED`: in attesa di invio. `SENDING`: tentativo in corso. `RETRYING`: un tentativo non è riuscito e il prossimo verrà eseguito alle `next_attempt_at`. `DELIVERED`: l'altra parte ha ricevuto il messaggio. `FAILED`: l'altra parte lo ha rifiutato o l'ultimo tentativo non è riuscito. rail: type: string enum: - INTERNAL - TRP - GTR - TRUST - VERIFYVASP - SYGNA - EMAIL - '' description: >- Il canale (rail) che trasporta il messaggio. Vuoto finché Didit non ne sceglie uno per un primo messaggio. attempts: type: integer minimum: 0 description: >- Tentativi effettuati finora per questo messaggio. Per un messaggio che non è un polling di stato vengono effettuati al massimo 6 tentativi. last_error: type: string description: >- Il tipo di errore riscontrato nell'ultimo tentativo, `""` se non ce ne sono stati: ad esempio `email undeliverable`, `trp identity endpoint unreachable` o `trp transfer inquiry delivery failed`. Non contiene mai la risposta della controparte stessa, che rimane nella `timeline` del trasferimento. Quando GTR risponde con un errore, vengono inclusi il codice di stato e il messaggio restituiti. I corpi della risposta non vengono mai inclusi. example: email undeliverable next_attempt_at: type: string format: date-time nullable: true description: >- Quando verrà eseguito il prossimo tentativo mentre il messaggio è in stato `QUEUED` o `RETRYING`. delivered_at: type: string format: date-time nullable: true description: Quando l'altra parte ha preso in carico il messaggio. TravelRuleDiscoveryStep: type: object description: >- Un passaggio del rilevamento della controparte eseguito da Didit per un trasferimento in uscita, nell'ordine in cui è stato eseguito. Il primo passaggio che identifica un VASP con un percorso conclude la catena. properties: step: type: string enum: - internal_address_book - wallet_attribution - network_lookup - customer_hint - end_user description: >- `internal_address_book`: un altro cliente Didit che ha dimostrato il controllo del wallet di destinazione. `wallet_attribution`: l'attribuzione di analisi blockchain del wallet. `network_lookup`: una rete in grado di indicare quale VASP detiene l'indirizzo. `customer_hint`: il nome del VASP, LEI o la giurisdizione che hai inviato in `beneficiary_data`. `end_user`: la controparte scelta dall'utente finale (o da te), oppure la richiesta di sceglierne una. outcome: type: string enum: - match - miss - skipped description: >- `match`: il passaggio ha indicato una controparte. `miss`: è stato eseguito e non ne ha trovata nessuna. `skipped`: non è stato possibile eseguirlo e `reason` ne indica il motivo. reason: type: string description: >- Motivo leggibile dalla macchina, `""` in caso di corrispondenza: `no_proven_internal_wallet`, `attribution_disabled`, `already_attributed`, `no_attributed_entity`, `directory_match_no_route`, `gtr_address_lookup_runs_on_dispatch`, `no_membership`, `network_switched_off`, `no_network_address_lookup`, `no_directory_match`, `awaiting_end_user` o `picked_member_without_proven_wallet`. vasp: type: string format: uuid nullable: true description: >- Il VASP della directory indicato dal passaggio, qualora ne abbia indicato uno. rail: type: string nullable: true description: >- Il canale (rail) che raggiunge tale controparte, quando il passaggio ne ha trovato uno. at: type: string format: date-time TravelRuleNextAction: type: object description: >- Un elemento che consente di far progredire un trasferimento bloccato nello stato `COUNTERPARTY_VASP_NOT_FOUND` o `COUNTERPARTY_VASP_NOT_REACHABLE`. Consulta [Perché un trasferimento è bloccato](/it/transaction-monitoring/travel-rule#perché-un-trasferimento-è-bloccato). properties: action: type: string enum: - select_counterparty_vasp - declare_self_hosted - add_vasp_hint - update_compliance_email - resend description: >- `select_counterparty_vasp`: l'utente finale seleziona il VASP di destinazione nel widget di titolarità del wallet, oppure invii una richiesta PATCH con `action=beneficiary_vasp`. `declare_self_hosted`: l'utente finale dichiara che il wallet è in autocustodia nel widget. `add_vasp_hint`: indica a Didit chi è la controparte specificando nome del VASP, LEI o Travel Address (ad esempio un `travel_address` nella voce della rubrica del wallet di destinazione), quindi invia nuovamente. `update_compliance_email` e `resend` sono valori di `action` per `PATCH /v3/transactions/{transaction_id}/travel-rule/`: fornisci nuovamente l'email di compliance della controparte ed esegui nuovamente l'instradamento. url: type: string format: uri description: >- Il link al widget di verifica della proprietà del wallet, su `select_counterparty_vasp` e `declare_self_hosted` mentre il trasferimento ha una sessione widget aperta. required: - action TravelRuleChainDetails: type: object description: >- In che modo la blockchain del trasferimento identifica i suoi due wallet, quando si tratta di più di un indirizzo che ne paga un altro. Vuoto (`{}`) per un trasferimento su blockchain basata su account (EVM, Solana, Tron), dove i due indirizzi corrispondono ai wallet. La corrispondenza, l'instradamento e la rubrica leggono innanzitutto i wallet da qui. properties: chain: type: string description: >- Rete blockchain canonica, ad es. `BTC`, `XRP` o `LIGHTNING` per un trasferimento Lightning. shape: type: string enum: - utxo - memo - lightning originator: $ref: '#/components/schemas/TravelRuleChainSide' beneficiary: $ref: '#/components/schemas/TravelRuleChainSide' utxo: type: object description: >- Su un trasferimento UTXO: gli input e gli output come memorizzati (importi come stringhe decimali) e quali output Didit ha interpretato come cosa. properties: inputs: type: array items: $ref: '#/components/schemas/TravelRuleUtxoEntry' outputs: type: array items: $ref: '#/components/schemas/TravelRuleUtxoEntry' change_output_indexes: type: array items: type: integer description: Output che rimborsano un indirizzo di input. beneficiary_output_index: type: integer nullable: true description: >- L'output che paga il beneficiario; null quando non è stato possibile distinguerne alcuno. lightning: type: object description: >- Su un trasferimento Lightning: ciò che indica la richiesta di pagamento. Sempre `kind` (`bolt11`, `bolt12_offer`, `bolt12_invoice`, `bolt12_invoice_request`, `lnurl`, `lightning_address`, `node_id` o `unknown`); una fattura BOLT11 aggiunge `network`, `payee_node_id`, `payment_hash`, `amount_msat`, `created_at` e `expires_at`; una stringa BOLT12 `blinded_paths` e `payee_node_id`; un LNURL o un Lightning Address il suo `domain`. Nulla viene risolto sulla rete: la richiesta viene solo decodificata. additionalProperties: true warnings: type: array items: type: string enum: - declared_originator_not_an_input - declared_beneficiary_not_an_output - beneficiary_output_ambiguous - beneficiary_output_amount_differs description: >- Incongruenze UTXO da esaminare: l'ordinante dichiarato non è un input, il beneficiario dichiarato non è un output, non è stato possibile distinguere un singolo output del beneficiario, oppure l'output del beneficiario corrisponde a un importo diverso rispetto a quello indicato nella transazione. not_applicable_reason: type: string enum: - LIGHTNING_NO_PAYEE_IDENTIFIER - LIGHTNING_BOLT12_BLINDED_PAYEE - LIGHTNING_LNURL_NAMES_NO_PAYEE description: >- Su un trasferimento Lightning in uscita la cui richiesta di pagamento non indica alcun beneficiario: perché il trasferimento è `NOT_APPLICABLE`. `LIGHTNING_NO_PAYEE_IDENTIFIER` (la richiesta non indica alcun nodo beneficiario o non è stato possibile decodificarla), `LIGHTNING_BOLT12_BLINDED_PAYEE` (l'offerta nasconde il proprio beneficiario dietro percorsi ciechi), `LIGHTNING_LNURL_NAMES_NO_PAYEE` (un LNURL indica un servizio, non un beneficiario). Lo stesso codice apre l'ultima voce `timeline` del trasferimento. TravelRuleChainSide: type: object description: >- Il wallet di una delle parti, così come Didit lo ha risolto a partire dai dati della blockchain. properties: address: type: string description: >- Il wallet. Su una rete con memo l'indirizzo classico (un X-address XRP viene suddiviso nel relativo indirizzo classico e tag); su Lightning l'ID del nodo del beneficiario o il Lightning Address. memo: type: string description: Il destination tag o memo che fa parte del wallet; `""` se assente. source: type: string enum: - declared - x_address - largest_input - only_non_change_output - amount_match - invoice_payee - updated description: >- Origine del wallet: `declared` (la tua richiesta), `x_address` (estratto da un X-address XRP), `largest_input` (l'indirizzo di input UTXO che ha contribuito maggiormente), `only_non_change_output` (l'unico output UTXO non di resto), `amount_match` (l'unico output UTXO che paga l'importo del trasferimento), `invoice_payee` (il beneficiario indicato in una richiesta di pagamento Lightning), `updated` (impostato successivamente con `action: update_originator_wallet`). 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.