> ## 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 के साथ एक ही अनुरोध में चुनिंदा पहचान, संपर्क जोखिम, एनरिचमेंट और नेटवर्क जाँच की योजना बनाएँ और उन्हें चलाएँ।

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

## प्रोफ़ाइल चुनें

`profile_version` को पिन करें, ताकि चुने गए डिफ़ॉल्ट और निर्णय नीति स्पष्ट रहें।
डिफ़ॉल्ट प्रोफ़ाइल `standard` है, संस्करण `2026-08-27`।
संस्करण `2026-09-14` में ईमेल और फ़ोन के वैकल्पिक सोशल एनरिचमेंट जुड़ जाते हैं, और पूरी हुई हर जाँच को नेटिव उपयोगकर्ता सत्यापन सत्र के रूप में दर्ज किया जाता है।
इस संस्करण में भुगतान वाले ऐड-ऑन ऑप्ट-इन होते हैं।
संस्करण `2026-09-14.1` में Enterprise प्लान वाले उन संगठनों के लिए वैश्विक धोखाधड़ी नेटवर्क पहचानकर्ता लुकअप भी सक्षम हो जाते हैं जो वैश्विक स्तर पर साझा करते हैं।
संस्करण `2026-09-14.2` ब्राज़ील के लिए एक वैकल्पिक सेल्फ़ी-से-CPF संदर्भ जाँच जोड़ता है।
पुराने संस्करण अपना मूल व्यवहार बनाए रखते हैं।

मौजूदा प्रोफ़ाइलें ईमेल जोखिम, फ़ोन जोखिम, IP जोखिम, योग्य डेटाबेस सत्यापन और आपके एप्लिकेशन के निजी नेटवर्क इतिहास को सपोर्ट करती हैं।
सेल्फ़ी-आधारित पहचान बाइंडिंग के लिए संस्करण `2026-09-14.2` की आवश्यकता होती है।
पुराने संस्करणों में इसे चुनने पर `not_available_in_profile_version` लौटता है।

## दावा की गई पहचान और संदर्भ

ईमेल, फ़ोन और सरकारी पहचानकर्ता `subject.identifiers` में डालें।
सरकारी पहचानकर्ताओं के लिए उनका जारीकर्ता देश आवश्यक है; जिन क्षेत्रों में संख्याएँ केवल एक क्षेत्र के भीतर अद्वितीय होती हैं, वहाँ जारीकर्ता की भी आवश्यकता हो सकती है।
नाम, जन्म तिथि, राष्ट्रीयता और पता `subject.attributes` में डालें।
ये वे दावे हैं जिन्हें चुने गए स्रोत के समर्थन की स्थिति में मिलाया जाता है; केवल सबमिट किए जाने से ये सत्यापित तथ्य नहीं बन जाते।

प्रयास के IP पते, उपयोगकर्ता एजेंट, उद्देश्य, देश और किसी भी आवश्यक सहमति कथन के लिए `context` का उपयोग करें।
इससे सत्यापन प्रयास की जानकारी और व्यक्ति की जानकारी अलग रहती है।
समर्थित बायोमेट्रिक जाँचों के लिए `subject.selfie` को base64-एन्कोडेड JPEG, PNG, या WebP के रूप में दें, जिसका आकार 6 MB तक हो।
मेल खाने वाला इमेज डेटा URI भी स्वीकार किया जाता है।
संदर्भ छवि, रिमोट URL, या स्टोरेज कुंजी न भेजें।

## सेल्फ़ी और दावा किया गया पहचानकर्ता

`biometric_identity` चुनें, एक ब्राज़ीलियाई `tax_number` पहचानकर्ता और सेल्फ़ी सबमिट करें, और `context.consent_obtained` की पुष्टि करें।
संदर्भ जाँच करती है कि वह सेल्फ़ी दावा किए गए CPF धारक की है या नहीं।
सहमति न होने पर `consent_required` लौटता है, और असमर्थित देशों के लिए `unsupported_region` लौटता है।
इस मॉड्यूल की प्रति-जाँच कीमत आपके संगठन की डेटाबेस सत्यापन दर पर आधारित है; इसे चलाने से पहले प्लान की जाँच करें।

जब संदर्भ जाँच का उत्तर मिलता है, तो `identity_relationship.result` `match`, `mismatch`, या `inconclusive` होता है।
अनिर्णायक उत्तर के लिए समीक्षा आवश्यक है, और उसे कभी भी असंगति नहीं माना जाता।
परिणाम केवल सेल्फ़ी और CPF के बीच के संबंध को स्थापित करता है।
यह सबमिट किए गए नाम या जन्म तिथि को सत्यापित नहीं करता, लाइवनेस साबित नहीं करता, और इंटरनेट या वैश्विक धोखाधड़ी नेटवर्क पर चेहरे की खोज नहीं करता।
नाम और जन्म तिथि दावे ही बने रहते हैं, जब तक कोई अन्य चुना गया स्रोत उन फ़ील्ड के लिए साक्ष्य न दे।
टाइमआउट और स्रोत त्रुटियाँ अनुपलब्ध परिणाम हैं और इनका बिल नहीं बनता।
जिन अनिर्णायक उत्तरों का निष्पादन पूरा हो चुका है, उनका बिल उसी संदर्भ-जाँच दर पर बनता है।
इस जाँच द्वारा सेल्फ़ी परिणाम में शामिल नहीं की जाती और सत्र मीडिया के रूप में संग्रहीत नहीं की जाती।

## जाँच चुनें

`checks.include` मॉड्यूल चुनता है, और `checks.exclude` को प्राथमिकता मिलती है।
`include` की स्पष्ट खाली सूची सभी वैकल्पिक कार्य बंद कर देती है; सामान्यीकरण फिर भी चलता है।
`include` छोड़ने पर पिन की गई प्रोफ़ाइल के डिफ़ॉल्ट उपयोग होते हैं।
ईमेल और फ़ोन सोशल एनरिचमेंट को `email_social` और `phone_social` से अलग-अलग चुना जाता है।
इनके लिए मान्य और मेल खाता पहचानकर्ता आवश्यक है, और ये OTP नहीं भेजते।

```json theme={null}
{
  "profile_version": "2026-09-14.1",
  "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"] }
}
```

## परिणामों को आपस में मिलाए बिना पढ़ें

हर मॉड्यूल अपनी निष्पादन स्थिति, कारण और बिलिंग योग्य इकाइयाँ रिपोर्ट करता है।
`not_requested`, `excluded_by_caller`, `missing_required_input`, और `source_unavailable` अलग-अलग परिणामों का वर्णन करते हैं।
अनुपस्थित स्रोत पहचान में असंगति नहीं है, और न ही शून्य-जोखिम परिणाम है।

`attribute_evidence` फ़ील्ड-स्तर के साक्ष्य का वर्णन करता है, जबकि `risk` पहचान, संपर्क, डिवाइस, व्यवहार और धोखाधड़ी-नेटवर्क के आयामों को अलग रखता है।
साझा ईमेल, डिवाइस या किसी अन्य पहचानकर्ता को देखा गया संबंध माना जाता है; यह इस बात का प्रमाण नहीं कि दो खाते एक ही व्यक्ति के हैं या उन्होंने धोखाधड़ी की है।
`recommendation` उस जाँच की सिफ़ारिश है; यह किसी अन्य रिकॉर्ड की स्थिति नहीं बदलती।
सोशल एनरिचमेंट के परिणाम `enrichment` के अंतर्गत दिखते हैं, और अनुपलब्ध परिणाम पूरे हुए परिणामों से अलग दिखाए जाते हैं।

## वैश्विक फ़्रॉड नेटवर्क

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

जाँच पूरी होने पर `network.cross_organization` में `signals_checked` और खुलासा किए गए समग्र `insights` होते हैं।
हर इनसाइट में सिग्नल का प्रकार, परिणाम श्रेणियाँ, योगदानकर्ता की संख्या और हालिया अवधि की श्रेणी होते हैं। उद्योग श्रेणियाँ केवल तब शामिल होती हैं जब खुलासा सक्षम हो।
इनसे कभी किसी दूसरे संगठन, खाते, व्यक्ति या सत्यापन की पहचान नहीं होती।
खुलासा थ्रेशोल्ड से नीचे के परिणाम छोड़ दिए जाते हैं। खाली सूची का अर्थ यह नहीं है कि फ़्रॉड का कोई इतिहास नहीं है।
खुलासा किया गया साझा सिग्नल समीक्षा की सिफ़ारिश को ट्रिगर करता है। वह कभी स्वचालित अस्वीकृति या पहचान मिलान नहीं होता।

अनुपलब्ध लुकअप का कारण, खाली लेकिन पूरे हुए लुकअप से अलग, रिपोर्ट किया जाता है।
अगर आपके संगठन की क्रॉस-ऑर्गनाइज़ेशन पहुँच बाद में खो जाती है, उदाहरण के लिए प्लान बदलने पर या शेयरिंग `global` न रहने पर, तो परिणाम की पुनर्प्राप्ति, पुनः प्रयास और सत्र का विवरण साझा समग्र डेटा और उससे निकले जोखिम साक्ष्य छिपा देते हैं।
मूल सिफ़ारिश एक ऐतिहासिक निर्णय बनी रहती है, और रीड से सत्यापन की स्थिति नहीं बदलती।

## सत्र, पुनः प्रयास और शुल्क

`check_id` [Get a Fraud Check](https://docs.didit.me/hi/standalone-apis/fraud-check-result.md) के ज़रिए संग्रहीत परिणाम लौटाता है।
मौजूद होने पर `request_id` उसके मूल सत्यापन सत्र की पहचान करता है।
संस्करण `2026-09-14`, `2026-09-14.1` और `2026-09-14.2` हमेशा वह सत्र बनाते हैं, भले ही केवल निजी नेटवर्क इतिहास चुना गया हो।

उसी अनुरोध बॉडी के साथ `client_reference` का दोबारा उपयोग करने पर, जब तक वह जाँच मौजूद है, मूल परिणाम लौटता है, बिना दोबारा निष्पादन या शुल्क के।
उसी संदर्भ के साथ अलग बॉडी भेजने पर `409` लौटता है।
अगर निष्पादन अब भी चल रहा है, तो रिस्पॉन्स के `Retry-After` अंतराल के बाद उसी अनुरोध को दोबारा भेजें।
संबंधित सत्यापन हटाने पर Fraud Check परिणाम भी हट जाता है, और फिर पुनर्प्राप्ति पर `404` लौटता है।
निष्पादन के दौरान हटाई गई जाँच पूरा परिणाम प्रकाशित नहीं कर सकती।

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


## OpenAPI

````yaml hi/openapi-25.json POST /v3/fraud/checks/
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/:
    post:
      tags:
        - Fraud Check
      summary: फ़्रॉड चेक चलाएं
      description: >-
        एक या अधिक टाइप किए गए पहचानकर्ता सबमिट करें और एक ही रिस्पॉन्स में
        सामान्यीकरण, ताज़ा संवर्धन, आधिकारिक सत्यापन (जहाँ देश और पहचानकर्ता
        प्रकार समर्थित हैं), स्वतंत्र जोखिम आयाम और अनुशंसा प्राप्त करें।


        ये प्रोफ़ाइल पहचानकर्ता जांच का समर्थन करती हैं। सेल्फ़ी-आधारित पहचान
        बाइंडिंग (`biometric_identity`) के लिए प्रोफ़ाइल संस्करण `2026-09-14.2`
        और ब्राज़ीलियाई CPF की आवश्यकता होती है; यह केवल उपयोगकर्ता की सहमति से
        और जब आपके संगठन के पास इसका अधिकार हो तभी चलता है। पूर्व संस्करण इसे
        `not_available_in_profile_version` के रूप में रिपोर्ट करते हैं। जो
        मॉड्यूल नहीं चल सकते, उन्हें एक निश्चित कारण के साथ छोड़ दिया गया
        (skipped) रिपोर्ट किया जाता है; जो स्रोत उत्तर नहीं दे सका, उसे कभी भी
        पहचान बेमेल के रूप में रिपोर्ट नहीं किया जाता है।
      operationId: create_fraud_check
      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/FraudCheckResponse'
          description: ''
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudClientCredentialsErrorMessage'
          description: ''
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/FraudClientCredentialsForbiddenErrorMessage
          description: ''
        '409':
          description: >-
            टकराव, बिना किसी शुल्क के वापस किया गया: `client_reference` का पहले
            से ही एक अलग अनुरोध बॉडी के साथ उपयोग किया गया था; समान
            `client_reference` वाली एक जांच अभी भी चल रही है (समान संदर्भ के साथ
            `Retry-After` सेकंड के बाद पुनः प्रयास करें); या जिस सत्यापन में यह
            जांच रिकॉर्ड होती है, उसे जांच पूरी होने से पहले हटा दिया गया था।
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                required:
                  - error
              examples:
                different_body:
                  summary: संदर्भ का उपयोग भिन्न बॉडी के साथ पुनः किया गया
                  value:
                    error: >-
                      client_reference has already been used with a different
                      request body.
                still_running:
                  summary: इस संदर्भ के साथ एक जाँच अभी भी चल रही है
                  value:
                    error: >-
                      A check with this client_reference is already running.
                      Retry with the same reference later.
                verification_deleted:
                  summary: जाँच पूरी होने से पहले सत्यापन हटा दिया गया था
                  value:
                    error: This verification was deleted before the check completed.
          headers:
            Retry-After:
              description: >-
                पुनः प्रयास करने से पहले प्रतीक्षा करने के सेकंड, जो तब भेजे
                जाते हैं जब उसी `client_reference` के साथ एक जाँच अभी भी चल रही
                हो।
              schema:
                type: integer
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.fraud_checks.create(
                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.create({
              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.Create(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().create(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->create([
                '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.create(
              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.CreateAsync(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
    FraudCheckResponse:
      type: object
      properties:
        check_id:
          type: string
          format: uuid
        request_id:
          type: string
          format: uuid
          description: इस जाँच के लिए बनाया गया मूल सत्यापन सत्र।
        client_reference:
          type: string
          nullable: true
        processing_status:
          $ref: '#/components/schemas/FraudProcessingStatusEnum'
        profile_id:
          type: string
        profile_version:
          type: string
        created_at:
          type: string
          format: date-time
        completed_at:
          type: string
          format: date-time
          nullable: true
        inputs:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckInput'
        modules:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckModuleReport'
        attribute_evidence:
          type: array
          items:
            type: object
            additionalProperties: {}
        compound_evidence:
          type: array
          items:
            type: object
            additionalProperties: {}
        risk:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckRisk'
        network:
          type: object
          additionalProperties: {}
        enrichment:
          type: object
          additionalProperties: {}
        identity_relationship:
          allOf:
            - $ref: '#/components/schemas/FraudCheckIdentityRelationship'
          nullable: true
        recommendation:
          $ref: '#/components/schemas/FraudRecommendationEnum'
        next_action:
          $ref: '#/components/schemas/FraudNextActionEnum'
        decision_reasons:
          type: array
          items:
            type: string
        coverage:
          type: object
          additionalProperties: {}
        usage:
          type: array
          items:
            type: object
            additionalProperties: {}
        vendor_data:
          type: string
          nullable: true
        metadata:
          nullable: true
      required:
        - attribute_evidence
        - check_id
        - client_reference
        - completed_at
        - compound_evidence
        - coverage
        - created_at
        - decision_reasons
        - inputs
        - modules
        - network
        - next_action
        - processing_status
        - profile_id
        - profile_version
        - recommendation
        - risk
        - usage
    FraudClientCredentialsErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: 'Authentication failed: Invalid client access token.'
    FraudClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    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'
    FraudProcessingStatusEnum:
      enum:
        - pending
        - running
        - completed
        - failed
      type: string
      description: |-
        * `pending` - लंबित
        * `running` - चल रहा है
        * `completed` - पूर्ण
        * `failed` - विफल
    FraudCheckInput:
      type: object
      properties:
        reference:
          type: string
          description: सबमिट किए गए पहचानकर्ता के लिए छिपाया गया हैंडल।
        type:
          $ref: '#/components/schemas/FraudTypeEnum'
        namespace:
          type: object
          additionalProperties: {}
        quality:
          type: string
        normalization:
          type: object
          additionalProperties: {}
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
      required:
        - availability
        - namespace
        - normalization
        - quality
        - reference
        - type
    FraudCheckModuleReport:
      type: object
      properties:
        module:
          $ref: '#/components/schemas/FraudExcludeEnum'
        status:
          $ref: '#/components/schemas/FraudStatusEnum'
        reason:
          type: string
          nullable: true
        latency_ms:
          type: integer
        freshness:
          type: string
          nullable: true
        billable_units:
          type: integer
      required:
        - billable_units
        - freshness
        - latency_ms
        - module
        - reason
        - status
    FraudCheckRisk:
      type: object
      properties:
        dimension:
          $ref: '#/components/schemas/FraudDimensionEnum'
        score:
          type: integer
          nullable: true
        band:
          $ref: '#/components/schemas/FraudBandEnum'
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
        requested_but_unavailable:
          type: boolean
          description: >-
            True जब अनुरोध ने वह सब कुछ प्रदान किया जिसकी इस आयाम को आवश्यकता थी
            और प्लेटफ़ॉर्म फिर भी इसका उत्तर नहीं दे सका। ऐसी जाँच को उन आयामों
            के आधार पर कभी भी स्वीकृति की अनुशंसा नहीं की जाती है जिन्होंने
            उत्तर दिया था।
        reason_codes:
          type: array
          items:
            type: string
        evidence_indexes:
          type: array
          items:
            type: integer
      required:
        - availability
        - band
        - dimension
        - evidence_indexes
        - reason_codes
        - requested_but_unavailable
        - score
    FraudCheckIdentityRelationship:
      type: object
      properties:
        result:
          $ref: '#/components/schemas/FraudResultEnum'
        reference_type:
          type: string
        country:
          type: string
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
        reason_codes:
          type: array
          items:
            type: string
      required:
        - availability
        - country
        - reason_codes
        - reference_type
        - result
    FraudRecommendationEnum:
      enum:
        - approve
        - review
        - reject
      type: string
      description: |-
        * `approve` - स्वीकृत करें
        * `review` - समीक्षा करें
        * `reject` - अस्वीकृत करें
    FraudNextActionEnum:
      enum:
        - none
        - manual_review
        - step_up
        - resubmit_capture
      type: string
      description: |-
        * `none` - कोई नहीं
        * `manual_review` - मैन्युअल समीक्षा
        * `step_up` - स्टेप अप
        * `resubmit_capture` - कैप्चर पुनः सबमिट करें
    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
    FraudAvailabilityEnum:
      enum:
        - available
        - not_requested
        - no_reference
        - insufficient_history
        - unsupported_region
        - source_unavailable
      type: string
      description: |-
        * `available` - उपलब्ध
        * `not_requested` - अनुरोध नहीं किया गया
        * `no_reference` - कोई संदर्भ नहीं
        * `insufficient_history` - अपर्याप्त इतिहास
        * `unsupported_region` - असमर्थित क्षेत्र
        * `source_unavailable` - स्रोत अनुपलब्ध
    FraudStatusEnum:
      enum:
        - planned
        - completed
        - skipped
        - failed
      type: string
      description: |-
        * `planned` - नियोजित
        * `completed` - पूर्ण
        * `skipped` - छोड़ा गया
        * `failed` - विफल
    FraudDimensionEnum:
      enum:
        - identity
        - contact
        - device_network
        - behavioral
        - fraud_network
      type: string
      description: |-
        * `identity` - पहचान
        * `contact` - संपर्क
        * `device_network` - डिवाइस नेटवर्क
        * `behavioral` - व्यवहार संबंधी
        * `fraud_network` - धोखाधड़ी नेटवर्क
    FraudBandEnum:
      enum:
        - low
        - medium
        - high
        - unknown
      type: string
      description: |-
        * `low` - कम
        * `medium` - मध्यम
        * `high` - उच्च
        * `unknown` - अज्ञात
    FraudResultEnum:
      enum:
        - match
        - mismatch
        - inconclusive
        - no_reference
      type: string
      description: |-
        * `match` - मिलान
        * `mismatch` - बेमेल
        * `inconclusive` - अनिर्णायक
        * `no_reference` - कोई संदर्भ नहीं
  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.