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

# KYB रजिस्ट्री खोज API - कंपनी खोज

> Didit KYB रजिस्ट्री खोज API से कंपनी उम्मीदवार खोजें। पेड कंपनी-डेटा स्रोतों पर सफल खोज $0.50 प्रति अनुरोध; प्रोफ़ाइल प्राप्ति अलग बिल होती है।

इस endpoint का उपयोग पहले कंपनी रजिस्ट्री में मिलान वाले उम्मीदवार खोजने के लिए करें।
खोज एक सहेजी गई Manual Check नहीं बनाती।

भुगतान वाले कंपनी-डेटा स्रोत का उपयोग करने वाली सफल स्टैंडअलोन खोजों की लागत **\$0.50 प्रति अनुरोध** है, चाहे उम्मीदवारों की संख्या कितनी भी हो। खाली परिणाम, विफल खोजें, और केवल अन्य स्रोतों से मिले परिणाम शुल्क-योग्य नहीं हैं। बाद में प्रोफ़ाइल प्राप्त करने का शुल्क अलग से लिया जाता है।

ऐसी खोज के लिए जो भुगतान वाला स्रोत उपयोग कर सकती है, Didit रजिस्ट्री से संपर्क करने से पहले लागू खोज कीमत की जाँच करता है और उसे आरक्षित करता है। अपर्याप्त बैलेंस पर `403` लौटता है, जिसमें `code: "insufficient_credits"` होता है।
अनुबंधित बिलिंग आपकी सहमत खोज दर का पालन करती है; बिना कॉन्फ़िगर की गई अनुबंध दर खोज से पहले अस्वीकार कर दी जाती है।
सैंडबॉक्स खोजें निःशुल्क हैं।
हर दोहराई गई सफल खोज एक नया शुल्क-योग्य अनुरोध है; कॉलबैक डिलीवरी से खोज शुल्क नहीं जुड़ता।

यदि आप `webhook_url` भेजते हैं, तो Didit प्रदाता द्वारा खोज हल होने के दौरान तुरंत उत्तर दे सकता है, और उम्मीदवार तैयार होने पर उन्हें आपके कॉलबैक URL पर पोस्ट करता है। यह कॉलबैक डिज़ाइन से ही हस्ताक्षररहित है, इसलिए इस खोज सूचना के लिए आपको webhook सीक्रेट कॉन्फ़िगर करने की ज़रूरत नहीं है। देखें [खोज कॉलबैक payload का उदाहरण](https://docs.didit.me/hi/standalone-apis/kyb-registry.md#खोज-कॉलबैक)।

सही `kyb_response_id` चुनने के बाद, शुल्क-योग्य रजिस्ट्री प्रोफ़ाइल को आपको जिस स्तर की ज़रूरत है उस पर प्राप्त करने के लिए `POST /v3/kyb/select/` (Lite), `POST /v3/kyb/shareholders/` या `POST /v3/kyb/ubo/` कॉल करें।

> [!NOTE]
>
> हर उम्मीदवार का `fetch_status` खोज के समय `pending` होता है, और जब तक आप उस उम्मीदवार का चयन नहीं करते तब तक `pending` ही रहता है। खोज केवल उम्मीदवारों की सूची देती है, और पूरी प्रोफ़ाइल चयन करने पर ही प्राप्त होती है। उसके हल होने की प्रतीक्षा में खोज को बार-बार न जाँचें।
>
> `kyb_response_id` एक अपारदर्शी, अस्थायी हैंडल है जो एक खोज अनुरोध तक सीमित है: इसे जैसा प्राप्त हुआ वैसा ही वापस भेजें, इसकी सामग्री को कभी पार्स न करें और उससे कुछ न निकालें, और यह अपेक्षा रखें कि वही खोज दोबारा करने पर नई ids मिलेंगी। खोज के बाद उम्मीदवार को शीघ्र चुनें, और कंपनी की स्थायी पहचान के लिए जब भी ज़रूरत हो `registration_number` का उपयोग करें।

## खोज स्तर

`tier` यह चुनता है कि खोज किस रजिस्ट्री स्तर की प्रदाता श्रृंखला पर चले: `basic` (डिफ़ॉल्ट, Lite श्रृंखला), `shareholders` या `ubo`। उम्मीदवार सूची उसी स्तर की श्रृंखला से आती है, और Lite खोज हमेशा उसी स्रोत से नहीं पढ़ती। इसलिए खाली Lite खोज यह साबित नहीं करती कि रजिस्ट्री में कंपनी नहीं है। जिस स्तर की आपको ज़रूरत है, उस पर फिर से खोजें।

जहाँ देश वह स्तर नहीं देता जिसका आप नाम लेते हैं, वहाँ खोज उस स्तर तक का सबसे ऊँचा स्तर चलाती है जिसे देश देता है। जिस देश में कोई भी रजिस्ट्री डेटा नहीं है, वह रजिस्ट्री जाँच के लिए उपलब्ध नहीं है; मैन्युअल कंपनी प्रविष्टि के साथ जारी रखें।

उस स्तर पर खोजें जिसे आप खरीदना चाहते हैं, फिर उम्मीदवार को उस endpoint से प्राप्त करें जो उसे बेचता है:

| खोजा गया `tier` | वह endpoint जो उम्मीदवार प्राप्त करता है |
| - | - |
| `basic` (डिफ़ॉल्ट) | `POST /v3/kyb/select/` (Lite) |
| `shareholders` | `POST /v3/kyb/shareholders/` |
| `ubo` | `POST /v3/kyb/ubo/` |

## search\_type

`search_type` केवल `contains` स्वीकार करता है, और यही डिफ़ॉल्ट है। जिन रजिस्ट्री स्रोतों पर खोज आधारित है, वे कंपनी के नाम का मिलान नाम में शामिल होने के आधार पर करते हैं। इसलिए `start_with` और `fuzzy` को `400` (`"start_with" is not a valid choice`) के साथ अस्वीकार किया जाता है, न कि चुपचाप `contains` मान लिया जाता है। सटीक कंपनी मिलान के लिए `registration_number` भेजें।

## होस्टेड और स्टैंडअलोन खोज

`POST /v1/kyb/search/` वह खोज है जिसे होस्टेड सत्यापन प्रवाह चलाता है। यह सत्यापन सत्र द्वारा प्रमाणित होती है और API कुंजी से किए गए अनुरोध पर `403` लौटाती है, और `tier` नहीं लेती। वर्कफ़्लो का KYB रजिस्ट्री कॉन्फ़िगरेशन श्रृंखला चुनता है। स्टैंडअलोन API अपनी `x-api-key` के साथ `POST /v2/kyb/search/` या `POST /v3/kyb/search/` कॉल करता है। `tier` इनपुट और स्तर-आधारित select endpoints वे माध्यम हैं जिनसे स्टैंडअलोन इंटीग्रेशन उन्हीं उम्मीदवारों तक, अपनी ज़रूरत के स्तर पर, पहुँचता है।

## रजिस्ट्री आउटेज को संभालना

यदि रजिस्ट्री प्रदाता अस्थायी रूप से उपलब्ध नहीं है, तो endpoint एक स्थिर, मशीन-पठनीय कोड के साथ `502` लौटाता है:

```json theme={null}
{
  "detail": "The company registry provider is temporarily unavailable.",
  "code": "kyb_registry_provider_unavailable"
}
```

यह कोड मिलने पर उपयोगकर्ता को मैन्युअल कंपनी प्रविष्टि के साथ जारी रखने दें, या उनसे बाद में पुनः प्रयास करने को कहें। सत्यापन त्रुटियों को अलग रखें: अमान्य खोज इनपुट `400` लौटाता है और इस आउटेज कोड का उपयोग नहीं करता।

## असमर्थित देशों और खोज सीमाओं को संभालना

दो और स्थिर कोड बताते हैं कि पुनः प्रयास रोकें और मैन्युअल कंपनी प्रविष्टि के साथ जारी रखें:

| स्थिति | `code` | कब |
| - | - | - |
| `400` | `kyb_registry_country_unsupported` | देश का किसी भी स्तर पर कोई कंपनी रजिस्ट्री स्रोत नहीं है। यह सीमा स्थायी है, इसलिए वही खोज दोबारा करने से कभी सफलता नहीं मिलती। |
| `429` | `kyb_registry_search_limit_reached` | आपके एप्लिकेशन ने भुगतान वाले कंपनी-डेटा स्रोतों पर प्रति घंटे 600 खोजों का अपना कोटा खर्च कर दिया है, और देश के लिए कोई मुफ़्त स्रोत नहीं बचा है। विंडो बीतने की प्रतीक्षा करें या कंपनी को मैन्युअल रूप से दर्ज करें। |

होस्टेड प्रवाह में, हर रजिस्ट्री चरण में भुगतान वाले कंपनी-डेटा स्रोत पर 3 खोजें अनुमत हैं। तीसरी के बाद आवेदक को मैन्युअल प्रविष्टि का विकल्प दिया जाता है।

ऐसा उम्मीदवार चुनना जो कंपनी नहीं, बल्कि ट्रेडमार्क पंजीकरण है, `400` लौटाता है, जिसमें `code: "kyb_registry_entry_not_a_company"` होता है। इसके बजाय खोज परिणामों में से कोई कंपनी चुनें।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/kyb/search/
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/kyb/search/:
    post:
      tags:
        - Standalone APIs
      summary: KYB रजिस्ट्री कंपनी खोज (स्टैंडअलोन)
      description: >-
        Search official company registries for candidate companies by name
        and/or registration number. This is step 1 of the two-step registry
        flow: **search** returns lightweight candidates, then `POST
        /v3/kyb/select/` retrieves the full profile of one candidate.


        **Search billing.** Successful searches using a paid company-data source
        cost USD 0.50 per request, regardless of candidate count. Empty results,
        failures and results served only by other sources are not charged. The
        applicable price is reserved before searching; insufficient balance
        returns 403 with code `insufficient_credits`. Contract rates apply where
        agreed, and an unconfigured contract search rate returns 403. Sandbox
        searches are free. Repeating a successful search can incur another
        charge; callback delivery does not add a charge. Profile retrieval is
        billed separately. This search fee also applies to v2. Candidates always
        come back with `fetch_status: "pending"`: the full company data is only
        fetched (and billed) on select.


        **`kyb_response_id` is ephemeral.** It is a per-search handle, not a
        stable company id. Select promptly after searching and re-search to get
        a fresh handle instead of storing it.


        **`tier` picks the provider chain.** `tier` names the registry tier the
        search runs on: `basic` (the default, the Lite chain), `shareholders` or
        `ubo`. The search uses the provider chain that serves that tier, and it
        is not always the same chain the Lite search reads, so an empty Lite
        search is not proof that the registry does not hold the company — search
        again at the tier you need. A country that does not offer the tier you
        name is searched at the highest tier it offers up to that one. Retrieve
        the candidate from the endpoint that sells that tier: `POST
        /v3/kyb/select/` (Lite), `POST /v3/kyb/shareholders/` or `POST
        /v3/kyb/ubo/`.


        **Authentication.** `POST /v3/kyb/search/` (and `/v2/`) takes your
        application's API key in the `x-api-key` header. The hosted `POST
        /v1/kyb/search/` is the session-authenticated route a hosted
        verification flow calls: API कुंजी देने पर यह `403` लौटाता है और कोई
        `tier` नहीं लेता है — वर्कफ़्लो का KYB रजिस्ट्री कॉन्फ़िगरेशन श्रृंखला
        का चयन करता है।


        **Two modes.**

        - *सिंक्रोनस (डिफ़ॉल्ट):* API रजिस्ट्री को तब तक पोल करता है जब तक कि
        सर्च पूरी न हो जाए और अंतिम उम्मीदवार सूची (`search_resolved: true`)
        वापस न आ जाए।

        - *असिंक्रोनस:* `webhook_url` पास करें और API तुरंत वापस आ जाता है —
        आमतौर पर `search_status: "pending"` और एक खाली उम्मीदवार सूची के साथ —
        फिर रजिस्ट्री की खोज पूरी होने पर आपके URL पर
        `kyb.registry_search.resolved` कॉलबैक POST करता है। कॉलबैक का मुख्य भाग
        `{"event_id", "event_type": "kyb.registry_search.resolved",
        "request_id", "vendor_data", "metadata", "search_status",
        "search_resolved", "kyb_registry", "timestamp", "created_at"}` होता है —
        ध्यान दें कि कॉलबैक में `timestamp` और `created_at` epoch पूर्णांक हैं,
        इस endpoint के ISO `created_at` के विपरीत — और इसे **अहस्ताक्षरित** भेजा
        जाता है (हेडर `X-Didit-Unsigned-Callback: true`, कोई `X-Signature`
        नहीं)।


        **देश कोड।** ISO 3166-1 alpha-2 (`GB`, `DE`), साथ ही `XX-YY` उपखंड कोड
        जहाँ रजिस्ट्रियां क्षेत्रीय हैं — उदाहरण के लिए कैलिफ़ोर्निया के लिए
        `US-CA`।


        **सैंडबॉक्स।** सैंडबॉक्स एप्लिकेशन की कुंजियाँ किसी भी रजिस्ट्री से
        संपर्क किए बिना एक स्थिर उम्मीदवार लौटाती हैं।
      operationId: post_v3_kyb_search
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - country_code
              properties:
                country_code:
                  type: string
                  maxLength: 10
                  description: >-
                    उस देश का ISO 3166-1 alpha-2 कोड जिसकी कंपनी रजिस्ट्री में
                    खोज करनी है। उदाहरण के लिए, `GB`। जहाँ कंपनी रजिस्ट्रियाँ
                    राज्य या प्रांत स्तर पर संचालित होती हैं, वहाँ ISO 3166-2
                    सबडिवीजन कोड को `XX-YY` के रूप में जोड़ें: `US-CA`
                    कैलिफ़ोर्निया रजिस्ट्री में खोज करता है। संयुक्त राज्य
                    अमेरिका की खोजों के लिए हमेशा सबडिवीजन की आवश्यकता होती है —
                    केवल `US` को अस्वीकार कर दिया जाता है। केस-असंवेदी; अपरकेस
                    में सामान्यीकृत किया जाता है।
                  example: GB
                name:
                  type: string
                  maxLength: 255
                  description: >-
                    खोजने के लिए कंपनी का नाम। या तो `name` या
                    `registration_number` आवश्यक है।
                  example: Tesco
                registration_number:
                  type: string
                  maxLength: 100
                  description: >-
                    खोजने के लिए रजिस्ट्री पंजीकरण संख्या। `name` या
                    `registration_number` में से कोई एक आवश्यक है।
                tier:
                  type: string
                  enum:
                    - basic
                    - shareholders
                    - ubo
                  default: basic
                  description: >-
                    रजिस्ट्री स्तर जिसकी प्रदाता श्रृंखला पर यह खोज चलती है।
                    `basic` (डिफ़ॉल्ट) देश की Lite श्रृंखला को खोजता है;
                    `shareholders` और `ubo` उस स्तर की स्वामित्व श्रृंखला को
                    खोजते हैं, जो एक अलग स्रोत हो सकता है, इसलिए खाली Lite खोज
                    यह साबित नहीं करती कि रजिस्ट्री में कंपनी मौजूद नहीं है। जिस
                    देश में नामित स्तर की सुविधा नहीं है, वहां उस स्तर तक उपलब्ध
                    उच्चतम स्तर पर खोज की जाती है। उस endpoint से उम्मीदवार को
                    पुनः प्राप्त करें जो आपके द्वारा खोजे गए स्तर को बेचता है:
                    `POST /v3/kyb/select/` (Lite), `POST /v3/kyb/shareholders/`
                    या `POST /v3/kyb/ubo/`।
                  example: basic
                search_type:
                  type: string
                  enum:
                    - contains
                  default: contains
                  description: >-
                    रजिस्ट्री खोज द्वारा लागू नाम-मिलान रणनीति। `contains`
                    एकमात्र स्वीकृत मान है: खोज के पीछे कोई भी रजिस्ट्री स्रोत
                    प्रीफ़िक्स या फ़ज़ी मोड प्रदान नहीं करता है, इसलिए
                    `start_with` और `fuzzy` को `400` (`not a valid choice`) के
                    साथ अस्वीकार कर दिया जाता है।
                vendor_data:
                  type: string
                  description: >-
                    इस लुकअप के लिए आपका पहचानकर्ता; वापस दोहराया जाता है और
                    webhook कॉलबैक में शामिल किया जाता है।
                metadata:
                  type: object
                  nullable: true
                  description: >-
                    फ़्री-फ़ॉर्म JSON; वापस लौटाया गया और webhook कॉलबैक में
                    शामिल किया गया।
                webhook_url:
                  type: string
                  format: uri
                  maxLength: 500
                  description: >-
                    खोज को एसिंक्रोनस मोड में स्विच करता है: API तुरंत रिस्पॉन्स
                    देता है और उम्मीदवारों की सूची तैयार होने पर इस URL पर एक
                    अनहस्ताक्षरित `kyb.registry_search.resolved` कॉलबैक POST
                    करता है।
            example:
              country_code: GB
              name: Tesco
              search_type: contains
              vendor_data: company-1234
      responses:
        '200':
          description: >-
            खोज स्वीकार कर ली गई। सिंक्रोनस मोड हल की गई उम्मीदवार सूची लौटाता
            है; webhook मोड तुरंत रिस्पॉन्स देता है (अक्सर `search_status:
            "pending"`) और `kyb.registry_search.resolved` कॉलबैक के माध्यम से
            अंतिम सूची डिलीवर करता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  request_id:
                    type: string
                    format: uuid
                    description: >-
                      `webhook_url` के साथ: स्थायी रूप से संग्रहीत खोज-अनुरोध
                      ID, जो `kyb.registry_search.resolved` कॉलबैक में
                      `request_id` के रूप में दोहराई जाती है। `webhook_url` के
                      बिना: एक अस्थायी कोरिलेशन UUID (खोज संग्रहीत नहीं की जाती
                      है)।
                  kyb_registry:
                    $ref: '#/components/schemas/KYBRegistrySearchResults'
                  vendor_data:
                    type: string
                    nullable: true
                    description: आपके द्वारा भेजे गए `vendor_data` का इको।
                  metadata:
                    type: object
                    nullable: true
                    description: आपके द्वारा भेजे गए `metadata` का इको।
                  created_at:
                    type: string
                    format: date-time
              examples:
                Resolved search:
                  summary: सिंक्रोनस मोड — अंतिम उम्मीदवार सूची
                  value:
                    request_id: 0c7e9a40-3a13-4f7e-8a44-9d2e2f1c5b6a
                    kyb_registry:
                      companies:
                        - kyb_response_id: 69aeeb95febb0f1704042259
                          name: Tesco PLC
                          registration_number: '00445790'
                          status: active
                          type: Public Limited Company
                          risk_level: null
                          fetch_status: pending
                        - kyb_response_id: 69aeeb95febb0f170404225a
                          name: E-TESCO LTD
                          registration_number: '15168476'
                          status: active
                          type: Private Limited Company
                          risk_level: null
                          fetch_status: pending
                      pagination:
                        total: 2
                        page: 1
                        per_page: 25
                      search_status: resolved
                      search_resolved: true
                    vendor_data: company-1234
                    metadata: null
                    created_at: '2026-06-11T10:40:00.000000+00:00'
                Pending search (webhook mode):
                  summary: >-
                    `webhook_url` प्रदान किया गया — उम्मीदवार
                    kyb.registry_search.resolved कॉलबैक के माध्यम से आते हैं
                  value:
                    request_id: 5f2d8c1b-7e4a-4b9c-9f0d-3a6e8c2b1d4f
                    kyb_registry:
                      companies: []
                      pagination:
                        total: 0
                        page: 1
                        per_page: 25
                      search_status: pending
                      search_resolved: false
                    vendor_data: company-1234
                    metadata:
                      source: onboarding
                    created_at: '2026-06-11T10:41:00.000000+00:00'
        '400':
          description: >-
            सत्यापन त्रुटि। फ़ील्ड-स्तरीय समस्याएं DRF के मानक एनवेलप का उपयोग
            करती हैं; नाम/पंजीकरण संख्या नियम `non_field_errors` के तहत रिपोर्ट
            करता है। ऐसा देश जिसे रजिस्ट्रियां कवर नहीं करती हैं, वह `code:
            kyb_registry_country_unsupported` के साथ `400` रिस्पॉन्स देता है।
          content:
            application/json:
              examples:
                Missing search criteria:
                  summary: न तो `name` और न ही `registration_number` प्रदान किया गया
                  value:
                    non_field_errors:
                      - Either 'name' or 'registration_number' is required.
                Invalid country_code:
                  summary: '`XX` (alpha-2) या `XX-YY` सबडिवीज़न होना चाहिए'
                  value:
                    country_code:
                      - country_code must be a 2-letter ISO code.
                Invalid search_type:
                  summary: केवल `contains` स्वीकार किया जाता है
                  value:
                    search_type:
                      - '"start_with" is not a valid choice.'
                Invalid webhook_url:
                  summary: '`webhook_url` एक मान्य URL होना चाहिए'
                  value:
                    webhook_url:
                      - Enter a valid URL.
                Country not covered:
                  summary: कोई भी कंपनी रजिस्ट्री इस देश को कवर नहीं करती है
                  value:
                    detail: >-
                      Company registry search is not available for this country.
                      Enter the company details manually to continue.
                    code: kyb_registry_country_unsupported
        '403':
          description: >-
            अनुमति अस्वीकृत। तब लौटाया जाता है जब `x-api-key` हेडर अनुपलब्ध हो;
            गलत, निरस्त या समय-सीमा समाप्त कुंजी `401` लौटाती है। अनुपलब्ध कुंजी
            `{"detail": ...}` के साथ `403` लौटाती है; गलत, निरस्त या समय-सीमा
            समाप्त कुंजी `401` लौटाती है। खोज करने से पहले तब भी लौटाया जाता है
            जब लागू खोज शुल्क को कवर नहीं किया जा सकता (`code:
            "insufficient_credits"`), या जब कोई अनुबंध खोज दर अनुपलब्ध हो।
          content:
            application/json:
              examples:
                Missing or invalid API key:
                  summary: कोई `x-api-key` हेडर नहीं, या कुंजी अमान्य/निरस्त है
                  value:
                    detail: You do not have permission to perform this action.
        '429':
          description: >-
            रेट लिमिट पार हो गई, या खोज की सीमा समाप्त हो गई है।
            POST/PATCH/DELETE endpoints प्रति मिनट प्रति API कुंजी 300 राइट
            अनुरोधों का बजट साझा करते हैं (लेन-देन निर्माण और इवेंट इनजेशन का
            600 का एक अलग बजट है), साथ ही `X-RateLimit-*` और `Retry-After` हेडर
            भी होते हैं। अलग से, सशुल्क रजिस्ट्री खोजें प्रति एप्लिकेशन प्रति
            घंटे 600 तक सीमित हैं: इसके बाद रिस्पॉन्स `code:
            kyb_registry_search_limit_reached` के साथ `429` होता है, और केवल
            मुफ़्त स्रोतों द्वारा प्रदान की जाने वाली खोजें अभी भी काम करती हैं।
            प्रतीक्षा करें और बाद में पुनः खोजें।
          content:
            application/json:
              examples:
                Write rate limit exceeded:
                  summary: वर्तमान मिनट में 300 से अधिक राइट अनुरोध
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
                Search allowance spent:
                  summary: पिछले एक घंटे में 600 से अधिक सशुल्क खोजें
                  value:
                    detail: >-
                      The maximum number of company registry searches for this
                      session has been reached. Enter the company details
                      manually to continue.
                    code: kyb_registry_search_limit_reached
              schema:
                type: object
                properties:
                  detail:
                    type: string
                  code:
                    type: string
        '502':
          description: >-
            KYB रजिस्ट्री प्रदाता अस्थायी रूप से अनुपलब्ध है - अपस्ट्रीम
            रजिस्ट्री से 5xx रिस्पॉन्स, टाइमआउट, या कनेक्शन विफलता। खोज के लिए
            बिल नहीं लिया जाता है। बाद में पुनः प्रयास करें, या Didit के होस्टेड
            सत्यापन फ़्लो में उपयोगकर्ता को केवल पुनः प्रयास वाली त्रुटि के बजाय
            स्वचालित रूप से मैन्युअल कंपनी प्रविष्टि की पेशकश की जाती है।
          content:
            application/json:
              examples:
                Registry provider outage:
                  summary: रजिस्ट्री प्रदाता ने खोज का उत्तर नहीं दिया
                  value:
                    detail: >-
                      The KYB registry provider is temporarily unavailable.
                      Please try again shortly.
                    code: kyb_registry_provider_unavailable
              schema:
                type: object
                properties:
                  detail:
                    type: string
                  code:
                    type: string
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST https://verification.didit.me/v3/kyb/search/ \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "country_code": "GB",
                "name": "Tesco",
                "search_type": "contains",
                "vendor_data": "company-1234"
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.kyb.search(
                country_code="GB",
                name="Tesco",
                search_type="contains",
                vendor_data="company-1234",
            )
            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.kyb.search({
              country_code: "GB",
              name: "Tesco",
              search_type: "contains",
              vendor_data: "company-1234",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.KYB.Search(ctx, didit.KYBSearchParams{\n\tCountryCode: \"GB\",\n\tName:        didit.String(\"Tesco\"),\n\tSearchType:  didit.Some(didit.KYBSearchParamsSearchType(\"contains\")),\n\tVendorData:  didit.String(\"company-1234\"),\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.KybSearchParams;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            var result = client.kyb().search(KybSearchParams.builder()
                    .countryCode("GB")
                    .name("Tesco")
                    .searchType(KybSearchParams.SearchType.of("contains"))
                    .vendorData("company-1234")
                    .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->kyb->search([
                'country_code' => 'GB',
                'name' => 'Tesco',
                'search_type' => 'contains',
                'vendor_data' => 'company-1234',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.kyb.search(
              country_code: "GB",
              name: "Tesco",
              search_type: "contains",
              vendor_data: "company-1234"
            )
            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.Kyb.SearchAsync(new KybSearchParams
            {
                CountryCode = "GB",
                Name = "Tesco",
                SearchType = new KybSearchParamsSearchType("contains"),
                VendorData = "company-1234",
            });
            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    KYBRegistrySearchResults:
      type: object
      properties:
        companies:
          type: array
          items:
            type: object
            properties:
              kyb_response_id:
                type: string
                nullable: true
                description: >-
                  इस उम्मीदवार के लिए हैंडल — पूरा प्रोफ़ाइल प्राप्त करने के लिए
                  इसे `POST /v3/kyb/select/` पर पास करें। अल्पकालिक और इस खोज तक
                  सीमित: इसे दीर्घावधि तक संग्रहीत न करें; नया प्राप्त करने के
                  लिए पुनः खोजें।
                example: 69aeeb95febb0f1704042259
              name:
                type: string
                nullable: true
                description: पंजीकृत कंपनी का नाम।
                example: Tesco PLC
              registration_number:
                type: string
                nullable: true
                description: रजिस्ट्री पंजीकरण संख्या।
                example: '00445790'
              status:
                type: string
                nullable: true
                description: >-
                  कंपनी की सामान्यीकृत रजिस्ट्री स्थिति (उदा. `active`,
                  `dissolved`, `inactive`, `struck off`)।
                example: active
              type:
                type: string
                nullable: true
                description: रजिस्ट्री द्वारा रिपोर्ट किया गया कानूनी रूप।
                example: Public Limited Company
              registered_address:
                type: string
                nullable: true
                description: >-
                  उम्मीदवार का पंजीकृत पता, जब रजिस्ट्री इसे लौटाती है। समान नाम
                  वाली कंपनियों में अंतर करने के लिए पंजीकरण संख्या के साथ इसका
                  उपयोग करें: संयुक्त राज्य अमेरिका में एक उम्मीदवार को आपके
                  द्वारा खोजे गए राज्य के बजाय उस राज्य के तहत सूचीबद्ध किया जा
                  सकता है जहाँ कंपनी संचालित होती है।
                example: >-
                  Tesco House, Shire Park, Kestrel Way, Welwyn Garden City, AL7
                  1GA
              risk_level:
                type: string
                nullable: true
                description: >-
                  रजिस्ट्री द्वारा रिपोर्ट किया गया जोखिम स्तर, जब उपलब्ध हो।
                  आमतौर पर खोज के समय `null`।
              fetch_status:
                type: string
                nullable: true
                description: >-
                  खोज में मिले उम्मीदवारों के लिए हमेशा `pending` — पूर्ण कंपनी
                  प्रोफ़ाइल केवल तभी प्राप्त की जाती है (और बिल की जाती है) जब
                  आप उम्मीदवार का चयन करते हैं।
                example: pending
          description: >-
            डुप्लिकेट हटाई गई उम्मीदवार सूची। `search_resolved=false` (webhook
            मोड) होने पर या कुछ भी मेल न खाने पर खाली।
        pagination:
          type: object
          properties:
            total:
              type: integer
              description: लौटाए गए उम्मीदवारों की संख्या।
            page:
              type: integer
            per_page:
              type: integer
              example: 25
        search_status:
          type: string
          nullable: true
          enum:
            - pending
            - resolved
          description: रजिस्ट्री खोज लाइफ़साइकिल स्थिति।
        search_resolved:
          type: boolean
          description: उम्मीदवार सूची अंतिम होने पर `true`।
  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.