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

# प्रतिपक्ष VASP निर्णय सेट करें: Travel Rule API

> Didit के साथ अपने एप्लिकेशन के लिए Travel Rule प्रतिपक्ष VASP को स्वीकृत, प्रतिबंधित या ब्लॉक करें, ताकि आपके लेन-देन नियम उस पर कार्रवाई कर सकें।



VASP निर्णय API प्रॉम्प्ट सेट करें
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Make or change my application's decision on a Travel Rule counterparty VASP.

Endpoint:
PUT https://verification.didit.me/v3/travel-rule/vasps/{vasp_id}/decision/

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

vasp_id is the id GET /v3/travel-rule/vasps/ returns for a directory entry or a Didit network member.

Example call:
curl -X PUT "https://verification.didit.me/v3/travel-rule/vasps/{vasp_id}/decision/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"decision": "BLOCKED", "reason": "Unlicensed in its home jurisdiction"}'

Body:
\- decision (required) - APPROVED, RESTRICTED or BLOCKED.
\- reason (optional) - up to 255 characters. It replaces the previous reason; leaving it out clears it.

The response is {"decision": {decision, reason, decided_by, updated_at, inherited_from}} as it now applies.

How it works:
\- The decision is private to my application: no other Didit customer sees it, and it never changes the shared directory entry or how a transfer is routed.
\- A decision on a brand also covers each of its entities that has no decision of its own (inherited_from names the brand there). A decision on an entity overrides the brand's for that entity.
\- It acts only through my transaction rules, through the rule field counterparty_dd_status. Install the presets travel-rule-counterparty-blocked (declines) and travel-rule-counterparty-restricted (holds for review), or write my own rule on that field.

Failure modes:
\- 400 - decision missing or not APPROVED, RESTRICTED or BLOCKED, or reason longer than 255 characters.
\- 404 - no directory entry or listed Didit network member has this id, or the id is my own VASP profile.

Full guide: /transaction-monitoring/travel-rule#your-decision-on-a-counterparty.`

\</pre>



      
      

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



## OpenAPI

````yaml hi/openapi-25.json PUT /v3/travel-rule/vasps/{vasp_id}/decision/
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/vasps/{vasp_id}/decision/:
    put:
      tags:
        - Travel Rule
      summary: किसी VASP पर अपना निर्णय सेट करें
      description: >-
        किसी प्रतिपक्ष के बारे में अपने एप्लिकेशन का निर्णय निर्धारित करें या
        बदलें: APPROVED, RESTRICTED या BLOCKED, एक वैकल्पिक कारण के साथ। यह साझा
        डायरेक्टरी प्रविष्टि को कभी नहीं बदलता है और केवल आपके लेन-देन नियमों
        (counterparty_dd_status) के माध्यम से कार्य करता है। किसी ब्रांड पर लिया
        गया निर्णय उसकी प्रत्येक ऐसी इकाई को भी कवर करता है जिसका अपना कोई
        निर्णय नहीं है।
      operationId: updateTravelRuleVaspDecision
      parameters:
        - name: vasp_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: >-
            GET /v3/travel-rule/vasps/ की एक पंक्ति की id: एक डायरेक्टरी
            प्रविष्टि या Didit नेटवर्क सदस्य।
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TravelRuleCounterpartyDecisionRequest'
            example:
              decision: BLOCKED
              reason: Unlicensed in its home jurisdiction
      responses:
        '200':
          description: निर्णय जैसा कि अब लागू होता है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleCounterpartyDecisionResponse'
              example:
                decision:
                  decision: BLOCKED
                  reason: Unlicensed in its home jurisdiction
                  decided_by: ''
                  updated_at: '2026-10-14T10:05:00Z'
                  inherited_from: null
        '400':
          description: >-
            निर्णय गायब है या APPROVED, RESTRICTED या BLOCKED में से एक नहीं है,
            अथवा कारण 255 वर्णों से अधिक लंबा है।
          content:
            application/json:
              schema:
                type: object
                additionalProperties:
                  type: array
                  items:
                    type: string
              example:
                decision:
                  - '"MAYBE" is not a valid choice.'
        '404':
          description: >-
            किसी भी डायरेक्टरी प्रविष्टि या सूचीबद्ध Didit नेटवर्क सदस्य की यह
            id नहीं है। आपकी अपनी VASP प्रोफ़ाइल कभी भी आपकी प्रतिपक्ष नहीं होती
            है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              example:
                detail: No directory entry or Didit network member has this id.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X PUT
            https://verification.didit.me/v3/travel-rule/vasps/{vasp_id}/decision/
            \
              -H 'x-api-key: YOUR_API_KEY' -H 'Content-Type: application/json' \
              -d '{"decision": "BLOCKED", "reason": "Unlicensed in its home jurisdiction"}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.travel_rule.update_vasp_decision(
                "11111111-2222-3333-4444-555555555555",
                decision="BLOCKED",
                reason="Unlicensed in its home jurisdiction",
            )
            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.updateVaspDecision("11111111-2222-3333-4444-555555555555",
            {
              decision: "BLOCKED",
              reason: "Unlicensed in its home jurisdiction",
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.TravelRule.UpdateVASPDecision(ctx, \"11111111-2222-3333-4444-555555555555\", didit.TravelRuleCounterpartyDecisionRequest{\n\tDecision: \"BLOCKED\",\n\tReason:   didit.String(\"Unlicensed in its home jurisdiction\"),\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.TravelRuleCounterpartyDecisionRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.travelRule().updateVaspDecision("11111111-2222-3333-4444-555555555555",
            TravelRuleCounterpartyDecisionRequest.builder()
                    .decision(TravelRuleCounterpartyDecisionRequest.Decision.of("BLOCKED"))
                    .reason("Unlicensed in its home jurisdiction")
                    .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->updateVaspDecision('11111111-2222-3333-4444-555555555555',
            [
                'decision' => 'BLOCKED',
                'reason' => 'Unlicensed in its home jurisdiction',
            ]);

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

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

            result = didit.travel_rule.update_vasp_decision(
              "11111111-2222-3333-4444-555555555555",
              decision: "BLOCKED",
              reason: "Unlicensed in its home jurisdiction"
            )
            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.UpdateVaspDecisionAsync("11111111-2222-3333-4444-555555555555",
            new TravelRuleCounterpartyDecisionRequest

            {
                Decision = "BLOCKED",
                Reason = "Unlicensed in its home jurisdiction",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TravelRuleCounterpartyDecisionRequest:
      type: object
      required:
        - decision
      properties:
        decision:
          type: string
          enum:
            - APPROVED
            - RESTRICTED
            - BLOCKED
        reason:
          type: string
          maxLength: 255
          description: वैकल्पिक। पिछले कारण को बदल देता है; इसे हटाने के लिए इसे छोड़ दें।
    TravelRuleCounterpartyDecisionResponse:
      type: object
      properties:
        decision:
          allOf:
            - $ref: '#/components/schemas/TravelRuleCounterpartyDecision'
          nullable: true
          description: >-
            आपके एप्लिकेशन के लिए प्रतिपक्ष पर लागू होने वाला निर्णय: इसका अपना,
            अन्यथा (किसी ब्रांड की इकाई के लिए) ब्रांड का। कुछ न होने पर null।
    TravelRuleCounterpartyDecision:
      type: object
      description: >-
        किसी प्रतिपक्ष VASP पर आपकी एप्लिकेशन का निर्णय। आपकी एप्लिकेशन के लिए
        निजी: यह साझा डायरेक्टरी प्रविष्टि को कभी नहीं बदलता है और दूसरा ग्राहक
        इसे कभी नहीं देखता है। यह केवल आपके लेन-देन नियमों
        (counterparty_dd_status नियम फ़ील्ड और travel-rule-counterparty-blocked
        तथा travel-rule-counterparty-restricted प्रीसेट) के माध्यम से कार्य करता
        है; यह ट्रांसफ़र को रूट करने के तरीके को कभी नहीं बदलता है।
      properties:
        decision:
          type: string
          enum:
            - APPROVED
            - RESTRICTED
            - BLOCKED
          description: >-
            APPROVED: आपकी टीम ने प्रतिपक्ष को मंज़ूरी दे दी है। RESTRICTED:
            समीक्षा के बाद इसमें ट्रांसफ़र आगे बढ़ सकते हैं। BLOCKED: आपकी टीम
            ने इसे अस्वीकार कर दिया है।
        reason:
          type: string
          maxLength: 255
          description: आपके द्वारा दिया गया मुक्त-पाठ कारण, कोई न होने पर खाली।
        decided_by:
          type: string
          description: >-
            कंसोल उपयोगकर्ता जिसने निर्णय लिया या अंतिम बार बदला। जब इसे किसी
            API कुंजी द्वारा लिया गया हो, तब यह रिक्त होता है।
        updated_at:
          type: string
          format: date-time
        inherited_from:
          type: object
          nullable: true
          description: >-
            वह ब्रांड जिसके निर्णय का यह इकाई पालन करती है क्योंकि आपने इकाई पर
            स्वयं कोई निर्णय नहीं लिया है। जब निर्णय प्रतिपक्ष का अपना होता है
            तो Null होता है।
          properties:
            id:
              type: string
              format: uuid
            name:
              type: string
  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.