> ## 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 para registrar endereço de carteira: Travel Rule

> Registre na Didit uma carteira sua no catálogo de endereços da Travel Rule para receber transferências INTERNAL, com autodeclaração opcional.



Prompt da API de registro de endereço de carteira
        Copiar o prompt para a área de transferência



      
      

\<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>



      
      

Colar em



## OpenAPI

````yaml pt-br/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 verificação de identidade. Autentique-se com o cabeçalho x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-addresses/:
    post:
      tags:
        - Travel Rule
      summary: Registrar um endereço de carteira
      description: >-
        Adiciona uma entrada ao seu catálogo de endereços de carteiras da Travel
        Rule para que transferências recebidas pelo trilho INTERNAL possam ser
        resolvidas com base nele.
      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: A entrada criada.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WalletAddressEntry'
        '400':
          description: >-
            Carteira duplicada (endereço, blockchain e memo) para esta
            aplicação, um memo ou X-address que a blockchain não suporta,
            `address` ausente, `travel_address` inválido, `self_declared: true`
            com `allow_self_declaration` desativado, ou `self_declared: true`
            com `ownership_validation_mode` igual a `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: >-
            O endereço da carteira. Um X-address da XRP é armazenado como seu
            endereço clássico e sua tag, para que corresponda a transferências
            que indiquem qualquer uma das formas.
        chain:
          type: string
          maxLength: 32
          description: >-
            Token da rede (chain) do endereço, por exemplo `ETH` ou `BTC`.
            Quando a Didit roteia ou registra uma transferência, ela associa as
            entradas do catálogo de endereços pelo endereço da carteira e,
            quando a transferência informa uma rede, também por este valor, sem
            diferenciar maiúsculas de minúsculas. A rede de uma transferência é
            `beneficiary_data.chain`, preenchida a partir da rede cripto ou do
            símbolo da moeda da transação (por exemplo `ETH`) quando você não a
            envia, ou o `chain` de um registro pós-depósito; por isso, use o
            mesmo token em todos os lugares. Uma entrada com rede vazia
            corresponde a qualquer rede. Redes conhecidas são armazenadas com um
            único identificador canônico, seja qual for a grafia enviada:
            "ethereum", "Ethereum" e "ERC20" são todos armazenados como ETH,
            "BNB Smart Chain" e "BEP20" como BNB, "tron" como TRX. Um nome de
            rede desconhecido é mantido como foi informado.
        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: >-
            Somente escrita. Quando true, a entrada é criada já com a
            propriedade verificada por meio de uma prova SELF_DECLARATION.
            Retorna 400 quando `allow_self_declaration` está desativado nas suas
            configurações de Travel Rule.
        travel_address:
          type: string
          description: >-
            Opcional. O travel address do VASP da contraparte para esta
            carteira, que habilita o roteamento TRP para os ativos que o TRP
            transporta (BTC, ETH e USDC em uma rede nomeada). Um travel address
            inválido retorna 400.
          maxLength: 512
        memo:
          type: string
          maxLength: 256
          description: >-
            Opcional. A tag de destino ou o memo que faz parte da carteira. XRP:
            uma tag de destino, um número inteiro de 0 a 4294967295 (um número
            JSON é aceito). XLM: um memo de texto de até 28 bytes, um id de 64
            bits ou um hash de 32 bytes em hexadecimal. EOS: até 256 bytes.
            ATOM: até 256 caracteres. HBAR: até 100 bytes. Carteiras Bitcoin,
            EVM, Solana, Tron, Litecoin, Bitcoin Cash, Dogecoin e Lightning não
            aceitam memo: enviar um nelas resulta em `400`. Alias:
            `destinationTag` ou `destination_tag`.
    WalletAddressEntry:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        address:
          type: string
          description: >-
            O endereço da carteira; `""` para uma entrada importada apenas pelo
            hash. Único por aplicação, cadeia e memo, comparando o endereço sem
            diferenciar maiúsculas de minúsculas. Depois de excluir uma entrada,
            você pode registrar o mesmo endereço novamente.
        chain:
          type: string
          description: >-
            Token de blockchain do endereço, por exemplo, `ETH` ou `BTC`. Quando
            a Didit roteia ou registra uma transferência, ela faz a
            correspondência das entradas do catálogo de endereços pelo endereço
            da carteira e, quando a transferência informa uma blockchain, também
            por este valor, sem distinção entre maiúsculas e minúsculas. A
            blockchain de uma transferência é `beneficiary_data.chain`,
            preenchida a partir da blockchain cripto ou do símbolo da moeda da
            transação (por exemplo, `ETH`) quando você não a envia, ou o `chain`
            de um registro pós-depósito, portanto use o mesmo token em todos os
            lugares. Uma entrada com blockchain vazia corresponde a qualquer
            blockchain. Um beneficiário Lightning (um id de nó ou um Lightning
            Address) registrado em bitcoin é armazenado em minúsculas em
            `LIGHTNING`, onde as transferências Lightning são correspondidas.
            Blockchains conhecidas são armazenadas sob um único identificador
            canônico, independentemente da grafia enviada: "ethereum",
            "Ethereum" e "ERC20" são todos armazenados como ETH, "BNB Smart
            Chain" e "BEP20" como BNB, "tron" como TRX. Um nome de blockchain
            desconhecido é mantido como enviado.
        holder_vendor_data:
          type: string
          description: Seu identificador interno para o titular.
        holder_name:
          type: string
          description: >-
            Nome do titular da carteira, usado na correspondência do nome do
            beneficiário.
        entity_type:
          type: string
          description: Texto livre; o padrão é "individual".
        is_ownership_verified:
          type: boolean
          description: >-
            Somente leitura. Indica se a propriedade deste endereço foi
            comprovada.
        created_at:
          type: string
          format: date-time
        travel_address:
          type: string
          description: >-
            O endereço de viagem (travel address) do VASP da contraparte para
            esta carteira, se conhecido. Permite que a Didit encaminhe as
            transferências deste beneficiário pelo canal TRP, para os ativos que
            o TRP suporta (BTC, ETH e USDC em uma rede especificada).
        address_hash:
          type: string
          description: >-
            Somente leitura. SHA-256 do endereço em minúsculas, em hexadecimal
            minúsculo. Uma entrada importada apenas pelo hash é correspondida
            por ele.
        memo:
          type: string
          description: >-
            A destination tag ou o memo que faz parte da carteira em uma rede
            com memo (XRP, XLM, EOS, ATOM, HBAR); `""` para o endereço inteiro.
            Uma entrada com memo corresponde apenas a transferências que indicam
            esse memo; uma sem memo corresponde ao endereço inteiro.
        receiving_travel_address:
          type: string
          readOnly: true
          description: >-
            Seu travel address por carteira para esta carteira: informe-o ao
            VASP remetente para que a consulta TRP dele indique esta carteira.
            Vazio para uma carteira registrada como de outro VASP, enquanto a
            Travel Rule estiver desativada e antes de o perfil do seu VASP ser
            salvo.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Chave de API da sua aplicação, em Developers -> API keys no Business
        Console. A chave principal tem acesso total. Uma chave nomeada pode ter
        escopo restrito: nenhum acesso, leitura ou escrita por recurso, limitada
        a alguns fluxos ou a sessões aprovadas, a uma lista de endereços IP e a
        uma data de validade. 401 significa que a chave está errada, revogada ou
        expirada; 403 significa que nenhuma chave foi enviada, que a chave não
        tem acesso a este recurso ou ação, ou que a requisição veio de um
        endereço fora da sua lista de IPs; 404 em uma rota de sessão significa
        que a sessão está fora dos fluxos ou status da chave. Uma chave sem
        acesso a mídia recebe URLs de imagem, vídeo e PDF como null, e uma chave
        sem permissão de escrita em sessões recebe links e tokens de sessão como
        null. Consulte https://docs.didit.me/console/api-keys.

````

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