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

# Wallet-Adresse registrieren: Travel Rule Adressbuch API

> Eigene Wallet mit Didit im Travel-Rule-Adressbuch registrieren, damit INTERNAL-Transfers ihr zugeordnet werden; optional vorverifiziert.



Prompt für die API zur Registrierung einer Adresse
        Prompt in die Zwischenablage kopieren



      
      

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



      
      

Einfügen in



## OpenAPI

````yaml de/openapi-25.json POST /v3/travel-rule/wallet-addresses/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API für Ausweisverifizierung. Authentifizierung über den x-api-key-Header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-addresses/:
    post:
      tags:
        - Travel Rule
      summary: Wallet-Adresse registrieren
      description: >-
        Einen Eintrag zu Ihrem Travel-Rule-Wallet-Adressbuch hinzufügen, damit
        eingehende Transfers über die INTERNAL-Schiene damit abgeglichen werden
        können.
      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: Der erstellte Eintrag.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WalletAddressEntry'
        '400':
          description: >-
            Eine doppelte Wallet (Adresse, Chain und Memo) für diese Anwendung,
            ein Memo oder eine X-Adresse, die die Chain nicht übertragen kann,
            eine fehlende `address`, eine ungültige `travel_address`,
            `self_declared: true`, während `allow_self_declaration` deaktiviert
            ist, oder `self_declared: true`, während `ownership_validation_mode`
            auf `FULL` gesetzt ist.
          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: >-
            Die Adresse. Eine XRP-X-Adresse wird als klassische Adresse und Tag
            gespeichert, sodass sie Transfers zugeordnet werden kann, die eine
            der beiden Formen nennen.
        chain:
          type: string
          maxLength: 32
          description: >-
            Chain-Token für die Adresse, zum Beispiel `ETH` oder `BTC`. Wenn
            Didit einen Transfer routet oder registriert, gleicht es
            Adressbucheinträge anhand der Adresse und – sofern der Transfer eine
            Chain enthält – auch anhand dieses Werts ab (Groß-/Kleinschreibung
            wird ignoriert). Die Chain eines Transfers ist
            `beneficiary_data.chain`, ausgefüllt anhand der Krypto-Chain der
            Transaktion oder des Währungssymbols (zum Beispiel `ETH`), falls Sie
            dies nicht übermitteln, oder das `chain`-Feld einer Registrierung
            nach der Einzahlung. Verwenden Sie daher überall dasselbe Token. Ein
            Eintrag mit leerer Chain stimmt mit jeder Chain überein. Bekannte
            Chains werden unter einer kanonischen Kennung gespeichert,
            unabhängig von der übermittelten Schreibweise: "ethereum",
            "Ethereum" und "ERC20" werden alle als ETH gespeichert, "BNB Smart
            Chain" und "BEP20" als BNB, "tron" als TRX. Ein unbekannter
            Chain-Name wird wie angegeben beibehalten.
        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: >-
            Nur schreibbar. Wenn true, wird der Eintrag bereits über einen
            SELF_DECLARATION-Nachweis zur Eigentümerschaft verifiziert erstellt.
            Gibt 400 zurück, wenn `allow_self_declaration` in Ihren Travel
            Rule-Einstellungen deaktiviert ist.
        travel_address:
          type: string
          description: >-
            Optional. Die Travel Address des VASP der Gegenpartei für diese
            Wallet, die das TRP-Routing für die von TRP unterstützten Assets
            (BTC, ETH und USDC auf einem benannten Netzwerk) ermöglicht. Eine
            ungültige Travel Address gibt 400 zurück.
          maxLength: 512
        memo:
          type: string
          maxLength: 256
          description: >-
            Optional. Das Destination-Tag oder Memo, das Teil der Wallet ist.
            XRP: ein Destination-Tag, eine Ganzzahl von 0 bis 4294967295 (eine
            JSON-Zahl wird akzeptiert). XLM: ein Text-Memo von bis zu 28 Bytes,
            eine 64-Bit-ID oder ein 32-Byte-Hash in Hex. EOS: bis zu 256 Bytes.
            ATOM: bis zu 256 Zeichen. HBAR: bis zu 100 Bytes. Bitcoin-, EVM-,
            Solana-, Tron-, Litecoin-, Bitcoin Cash-, Dogecoin- und
            Lightning-Wallets unterstützen kein Memo: die Angabe eines Memos
            führt zu einem `400`. Alias: `destinationTag` oder
            `destination_tag`.
    WalletAddressEntry:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        address:
          type: string
          description: >-
            Die Adresse; `""` für einen Eintrag, der nur anhand seines Hashs
            importiert wurde. Eindeutig pro Anwendung, Netzwerk und Memo, wobei
            die Adresse ohne Berücksichtigung der Groß-/Kleinschreibung
            verglichen wird. Nachdem Sie einen Eintrag gelöscht haben, können
            Sie dieselbe Adresse erneut registrieren.
        chain:
          type: string
          description: >-
            Chain-Token für die Adresse, zum Beispiel `ETH` oder `BTC`. Wenn
            Didit einen Transfer weiterleitet oder registriert, gleicht es
            Adressbucheinträge anhand der Adresse ab und, wenn der Transfer eine
            Chain enthält, auch anhand dieses Werts, unabhängig von
            Groß-/Kleinschreibung. Die Chain eines Transfers ist
            `beneficiary_data.chain`, ausgefüllt aus der Krypto-Chain der
            Transaktion oder dem Währungssymbol (zum Beispiel `ETH`), wenn Sie
            sie nicht senden, oder die `chain` einer Registrierung nach der
            Einzahlung; verwenden Sie daher überall denselben Token. Ein Eintrag
            mit leerer Chain stimmt mit jeder Chain überein. Ein auf Bitcoin
            registrierter Lightning-Zahlungsempfänger (eine Knoten-ID oder eine
            Lightning-Adresse) wird in Kleinbuchstaben unter `LIGHTNING`
            gespeichert, wo Lightning-Transfers abgeglichen werden. Bekannte
            Chains werden unter einer kanonischen Kennung gespeichert,
            unabhängig von der Schreibweise, die Sie senden: „ethereum“,
            „Ethereum“ und „ERC20“ werden alle als ETH gespeichert, „BNB Smart
            Chain“ und „BEP20“ als BNB, „tron“ als TRX. Ein unbekannter
            Chain-Name wird unverändert beibehalten.
        holder_vendor_data:
          type: string
          description: Ihre interne Kennung für den Inhaber.
        holder_name:
          type: string
          description: >-
            Name des Wallet-Inhabers, der für den Abgleich des
            Begünstigtennamens verwendet wird.
        entity_type:
          type: string
          description: Freitext, standardmäßig "individual".
        is_ownership_verified:
          type: boolean
          description: >-
            Schreibgeschützt. Gibt an, ob das Eigentum an dieser Adresse
            nachgewiesen wurde.
        created_at:
          type: string
          format: date-time
        travel_address:
          type: string
          description: >-
            Die Travel Address des VASP der Gegenpartei für diese Wallet, falls
            bekannt. Ermöglicht Didit, die Transfers dieses Begünstigten über
            die TRP-Schiene für die von TRP unterstützten Assets (BTC, ETH und
            USDC auf einem angegebenen Netzwerk) weiterzuleiten.
        address_hash:
          type: string
          description: >-
            Schreibgeschützt. SHA-256 der Adresse in Kleinbuchstaben, als
            hexadezimale Zeichenkette in Kleinbuchstaben. Ein Eintrag, der nur
            über seinen Hash importiert wurde, wird darüber abgeglichen.
        memo:
          type: string
          description: >-
            Das Destination-Tag oder Memo, das Teil der Wallet in einem
            Memo-Netzwerk ist (XRP, XLM, EOS, ATOM, HBAR); `""` für die gesamte
            Adresse. Ein Eintrag mit einem Memo stimmt nur mit Überweisungen
            überein, die dieses Memo angeben; ein Eintrag ohne Memo stimmt mit
            der gesamten Adresse überein.
        receiving_travel_address:
          type: string
          readOnly: true
          description: >-
            Ihre wallet-spezifische Travel Address für diese Wallet: Geben Sie
            sie an den sendenden VASP weiter, damit dessen TRP-Anfrage diese
            Wallet benennt. Leer für eine Wallet, die als die eines anderen VASP
            erfasst ist, solange Travel Rule deaktiviert ist und bevor Ihr
            VASP-Profil gespeichert wird.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Der API-Schlüssel Ihrer Anwendung, aus Entwickler -> API-Schlüssel in
        der Business Console. Der Primärschlüssel hat Vollzugriff. Ein benannter
        Schlüssel kann im Geltungsbereich eingeschränkt werden: keine, Lese-
        oder Schreibberechtigung pro Ressource, beschränkt auf bestimmte
        Workflows oder genehmigte Sitzungen, auf eine Liste von IP-Adressen und
        auf ein Ablaufdatum. 401 bedeutet, dass der Schlüssel falsch, widerrufen
        oder abgelaufen ist; 403 bedeutet, dass kein Schlüssel gesendet wurde,
        der Schlüssel keinen Zugriff auf diese Ressource oder Aktion hat oder
        die Anfrage von einer Adresse außerhalb seiner IP-Liste stammte; 404 bei
        einer Sitzungsroute bedeutet, dass die Sitzung außerhalb der Workflows
        oder Status des Schlüssels liegt. Ein Schlüssel ohne Medienzugriff
        erhält Bild-, Video- und PDF-URLs als null, und ein Schlüssel ohne
        Schreibberechtigung für Sitzungen erhält Sitzungslinks und Token als
        null. Siehe https://docs.didit.me/console/api-keys.

````

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