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

# Créer ou envoyer un lien Travel Rule pour l'utilisateur final

> Créez un lien Travel Rule pour l'utilisateur final ou envoyez-le à l'adresse enregistrée avec Didit : expiration, révocation et livraison.

L'API de lien Travel Rule destinée à l'utilisateur final de Didit émet un lien permettant à l'utilisateur de finaliser le choix de son portefeuille ou de sa contrepartie, et peut l'envoyer à l'adresse e-mail enregistrée.

Envoyez `{"channel": "link"}` pour copier un lien, ou `{"channel": "email"}` pour tenter aussi l'envoi par e-mail. Si `channel` est omis, la valeur par défaut est `link`. L'e-mail utilise l'adresse enregistrée de l'utilisateur final dans Didit et la langue de sa session de vérification lorsqu'elle est disponible. Vous ne pouvez pas indiquer un destinataire arbitraire.

L'API exige un accès en écriture aux transactions ainsi qu'un transfert sortant dans l'état `AWAITING_COUNTERPARTY`, `COUNTERPARTY_VASP_NOT_FOUND`, `COUNTERPARTY_VASP_NOT_REACHABLE`, `UNCONFIRMED_OWNERSHIP` ou `ON_HOLD`. Dans les autres états, elle renvoie `409`. Si la transaction est inconnue ou si le transfert est absent, elle renvoie `404`.

La réponse contient `end_user_link`, `expires_at`, `emailed_to` et `email_available`. Un nouveau lien révoque les liens utilisateur final ouverts précédemment pour ce transfert. Ne le partagez qu'avec l'utilisateur final concerné.

Lorsqu'aucune adresse e-mail enregistrée n'existe, `channel: email` renvoie `409` avec `code: end_user_email_missing` ;  demandez plutôt `channel: link`. Si l'envoi échoue, l'API renvoie tout de même un lien utilisable, avec un `emailed_to` vide. `email_available` indique qu'une adresse existe, et non que la livraison a réussi.

Pour le choix explicite de l'utilisateur lors de la création, consultez [Créer une transaction](https://docs.didit.me/fr/management-api/transactions/create.md) et le [guide Travel Rule](https://docs.didit.me/fr/transaction-monitoring/travel-rule.md#découverte-de-la-contrepartie). Pour les actions sur un transfert, consultez [Mettre à jour un transfert](https://docs.didit.me/fr/management-api/travel-rule/update-transfer.md).


## OpenAPI

````yaml fr/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 de vérification d'identité. Authentifiez-vous avec l'en-tête 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: >-
        Créer ou envoyer par e-mail un lien Travel Rule destiné à l'utilisateur
        final
      description: >-
        Émettez un nouveau lien et révoquez les liens ouverts précédents pour ce
        transfert. Nécessite un accès en écriture aux transactions et un
        transfert sortant dans l'état AWAITING_COUNTERPARTY,
        COUNTERPARTY_VASP_NOT_FOUND, COUNTERPARTY_VASP_NOT_REACHABLE,
        UNCONFIRMED_OWNERSHIP ou ON_HOLD. channel=email utilise l'e-mail de
        l'utilisateur final enregistré dans Didit et la langue de la session de
        vérification, lorsqu'ils sont disponibles. En cas d'échec de l'envoi, le
        lien est renvoyé avec emailed_to vide ; email_available indique si
        l'adresse est disponible, et non si l'envoi a abouti. Voir [Liens
        utilisateur](/fr/management-api/travel-rule/create-user-link).
      operationId: createTravelRuleUserLink
      parameters:
        - name: transaction_id
          in: path
          required: true
          description: >-
            UUID de transaction stable attribué par Didit propriétaire du
            transfert.
          schema:
            type: string
            format: uuid
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TravelRuleUserLinkRequest'
            example:
              channel: link
      responses:
        '200':
          description: Réponse réussie.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleUserLinkResponse'
        '400':
          description: Champs de requête invalides.
        '403':
          description: Autorisation manquante pour écrire des transactions.
        '404':
          description: Transaction inconnue ou aucun transfert Travel Rule.
        '409':
          description: >-
            La direction ou le statut du transfert ne permet pas la création
            d'un lien, ou channel=email n'a pas d'adresse d'utilisateur final.
            Dans ce dernier cas, code=end_user_email_missing ; réessayez avec
            channel=link.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Explication du conflit.
                  code:
                    type: string
                    description: Présent lorsque l'e-mail est indisponible.
                    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 renvoie un nouveau lien ; email tente aussi de l'envoyer à
            l'adresse e-mail de la fiche Didit de l'utilisateur final.
          enum:
            - link
            - email
          default: link
    TravelRuleUserLinkResponse:
      type: object
      properties:
        end_user_link:
          type: string
          description: >-
            Nouveau lien pour l'utilisateur final. Les liens ouverts
            précédemment pour ce transfert sont révoqués.
          format: uri
        expires_at:
          type: string
          description: Date d'expiration du lien.
          format: date-time
        emailed_to:
          type: string
          description: >-
            Destinataire lorsque l'envoi a réussi, sinon une chaîne vide. Un
            échec d'envoi renvoie tout de même un lien utilisable.
        email_available:
          type: boolean
          description: >-
            Indique si l'utilisateur final a une adresse e-mail dans son
            enregistrement Didit.
      required:
        - end_user_link
        - expires_at
        - emailed_to
        - email_available
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.

````

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