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

> Didit API के माध्यम से अपने एप्लिकेशन पर प्रीसेट KYT नियम इंस्टॉल करें, लाइब्रेरी कुंजी से अलग-अलग या पूरे बंडल को एक साथ।



नियम लाइब्रेरी इंस्टॉल करने के लिए API प्रॉम्प्ट
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Install preset rules from the Didit library onto my application.

Endpoint:
POST https://verification.didit.me/v3/transactions/rules/install/

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

Request body (application/json) - provide at least one selector:
\{ "library_keys": ["structuring-inbound", "structuring-outbound"] }
\{ "bundle": "responsible_gaming" }
\{ "library_keys": ["structuring-inbound"], "bundle": "aml_ctf" }

Response:
\{ "installed_library_keys": ["structuring-inbound", "structuring-outbound"], "installed_count": 2 }

Behavior:
\- Installed presets evaluate immediately - in ACTIVE mode when transaction monitoring is enabled on the application, DISABLED otherwise. Tune them afterwards with PATCH (mode only).
\- You may send both selectors. When you do, only the requested library keys that belong to the bundle are installed.
\- Already-installed keys are skipped, so the call is safe to repeat.
\- Discover keys and bundles via GET /v3/transactions/rules/library/.

Failure modes:
\- 400 - neither library_keys nor bundle provided, or library_keys is not a list.`

\</pre>



      
      

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



## OpenAPI

````yaml hi/openapi-25.json POST /v3/transactions/rules/install/
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/transactions/rules/install/:
    post:
      tags:
        - Transactions
      summary: लाइब्रेरी नियम इंस्टॉल करें
      description: >-
        `library_keys` या पूरे `bundle` द्वारा एप्लिकेशन पर एक या अधिक प्रीसेट
        इंस्टॉल करें। लेन-देन निगरानी चालू रहने पर इंस्टॉल किया गया प्रीसेट
        तुरंत सक्रिय हो जाता है, अन्यथा अक्षम रहता है; पहले से इंस्टॉल की गई
        कुंजियों को छोड़ दिया जाता है। एक लाइब्रेरी नियम जिसकी शर्तें ऐसे डेटा
        को पढ़ती हैं जिनका नियम इंजन अभी मूल्यांकन नहीं कर सकता, उसे तब तक रोक
        कर रखा जाता है जब तक कि वह चल न सके। एक अनुरोध जो `library_keys` में से
        किसी एक का नाम देता है, वह 400 रिस्पॉन्स देता है और कुछ भी इंस्टॉल नहीं
        करता है ("ये लाइब्रेरी नियम अभी नहीं चल सकते: उनकी शर्तों में ऐसा डेटा
        पढ़ा जाता है जिसका नियम इंजन अभी मूल्यांकन नहीं कर सकता।" जिसके बाद
        कुंजियाँ होती हैं), और एक `bundle` इंस्टॉलेशन इसे छोड़ देता है। एक रोक
        कर रखा गया नियम एक बार उसकी शर्तों का मूल्यांकन किए जाने के बाद अपने आप
        वापस आ जाता है। एक `library_keys` प्रविष्टि जो लाइब्रेरी में नहीं है,
        उसे छोड़ दिया जाता है, अस्वीकार नहीं किया जाता।
      operationId: installTransactionRuleLibrary
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TransactionRuleInstallRequest'
            example:
              library_keys:
                - structuring-inbound
                - structuring-outbound
      responses:
        '200':
          description: क्या इंस्टॉल किया गया था।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionRuleInstallResult'
              example:
                installed_library_keys:
                  - structuring-inbound
                  - structuring-outbound
                installed_count: 2
        '400':
          description: >-
            न तो library_keys और न ही bundle प्रदान किया गया, `library_keys` एक
            सूची नहीं है, या एक `library_keys` प्रविष्टि रोकी गई है। एक अज्ञात
            प्रविष्टि को छोड़ दिया जाता है और उसके बिना 200 रिस्पॉन्स दिया जाता
            है।
          content:
            application/json:
              schema:
                type: object
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/transactions/rules/install/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"library_keys": ["structuring-inbound", "structuring-outbound"]}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.transactions.rules.install_library(
                library_keys=["structuring-inbound", "structuring-outbound"],
            )
            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.transactions.rules.installLibrary({
              library_keys: ["structuring-inbound", "structuring-outbound"],
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.Rules.InstallLibrary(ctx, didit.TransactionRuleInstallRequest{\n\tLibraryKeys: didit.Some([]string{\"structuring-inbound\", \"structuring-outbound\"}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.TransactionRuleInstallRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.transactions().rules().installLibrary(TransactionRuleInstallRequest.builder()
                    .libraryKeys(List.of("structuring-inbound", "structuring-outbound"))
                    .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->transactions->rules->installLibrary([
                'library_keys' => ['structuring-inbound', 'structuring-outbound'],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: >-
            require "didit"


            # Reads DIDIT_API_KEY.

            didit = Didit::Client.new


            result = didit.transactions.rules.install_library(library_keys:
            ["structuring-inbound", "structuring-outbound"])

            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.Transactions.Rules.InstallLibraryAsync(new
            TransactionRuleInstallRequest

            {
                LibraryKeys = new string[] { "structuring-inbound", "structuring-outbound" },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TransactionRuleInstallRequest:
      type: object
      properties:
        library_keys:
          type: array
          items:
            type: string
          description: इंस्टॉल या अनइंस्टॉल करने के लिए विशिष्ट प्रीसेट।
        bundle:
          type: string
          description: इसके बजाय इस बंडल के प्रत्येक प्रीसेट को इंस्टॉल या अनइंस्टॉल करें।
      description: library_keys या bundle प्रदान करें।
    TransactionRuleInstallResult:
      type: object
      properties:
        installed_library_keys:
          type: array
          items:
            type: string
          description: 'केवल POST (इंस्टॉल): इस कॉल द्वारा इंस्टॉल किए गए प्रीसेट।'
        installed_count:
          type: integer
          description: केवल POST (इंस्टॉल)।
        uninstalled_count:
          type: integer
          description: 'केवल DELETE (अनइंस्टॉल): इस कॉल द्वारा हटाए गए प्रीसेट।'
  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.