> ## 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 से भुगतान भेजने से पहले जाँचें कि बैंक खाता आपके बताए व्यक्ति या कंपनी का है। इसके लिए कोई सत्र या साइन-इन नहीं चाहिए।

> [!NOTE]
>
> प्रोडक्शन में खाता जाँच नाइजीरिया, घाना और केन्या में चलती है।
> कोई अन्य देश `404` के साथ `code: country_not_covered` लौटाता है और उस पर कोई शुल्क नहीं लगता।
> समय के साथ और देश जुड़ेंगे, और [बैंक सत्यापन मूल्य निर्धारण](https://docs.didit.me/hi/getting-started/bank-verification-pricing.md) में हमेशा दिखता है कि आज हर देश में क्या उपलब्ध है।

आपका बैकएंड नाम और खाता भेजता है, और परिणाम पढ़ता है। यह बैंक सत्यापन चरण की [खाता जाँच](https://docs.didit.me/hi/core-technology/bank-verification/account-check.md) है, जिसमें व्यक्ति शामिल नहीं होता।

## खाता उसी तरह भेजें जैसे उसे उसके देश में लिखा जाता है

| देश | `account` |
| - | - |
| IBAN वाले देश | `{"iban": "..."}` |
| यूनाइटेड किंगडम | `{"sort_code": "...", "account_number": "..."}` |
| संयुक्त राज्य अमेरिका | `{"routing_number": "...", "account_number": "..."}` |
| कनाडा | `{"transit_institution": "...", "account_number": "..."}` |
| ऑस्ट्रेलिया | `{"bsb": "...", "account_number": "..."}` |
| भारत | `{"ifsc": "...", "account_number": "..."}` |
| नाइजीरिया | `{"bank_code": "...", "account_number": "..."}`, बैंक के 6 अंकों के NIP कोड (Access Bank के लिए `000014`) और 10 अंकों के NUBAN के साथ |
| घाना | `{"bank_code": "...", "account_number": "..."}`, बैंक के 3 अक्षरों के कोड (GCB Bank के लिए `GCB`) के साथ |
| केन्या | `{"bank_code": "...", "account_number": "..."}`, बैंक के 2 अंकों के कोड (KCB के लिए `01`) के साथ |
| मेक्सिको | `{"clabe": "..."}` |
| अर्जेंटीना | `{"cbu_cvu": "..."}` |

कुछ देश `bic` भी माँगते हैं, और व्यावसायिक खाते के लिए `registration_id`। स्पेस, डैश और बिंदु अनदेखे किए जाते हैं। जो कुंजी देश की जाँच को चाहिए और आप नहीं भेजते, उसके लिए `400` मिलता है जो उसका नाम बताता है, जैसे `"field": "account.bank_code", "reason": "required"`।

किसी व्यक्ति के खाते की जाँच के लिए `holder.full_name` भेजें, और किसी कंपनी के खाते की जाँच के लिए `holder.business_name`।

## खाताधारक की सहमति भेजें

कुछ देशों में खाता जाँच से पहले हर जाँच के लिए खाताधारक की स्पष्ट सहमति चाहिए।
अपने उत्पाद में सहमति लें, फिर `"consent": true` भेजें।
इसके बिना उन देशों में जाँच `400` (`field: consent`, `reason: required`) के साथ अस्वीकार होती है और उसका शुल्क नहीं लगता।
बाकी देशों में `consent` वैकल्पिक है, और जब आप इसे भेजते हैं तो Didit इसे जाँच के शुल्क के साथ दर्ज करता है।
सैंडबॉक्स कुंजी उन्हीं देशों में सहमति माँगती है जिनमें लाइव कुंजी माँगती है।

## परिणाम पढ़ें

| `result` | इसका मतलब | सामान्य अगला कदम |
| - | - | - |
| `match` | बैंक के रिकॉर्ड में खाता आपके भेजे हुए नाम पर है। | पैसा भेजें। |
| `close_match` | बैंक के रिकॉर्ड में खाता मिलते-जुलते नाम पर है। `holder_name` वह नाम है, यदि बैंक ने उसे लौटाया हो। | `holder_name` की तुलना करें, या व्यक्ति से पुष्टि करने को कहें। |
| `no_match` | बैंक के रिकॉर्ड में खाता किसी दूसरे नाम पर है, या ऐसा कोई खाता नहीं है। | पैसा न भेजें। |
| `cannot_verify` | बैंक ने नाम की तुलना किए बिना जवाब दिया, जैसे ब्लॉक या बंद खाते के लिए। | अपनी नीति लागू करें, उदाहरण के लिए कोई दूसरा खाता माँगें। |

## बिलिंग और पुनः प्रयास

बैंक जिस हर जाँच का जवाब देता है, उस पर परिणाम चाहे जो हो, खाते के देश के [खाता जाँच कीमत](https://docs.didit.me/hi/getting-started/bank-verification-pricing.md) के अनुसार एक बार शुल्क लिया जाता है। त्रुटि के साथ जवाब मिलने वाला अनुरोध कभी बिल नहीं होता: अस्वीकृत बॉडी (`400`), क्रेडिट न होना (`402`), ऐसा खाता जिसकी जाँच अभी उपलब्ध नहीं है (`404`), या ऐसा बैंक जो जवाब नहीं दे सका (`503`)।

इसमें कोई आइडेम्पोटेंसी कुंजी नहीं है, और जाँच को वापस पढ़ने के लिए कोई endpoint नहीं है। दोबारा भेजा गया अनुरोध नई जाँच चलाता है, नए `request_id` के साथ, और उसका फिर से शुल्क लगता है, इसलिए रिस्पॉन्स सहेजकर रखें। Didit केवल शुल्क को रिकॉर्ड करता है, साथ में अनुरोध ID, देश, परिणाम और मास्क किया गया खाता। नाम या पूरा खाता नंबर वह कभी नहीं रखता।

## सैंडबॉक्स में परखें

सैंडबॉक्स API कुंजी किसी बैंक को कॉल नहीं करती और उससे कोई शुल्क नहीं लगता। IBAN के आखिरी 4 अक्षर, या IBAN न होने पर खाता नंबर के आखिरी 4 अक्षर, तय करते हैं कि जवाब क्या होगा:

| इन पर खत्म होता है | जवाब |
| - | - |
| `0001` | `close_match`, `holder_name` के साथ |
| `0002` | `close_match`, `holder_name: null` |
| `0003`, `0006` | `no_match` |
| `0004` | `cannot_verify` |
| `0005` | `503`, `account_check_unavailable` |
| `0009` | `400`, `reason: rejected` |
| बाकी कुछ भी | `match` |

IBAN, CLABE और CBU में चेक डिजिट होते हैं, इसलिए हर प्रारूप जाँच पास करने वाले [सैंडबॉक्स मान](https://docs.didit.me/hi/core-technology/bank-verification/account-check.md#सैंडबॉक्स-में-इसका-परीक्षण-करें) इस्तेमाल करें।

## पहुँच

अपने एप्लिकेशन की `x-api-key` से प्रमाणित करें, या उसके क्लाइंट-क्रेडेंशियल्स बेयरर टोकन से। स्कोप्ड API कुंजी को सत्रों पर लिखने की पहुँच चाहिए। यह endpoint हर API कुंजी के लिए लिखने की वही सीमा साझा करता है, यानी प्रति मिनट 300 अनुरोध।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/bank/account-check/
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/bank/account-check/:
    post:
      tags:
        - Standalone APIs
      summary: बैंक खाते की जांच करें
      description: >-
        बैंक खाते में पैसे भेजने से पहले यह जांचें कि वह आपके द्वारा नामित
        व्यक्ति या कंपनी का है या नहीं। कोई सत्र नहीं और कोई साइन-इन नहीं: नाम
        और खाता भेजें, परिणाम पढ़ें। यह आपके बैकएंड से चलने वाला बैंक सत्यापन
        चरण का [खाता जांच](/hi/core-technology/bank-verification/account-check)
        है।


        **आप क्या भेजते हैं।** खाते का `country` (ISO 3166-1 alpha-3),
        `account`, उस देश में प्रचलित प्रारूप में, और `holder` नाम: किसी व्यक्ति
        के लिए `full_name` या किसी कंपनी के लिए `business_name`। व्यवसाय का नाम
        देने पर व्यावसायिक खाते की जांच होती है।


        **आपको क्या वापस मिलता है।** `result` या तो `match`, `close_match`,
        `no_match` या `cannot_verify` होता है। `close_match` पर, `holder_name`
        वह नाम होता है जिसके नाम पर बैंक ने खाता रखा है, जब बैंक ने इसे लौटाया
        हो। `account` केवल अंतिम 4 वर्ण दिखाते हुए मास्क होकर वापस आता है।


        **बिलिंग।** बैंक जिस प्रत्येक जांच का उत्तर देता है, उसका बिल खाते के
        देश के लिए निर्धारित खाता जांच की कीमत पर एक बार लगाया जाता है, चाहे
        परिणाम कुछ भी हो: `no_match`, जो खाता मौजूद नहीं है और `cannot_verify`
        का भी बिल भेजा जाता है। त्रुटि के साथ उत्तर दिए गए अनुरोध का कभी बिल
        नहीं भेजा जाता है।


        **प्रत्येक अनुरोध एक नई जांच है।** कोई आइडेम्पोटेंसी कुंजी नहीं है और
        जांच को वापस पढ़ने के लिए कोई endpoint नहीं है, इसलिए पुनः प्रयास किया
        गया अनुरोध फिर से चलता है, और उसका फिर से बिल भेजा जाता है। रिस्पॉन्स को
        संग्रहीत करें।


        **सैंडबॉक्स।** नमूना खाता विवरणों के साथ सैंडबॉक्स API कुंजी का उपयोग
        करें। एक सैंडबॉक्स कुंजी किसी भी बैंक को कॉल नहीं करती है और कोई शुल्क
        नहीं लिया जाता है। IBAN के अंतिम 4 वर्ण, अन्यथा खाता संख्या के अंतिम 4
        वर्ण, उत्तर चुनते हैं: `0001` एक `holder_name` के साथ `close_match`,
        `0002` बिना किसी नाम के `close_match`, `0003` और `0006` एक `no_match`,
        `0004` `cannot_verify`, `0005` एक `503` और `0009` एक `400`। कोई भी अन्य
        अंतिम 4 वर्ण `match` चुनते हैं।


        **API कुंजियाँ।** एक स्कोप्ड API कुंजी को सत्रों के लिए राइट एक्सेस की
        आवश्यकता होती है।
      operationId: post_v3_bank_account_check
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankAccountCheckRequest'
            examples:
              Person, Nigeria:
                summary: >-
                  एक बैंक कोड और खाता संख्या, जिसे किसी व्यक्ति के नाम के
                  विरुद्ध जाँचा गया है
                value:
                  country: NGA
                  account:
                    bank_code: '000014'
                    account_number: '0123450001'
                  holder:
                    full_name: Maria Oliveira
                  vendor_data: payout_20481
              Company, Nigeria:
                summary: >-
                  एक बैंक कोड और खाता संख्या, जिसे कंपनी के नाम के विरुद्ध जाँचा
                  गया है
                value:
                  country: NGA
                  account:
                    bank_code: '000014'
                    account_number: '0123456789'
                  holder:
                    business_name: Northwind Trading Ltd
      responses:
        '200':
          description: >-
            बैंक ने उत्तर दिया। परिणाम चाहे जो भी हो, जाँच के लिए शुल्क लिया
            जाता है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckResponse'
              examples:
                Close match:
                  summary: बैंक खाते को मिलते-जुलते नाम के तहत रखता है
                  value:
                    request_id: c2f4a9e0-7b1d-4c3a-9e55-1d0a6b8f2a47
                    result: close_match
                    holder_name: MARIA R OLIVEIRA
                    account: '****0001'
                    vendor_data: payout_20481
                    created_at: '2026-10-21T14:32:08Z'
                Match:
                  summary: बैंक भेजे गए नाम के तहत खाता रखता है
                  value:
                    request_id: 5b0e2d7c-41a8-4f6e-9c3b-8e7d1a2f6c90
                    result: match
                    holder_name: null
                    account: '****6789'
                    vendor_data: null
                    created_at: '2026-10-21T14:35:41Z'
        '400':
          description: >-
            भेजे गए रूप में अस्वीकार कर दिया गया, और बिल नहीं किया गया। `field`
            उस बॉडी फ़ील्ड का नाम बताता है जिसे ठीक करना है और `reason` बताता है
            कि क्यों, उन्हीं कारणों के साथ जो होस्टेड खाता फ़ॉर्म दिखाता है।
            केवल पहले अस्वीकार किए गए फ़ील्ड की रिपोर्ट की जाती है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Missing field:
                  summary: देश के सत्यापन के लिए बैंक कोड की आवश्यकता होती है
                  value:
                    detail: The bank code is not valid (required).
                    code: invalid_account_input
                    field: account.bank_code
                    reason: required
                Invalid IBAN:
                  summary: IBAN की लंबाई उसके देश के अनुसार गलत है
                  value:
                    detail: The iban is not valid (length).
                    code: invalid_account_input
                    field: account.iban
                    reason: length
                Refused by the bank:
                  summary: बैंक ने भेजे गए खाते को अस्वीकार कर दिया
                  value:
                    detail: The account was refused as typed (rejected).
                    code: invalid_account_input
                    field: account.account_number
                    reason: rejected
                No name:
                  summary: '`holder` में न तो `full_name` है और न ही `business_name`'
                  value:
                    detail: >-
                      Send full_name for a person or business_name for a
                      company.
                    code: invalid_account_input
                    field: holder
                    reason: required
                Consent required:
                  summary: देश के खाता सत्यापन के लिए खाताधारक की सहमति आवश्यक है
                  value:
                    detail: >-
                      Account checks in this country need the account holder's
                      explicit consent. Ask for it, then send `consent=true`.
                    code: invalid_account_input
                    field: consent
                    reason: required
        '401':
          description: स्कोप्ड API कुंजी की समय-सीमा समाप्त हो गई है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Expired key:
                  summary: कुंजी की समाप्ति तिथि बीत चुकी है
                  value:
                    detail: This API key has expired.
        '402':
          description: >-
            जाँच के लिए भुगतान नहीं किया जा सकता, इसलिए यह नहीं चली। अपना बैलेंस
            टॉप अप करें, फिर इसे दोबारा भेजें।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Out of credit:
                  summary: आपका बैलेंस एक जांच को कवर नहीं कर सकता
                  value:
                    detail: >-
                      You don't have enough credits to perform this request.
                      Please top up at https://business.didit.me
                    code: insufficient_credits
                Not in your contract:
                  summary: आपके अनुबंध में Account check API के लिए कोई कीमत नहीं है
                  value:
                    detail: >-
                      Your contract does not price the Account check API.
                      Contact your account manager.
                    code: contract_rate_missing
        '403':
          description: >-
            `x-api-key` हेडर या वाहक token अनुपस्थित या अमान्य है, अनुरोध कुंजी
            की IP सूची से बाहर के पते से आया है, या किसी स्कोप्ड कुंजी के पास
            सत्रों के लिए राइट एक्सेस नहीं है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Missing or invalid credentials:
                  summary: कोई मान्य API कुंजी या token नहीं
                  value:
                    detail: You do not have permission to perform this action.
                No sessions write:
                  summary: सत्रों के लिए राइट (write) एक्सेस के बिना एक स्कोप्ड कुंजी
                  value:
                    detail: This API key has no write access to sessions.
        '404':
          description: >-
            कोई खाता जाँच अभी इस खाते की सेवा नहीं करती है, इसलिए कुछ भी जाँचा
            या बिल नहीं किया गया। `country_not_covered`: कोई भी इसके देश, या
            वहाँ इसके प्रकार के खाते (व्यक्ति या व्यवसाय) की सेवा नहीं करता है।
            `bank_not_covered`: कोई भी इसके बैंक की सेवा नहीं करता है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Country not covered:
                  summary: देश के लिए कोई खाता जाँच उपलब्ध नहीं है
                  value:
                    detail: No account check serves this country yet.
                    code: country_not_covered
                Bank not covered:
                  summary: खाते के बैंक के लिए कोई खाता जाँच उपलब्ध नहीं है
                  value:
                    detail: No account check serves this account's bank yet.
                    code: bank_not_covered
        '429':
          $ref: '#/components/responses/RateLimitedWrite'
        '503':
          description: >-
            बैंक उत्तर नहीं दे सका। न तो जाँच की गई और न ही शुल्क लिया गया; जाँच
            बाद में पुनः भेजें।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Unavailable:
                  summary: बैंक ने उत्तर नहीं दिया
                  value:
                    detail: >-
                      The account check is temporarily unavailable and this
                      request was not charged. Please try again.
                    code: account_check_unavailable
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST https://verification.didit.me/v3/bank/account-check/ \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "country": "NGA",
                "account": {"bank_code": "000014", "account_number": "0123450001"},
                "holder": {"full_name": "Maria Oliveira"},
                "vendor_data": "payout_20481"
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.account_check(
                country="NGA",
                account={
                    "account_number": "0123450001",
                    "bank_code": "000014",
                },
                holder={
                    "full_name": "Maria Oliveira",
                },
                vendor_data="payout_20481",
            )
            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.bank.accountCheck({
              country: "NGA",
              account: {
                account_number: "0123450001",
                bank_code: "000014",
              },
              holder: {
                full_name: "Maria Oliveira",
              },
              vendor_data: "payout_20481",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.AccountCheck(ctx, didit.BankAccountCheckRequest{\n\tCountry: \"NGA\",\n\tAccount: didit.BankAccountCheckRequestAccount{\n\t\tAccountNumber: didit.String(\"0123450001\"),\n\t\tBankCode:      didit.String(\"000014\"),\n\t},\n\tHolder: didit.BankAccountCheckHolder{\n\t\tFullName: didit.String(\"Maria Oliveira\"),\n\t},\n\tVendorData: didit.String(\"payout_20481\"),\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.BankAccountCheckHolder;

            import me.didit.types.BankAccountCheckPersonHolder;

            import me.didit.types.BankAccountCheckRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().accountCheck(BankAccountCheckRequest.builder()
                    .country("NGA")
                    .account(BankAccountCheckRequest.Account.builder()
                            .accountNumber("0123450001")
                            .bankCode("000014")
                            .build())
                    .holder(BankAccountCheckHolder.ofBankAccountCheckPersonHolder(BankAccountCheckPersonHolder.builder()
                            .fullName("Maria Oliveira")
                            .build()))
                    .vendorData("payout_20481")
                    .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->bank->accountCheck([
                'country' => 'NGA',
                'account' => [
                    'account_number' => '0123450001',
                    'bank_code' => '000014',
                ],
                'holder' => [
                    'full_name' => 'Maria Oliveira',
                ],
                'vendor_data' => 'payout_20481',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.bank.account_check(
              country: "NGA",
              account: {
                account_number: "0123450001",
                bank_code: "000014",
              },
              holder: {
                full_name: "Maria Oliveira",
              },
              vendor_data: "payout_20481"
            )
            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.Bank.AccountCheckAsync(new
            BankAccountCheckRequest

            {
                Country = "NGA",
                Account = new()
                {
                    AccountNumber = "0123450001",
                    BankCode = "000014",
                },
                Holder = new()
                {
                    FullName = "Maria Oliveira",
                },
                VendorData = "payout_20481",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    BankAccountCheckRequest:
      type: object
      required:
        - country
        - account
        - holder
      properties:
        country:
          type: string
          minLength: 3
          maxLength: 3
          description: >-
            खाते का देश, ISO 3166-1 alpha-3 कोड के रूप में, उदाहरण के लिए `NGA`।
            लोअरकेस स्वीकार किया जाता है।
          example: NGA
        account:
          type: object
          description: >-
            खाता जिस तरह से उसका देश इसे लिखता है: एक `iban`, या देश के लिए
            आवश्यक बैंक या शाखा कोड के साथ एक `account_number` (`sort_code`,
            `routing_number`, `transit_institution`, `bsb`, `ifsc`, `bank_code`
            या `bic`)। मेक्सिको एक `clabe` और अर्जेंटीना एक `cbu_cvu` लेता है,
            जो पहले से ही बैंक का नाम बताते हैं। एक व्यावसायिक खाता वहां एक
            `registration_id` जोड़ता है जहां देश इसकी मांग करता है। रिक्त स्थान,
            डैश और बिंदुओं को अनदेखा किया जाता है। देश की जांच में उपयोग न की
            जाने वाली कुंजियों को अनदेखा किया जाता है; एक कुंजी जिसकी उसे
            आवश्यकता है और जो नहीं मिलती है वह एक `400` है जो इसका नाम बताती है।
          properties:
            iban:
              type: string
              maxLength: 64
              description: >-
                IBAN, ऐसे देश में जो IBAN का उपयोग करता है। यह `country` से
                संबंधित होना चाहिए।
            account_number:
              type: string
              maxLength: 64
              description: >-
                खाता संख्या, ऐसे देश में जो खाते को एक अलग बैंक या शाखा कोड के
                साथ लिखता है।
            sort_code:
              type: string
              maxLength: 64
              description: 'यूनाइटेड किंगडम: 6-अंकीय सॉर्ट कोड।'
            routing_number:
              type: string
              maxLength: 64
              description: 'संयुक्त राज्य अमेरिका: 9-अंकीय ABA रूटिंग नंबर।'
            transit_institution:
              type: string
              maxLength: 64
              description: 'कनाडा: 8-अंकीय ट्रांज़िट और संस्थान संख्या।'
            bsb:
              type: string
              maxLength: 64
              description: 'ऑस्ट्रेलिया: 6-अंकीय BSB।'
            ifsc:
              type: string
              maxLength: 64
              description: 'भारत: 11-वर्णीय IFSC।'
            bank_code:
              type: string
              maxLength: 64
              description: >-
                बैंक का कोड, जहाँ देश को इसकी आवश्यकता होती है, उदाहरण के लिए
                नाइजीरिया में।
            bic:
              type: string
              maxLength: 64
              description: बैंक का BIC, जहाँ देश की जांच में इसकी आवश्यकता होती है।
            clabe:
              type: string
              maxLength: 64
              description: 'मेक्सिको: 18-अंकीय CLABE। यह पहले से ही बैंक की पहचान करता है।'
            cbu_cvu:
              type: string
              maxLength: 64
              description: >-
                अर्जेंटीना: 22-अंकीय CBU या CVU। यह पहले से ही बैंक का नाम बताता
                है।
            registration_id:
              type: string
              maxLength: 64
              description: एक व्यवसाय खाते की पंजीकरण संख्या, जहाँ देश इसकी माँग करता है।
          additionalProperties:
            type: string
            maxLength: 64
          example:
            bank_code: '000014'
            account_number: '0123450001'
        holder:
          $ref: '#/components/schemas/BankAccountCheckHolder'
        vendor_data:
          type: string
          nullable: true
          description: इस जाँच के लिए आपका अपना संदर्भ, बिना किसी बदलाव के वापस किया गया।
          example: payout_20481
        consent:
          type: boolean
          default: false
          description: >-
            जब खाताधारक ने इस जाँच के लिए स्पष्ट रूप से सहमति दी हो, तो `true`
            पर सेट करें। उन देशों में आवश्यक है जहाँ खाता जाँच के लिए उस सहमति
            की आवश्यकता होती है: इसके बिना जाँच को `400` के साथ अस्वीकार कर दिया
            जाता है जिसका `field` `consent` है और जिसका `reason` `required` है,
            और कुछ भी बिल नहीं किया जाता है। अन्य जगहों पर यह वैकल्पिक है, और जब
            आप इसे भेजते हैं तो Didit इसे जाँच के शुल्क के साथ रिकॉर्ड करता है।
          example: true
    BankAccountCheckResponse:
      type: object
      required:
        - request_id
        - result
        - holder_name
        - account
        - vendor_data
        - created_at
      properties:
        request_id:
          type: string
          format: uuid
          description: इस जांच की ID।
        result:
          type: string
          enum:
            - match
            - close_match
            - no_match
            - cannot_verify
          description: >-
            `match`: बैंक में खाता आपके द्वारा भेजे गए नाम के तहत है।
            `close_match`: मिलते-जुलते नाम के तहत, उदाहरण के लिए छूटा हुआ मध्य
            नाम या कोई टाइपो। `no_match`: किसी अन्य नाम के तहत, या ऐसा कोई खाता
            मौजूद नहीं है। `cannot_verify`: बैंक ने नाम की तुलना किए बिना उत्तर
            दिया, उदाहरण के लिए किसी ब्लॉक या बंद खाते के लिए।
        holder_name:
          type: string
          nullable: true
          description: >-
            केवल `close_match` पर, और केवल तभी जब बैंक ने इसे लौटाया हो: खाते
            में दर्ज नाम, जैसा कि बैंक के रिकॉर्ड में है। अन्यथा `null`।
        account:
          type: string
          description: खाता, केवल अंतिम 4 वर्ण दिखाते हुए मास्क किया गया।
        vendor_data:
          type: string
          nullable: true
          description: आपका अपना संदर्भ, जैसा आपने भेजा था।
        created_at:
          type: string
          format: date-time
          description: जब जाँच चली थी, UTC में।
    BankAccountCheckError:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          description: क्या समस्या हुई, अंग्रेज़ी में।
        code:
          type: string
          description: >-
            शाखा (branch) निर्धारित करने के लिए एक स्थिर कोड। `401` और `403` पर
            अनुपस्थित।
        field:
          type: string
          description: >-
            केवल `400`: सही करने के लिए बॉडी फ़ील्ड, एक डॉटेड पाथ के रूप में,
            उदाहरण के लिए `account.sort_code`।
        reason:
          type: string
          enum:
            - required
            - length
            - format
            - checksum
            - country_mismatch
            - rejected
          description: >-
            केवल `400`: फ़ील्ड अस्वीकार किए जाने का कारण। `required`, `length`,
            `format`, `checksum` और `country_mismatch` (किसी अन्य देश का IBAN)
            Didit के अपने चेक हैं; `rejected` का अर्थ है कि बैंक ने खाते को भेजे
            गए अनुसार अस्वीकार कर दिया।
    BankAccountCheckHolder:
      description: >-
        वह नाम जिसके विरुद्ध खाते की जांच की जाती है। `full_name` और
        `business_name` में से ठीक एक भेजें।
      oneOf:
        - $ref: '#/components/schemas/BankAccountCheckPersonHolder'
        - $ref: '#/components/schemas/BankAccountCheckBusinessHolder'
    BankAccountCheckPersonHolder:
      type: object
      description: वह व्यक्ति जिसके पास खाता होना चाहिए।
      required:
        - full_name
      properties:
        full_name:
          type: string
          maxLength: 255
          description: उस व्यक्ति का पूरा नाम जिसके पास खाता होना चाहिए।
          example: Maria Oliveira
    BankAccountCheckBusinessHolder:
      type: object
      description: वह कंपनी जिसके पास खाता होना चाहिए। किसी व्यवसाय खाते की जाँच करता है।
      required:
        - business_name
      properties:
        business_name:
          type: string
          maxLength: 255
          description: >-
            उस कंपनी का नाम जिसके पास खाता होना चाहिए। किसी व्यावसायिक खाते की
            जांच करता है।
  responses:
    RateLimitedWrite:
      description: >-
        प्रति API कुंजी प्रति मिनट 300 अनुरोधों की साझा लिखने की सीमा पार हो गई।
        पुनः प्रयास करने से पहले `Retry-After` का पालन करें।
      content:
        application/json:
          schema:
            type: object
            required:
              - detail
            properties:
              detail:
                type: string
          example:
            detail: >-
              Write request rate limit exceeded. You can make up to 300 requests
              per minute.
  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.