> ## 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.

# Link Travel Rule per l'utente finale: creazione e invio via email

> Con Didit crea un link Travel Rule per l'utente finale o invialo all'indirizzo email registrato, con scadenza, revoca ed esito della consegna.

L'API dei link per l'utente finale della Travel Rule di Didit emette un link che consente all'utente di completare la scelta del wallet o della controparte e può inviarlo via email all'indirizzo registrato.

Invia `{"channel": "link"}` per copiare un link, oppure `{"channel": "email"}` per copiarlo e tentare anche l'invio via email. Se ometti `channel`, il valore predefinito è `link`. L'email usa l'indirizzo dell'utente finale registrato in Didit e, quando disponibile, la lingua della sua sessione di verifica. Non puoi indicare un destinatario arbitrario.

L'API richiede l'accesso in scrittura alle transazioni e un trasferimento in uscita in stato `AWAITING_COUNTERPARTY`, `COUNTERPARTY_VASP_NOT_FOUND`, `COUNTERPARTY_VASP_NOT_REACHABLE`, `UNCONFIRMED_OWNERSHIP` o `ON_HOLD`. Negli altri stati la risposta è `409`; una transazione sconosciuta o un trasferimento mancante restituisce `404`.

La risposta contiene `end_user_link`, `expires_at`, `emailed_to` e `email_available`. Un nuovo link revoca i link precedenti per l'utente finale ancora aperti per quel trasferimento. Condividilo solo con l'utente finale previsto.

Se non esiste un'email registrata, `channel: email` restituisce `409` con `code: end_user_email_missing`; usa invece `channel: link`. Se l'invio fallisce, l'API restituisce comunque un link utilizzabile con `emailed_to` vuoto. `email_available` indica che esiste un indirizzo, non che l'invio sia riuscito.

Per la scelta esplicita dell'utente durante la creazione, consulta [Crea una transazione](https://docs.didit.me/it/management-api/transactions/create.md) e la [guida alla Travel Rule](https://docs.didit.me/it/transaction-monitoring/travel-rule.md#individuazione-della-controparte). Per le azioni sul trasferimento, consulta [Aggiorna un trasferimento](https://docs.didit.me/it/management-api/travel-rule/update-transfer.md).


## OpenAPI

````yaml it/openapi-25.json POST /v3/transactions/{transaction_id}/travel-rule/user-link/
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/{transaction_id}/travel-rule/user-link/:
    post:
      tags:
        - Travel Rule
      summary: Crea o invia via email un link per l'utente finale della Travel Rule
      description: >-
        Emette un nuovo link e revoca i link aperti precedenti per questo
        trasferimento. Richiede l'accesso in scrittura alle transazioni e un
        trasferimento in uscita in stato AWAITING_COUNTERPARTY,
        COUNTERPARTY_VASP_NOT_FOUND, COUNTERPARTY_VASP_NOT_REACHABLE,
        UNCONFIRMED_OWNERSHIP o ON_HOLD. channel=email usa l'indirizzo email del
        record Didit dell'utente finale e la lingua della sessione di verifica,
        quando disponibili. Un errore di invio restituisce il link con
        emailed_to vuoto; email_available indica la disponibilità
        dell'indirizzo, non la consegna. Vedi [Link
        utente](/it/management-api/travel-rule/create-user-link).
      operationId: createTravelRuleUserLink
      parameters:
        - name: transaction_id
          in: path
          required: true
          description: >-
            UUID della transazione stabile di Didit a cui appartiene il
            trasferimento.
          schema:
            type: string
            format: uuid
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TravelRuleUserLinkRequest'
            example:
              channel: link
      responses:
        '200':
          description: Risposta riuscita.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleUserLinkResponse'
        '400':
          description: Campi della richiesta non validi.
        '403':
          description: Autorizzazione mancante per scrivere transazioni.
        '404':
          description: Transazione sconosciuta o nessun trasferimento Travel Rule.
        '409':
          description: >-
            La direzione o lo stato del trasferimento non consente un link,
            oppure channel=email non ha un indirizzo dell'utente finale. Nel
            secondo caso, code=end_user_email_missing; riprova con channel=link.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Spiegazione del conflitto.
                  code:
                    type: string
                    description: Presente quando l'email non è disponibile.
                    enum:
                      - end_user_email_missing
                required:
                  - detail
              example:
                detail: >-
                  This end user has no email on their Didit record. Copy the
                  link instead.
                code: end_user_email_missing
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/transactions/{transaction_id}/travel-rule/user-link/'
            \
              -H 'x-api-key: YOUR_API_KEY' -H 'Content-Type: application/json' \
              -d '{"channel": "link"}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.transactions.travel_rule.create_user_link(
                "11111111-2222-3333-4444-555555555555",
                channel="link",
            )
            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.travelRule.createUserLink("11111111-2222-3333-4444-555555555555",
            {
              channel: "link",
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.TravelRule.CreateUserLink(ctx, \"11111111-2222-3333-4444-555555555555\", didit.TravelRuleUserLinkRequest{\n\tChannel: didit.Some(didit.TravelRuleUserLinkRequestChannel(\"link\")),\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.TravelRuleUserLinkRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.transactions().travelRule().createUserLink("11111111-2222-3333-4444-555555555555",
            TravelRuleUserLinkRequest.builder()
                    .channel(TravelRuleUserLinkRequest.Channel.of("link"))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $result =
            $didit->transactions->travelRule->createUserLink('11111111-2222-3333-4444-555555555555',
            [
                'channel' => 'link',
            ]);

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.transactions.travel_rule.create_user_link(
              "11111111-2222-3333-4444-555555555555",
              channel: "link"
            )
            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.TravelRule.CreateUserLinkAsync("11111111-2222-3333-4444-555555555555",
            new TravelRuleUserLinkRequest

            {
                Channel = new TravelRuleUserLinkRequestChannel("link"),
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TravelRuleUserLinkRequest:
      type: object
      properties:
        channel:
          type: string
          description: >-
            link restituisce un nuovo link; email tenta anche di inviarlo
            all'indirizzo email del record Didit dell'utente finale.
          enum:
            - link
            - email
          default: link
    TravelRuleUserLinkResponse:
      type: object
      properties:
        end_user_link:
          type: string
          description: >-
            Nuovo link per l'utente finale. I link aperti precedenti per questo
            trasferimento vengono revocati.
          format: uri
        expires_at:
          type: string
          description: Scadenza del link.
          format: date-time
        emailed_to:
          type: string
          description: >-
            Destinatario quando l'invio è riuscito, altrimenti una stringa
            vuota. Un errore nell'invio dell'email restituisce comunque un link
            utilizzabile.
        email_available:
          type: boolean
          description: Se l'utente finale ha un'email nel proprio record Didit.
      required:
        - end_user_link
        - expires_at
        - emailed_to
        - email_available
  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.