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

# Registrar adreça de cartera: API llibreta Travel Rule

> Registra una cartera pròpia a la llibreta de Travel Rule de Didit perquè les transferències internes hi arribin, opcionalment pre-verificada.



Prompt de l'API per registrar una adreça de cartera
        Copia el prompt al porta-retalls



      
      

\<pre>

\`Register a wallet address in the application's Travel Rule address book so inbound INTERNAL-rail transfers can resolve against it.

Endpoint:
POST https://verification.didit.me/v3/travel-rule/wallet-addresses/

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

Request body (application/json):
\{
"address": "0x8ba1f109551bD432803012645Ac136ddd64DBA72",   // required; one entry per address (case-insensitive) and chain (exact text) in the application, a duplicate returns 400
"chain": "ETH",                        // optional; use the same chain token your transfers carry (ETH, BTC), or leave blank to match any chain
"memo": "",                            // optional destination tag or memo on XRP, XLM, EOS, ATOM, HBAR (alias: destinationTag); part of the wallet's identity there
"holder_name": "Ana Diaz",             // used for the beneficiary name match
"holder_vendor_data": "user-042",      // your internal id for the holder
"entity_type": "individual",           // free text, defaults to "individual"
"travel_address": "taiwwrTeRpaRbqpQXB9A1JiLtdE686XtYRC316kPuQzbJSTgv7ndnF4ceHM7CReVGuzqcCCu5RfUHdL1FffHhdf3dzQDEgKAUMtAuD6uteY",   // optional: the counterparty VASP's travel address for this wallet, so outbound BTC, ETH and USDC transfers to it can route over TRP
"self_declared": true                  // write-only, POST only: create the entry already verified via a SELF_DECLARATION proof
}

Behavior:
\- self_declared: true creates the entry already ownership-verified - inbound transfers to it skip UNCONFIRMED_OWNERSHIP entirely and go straight to the name match.
It requires allow_self_declaration: true in Travel Rule settings, otherwise 400.
\- Without it, verify ownership later via the wallet-ownership widget (POST /v3/travel-rule/widget-session/).
\- Matching is scoped by chain.
When a transfer carries a chain, an entry matches only if its chain equals that chain (case-insensitive) or the entry's chain is blank.
Chain names are not translated: an entry with chain "ethereum" does not match a transfer with chain "ETH".
A transfer takes its chain from beneficiary_data.chain, else transaction_details.crypto_params.crypto_chain, else custom_properties.crypto_chain, else the currency, uppercased and used only when it is a chain Didit recognises (for example ETH or BTC).
Register entries with the same token your transfers carry (ETH, BTC), or leave chain blank to match any chain.
Inbound TRP inquiries ignore the chain: they match by address, or by the holder_name of a verified entry when the inquiry carries no address.
Confirming ownership with POST /v3/transactions/{transaction_id}/travel-rule/ownership/ also matches by address only.
\- On a memo network the memo is part of the wallet: an entry with a memo matches only transfers naming that memo, an entry without one matches the whole address. A transfer that names no memo never reaches an entry that has one.
\- An XRP X-address is stored as its classic address and its tag. A Lightning payee (node id or Lightning Address) registered on bitcoin is stored lowercased on the LIGHTNING chain, where Lightning transfers are matched.
\- The response carries address_hash (SHA-256 of the lowercased address, hex). To register many wallets at once, or by hash only, use POST /v3/travel-rule/wallet-addresses/import/.

Failure modes:
\- 400 - an entry with this address, chain and memo already exists: {"address": ["A wallet address entry with this address and chain already exists."]}.
\- 400 - a memo or X-address the chain cannot carry, missing address, an invalid travel_address ("Invalid travel address."), or self_declared: true while allow_self_declaration is off.
\- 403 - missing x-api-key (a wrong, revoked or expired key gets 401).

Full guide: /transaction-monitoring/travel-rule#wallet-address-book.`

\</pre>



      
      

Enganxa a



## OpenAPI

````yaml ca/openapi-25.json POST /v3/travel-rule/wallet-addresses/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de verificació d'identitat. Autentica't amb la capçalera x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-addresses/:
    post:
      tags:
        - Travel Rule
      summary: Registra una adreça de cartera
      description: >-
        Afegeix una entrada a la llibreta d'adreces de carteres de la Travel
        Rule perquè les transferències entrants per la via INTERNAL s'hi puguin
        associar.
      operationId: createTravelRuleWalletAddress
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/WalletAddressEntryCreate'
            example:
              address: 0xBeneficiaryWallet01
              chain: ETH
              holder_name: Ana Diaz
              holder_vendor_data: user-042
              self_declared: true
      responses:
        '201':
          description: L'entrada creada.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WalletAddressEntry'
        '400':
          description: >-
            Cartera duplicada (adreça, cadena i memo) per a aquesta aplicació,
            un memo o adreça X que la cadena no pot admetre, una `address`
            absent, una `travel_address` no vàlida, `self_declared: true` mentre
            `allow_self_declaration` està desactivat, o `self_declared: true`
            mentre `ownership_validation_mode` és `FULL`.
          content:
            application/json:
              schema:
                type: object
              examples:
                Duplicate entry:
                  value:
                    address:
                      - >-
                        A wallet address entry with this address and chain
                        already exists.
                Invalid travel address:
                  value:
                    travel_address:
                      - Invalid travel address.
                Self-declaration disabled:
                  value:
                    self_declared:
                      - >-
                        Self-declared ownership is disabled for this
                        application.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            https://verification.didit.me/v3/travel-rule/wallet-addresses/ \
              -H 'x-api-key: YOUR_API_KEY' -H 'Content-Type: application/json' \
              -d '{"address": "0xBeneficiaryWallet01", "chain": "ETH", "holder_name": "Ana Diaz", "self_declared": true}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.travel_rule.wallet_addresses.create(
                address="0xBeneficiaryWallet01",
                chain="ETH",
                holder_vendor_data="user-042",
                holder_name="Ana Diaz",
                self_declared=True,
            )
            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.travelRule.walletAddresses.create({
              address: "0xBeneficiaryWallet01",
              chain: "ETH",
              holder_vendor_data: "user-042",
              holder_name: "Ana Diaz",
              self_declared: true,
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.TravelRule.WalletAddresses.Create(ctx, didit.WalletAddressEntryCreate{\n\tAddress:          \"0xBeneficiaryWallet01\",\n\tChain:            didit.String(\"ETH\"),\n\tHolderVendorData: didit.String(\"user-042\"),\n\tHolderName:       didit.String(\"Ana Diaz\"),\n\tSelfDeclared:     didit.Bool(true),\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.WalletAddressEntryCreate;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.travelRule().walletAddresses().create(WalletAddressEntryCreate.builder()
                    .address("0xBeneficiaryWallet01")
                    .chain("ETH")
                    .holderVendorData("user-042")
                    .holderName("Ana Diaz")
                    .selfDeclared(true)
                    .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->travelRule->walletAddresses->create([
                'address' => '0xBeneficiaryWallet01',
                'chain' => 'ETH',
                'holder_vendor_data' => 'user-042',
                'holder_name' => 'Ana Diaz',
                'self_declared' => true,
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.travel_rule.wallet_addresses.create(
              address: "0xBeneficiaryWallet01",
              chain: "ETH",
              holder_vendor_data: "user-042",
              holder_name: "Ana Diaz",
              self_declared: true
            )
            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.TravelRule.WalletAddresses.CreateAsync(new
            WalletAddressEntryCreate

            {
                Address = "0xBeneficiaryWallet01",
                Chain = "ETH",
                HolderVendorData = "user-042",
                HolderName = "Ana Diaz",
                SelfDeclared = true,
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    WalletAddressEntryCreate:
      type: object
      required:
        - address
      properties:
        address:
          type: string
          maxLength: 128
          description: >-
            L'adreça de la cartera. Una X-address de XRP s'emmagatzema com la
            seva adreça clàssica i la seva etiqueta, de manera que coincideix
            amb les transferències que mencionin qualsevol de les dues formes.
        chain:
          type: string
          maxLength: 32
          description: >-
            Token de la blockchain per a l'adreça, per exemple `ETH` o `BTC`.
            Quan Didit enruta o registra una transferència, fa coincidir les
            entrades de la llibreta d'adreces amb l'adreça de la cartera i, si
            la transferència inclou una blockchain, també amb aquest valor,
            sense distingir majúscules de minúscules. La blockchain d'una
            transferència és `beneficiary_data.chain`, emplenada a partir de la
            blockchain de criptomonedes o el símbol de la moneda de la
            transacció (per exemple `ETH`) si no l'envies, o el `chain` d'un
            registre posterior al dipòsit, per la qual cosa cal utilitzar el
            mateix token arreu. Una entrada amb una blockchain buida coincideix
            amb qualsevol blockchain. Les blockchains conegudes s'emmagatzemen
            sota un identificador canònic, independentment de com s'escriguin:
            "ethereum", "Ethereum" i "ERC20" s'emmagatzemen com a ETH, "BNB
            Smart Chain" i "BEP20" com a BNB, i "tron" com a TRX. Un nom de
            blockchain desconegut es manté tal com s'ha proporcionat.
        holder_vendor_data:
          type: string
          maxLength: 255
        holder_name:
          type: string
          maxLength: 255
        entity_type:
          type: string
          default: individual
          maxLength: 16
        self_declared:
          type: boolean
          default: false
          description: >-
            Només escriptura. Quan és cert, l'entrada es crea ja amb la
            titularitat verificada mitjançant una prova de tipus
            SELF_DECLARATION. Retorna 400 quan `allow_self_declaration` està
            desactivat a la teva configuració de Travel Rule.
        travel_address:
          type: string
          description: >-
            Opcional. La Travel Address del VASP de la contrapart per a aquesta
            cartera, que habilita l'encaminament TRP per als actius que
            transporta TRP (BTC, ETH i USDC en una xarxa designada). Una Travel
            Address no vàlida retorna 400.
          maxLength: 512
        memo:
          type: string
          maxLength: 256
          description: >-
            Opcional. L'etiqueta de destinació o memo que forma part de la
            cartera. XRP: una etiqueta de destinació, un nombre enter de 0 a
            4294967295 (s'accepta un nombre JSON). XLM: un memo de text de fins
            a 28 bytes, un id de 64 bits o un hash de 32 bytes en hexadecimal.
            EOS: fins a 256 bytes. ATOM: fins a 256 caràcters. HBAR: fins a 100
            bytes. Les carteres de Bitcoin, EVM, Solana, Tron, Litecoin, Bitcoin
            Cash, Dogecoin i Lightning no admeten memo: si se n'inclou un, es
            retorna un `400`. Àlies: `destinationTag` o `destination_tag`.
    WalletAddressEntry:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        address:
          type: string
          description: >-
            L'adreça de la cartera; `""` per a una entrada importada només pel
            seu resum criptogràfic. Única per aplicació, cadena i memo,
            comparant l'adreça sense distingir majúscules de minúscules. Després
            de suprimir una entrada, pots tornar a registrar la mateixa adreça.
        chain:
          type: string
          description: >-
            Token de cadena per a l'adreça, per exemple `ETH` o `BTC`. Quan
            Didit encamina o registra una transferència, fa coincidir les
            entrades de la llibreta d'adreces amb l'adreça de la cartera i, quan
            la transferència inclou una cadena, també amb aquest valor, ignorant
            majúscules i minúscules. La cadena d'una transferència és
            `beneficiary_data.chain`, que s'omple a partir de la cadena cripto
            de la transacció o del símbol de la moneda (per exemple, `ETH`) quan
            no l'envies, o del camp `chain` d'un registre posterior al dipòsit,
            de manera que has de fer servir el mateix token a tot arreu. Una
            entrada amb una cadena buida coincideix amb qualsevol cadena. Un
            beneficiari de Lightning (un id de node o una Lightning Address)
            registrat a bitcoin s'emmagatzema en minúscules a `LIGHTNING`, on es
            fan coincidir les transferències de Lightning. Les cadenes conegudes
            s'emmagatzemen sota un únic identificador canònic, independentment
            de com s'escriguin: "ethereum", "Ethereum" i "ERC20" s'emmagatzemen
            com a ETH; "BNB Smart Chain" i "BEP20" com a BNB; "tron" com a TRX.
            Els noms de cadena desconeguts es mantenen tal com s'han indicat.
        holder_vendor_data:
          type: string
          description: El teu identificador intern per al titular.
        holder_name:
          type: string
          description: >-
            Nom del titular de la cartera, utilitzat per a la coincidència del
            nom del beneficiari.
        entity_type:
          type: string
          description: Text lliure, per defecte "individual".
        is_ownership_verified:
          type: boolean
          description: >-
            Només de lectura. Indica si s'ha demostrat la titularitat d'aquesta
            adreça.
        created_at:
          type: string
          format: date-time
        travel_address:
          type: string
          description: >-
            La Travel Address del VASP contrapart per a aquesta cartera, si es
            coneix. Permet a Didit encaminar les transferències d'aquest
            beneficiari a través del canal TRP, per als actius que admet TRP
            (BTC, ETH i USDC en una xarxa designada).
        address_hash:
          type: string
          description: >-
            Només de lectura. SHA-256 de l'adreça en minúscules, en format
            hexadecimal en minúscules. Una entrada importada només pel seu hash
            s'hi emparella mitjançant aquest valor.
        memo:
          type: string
          description: >-
            L'etiqueta de destinació o nota que forma part de la cartera en una
            xarxa de notes (XRP, XLM, EOS, ATOM, HBAR); `""` per a tota
            l'adreça. Una entrada amb una nota només coincideix amb
            transferències que indiquin aquesta nota; una sense coincideix amb
            tota l'adreça.
        receiving_travel_address:
          type: string
          readOnly: true
          description: >-
            La teva Travel Address específica per a aquesta cartera:
            proporciona-la al VASP remitent perquè la seva consulta TRP designi
            aquesta cartera. Està buida per a una cartera registrada com a
            pertanyent a un altre VASP, mentre Travel Rule estigui desactivada i
            abans que es desi el teu perfil de VASP.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clau d'API de la teva aplicació, des de Developers -> API keys a la
        Business Console. La clau primària té accés complet. Una clau amb nom
        pot tenir l'abast limitat: cap, lectura o escriptura per recurs,
        limitada a determinats fluxos de treball o a sessions aprovades, a una
        llista d'adreces IP i a una data de caducitat. 401 significa que la clau
        és incorrecta, revocada o caducada; 403 significa que no s'ha enviat cap
        clau, que la clau no té accés a aquest recurs o acció, o que la
        sol·licitud prové d'una adreça fora de la seva llista d'IP; 404 en una
        ruta de sessió significa que la sessió està fora dels fluxos de treball
        o estats de la clau. Una clau sense accés a fitxers multimèdia rep els
        URL d'imatge, vídeo i PDF com a null, i una clau sense permís
        d'escriptura de sessions rep els enllaços de sessió i els tokens com a
        null. Consulta https://docs.didit.me/console/api-keys.

````

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