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

# Travel Rule नेटवर्क एक्सेस अनुरोध API

> स्वीकृत प्रश्नावली के बाद, Didit से अपने एप्लिकेशन को GTR या Sygna पर स्वयं के प्रतिभागी के रूप में आगे ले जाने का अनुरोध करें।

Travel Rule Network API प्रॉम्प्ट का अनुरोध करें
प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें

<pre>
  \`Ask Didit to carry my application on a Travel Rule network as my own participant.

  Endpoint:
  POST [https://verification.didit.me/v3/travel-rule/networks/\{network}/request/](https://verification.didit.me/v3/travel-rule/networks/\{network}/request/)
  network: gtr | sygna

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

  Behavior:

  * Without an approved questionnaire, the participant waits for it (status questionnaire\_pending).
  * With one, it goes to the network's onboarding (submitted\_to\_network) and becomes active once the network gives it a participant code.
  * Idempotent: a pending, onboarding or active participant is returned unchanged.
  * If the network refused the registration (last\_error is set and the network's state is error / provisioning\_failed), requesting again retries.
  * 400 travel\_rule\_network\_own\_membership\_only for TRUST and VerifyVASP (connect your own membership instead), 400 travel\_rule\_network\_sandbox\_application from a sandbox application, 403 travel\_rule\_platform\_networks\_disabled until network access through Didit opens.

  What to read from the response:

  * status, participant\_code, last\_error and history of my participant.

  Full guide: /transaction-monitoring/travel-rule.\`
</pre>

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

[Get Travel Rule Networks](https://docs.didit.me/hi/management-api/travel-rule/get-networks.md) का परिणाम पढ़ें: जब आपका प्रतिभागी सक्रिय हो जाए और उस नेटवर्क में Didit की सदस्यता लाइव हो जाए, तब नेटवर्क की `state` `live_through_didit` हो जाती है।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/travel-rule/networks/{network}/request/
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/networks/{network}/request/:
    post:
      tags:
        - Travel Rule
      summary: Travel Rule नेटवर्क का अनुरोध करें
      description: >-
        किसी ऐसे नेटवर्क पर इस एप्लिकेशन के अपने प्रतिभागी के लिए अनुरोध करें
        जिसमें Didit की सदस्यता शामिल है (GTR या Sygna)। स्वीकृत प्रश्नावली के
        बिना प्रतिभागी इसके लिए प्रतीक्षा करता है (questionnaire_pending); इसके
        होने पर वह नेटवर्क के ऑनबोर्डिंग (submitted_to_network) में जाता है और
        नेटवर्क द्वारा कोड दिए जाने पर सक्रिय हो जाता है। आइडेम्पोटेंट: एक
        लंबित, ऑनबोर्डिंग या लाइव प्रतिभागी अपरिवर्तित लौटाया जाता है। यदि
        नेटवर्क ने पंजीकरण अस्वीकार कर दिया (last_error सेट है), तो पुनः अनुरोध
        करने पर पुनः प्रयास किया जाता है। TRUST और VerifyVASP केवल आपकी अपनी
        सदस्यता के माध्यम से ही पहुंच योग्य हैं: TRUST प्रति VASP सदस्यों को
        स्वीकार करता है, और VerifyVASP Enclave एक VASP ID को सेवा प्रदान करता
        है।
      operationId: requestTravelRuleNetworkAccess
      parameters:
        - name: network
          in: path
          required: true
          schema:
            type: string
            enum:
              - gtr
              - sygna
          description: Didit की सदस्यता के माध्यम से जुड़ने के लिए नेटवर्क।
      responses:
        '200':
          description: नेटवर्क पर आपका प्रतिभागी।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleNetworkParticipant'
        '400':
          description: >-
            अज्ञात नेटवर्क, ऐसा नेटवर्क जिसे Didit सपोर्ट नहीं करता (अपनी
            सदस्यता कनेक्ट करें), या सैंडबॉक्स एप्लिकेशन।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                  code:
                    type: string
                    enum:
                      - travel_rule_network_own_membership_only
                      - travel_rule_network_sandbox_application
        '401':
          description: अनुपलब्ध या अमान्य API कुंजी।
        '403':
          description: Didit की सदस्यता के माध्यम से नेटवर्क एक्सेस अभी खुला नहीं है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                  code:
                    type: string
                    enum:
                      - travel_rule_platform_networks_disabled
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            https://verification.didit.me/v3/travel-rule/networks/gtr/request/ \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.travel_rule.networks.request_access(
                "your-network",
            )
            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.networks.requestAccess("your-network");

            console.log(result);
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.travelRule().networks().requestAccess("your-network");

            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->networks->requestAccess('your-network');

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.travel_rule.networks.request_access("your-network")
            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.Networks.RequestAccessAsync("your-network");

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TravelRuleNetworkParticipant:
      type: object
      description: एक नेटवर्क पर इस एप्लिकेशन का अपना प्रतिभागी।
      properties:
        network:
          type: string
          enum:
            - gtr
            - trust
            - verifyvasp
            - sygna
        rail:
          type: string
          enum:
            - GTR
            - TRUST
            - VERIFYVASP
            - SYGNA
        mode:
          type: string
          enum:
            - platform
            - own
        status:
          type: string
          enum:
            - not_requested
            - questionnaire_pending
            - submitted_to_network
            - active
            - suspended
            - rejected
          description: >-
            not_requested: कभी अनुरोध नहीं किया गया, या नेटवर्क ने पहले अनुरोध
            को अस्वीकार कर दिया (last_error देखें); questionnaire_pending: ड्यू
            डिलिजेंस प्रश्नावली के स्वीकृत होने की प्रतीक्षा की जा रही है;
            submitted_to_network: नेटवर्क की ऑनबोर्डिंग को सौंप दिया गया;
            active: नेटवर्क ने इस एप्लिकेशन को अपना स्वयं का प्रतिभागी कोड दिया;
            suspended / rejected: Didit ने इसे निलंबित या अस्वीकार कर दिया।
        participant_code:
          type: string
        requested_at:
          type: string
          format: date-time
          nullable: true
        submitted_at:
          type: string
          format: date-time
          nullable: true
        activated_at:
          type: string
          format: date-time
          nullable: true
        suspended_at:
          type: string
          format: date-time
          nullable: true
        last_error:
          type: string
          description: नेटवर्क का उत्तर जब उसने पंजीकरण अस्वीकार कर दिया; अन्यथा खाली।
        history:
          type: array
          readOnly: true
          description: प्रत्येक स्थिति परिवर्तन, सबसे पुराना पहले।
          items:
            type: object
            properties:
              at:
                type: string
                format: date-time
              from:
                type: string
              to:
                type: string
              note:
                type: string
                description: समीक्षा नोट या नेटवर्क का उत्तर, जब कोई उपलब्ध हो।
  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.