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

# धोखाधड़ी जाँच की योजना बनाएँ

> Didit के साथ इनपुट मान्य करें और अनुरोध चलाने से पहले चुनी गई धोखाधड़ी जाँच के शुल्क का अनुमान लगाएँ।

[Fraud Check](https://docs.didit.me/hi/standalone-apis/fraud-check.md) के लिए आप जो बॉडी उपयोग करने का इरादा रखते हैं, वही बॉडी भेजें।
प्लानिंग न कोई जाँच बनाती है और न कोई सत्र, न किसी एनरिचमेंट प्रदाता को कॉल करती है, न नेटवर्क इतिहास पढ़ती है, और कोई शुल्क नहीं लेती।

हर मॉड्यूल `available` और `will_run` को अलग करता है।
`availability_reason` बताता है कि दिए गए इनपुट उसे सपोर्ट कर सकते हैं या नहीं, जबकि `selection_reason` बताता है कि वह चुना गया है या नहीं और क्यों।
अनुपलब्ध स्विच दिखाई देते रखें और उनकी इनपुट आवश्यकताएँ दिखाएँ।

`networks_cross_org` के लिए Enterprise प्लान और आपके संगठन का साझाकरण मोड `global` पर सेट होना ज़रूरी है।
इनके बिना, या जब आपके संगठन के लिए Networks सक्षम न हो, तो प्लान इसे `available: false` और `availability_reason: "entitlement_required"` के साथ रिपोर्ट करता है।
जो जाँच इसे चुनती है, वह इसे उसी कारण से छोड़ देती है।
सैंडबॉक्स एप्लिकेशन प्लान या साझाकरण मोड से सीमित नहीं होते: समर्थित पहचानकर्ता के साथ मॉड्यूल चलता है और एक खाली सैंपल परिणाम लौटाता है।

`estimated_price` लौटाई गई `currency` में एक दशमलव स्ट्रिंग है।
null कीमत का मतलब है अनुपलब्ध या बिना कीमत वाला, निःशुल्क नहीं।
शीर्ष स्तर का अनुमान चुने गए चलने योग्य मॉड्यूल का कुल जोड़ है; `can_afford` लागू बिलिंग व्यवस्था की भी जाँच करता है।
पहचानकर्ता, संदर्भ या चयन बदलने के बाद दोबारा प्लान करें।
निष्पादन के समय पात्रता और कीमत दोबारा जाँची जाती है, इसलिए प्लान कोई आरक्षण नहीं है, और न ही इस बात की गारंटी है कि कोई बाहरी स्रोत जवाब देगा।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/fraud/checks/plan/
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/fraud/checks/plan/:
    post:
      tags:
        - Fraud Check
      summary: धोखाधड़ी जांच की योजना बनाएं
      description: >-
        बिना निष्पादित किए, बिना सत्र बनाए या बिलिंग के चयनित जांचों को सत्यापित
        करें और उनकी कीमत का अनुमान लगाएं।
      operationId: plan_create
      requestBody:
        content:
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
          application/json:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
            example:
              client_reference: review-attempt-001
              subject:
                identifiers:
                  - type: email
                    value: applicant@example.com
                attributes:
                  first_name: Alex
                  last_name: Example
              checks:
                include:
                  - networks_same_org
                  - networks_cross_org
                  - email_risk
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudCheckPlan'
          description: ''
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudBadRequestErrorMessage'
          description: ''
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.fraud_checks.plan(
                client_reference="review-attempt-001",
                subject={
                    "identifiers": [{
                        "type": "email",
                        "value": "applicant@example.com",
                    }],
                    "attributes": {
                        "first_name": "Alex",
                        "last_name": "Example",
                    },
                },
                checks={
                    "include": ["networks_same_org", "networks_cross_org", "email_risk"],
                },
            )
            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.fraudChecks.plan({
              client_reference: "review-attempt-001",
              subject: {
                identifiers: [{
                  type: "email",
                  value: "applicant@example.com",
                }],
                attributes: {
                  first_name: "Alex",
                  last_name: "Example",
                },
              },
              checks: {
                include: ["networks_same_org", "networks_cross_org", "email_risk"],
              },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.FraudChecks.Plan(ctx, didit.FraudCheckRequestRequest{\n\tClientReference: didit.String(\"review-attempt-001\"),\n\tSubject: didit.FraudCheckSubjectRequest{\n\t\tIdentifiers: []didit.FraudCheckIdentifierRequest{{\n\t\t\tType:  didit.FraudTypeEnum(\"email\"),\n\t\t\tValue: \"applicant@example.com\",\n\t\t}},\n\t\tAttributes: didit.Some(didit.FraudCheckAttributesRequest{\n\t\t\tFirstName: didit.String(\"Alex\"),\n\t\t\tLastName:  didit.String(\"Example\"),\n\t\t}),\n\t},\n\tChecks: didit.Some(didit.FraudCheckModuleSelectionRequest{\n\t\tInclude: didit.Some([]didit.FraudExcludeEnum{didit.FraudExcludeEnum(\"networks_same_org\"), didit.FraudExcludeEnum(\"networks_cross_org\"), didit.FraudExcludeEnum(\"email_risk\")}),\n\t}),\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.FraudCheckAttributesRequest;

            import me.didit.types.FraudCheckIdentifierRequest;

            import me.didit.types.FraudCheckModuleSelectionRequest;

            import me.didit.types.FraudCheckRequestRequest;

            import me.didit.types.FraudCheckSubjectRequest;

            import me.didit.types.FraudExcludeEnum;

            import me.didit.types.FraudTypeEnum;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.fraudChecks().plan(FraudCheckRequestRequest.builder()
                    .clientReference("review-attempt-001")
                    .subject(FraudCheckSubjectRequest.builder()
                            .identifiers(List.of(FraudCheckIdentifierRequest.builder()
                                    .type(FraudTypeEnum.of("email"))
                                    .value("applicant@example.com")
                                    .build()))
                            .attributes(FraudCheckAttributesRequest.builder()
                                    .firstName("Alex")
                                    .lastName("Example")
                                    .build())
                            .build())
                    .checks(FraudCheckModuleSelectionRequest.builder()
                            .include(List.of(FraudExcludeEnum.of("networks_same_org"), FraudExcludeEnum.of("networks_cross_org"), FraudExcludeEnum.of("email_risk")))
                            .build())
                    .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->fraudChecks->plan([
                'client_reference' => 'review-attempt-001',
                'subject' => [
                    'identifiers' => [[
                        'type' => 'email',
                        'value' => 'applicant@example.com',
                    ]],
                    'attributes' => [
                        'first_name' => 'Alex',
                        'last_name' => 'Example',
                    ],
                ],
                'checks' => [
                    'include' => ['networks_same_org', 'networks_cross_org', 'email_risk'],
                ],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.fraud_checks.plan(
              client_reference: "review-attempt-001",
              subject: {
                identifiers: [{
                  type: "email",
                  value: "applicant@example.com",
                }],
                attributes: {
                  first_name: "Alex",
                  last_name: "Example",
                },
              },
              checks: {
                include: ["networks_same_org", "networks_cross_org", "email_risk"],
              }
            )
            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.FraudChecks.PlanAsync(new
            FraudCheckRequestRequest

            {
                ClientReference = "review-attempt-001",
                Subject = new()
                {
                    Identifiers = new FraudCheckIdentifierRequest[]
                    {
                        new()
                        {
                            Type = "email",
                            Value = "applicant@example.com",
                        },
                    },
                    Attributes = new FraudCheckAttributesRequest
                    {
                        FirstName = "Alex",
                        LastName = "Example",
                    },
                },
                Checks = new FraudCheckModuleSelectionRequest
                {
                    Include = new FraudExcludeEnum[] { "networks_same_org", "networks_cross_org", "email_risk" },
                },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    FraudCheckRequestRequest:
      type: object
      properties:
        client_reference:
          type: string
          minLength: 1
          description: >-
            इस जाँच के लिए आपका अपना संदर्भ। यह आइडेम्पोटेंसी कुंजी के रूप में
            भी काम करता है: समान बॉडी के साथ इसका पुन: उपयोग करने से मॉड्यूल को
            दोबारा चलाए या बिल किए बिना मूल जाँच वापस मिल जाती है; एक अलग बॉडी
            के साथ इसका पुन: उपयोग करने पर 409 वापस आता है।
          maxLength: 255
        profile:
          type: string
          minLength: 1
          default: standard
          description: >-
            ऑर्केस्ट्रेशन प्रोफ़ाइल id। डिफ़ॉल्ट रूप से Didit `standard`
            प्रोफ़ाइल पर सेट होता है।
          maxLength: 64
        profile_version:
          type: string
          minLength: 1
          description: >-
            फ़्रीज़ किए गए प्रोफ़ाइल संस्करण को पिन करें। डिफ़ॉल्ट रूप से
            प्रोफ़ाइल का वर्तमान संस्करण होता है।
          maxLength: 32
        subject:
          $ref: '#/components/schemas/FraudCheckSubjectRequest'
        context:
          $ref: '#/components/schemas/FraudCheckContextRequest'
        checks:
          $ref: '#/components/schemas/FraudCheckModuleSelectionRequest'
        vendor_data:
          type: string
          maxLength: 1000
        metadata: {}
      required:
        - subject
    FraudCheckPlan:
      type: object
      properties:
        profile_id:
          type: string
        profile_version:
          type: string
        modules:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckPlannedModule'
        estimated_price:
          type: string
          nullable: true
        currency:
          type: string
          nullable: true
        is_sandbox:
          type: boolean
        can_afford:
          type: boolean
      required:
        - can_afford
        - currency
        - estimated_price
        - is_sandbox
        - modules
        - profile_id
        - profile_version
    FraudBadRequestErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Bad Request - Invalid request data
    FraudCheckSubjectRequest:
      type: object
      properties:
        selfie:
          type: string
          minLength: 1
          description: >-
            Base64 JPEG, PNG या WebP सेल्फ़ी, 6 MB तक। कोई संदर्भ छवि या URL
            नहीं।
          maxLength: 8388672
        identifiers:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckIdentifierRequest'
          description: एक या अधिक टाइप किए गए पहचानकर्ता। एक ही पर्याप्त है।
          maxItems: 10
          minItems: 1
        attributes:
          $ref: '#/components/schemas/FraudCheckAttributesRequest'
      required:
        - identifiers
    FraudCheckContextRequest:
      type: object
      properties:
        ip_address:
          type: string
          minLength: 1
        user_agent:
          type: string
          maxLength: 512
        country:
          type: string
          description: >-
            वह देश जिसमें संबंधित व्यक्ति होने का दावा करता है। केवल प्रासंगिक -
            कभी भी पहचान स्वामित्व का प्रमाण नहीं।
          maxLength: 3
        purpose:
          type: string
          maxLength: 128
        consent_obtained:
          type: boolean
    FraudCheckModuleSelectionRequest:
      type: object
      properties:
        include:
          type: array
          items:
            $ref: '#/components/schemas/FraudExcludeEnum'
        exclude:
          type: array
          items:
            $ref: '#/components/schemas/FraudExcludeEnum'
    FraudCheckPlannedModule:
      type: object
      properties:
        module:
          $ref: '#/components/schemas/FraudExcludeEnum'
        available:
          type: boolean
        availability_reason:
          type: string
          nullable: true
        will_run:
          type: boolean
        selection_reason:
          type: string
          nullable: true
        estimated_price:
          type: string
          nullable: true
      required:
        - availability_reason
        - available
        - estimated_price
        - module
        - selection_reason
        - will_run
    FraudCheckIdentifierRequest:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/FraudTypeEnum'
          description: >-
            पहचानकर्ता का प्रकार। यह निर्धारित करता है कि कौन से नेमस्पेस फ़ील्ड
            आवश्यक हैं।


            * `email` - ईमेल

            * `phone` - फ़ोन

            * `national_id` - राष्ट्रीय ID

            * `tax_number` - कर पहचान संख्या

            * `passport_number` - पासपोर्ट संख्या

            * `driving_licence_number` - ड्राइविंग लाइसेंस संख्या

            * `residence_permit_number` - निवास परमिट संख्या

            * `voter_id` - मतदाता ID

            * `external_id` - बाहरी ID
        value:
          type: string
          minLength: 1
          description: पहचानकर्ता मान, किसी भी प्रथागत प्रारूप में।
          maxLength: 255
        country:
          type: string
          description: >-
            ISO-3166 alpha-2 या alpha-3 जारीकर्ता देश। सरकारी पहचानकर्ता
            प्रकारों के लिए आवश्यक: अलग-अलग देशों में समान अंकों का अर्थ अलग-अलग
            व्यक्ति हो सकता है।
          maxLength: 3
        issuer:
          type: string
          description: >-
            वैकल्पिक जारीकर्ता प्राधिकरण या उप-राष्ट्रीय जारीकर्ता, जब केवल देश
            अद्वितीय न हो।
          maxLength: 128
      required:
        - type
        - value
    FraudCheckAttributesRequest:
      type: object
      description: >-
        पुष्टिकारक विशेषताएँ। सभी वैकल्पिक; वे मॉड्यूल कवरेज का विस्तार करते
        हैं।
      properties:
        first_name:
          type: string
          maxLength: 128
        last_name:
          type: string
          maxLength: 128
        full_name:
          type: string
          maxLength: 256
        date_of_birth:
          type: string
          format: date
        nationality:
          type: string
          maxLength: 3
        gender:
          type: string
          maxLength: 16
        address:
          type: string
          maxLength: 512
        city:
          type: string
          maxLength: 128
        state:
          type: string
          maxLength: 128
        postal_code:
          type: string
          maxLength: 32
    FraudExcludeEnum:
      enum:
        - normalization
        - email_risk
        - email_social
        - phone_social
        - phone_risk
        - ip_risk
        - database_validation
        - networks_same_org
        - networks_cross_org
        - biometric_identity
      type: string
      description: |-
        * `normalization` - सामान्यीकरण
        * `email_risk` - ईमेल जोखिम
        * `email_social` - ईमेल सोशल
        * `phone_social` - फ़ोन सोशल
        * `phone_risk` - फ़ोन जोखिम
        * `ip_risk` - IP जोखिम
        * `database_validation` - डेटाबेस सत्यापन
        * `networks_same_org` - समान संगठन नेटवर्क
        * `networks_cross_org` - क्रॉस-संगठन नेटवर्क
        * `biometric_identity` - बायोमेट्रिक पहचान
    FraudTypeEnum:
      enum:
        - email
        - phone
        - national_id
        - tax_number
        - passport_number
        - driving_licence_number
        - residence_permit_number
        - voter_id
        - external_id
      type: string
      description: |-
        * `email` - ईमेल
        * `phone` - फ़ोन
        * `national_id` - राष्ट्रीय ID
        * `tax_number` - कर पहचान संख्या
        * `passport_number` - पासपोर्ट संख्या
        * `driving_licence_number` - ड्राइविंग लाइसेंस संख्या
        * `residence_permit_number` - निवास परमिट संख्या
        * `voter_id` - वोटर ID
        * `external_id` - बाहरी ID
  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।
    BearerAuth:
      type: http
      scheme: bearer
      description: एप्लिकेशन का क्लाइंट-क्रेडेंशियल एक्सेस टोकन।

````

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