> ## 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: Travel Rule एड्रेस बुक

> Didit की वॉलेट एड्रेस बुक एंट्री सूची, जिनसे आने वाले INTERNAL-rail Travel Rule ट्रांसफ़र मिलान करते हैं, स्वामित्व सत्यापन स्थिति के साथ।

वॉलेट पतों की सूची बनाने का API प्रॉम्प्ट
प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें

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

यहाँ पेस्ट करें


## OpenAPI

````yaml hi/openapi-25.json GET /v3/travel-rule/wallet-addresses/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: पहचान सत्यापन API। x-api-key हेडर के साथ प्रमाणीकृत करें।
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-addresses/:
    get:
      tags:
        - Travel Rule
      summary: वॉलेट पता पुस्तिका प्रविष्टियाँ सूचीबद्ध करें
      description: >-
        आपके एप्लिकेशन की Travel Rule वॉलेट पता पुस्तिका की पेजिनेटेड सूची,
        नवीनतम पहले।
      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: पेजिनेटेड वॉलेट पता पुस्तिका प्रविष्टियां।
          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: >-
            वॉलेट पता; केवल इसके हैश द्वारा इंपोर्ट की गई प्रविष्टि के लिए `""`।
            यह प्रत्येक एप्लिकेशन, चेन और मेमो के लिए अद्वितीय है और केस की
            परवाह किए बिना पते की तुलना करता है। किसी प्रविष्टि को हटाने के बाद,
            आप उसी पते को फिर से पंजीकृत कर सकते हैं।
        chain:
          type: string
          description: >-
            पते के लिए चेन token, उदाहरण के लिए `ETH` या `BTC`। जब Didit किसी
            ट्रांसफ़र को रूट या पंजीकृत करता है, तो यह वॉलेट पते पर और, जब
            ट्रांसफ़र में चेन शामिल होती है, तो केस को नज़रअंदाज़ करते हुए इस
            मान पर भी एड्रेस बुक प्रविष्टियों का मिलान करता है। ट्रांसफ़र की चेन
            `beneficiary_data.chain` होती है, जिसे लेन-देन की क्रिप्टो चेन या
            मुद्रा प्रतीक (उदाहरण के लिए `ETH`) से भरा जाता है जब आप इसे नहीं
            भेजते हैं, या डिपॉज़िट के बाद पंजीकरण की `chain` होती है, इसलिए हर
            जगह एक ही token का उपयोग करें। खाली चेन वाली प्रविष्टि किसी भी चेन
            से मेल खाती है। bitcoin पर पंजीकृत एक Lightning भुगतानकर्ता (नोड id
            या Lightning Address) को `LIGHTNING` पर लोअरकेस में संग्रहीत किया
            जाता है, जहां Lightning ट्रांसफ़र का मिलान किया जाता है। ज्ञात चेन
            एक कैनोनिकल पहचानकर्ता के तहत संग्रहीत की जाती हैं, चाहे आप कोई भी
            वर्तनी भेजें: "ethereum", "Ethereum" और "ERC20" सभी ETH के रूप में
            संग्रहीत होते हैं, "BNB Smart Chain" और "BEP20" BNB के रूप में,
            "tron" TRX के रूप में। एक अज्ञात चेन नाम दिए गए रूप में ही रखा जाता
            है।
        holder_vendor_data:
          type: string
          description: धारक के लिए आपका आंतरिक पहचानकर्ता।
        holder_name:
          type: string
          description: >-
            वॉलेट धारक का नाम, जिसका उपयोग लाभार्थी नाम मिलान के लिए किया जाता
            है।
        entity_type:
          type: string
          description: फ़्री टेक्स्ट, डिफ़ॉल्ट रूप से "individual"।
        is_ownership_verified:
          type: boolean
          description: केवल-पढ़ने योग्य। क्या इस पते का स्वामित्व सिद्ध हो चुका है।
        created_at:
          type: string
          format: date-time
        travel_address:
          type: string
          description: >-
            इस वॉलेट के लिए प्रतिपक्ष VASP का Travel Address, यदि ज्ञात हो।
            Didit को इस लाभार्थी के ट्रांसफ़र TRP द्वारा समर्थित संपत्तियों
            (BTC, ETH, और किसी नामित नेटवर्क पर USDC) के लिए TRP रेल पर रूट करने
            की अनुमति देता है।
        address_hash:
          type: string
          description: >-
            केवल-पढ़ने योग्य। लोअरकेस पते का SHA-256, लोअरकेस हेक्स में। केवल
            इसके हैश द्वारा इंपोर्ट की गई प्रविष्टि का मिलान इसी से किया जाता
            है।
        memo:
          type: string
          description: >-
            मेमो नेटवर्क (XRP, XLM, EOS, ATOM, HBAR) पर वॉलेट का हिस्सा बनने
            वाला डेस्टिनेशन टैग या मेमो; पूरे पते के लिए `""`। मेमो वाली
            प्रविष्टि केवल उस मेमो को निर्दिष्ट करने वाले ट्रांसफ़र से मेल खाती
            है; बिना मेमो वाली प्रविष्टि पूरे पते से मेल खाती है।
        receiving_travel_address:
          type: string
          readOnly: true
          description: >-
            इस वॉलेट के लिए आपका प्रति-वॉलेट Travel Address: इसे भेजने वाले VASP
            को दें ताकि उसकी TRP पूछताछ इस वॉलेट का नाम निर्दिष्ट करे। किसी अन्य
            VASP के रूप में रिकॉर्ड किए गए वॉलेट के लिए, जब Travel Rule बंद हो,
            और आपकी VASP प्रोफ़ाइल सहेजे जाने से पहले यह खाली रहता है।
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        आपकी एप्लिकेशन की API कुंजी, Business Console में Developers -> API keys
        से। प्राथमिक कुंजी के पास पूर्ण एक्सेस होता है। एक नामित कुंजी को स्कोप
        किया जा सकता है: प्रति संसाधन none, read या write, कुछ वर्कफ़्लो या
        स्वीकृत सत्रों तक सीमित, IP पतों की सूची तक सीमित, और समाप्ति तिथि तक
        सीमित। 401 का अर्थ है कि कुंजी गलत है, निरस्त कर दी गई है या उसकी
        समय-सीमा समाप्त हो गई है; 403 का अर्थ है कि कोई कुंजी नहीं भेजी गई थी,
        कुंजी के पास इस संसाधन या कार्रवाई का एक्सेस नहीं है, या अनुरोध उसकी IP
        सूची से बाहर के पते से आया था; सत्र रूट पर 404 का अर्थ है कि सत्र कुंजी
        के वर्कफ़्लो या स्थितियों से बाहर है। मीडिया एक्सेस के बिना एक कुंजी को
        छवि, वीडियो और PDF URL null के रूप में प्राप्त होते हैं, और सत्र write
        के बिना एक कुंजी को सत्र लिंक और token null के रूप में प्राप्त होते हैं।
        देखें https://docs.didit.me/console/api-keys।

````

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