> ## 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 listar endereços de carteira: Travel Rule

> Liste no Didit os endereços de carteira que identificam transferências Travel Rule recebidas via INTERNAL, com status de verificação de propriedade.

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

<pre>
  \`List the application's Travel Rule wallet address book - the registry of wallets you control that inbound INTERNAL-rail transfers resolve against.

  Endpoint:
  GET [https://verification.didit.me/v3/travel-rule/wallet-addresses/](https://verification.didit.me/v3/travel-rule/wallet-addresses/)

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

  Query parameters:

  * limit / offset - pagination; count/next/previous describe the page window.

  What to read from each entry:

  * uuid - the entry id, used in PATCH/DELETE /v3/travel-rule/wallet-addresses/{entry_uuid}/.
  * address, chain - the registered wallet.
    When a transfer names a chain, sunrise registration, the INTERNAL rail and the outbound TRP travel-address lookup match an entry only when its chain equals the transfer's chain (case-insensitive) or the entry's chain is blank.
    Chain names are not translated, so an entry with chain "ethereum" does not match a transfer with chain "ETH".
    Inbound TRP inquiries and ownership confirmation ignore the chain and match by address (an inbound TRP inquiry that carries no address matches a verified entry by holder\_name instead).
  * holder\_name / holder\_vendor\_data / entity\_type - the wallet holder, used for the beneficiary name match.
  * travel\_address - the counterparty VASP's travel address for this wallet, when known; it lets outbound transfers of an asset TRP carries (BTC, ETH, and USDC on a named network) to this wallet route over TRP.
  * is\_ownership\_verified - whether control of this address has been proven (wallet-ownership widget or self-declaration). Verified entries let inbound transfers skip UNCONFIRMED\_OWNERSHIP.

  Full guide: /transaction-monitoring/travel-rule#wallet-address-book.\`
</pre>

Colar em


## OpenAPI

````yaml pt-br/openapi-25.json GET /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/:
    get:
      tags:
        - Travel Rule
      summary: Listar entradas do catálogo de endereços de carteiras
      description: >-
        Lista paginada do catálogo de endereços de carteiras da Travel Rule da
        sua aplicação, dos mais recentes para os mais antigos.
      operationId: listTravelRuleWalletAddresses
      parameters:
        - name: limit
          in: query
          schema:
            type: integer
            default: 50
            minimum: 1
        - name: offset
          in: query
          schema:
            type: integer
            default: 0
            minimum: 0
      responses:
        '200':
          description: Entradas paginadas do catálogo de endereços de carteiras.
          content:
            application/json:
              schema:
                type: object
                properties:
                  count:
                    type: integer
                  next:
                    type: string
                    nullable: true
                  previous:
                    type: string
                    nullable: true
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/WalletAddressEntry'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            https://verification.didit.me/v3/travel-rule/wallet-addresses/ \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            for item in client.travel_rule.wallet_addresses.list():
                print(item)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            for await (const item of didit.travelRule.walletAddresses.list()) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.TravelRule.WalletAddresses.ListAutoPaging(ctx, didit.TravelRuleWalletAddressesListParams{})\nfor iter.Next() {\n\tfmt.Printf(\"%+v\\n\", iter.Current())\n}\nif err := iter.Err(); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            for (var item : client.travelRule().walletAddresses().list()) {
                System.out.println(item);
            }
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            foreach ($didit->travelRule->walletAddresses->list() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            didit.travel_rule.wallet_addresses.list.auto_paging_each do |item|
              puts item.to_h
            end
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            await foreach (var item in await
            client.TravelRule.WalletAddresses.ListAsync())

            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    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.