> ## 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 का Create a Bank Link endpoint आपके सर्वर पर Bank Link का एक रन शुरू करता है और होस्टेड URL लौटाता है, जहाँ व्यक्ति बैंक कनेक्ट करता है।

Didit का Create a Bank Link endpoint आपके सर्वर पर Bank Link का एक रन शुरू करता है, ताकि कोई बैंक कनेक्ट किया जा सके या मौजूदा कनेक्शन नवीनीकृत किया जा सके, और होस्टेड `url` लौटाता है।
हर फ़ील्ड का एक डिफ़ॉल्ट मान होता है, इसलिए सबसे छोटा अनुरोध `{}` होता है, जिसमें आप चाहें तो और फ़ील्ड जोड़ सकते हैं।
लौटाए गए `id` को अपने उपयोगकर्ता के साथ सहेजकर रखें और परिणाम की पुष्टि स्वयं करें, इसके लिए [बैंक लिंक प्राप्त करें](https://docs.didit.me/hi/standalone-apis/bank-link-get.md) या `bank.link.completed` webhook का उपयोग करें।
[क्विकस्टार्ट](https://docs.didit.me/hi/core-technology/bank-verification/quickstart.md) और [Bank Link](https://docs.didit.me/hi/core-technology/bank-verification/bank-link.md) देखें।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/bank/links/
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:
  - name: Bank Data
    description: >-
      Bank Link, कनेक्शन, खाते, बैलेंस, लेन-देन, संस्थान और कवरेज। बैंक डेटा
      सैंडबॉक्स एप्लिकेशन के लिए उपलब्ध है। किसी लाइव एप्लिकेशन की कॉल तब तक
      `404` लौटाती हैं जब तक लाइव पहुँच की घोषणा नहीं होती। सैंडबॉक्स में कोई
      शुल्क नहीं लिया जाता। API कुंजी से की गई कॉल के लिए ऐसी कुंजी चाहिए जिसमें
      बैंक डेटा अनुमति (`bank-data`) हो: पढ़ने के लिए read, और कुछ बदलने वाली
      संक्रियाओं के लिए write। खाता जाँच अपवाद है: इसके लिए सत्रों के लिए write
      पहुँच, या पूर्ण पहुँच चाहिए, बैंक डेटा अनुमति नहीं। बैंक डेटा पूर्ण पहुँच
      में शामिल नहीं है: पूर्ण पहुँच वाली कुंजी अस्वीकार की जाती है, और कॉल `403
      bank_data_access_denied` लौटाती है, जब तक आप ऐसी कुंजी नहीं बनाते जिसमें
      यह अनुमति हो। कच्चा बैंक डेटा (खाते, बैलेंस, लेन-देन और बदलाव फ़ीड) भी ऐसे
      अनुरोध को अस्वीकार करता है जिसमें API कुंजी न हो।


      `/v3/bank/` के अंतर्गत खाता जाँच के अलावा हर अस्वीकृति का एक ही JSON बॉडी
      होती है (`code`, `message`, `request_id`, `field`, `next_action`,
      `retry_after`)। ऐसा पथ जो कोई संक्रिया नहीं है, ऐसा ID जो UUID नहीं है, या
      कोई अज्ञात उप-संसाधन हर मेथड के लिए `404 not_found` लौटाता है, और कोई भी
      अनपेक्षित त्रुटि `request_id` के साथ `500 internal_error` लौटाती है। जहाँ
      बैंक डेटा उपलब्ध नहीं है, वहाँ हर संक्रिया प्लेटफ़ॉर्म का मानक `404`
      लौटाती है, ठीक वैसे ही जैसे कोई अज्ञात रूट लौटाता है।
paths:
  /v3/bank/links/:
    post:
      tags:
        - Bank Data
      summary: बैंक लिंक बनाएँ
      description: >-
        बैंक लिंक बनाता है: प्रवाह का एक रन, जिसमें कोई व्यक्ति बैंक कनेक्ट करता
        है या कनेक्शन नवीनीकृत करता है। व्यक्ति को `url` पर भेजें।
        `client_token` Didit के एम्बेडेड बैंक लिंक के लिए है, जो अभी जारी नहीं
        हुआ है: आज `url` खोलें। पूरा हो चुका लिंक एक कनेक्शन देता है।


        सबसे छोटा अनुरोध `{}` है, साथ में जो चाहिए वह। डिफ़ॉल्ट: `mode` connect,
        `access` one_time, `data` केवल accounts, `history_days` 90,
        `ownership.compare` none, `segment` any, `duplicates` reuse,
        `allow_one_time_fallback` false, और सतत पहुँच के लिए बैंक जितनी अवधि की
        अनुमति दे उतनी लंबी सहमति।


        रिस्पॉन्स में कोट होता है: कीमत लिंक पर पिन रहती है और कोट के अनुसार
        चार्ज होती है। API कुंजी कभी ब्राउज़र या एप्लिकेशन तक नहीं पहुँचती: केवल
        `url` पहुँचता है।


        परिणाम की पुष्टि स्वयं `get_link` से या `bank.link.completed` webhook से
        करें; ब्राउज़र से भेजे गए लिंक id पर कभी भरोसा न करें। इतिहास:
        `history_from` या `history_days` में से कोई एक भेजें, दोनों नहीं। जहाँ
        बैंक अनुमति देता है, सतत पहुँच सहमति समाप्त होने तक चलती रहती है;
        वास्तविक तारीख हर कनेक्शन पर होती है।


        इसके लिए बैंक डेटा अनुमति (`bank-data`) वाली API कुंजी चाहिए: यह ऑपरेशन
        कुछ बदलता है, इसलिए write चाहिए। पूरी पहुँच वाली कुंजी में यह शामिल नहीं
        होती: कुंजी बनाते समय इसे स्पष्ट रूप से दें, नहीं तो कॉल `403
        bank_data_access_denied` उत्तर देती है।
      operationId: createBankLink
      parameters:
        - $ref: '#/components/parameters/IdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankLinkCreateRequest'
            example:
              mode: connect
              access: ongoing
              country: ESP
              segment: business
              data:
                - accounts
                - balances
                - transactions
              history_from: '2026-01-01'
              consent_days: 180
              ownership:
                compare: none
              end_user:
                reference: client-7731
                email: ana@example.com
              redirect_url: https://app.example.com/bank/return
              allowed_origins:
                - https://app.example.com
              language: es
              vendor_data: client-7731
      responses:
        '201':
          description: लिंक बनाया गया।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankLink'
              examples:
                Ongoing business connection:
                  summary: स्पेन में बिज़नेस खाते के लिए सतत पहुँच
                  value:
                    id: 0b9c4f1e-6a2d-4e8b-9f31-7c5d2e1a8b40
                    mode: connect
                    access: ongoing
                    status: created
                    url: https://verify.didit.me/bank/link/example-link-token
                    client_token: example-client-token
                    expires_at: '2026-11-21T13:00:00Z'
                    connection_id: null
                    check_id: null
                    reused: false
                    error: null
                    quote:
                      id: 7a3e9c52-1d84-4b06-8f2a-c5e0b9d17a43
                      lines:
                        - meter: bank_data_connection_month
                          unit: connection_month
                          price_usd: '0.9000'
                      fallback_lines: null
                      total_usd: '0.9000'
                      valid_until: '2026-11-21T13:00:00Z'
                      scopes:
                        - accounts
                        - balances
                        - transactions
                    vendor_data: client-7731
        '400':
          description: >-
            अनुरोध किसी भी स्क्रीन से पहले अस्वीकार किया गया। `field` बताता है
            कि क्या सुधारना है: किसी सीमा से बाहर के मान या अनुमति न दिए गए
            संयोजन के लिए `invalid_request`, और यहाँ दिखाए गए अधिक विशिष्ट कोड।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Bank cannot keep access open:
                  summary: बैंक पहुँच खुली नहीं रख सकता
                  value:
                    code: ongoing_access_not_available
                    message: >-
                      This bank cannot keep access open. Use access one_time or
                      choose another bank.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: institution_id
                    next_action: create_link
                    retry_after: null
                History window ambiguous:
                  summary: इतिहास अवधि अस्पष्ट है
                  value:
                    code: history_window_ambiguous
                    message: Send history_from or history_days, not both.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: history_from
                    next_action: null
                    retry_after: null
                Redirect URL not registered:
                  summary: रीडायरेक्ट URL पंजीकृत नहीं है
                  value:
                    code: redirect_url_not_registered
                    message: >-
                      This redirect_url is not one of the return addresses
                      registered for your application. Addresses are matched
                      exactly (scheme, host, port, path and query); in sandbox a
                      plain http localhost address needs no registration. Send a
                      registered address, or leave redirect_url out (automatic
                      return to your page is then not promised).
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: redirect_url
                    next_action: null
                    retry_after: null
                Segment not available:
                  summary: सेगमेंट उपलब्ध नहीं है
                  value:
                    code: segment_not_available
                    message: >-
                      This bank does not offer this kind of account through Bank
                      Link.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: segment
                    next_action: null
                    retry_after: null
                Window not available:
                  summary: विंडो उपलब्ध नहीं
                  value:
                    code: window_not_available
                    message: This bank cannot deliver the requested history window.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: history_from
                    next_action: null
                    retry_after: null
                Invalid request:
                  summary: अमान्य अनुरोध
                  value:
                    code: invalid_request
                    message: The request is not valid.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: expires_in
                    next_action: null
                    retry_after: null
        '401':
          $ref: '#/components/responses/Unauthorized'
        '402':
          description: >-
            बैलेंस उद्धृत कीमत के लिए पर्याप्त नहीं है। टॉप अप करें, फिर पुनः
            प्रयास करें।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Insufficient credits:
                  summary: अपर्याप्त क्रेडिट
                  value:
                    code: insufficient_credits
                    message: The balance cannot cover the quoted price.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: top_up_balance
                    retry_after: null
        '403':
          description: >-
            अस्वीकृत: आपके अनुबंध में इस देश के लिए दर नहीं है, या कुंजी में
            Bank data अनुमति नहीं है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                No contract rate:
                  summary: कोई अनुबंध दर नहीं
                  value:
                    code: contract_rate_missing
                    message: Your contract has no rate for bank data in this country.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: null
                    retry_after: null
                Bank data not allowed:
                  summary: बैंक डेटा की अनुमति नहीं है
                  value:
                    code: bank_data_access_denied
                    message: >-
                      Bank data calls need an API key that carries the Bank data
                      permission.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: enable_bank_data_access
                    retry_after: null
        '404':
          description: यह संसाधन इस एप्लिकेशन और एनवायरनमेंट में मौजूद नहीं है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not found:
                  summary: नहीं मिला
                  value:
                    code: not_found
                    message: The resource does not exist.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: null
                    retry_after: null
        '429':
          $ref: '#/components/responses/RateLimitedWrite'
        '500':
          $ref: '#/components/responses/BankDataInternalError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST 'https://verification.didit.me/v3/bank/links/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "mode": "connect",
                "access": "ongoing",
                "country": "ESP",
                "segment": "business",
                "data": [
                  "accounts",
                  "balances",
                  "transactions"
                ],
                "history_from": "2026-01-01",
                "consent_days": 180,
                "ownership": {
                  "compare": "none"
                },
                "end_user": {
                  "reference": "client-7731",
                  "email": "ana@example.com"
                },
                "redirect_url": "https://app.example.com/bank/return",
                "allowed_origins": [
                  "https://app.example.com"
                ],
                "language": "es",
                "vendor_data": "client-7731"
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.create_link(
                mode="connect",
                access="ongoing",
                country="ESP",
                segment="business",
                data=["accounts", "balances", "transactions"],
                history_from="2026-01-01",
                consent_days=180,
                ownership={
                    "compare": "none",
                },
                end_user={
                    "reference": "client-7731",
                    "email": "ana@example.com",
                },
                redirect_url="https://app.example.com/bank/return",
                allowed_origins=["https://app.example.com"],
                language="es",
                vendor_data="client-7731",
            )
            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.createLink({
              mode: "connect",
              access: "ongoing",
              country: "ESP",
              segment: "business",
              data: ["accounts", "balances", "transactions"],
              history_from: "2026-01-01",
              consent_days: 180,
              ownership: {
                compare: "none",
              },
              end_user: {
                reference: "client-7731",
                email: "ana@example.com",
              },
              redirect_url: "https://app.example.com/bank/return",
              allowed_origins: ["https://app.example.com"],
              language: "es",
              vendor_data: "client-7731",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.CreateLink(ctx, didit.BankCreateLinkParams{\n\tBody: didit.BankLinkCreateRequest{\n\t\tMode:        didit.Some(didit.BankLinkCreateRequestMode(\"connect\")),\n\t\tAccess:      didit.Some(didit.BankLinkCreateRequestAccess(\"ongoing\")),\n\t\tCountry:     didit.String(\"ESP\"),\n\t\tSegment:     didit.Some(didit.BankLinkCreateRequestSegment(\"business\")),\n\t\tData:        didit.Some([]didit.BankLinkCreateRequestData{\"accounts\", \"balances\", \"transactions\"}),\n\t\tHistoryFrom: didit.String(\"2026-01-01\"),\n\t\tConsentDays: didit.Int(180),\n\t\tOwnership: didit.Some(didit.BankLinkOwnershipRequest{\n\t\t\tCompare: didit.Some(didit.BankLinkOwnershipRequestCompare(\"none\")),\n\t\t}),\n\t\tEndUser: didit.Some(didit.BankLinkEndUser{\n\t\t\tReference: didit.String(\"client-7731\"),\n\t\t\tEmail:     didit.String(\"ana@example.com\"),\n\t\t}),\n\t\tRedirectURL:    didit.String(\"https://app.example.com/bank/return\"),\n\t\tAllowedOrigins: didit.Some([]string{\"https://app.example.com\"}),\n\t\tLanguage:       didit.String(\"es\"),\n\t\tVendorData:     didit.String(\"client-7731\"),\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.time.LocalDate;

            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.BankLinkCreateRequest;

            import me.didit.types.BankLinkEndUser;

            import me.didit.types.BankLinkOwnershipRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().createLink(BankLinkCreateRequest.builder()
                    .mode(BankLinkCreateRequest.Mode.of("connect"))
                    .access(BankLinkCreateRequest.Access.of("ongoing"))
                    .country("ESP")
                    .segment(BankLinkCreateRequest.Segment.of("business"))
                    .data(List.of(BankLinkCreateRequest.Data.of("accounts"), BankLinkCreateRequest.Data.of("balances"), BankLinkCreateRequest.Data.of("transactions")))
                    .historyFrom(LocalDate.parse("2026-01-01"))
                    .consentDays(180L)
                    .ownership(BankLinkOwnershipRequest.builder()
                            .compare(BankLinkOwnershipRequest.Compare.of("none"))
                            .build())
                    .endUser(BankLinkEndUser.builder()
                            .reference("client-7731")
                            .email("ana@example.com")
                            .build())
                    .redirectUrl("https://app.example.com/bank/return")
                    .allowedOrigins(List.of("https://app.example.com"))
                    .language("es")
                    .vendorData("client-7731")
                    .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->createLink([
                'mode' => 'connect',
                'access' => 'ongoing',
                'country' => 'ESP',
                'segment' => 'business',
                'data' => ['accounts', 'balances', 'transactions'],
                'history_from' => '2026-01-01',
                'consent_days' => 180,
                'ownership' => [
                    'compare' => 'none',
                ],
                'end_user' => [
                    'reference' => 'client-7731',
                    'email' => 'ana@example.com',
                ],
                'redirect_url' => 'https://app.example.com/bank/return',
                'allowed_origins' => ['https://app.example.com'],
                'language' => 'es',
                'vendor_data' => 'client-7731',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.bank.create_link(
              mode: "connect",
              access: "ongoing",
              country: "ESP",
              segment: "business",
              data: ["accounts", "balances", "transactions"],
              history_from: "2026-01-01",
              consent_days: 180,
              ownership: {
                compare: "none",
              },
              end_user: {
                reference: "client-7731",
                email: "ana@example.com",
              },
              redirect_url: "https://app.example.com/bank/return",
              allowed_origins: ["https://app.example.com"],
              language: "es",
              vendor_data: "client-7731"
            )
            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.CreateLinkAsync(new
            BankLinkCreateRequest

            {
                Mode = new BankLinkCreateRequestMode("connect"),
                Access = new BankLinkCreateRequestAccess("ongoing"),
                Country = "ESP",
                Segment = new BankLinkCreateRequestSegment("business"),
                Data = new BankLinkCreateRequestData[] { "accounts", "balances", "transactions" },
                HistoryFrom = "2026-01-01",
                ConsentDays = 180,
                Ownership = new BankLinkOwnershipRequest
                {
                    Compare = new BankLinkOwnershipRequestCompare("none"),
                },
                EndUser = new BankLinkEndUser
                {
                    Reference = "client-7731",
                    Email = "ana@example.com",
                },
                RedirectUrl = "https://app.example.com/bank/return",
                AllowedOrigins = new string[] { "https://app.example.com" },
                Language = "es",
                VendorData = "client-7731",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  parameters:
    IdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >-
        एक ऑपरेशन के लिए आपके द्वारा चुनी गई वैकल्पिक पुनः प्रयास-सुरक्षा कुंजी,
        जो अधिकतम 255 अक्षरों की हो सकती है (UUID उपयोग की जा सकती है)। वही
        कुंजी, endpoint, क्वेरी और बॉडी के साथ दोहराया गया अनुरोध पहले वाले
        रिस्पॉन्स से ही उत्तर पाता है, वही स्टेटस और वही बॉडी, और दूसरी बार न
        कोई प्रक्रिया चलती है न कोई शुल्क लगता है। वही कुंजी किसी दूसरे
        endpoint, क्वेरी या बॉडी के साथ भेजने पर `409` `idempotency_key_reused`
        रिस्पॉन्स मिलता है, और जब पहला अनुरोध अभी भी चल रहा हो, तब `Retry-After`
        के साथ `409` `idempotency_key_in_progress` मिलता है। विफल अनुरोध (कोई भी
        `4xx` या `5xx`) सहेजा नहीं जाता, इसलिए आप उसी कुंजी के साथ उसे दोबारा
        भेज सकते हैं। कुंजियाँ आपके एप्लिकेशन की होती हैं, चाहे आप API कुंजी से
        कॉल करें या एक्सेस टोकन से। देखें [पुनः प्रयास और
        आइडेम्पोटेंसी](/hi/integration/api-errors#पुनः-प्रयास-और-आइडेम्पोटेंसी)।
      schema:
        type: string
        minLength: 1
        maxLength: 255
  schemas:
    BankLinkCreateRequest:
      type: object
      description: >-
        बैंक लिंक बनाएँ। सबसे छोटा अनुरोध `{}` है; इसके साथ जो चाहिए वह भेजें।
        हर फ़ील्ड का एक डिफ़ॉल्ट होता है।
      properties:
        mode:
          type: string
          enum:
            - connect
            - renew
          description: >-
            `connect` (डिफ़ॉल्ट) नया कनेक्शन बनाता है। `renew` के लिए
            `connection_id` चाहिए और वह उस कनेक्शन की सेटिंग्स दोबारा उपयोग करता
            है।
          default: connect
        connection_id:
          type: string
          description: 'नवीनीकृत किया जाने वाला कनेक्शन। केवल `mode: renew` के साथ।'
          format: uuid
        access:
          type: string
          enum:
            - one_time
            - ongoing
          description: >-
            `one_time` (डिफ़ॉल्ट) डेटा एक बार पढ़ता है। `ongoing` सहमति समाप्त
            होने या किसी के रोकने तक पहुँच खुली रखता है। `institution_id` सेट
            होने पर, जो बैंक पहुँच खुली नहीं रख सकता, वह किसी भी स्क्रीन के
            दिखने से पहले `400 ongoing_access_not_available` लौटाता है। इसके
            बिना, बैंक चुनने वाली सूची में केवल वही बैंक दिखते हैं जो ऐसा कर
            सकते हैं।
          default: one_time
        country:
          type: string
          description: >-
            वैकल्पिक। इसके बिना व्यक्ति उन देशों में से चुनता है जिन्हें आपके
            एप्लिकेशन ने सक्षम किया है। यह ऐसा देश होना चाहिए जिसे Bank Link
            सेवा देता है; कोई भी अन्य, `ZZZ` सहित, `400 invalid_request` लौटाता
            है, जिसमें `field: country` होता है। खाली अनुरोध बॉडी मान्य रहती है।
          pattern: ^[A-Z]{3}$
        institution_id:
          type: string
          description: >-
            वैकल्पिक बैंक, जिसे `list_institutions` से पहले से चुना जा सके। चयन
            स्क्रीन छोड़ देता है।
          maxLength: 64
        segment:
          type: string
          enum:
            - personal
            - business
            - any
          description: >-
            पिकर को फ़िल्टर करता है और जहाँ बैंक लॉगिन अलग करता है, वहाँ बताता
            है कि कौन-सा लॉगिन खोलना है। डिफ़ॉल्ट `any`।
          default: any
        data:
          type: array
          items:
            type: string
            enum:
              - accounts
              - balances
              - transactions
          description: >-
            क्या पढ़ना है। `accounts` हमेशा शामिल होता है: नाम, प्रकार, मुद्रा,
            पहचानकर्ता और जहाँ बैंक इसे साझा करता है, वहाँ धारक का नाम। डिफ़ॉल्ट
            `["accounts"]` है।
          default:
            - accounts
          maxItems: 3
        history_days:
          type: integer
          description: >-
            अनुरोध करने के लिए लेन-देन इतिहास के दिन, 1 से 365, डिफ़ॉल्ट 90।
            बैंक इससे कम दे सकता है: हर खाता `history_coverage` में बताता है कि
            उसने वास्तव में कितना दिया। इसे `history_from` के साथ नहीं भेजा जा
            सकता।
          minimum: 1
          maximum: 365
          default: 90
        history_from:
          type: string
          description: >-
            `history_days` की जगह वह इतिहास का प्रारंभ दिनांक जो माँगना है। इसे
            `history_days` के साथ नहीं भेजा जा सकता: दोनों एक साथ भेजने पर `400
            history_window_ambiguous` मिलता है। 365 दिन से पुरानी, या भविष्य की
            तारीख `400 window_not_available` देती है।
          format: date
        extended_history:
          type: string
          enum:
            - standard
            - allow_extra_auth
          description: >-
            `allow_extra_auth` उस बैंक को, जो एक और पुष्टि माँगता है, पुराना
            इतिहास जारी करने देता है।
          default: standard
        consent_days:
          type: integer
          description: >-
            केवल Ongoing के लिए। बैंक से कितने दिनों तक पहुँच खुली रखने का
            अनुरोध करना है, 1 या अधिक। डिफ़ॉल्ट: बैंक जितनी लंबी अवधि की अनुमति
            देता है। कनेक्शन वास्तविक स्वीकृत तिथि `consent.expires_at` में
            बताता है। `access: one_time` के साथ यह `400 invalid_request` लौटाता
            है, जिसमें `field: consent_days` होता है।
          minimum: 1
          maximum: 32767
        ownership:
          $ref: '#/components/schemas/BankLinkOwnershipRequest'
        end_user:
          $ref: '#/components/schemas/BankLinkEndUser'
        redirect_url:
          type: string
          description: >-
            अंत में ब्राउज़र कहाँ जाता है, साथ में `link_id`, `status` और
            हस्ताक्षरित `state` (केवल प्रदर्शन के लिए; webhook और `get_link` ही
            आधिकारिक हैं)। सैंडबॉक्स एप्लिकेशन में `localhost`, `127.0.0.1` या
            `[::1]` का सादा `http` पता (कोई भी पोर्ट और पथ, बिना क्रेडेंशियल और
            बिना फ़्रैगमेंट) पंजीकरण की आवश्यकता नहीं रखता। कोई अन्य पता `400
            redirect_url_not_registered` लौटाता है: अन्य पते पंजीकृत करने की
            सुविधा अभी उपलब्ध नहीं है। `redirect_url` के बिना व्यक्ति Didit के
            अपने परिणाम पृष्ठ पर समाप्त करता है।
          format: uri
          maxLength: 2048
        allowed_origins:
          type: array
          items:
            type: string
            format: uri
          description: >-
            स्वीकृत है, लेकिन अभी इसका उपयोग नहीं होता: यह Didit के एम्बेडेड
            Bank Link के लिए आरक्षित है, जो अभी जारी नहीं हुआ है। HTTPS ओरिजिन,
            अधिकतम 50।
          maxItems: 50
        language:
          type: string
          description: >-
            वैकल्पिक भाषा कोड, जैसे `es` या `pt-BR`। नहीं दिया तो ब्राउज़र की
            भाषा।
          pattern: ^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})?$
          maxLength: 16
        vendor_data:
          type: string
          description: आपका अपना संदर्भ, जो लिंक और कनेक्शन पर लौटाया जाता है।
          maxLength: 255
        expires_in:
          type: integer
          description: लिंक का जीवनकाल सेकंड में, 300 से 86400 तक। डिफ़ॉल्ट 3600।
          minimum: 300
          maximum: 86400
          default: 3600
        duplicates:
          type: string
          enum:
            - reuse
            - allow
          description: >-
            `reuse` (डिफ़ॉल्ट) उस लिंक को पूरा करता है जो उन खातों से जुड़ता है
            जिन्हें आप पहले से साझा करते हैं, और इसे उस कनेक्शन के नवीनीकरण के
            रूप में गिना जाता है। `allow` एक स्वतंत्र दूसरा कनेक्शन बनाता है।
          default: reuse
        allow_one_time_fallback:
          type: boolean
          description: >-
            `ongoing` के साथ, यह व्यक्ति को उस बैंक में एक बार पढ़ना जारी रखने
            देता है जो पहुँच खुली नहीं रख सकता, बशर्ते वह बैंक की अपनी स्क्रीन
            पर कम हुई पहुँच की पुष्टि कर दे। कोट बताता है कि इसकी लागत कितनी है।
            केवल `access: ongoing` के साथ: एक बार की पहुँच के साथ यह `400
            invalid_request` लौटाता है और `field: allow_one_time_fallback` आता
            है।
          default: false
        accept_reduced_grant:
          type: boolean
          description: >-
            जब बैंक या व्यक्ति आपके माँगे गए दायरे से कम अनुमति दे, तो लिंक पूरा
            करें और केवल दी गई अनुमतियों का शुल्क लें। अन्यथा लिंक
            `reduced_grant` के साथ `failed` पर समाप्त होता है और कोई शुल्क नहीं
            लिया जाता।
          default: false
        sandbox:
          type: object
          description: >-
            केवल सैंडबॉक्स एप्लिकेशन के लिए: Didit Test Bank का ग्राहक चुनता है।
            लाइव एप्लिकेशन में इसे अनदेखा किया जाता है।
          properties:
            persona:
              type: string
              enum:
                - personal_basic
                - business_multi
                - long_history
                - pending
                - sparse_fields
                - no_ongoing
              description: >-
                टेस्ट बैंक ग्राहक: `personal_basic` (एक चालू खाता, 60 लेन-देन),
                `business_multi` (कंपनी के पास तीन खाते), `long_history` (400
                दिन और 1,400 लेन-देन वाला एक खाता; रीड में पिछले 365 दिन लौटते
                हैं, इसलिए `history_days` को 365 पर सेट करें), `pending` (लंबित
                लेन-देन शामिल हैं), `sparse_fields` (कोई वैल्यू डेट नहीं, कोई
                काउंटरपार्टी IBAN नहीं, कोई बैंक संदर्भ नहीं) या `no_ongoing`
                (एक ऐसा बैंक जो केवल एक बार की पहुँच की अनुमति देता है:
                `allow_one_time_fallback` का उपयोग करें)।
            switches:
              type: array
              items:
                type: string
                enum:
                  - partial_grant
                  - renewal_other_login
                  - expired_cursor
                  - webhook_twice
                  - midnight_booking
                  - blocked_popup
                  - bank_app_return
              description: >-
                स्वीकृत और सैंडबॉक्स सिमुलेटर के लिए आरक्षित: ये मान अभी कुछ
                नहीं बदलते।
    BankLink:
      type: object
      description: >-
        एक व्यक्ति के लिए Bank Link का एक रन: बैंक कनेक्ट करना, या कनेक्शन
        नवीनीकृत करना। `get_link` से लिंक की पुष्टि स्वयं करें: ब्राउज़र से भेजे
        गए ID पर कभी भरोसा न करें।
      properties:
        id:
          type: string
          description: लिंक का पहचानकर्ता।
          format: uuid
        mode:
          type: string
          enum:
            - connect
            - renew
        access:
          type: string
          enum:
            - one_time
            - ongoing
        status:
          type: string
          enum:
            - created
            - opened
            - connecting
            - completed
            - cancelled
            - expired
            - failed
          description: >-
            लिंक की स्थिति। `completed`, `cancelled`, `expired` और `failed`
            अंतिम हैं।
        url:
          type: string
          description: >-
            वह होस्टेड पेज जिस पर व्यक्ति को भेजना है। यह केवल लिंक बनाते समय
            लौटाया जाता है; बाद की रीड में यह `null` होता है, क्योंकि टोकन
            संग्रहीत नहीं किया जाता।
          nullable: true
          format: uri
        client_token:
          type: string
          description: >-
            Didit के एम्बेडेड Bank Link का टोकन, जो अभी जारी नहीं हुआ है: आज
            `url` खोलें। यह केवल लिंक बनाते समय लौटाया जाता है; बाद की रीड पर
            `null`। इसका उद्देश्य एक है और यह कम समय के लिए वैध है। इसमें कोई
            व्यक्तिगत डेटा नहीं होता। इसे कभी लॉग न करें।
          nullable: true
        expires_at:
          type: string
          description: जो लिंक अभी तक उपयोग नहीं हुआ है, वह कब काम करना बंद कर देता है।
          format: date-time
        connection_id:
          type: string
          description: >-
            वह कनेक्शन जिसे इस लिंक ने बनाया या नवीनीकृत किया है, जब `status`
            `completed` हो जाए।
          format: uuid
          nullable: true
        check_id:
          type: string
          description: >-
            इस लिंक का स्वामित्व परिणाम, जब उसने `ownership.compare` के लिए
            `none` से भिन्न कोई मान माँगा हो।
          format: uuid
          nullable: true
        reused:
          type: boolean
          description: >-
            `true` तब होता है जब लिंक एक मौजूदा कनेक्शन के नवीनीकरण के रूप में
            पूरा हुआ, क्योंकि व्यक्ति पहले से ठीक ये ही खाते साझा करता है
            (`duplicates: reuse`)। कोई शुल्क दोबारा नहीं लगता।
        error:
          allOf:
            - $ref: '#/components/schemas/BankLinkError'
          nullable: true
          description: लिंक विफल होने का कारण, जब `status` `failed` हो। अन्यथा `null`।
        quote:
          $ref: '#/components/schemas/BankLinkQuote'
        vendor_data:
          type: string
          description: अनुरोध से आपका संदर्भ।
          nullable: true
      required:
        - id
        - mode
        - access
        - status
        - url
        - client_token
        - expires_at
        - connection_id
        - check_id
        - reused
        - error
        - quote
        - vendor_data
    BankDataError:
      type: object
      description: Bank data के हर ऑपरेशन का एरर बॉडी। हर फ़ील्ड हमेशा मौजूद रहता है।
      properties:
        code:
          type: string
          enum:
            - ongoing_access_not_available
            - segment_not_available
            - window_not_available
            - history_window_ambiguous
            - redirect_url_not_registered
            - link_origin_not_allowed
            - bank_data_access_denied
            - connection_not_active
            - consent_expired
            - renewal_not_needed
            - renewal_window_expired
            - access_removed
            - refresh_limit_reached
            - cursor_expired
            - page_expired
            - invalid_cursor
            - page_token_mismatch
            - contract_rate_missing
            - insufficient_credits
            - invalid_request
            - not_found
            - internal_error
          description: >-
            मशीन-पठनीय त्रुटि कोड। शर्त इसी के आधार पर लिखें, कभी `message` के
            आधार पर नहीं।
        message:
          type: string
          description: >-
            डेवलपर के लिए सरल भाषा में स्पष्टीकरण। शब्द बदल सकते हैं; इसे पार्स
            न करें।
        request_id:
          type: string
          description: इस अनुरोध का पहचानकर्ता। सहायता से संपर्क करते समय इसे उद्धृत करें।
        field:
          type: string
          description: >-
            वह अनुरोध फ़ील्ड जिसे सुधारना है, जब त्रुटि किसी एक फ़ील्ड के बारे
            में हो। अन्यथा `null`।
          nullable: true
        next_action:
          type: string
          enum:
            - retry_later
            - renew_connection
            - create_link
            - restart_from_cursor
            - restart_read
            - top_up_balance
            - enable_bank_data_access
            - contact_support
            - null
          description: >-
            आगे क्या करना है, ताकि क्लाइंट अनुमान लगाए बिना कार्रवाई कर सके। कोई
            मानक अगला चरण न होने पर `null`।
          nullable: true
        retry_after:
          type: integer
          description: >-
            पुनः प्रयास करने से पहले प्रतीक्षा के सेकंड। रेट लिमिट और अस्थायी
            त्रुटियों पर सेट होता है, अन्यथा `null`।
          nullable: true
      required:
        - code
        - message
        - request_id
        - field
        - next_action
        - retry_after
      example:
        code: ongoing_access_not_available
        message: >-
          This bank cannot keep access open. Use access one_time or choose
          another bank.
        request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
        field: institution_id
        next_action: create_link
        retry_after: null
    BankLinkOwnershipRequest:
      type: object
      description: वैकल्पिक, खाताधारक की तुलना किसी व्यक्ति या कंपनी से करने के लिए।
      properties:
        compare:
          type: string
          enum:
            - none
            - person
            - business
          description: >-
            खाताधारक की तुलना किससे की जाती है। `none` (डिफ़ॉल्ट) कोई निर्णय
            नहीं देता और उसे कोई संदर्भ नहीं चाहिए। `person` के लिए
            `reference_identity` या `session_id` चाहिए। `business` के लिए
            `business` या `business_session_id` चाहिए। जिस प्रकार की तुलना करनी
            है, उसका ठीक एक संदर्भ भेजें, और `none` के साथ कोई संदर्भ न भेजें।
          default: none
        match:
          type: string
          enum:
            - any_holder
            - all_holders
          description: >-
            यह कि एक कानूनी धारक का मिलान होना चाहिए या हर कानूनी धारक का।
            प्रतिनिधि कभी नहीं गिने जाते।
          default: any_holder
        reference_identity:
          type: object
          description: >-
            कॉलर द्वारा दिए गए मान, जिनकी तुलना खाताधारक से की जाती है। इन्हें
            `session_id` के साथ नहीं भेजा जा सकता।
          properties:
            full_name:
              type: string
              maxLength: 255
            date_of_birth:
              type: string
              format: date
            address:
              type: string
              maxLength: 500
            phone:
              type: string
              maxLength: 64
            email:
              type: string
              maxLength: 255
        session_id:
          type: string
          description: >-
            जिस व्यक्ति से तुलना करनी है, उसका एक पूरा हुआ Didit सत्यापन सत्र।
            इसे `reference_identity` के साथ नहीं भेजा जा सकता।
          format: uuid
        business:
          type: object
          description: वह कंपनी जिसकी तुलना खाताधारक से की जाएगी।
          properties:
            legal_name:
              type: string
              maxLength: 255
            registration_id:
              type: string
              maxLength: 128
          required:
            - legal_name
        business_session_id:
          type: string
          description: >-
            तुलना के लिए एक Didit व्यवसाय सत्यापन। इसे `business` के साथ नहीं
            भेजा जा सकता।
          format: uuid
    BankLinkEndUser:
      type: object
      description: वह व्यक्ति या कंपनी जो खाते को कनेक्ट करती है।
      properties:
        reference:
          type: string
          description: >-
            व्यक्ति या कंपनी के लिए आपका अपना ID। `end_user_reference` से खोजा
            जा सकता है, और दोबारा आने वाले कनेक्शन को पहचानने के लिए इस्तेमाल
            होता है।
          maxLength: 255
        email:
          type: string
          description: >-
            वैकल्पिक। जहाँ बैंक मार्ग को व्यक्ति का सत्यापित पता चाहिए और आपने
            नहीं भेजा, Bank Link व्यक्ति से यह माँगता है। इसका उपयोग कभी
            मार्केटिंग के लिए नहीं होता।
          format: email
          maxLength: 254
    BankLinkError:
      type: object
      description: >-
        वह कारण जिससे लिंक `failed` पर समाप्त हुआ। कुछ भी प्रकाशित या चार्ज नहीं
        हुआ।
      properties:
        code:
          type: string
          enum:
            - duplicate_conflict
            - renewal_login_mismatch
            - reduced_grant
            - corporate_approval_not_supported
            - ongoing_access_not_available
            - bank_unavailable
            - bank_cancelled
            - consent_declined
            - read_limit
            - renewal_not_needed
            - renewal_window_expired
            - first_sync_failed
          description: >-
            लिंक विफल होने का कारण। विफल लिंक HTTP त्रुटि नहीं है: लिंक `status:
            failed` और यह ऑब्जेक्ट लौटाता है। यदि नवीनीकरण लिंक का कनेक्शन इस
            बीच बदल गया हो, तो वह `renewal_not_needed` या
            `renewal_window_expired` दिखाता है।
        message:
          type: string
          description: डेवलपर के लिए सरल भाषा में स्पष्टीकरण।
        conflicts_with:
          type: array
          nullable: true
          items:
            type: string
            format: uuid
          description: >-
            `duplicate_conflict` के साथ: ओवरलैप होने वाले सक्रिय कनेक्शनों के
            ID। उनमें से किसी एक को नवीनीकृत करें, या `duplicates: allow` के साथ
            लिंक फिर से बनाएँ।
      required:
        - code
        - message
        - conflicts_with
    BankLinkQuote:
      type: object
      description: >-
        लिंक की कीमत, जो उसके बनने के समय तय हो जाती है। चार्ज की गई कीमत कोट की
        होती है। रीड कभी बिल नहीं होते।
      properties:
        id:
          type: string
          description: कोट का पहचानकर्ता।
          format: uuid
        lines:
          type: array
          items:
            $ref: '#/components/schemas/BankLinkQuoteLine'
          description: >-
            ये वे लाइनें हैं जो इस लिंक के लिए शुल्क में जुड़ती हैं, उन स्कोप्स
            के लिए जो यह माँगता है।
        fallback_lines:
          type: array
          nullable: true
          items:
            $ref: '#/components/schemas/BankLinkQuoteLine'
          description: >-
            एक बार का फ़ॉलबैक कितना चार्ज करेगा, केवल तब जब लिंक
            `allow_one_time_fallback` के साथ बनाया गया हो। यह लिंक बनाने के
            रिस्पॉन्स में दिखता है और अन्यथा `null` है। डेटा वाली एक बार की रीड
            पहले महीने की सतत एक्सेस से अधिक लागत ला सकती है।
        total_usd:
          type: string
          description: >-
            `lines` का कुल योग USD में। यह कुल केवल घट सकता है: कम अनुदान के
            साथ, या जब व्यक्ति कम कीमत वाला देश चुनता है।
          pattern: ^-?\d+(\.\d+)?$
        valid_until:
          type: string
          description: >-
            कोट लिंक से जुड़ा रहता है और लिंक के पूरे जीवनकाल तक वैध रहता है,
            इसलिए यह `expires_at` के बराबर है।
          format: date-time
        scopes:
          type: array
          items:
            type: string
            enum:
              - accounts
              - balances
              - transactions
          description: यह डेटा कोट की कीमतों का दायरा तय करता है।
      required:
        - id
        - lines
        - fallback_lines
        - total_usd
        - valid_until
        - scopes
    RateLimitBudgetError:
      type: object
      description: >-
        यह केवल रेट-लिमिट मिडलवेयर बजट अस्वीकृति के लिए लौटाया जाता है। अन्य 429
        त्रुटियाँ, जिनमें आइडेम्पोटेंसी टकराव और endpoint-विशिष्ट सीमाएँ शामिल
        हैं, इन मेटाडेटा फ़ील्ड्स की गारंटी नहीं देतीं।
      required:
        - detail
        - reference
        - limit
        - remaining
        - reset
        - window_seconds
      properties:
        detail:
          type: string
          description: मौजूदा मानव-पठनीय बजट अस्वीकृति संदेश।
        reference:
          type: string
          pattern: ^RL-[0-9a-f]{32}$
          description: >-
            अपारदर्शी सहायता संदर्भ: RL- के बाद 32 लोअरकेस UUID हेक्साडेसिमल
            अक्षर।
        limit:
          type: integer
          description: सीमा से अधिक हुए दायरे का बजट; यह X-RateLimit-Limit के बराबर है।
        remaining:
          type: integer
          minimum: 0
          description: शेष बजट, शून्य पर सीमित; X-RateLimit-Remaining के बराबर।
        reset:
          type: integer
          format: int64
          description: >-
            विंडो रीसेट का समय Unix सेकंड में; यह X-RateLimit-Reset के बराबर
            होता है।
        window_seconds:
          type: integer
          description: >-
            फ़िक्स्ड-विंडो की अवधि सेकंड में, शेष प्रतीक्षा समय नहीं। दोबारा
            प्रयास करने से पहले Retry-After का पालन करें।
      example:
        detail: >-
          Write request rate limit exceeded. You can make up to 300 requests per
          minute.
        reference: RL-00000000000040008000000000000001
        limit: 300
        remaining: 0
        reset: 1794358860
        window_seconds: 60
    BankLinkQuoteLine:
      type: object
      description: कोटेशन की एक मूल्य-निर्धारित पंक्ति।
      properties:
        meter:
          type: string
          description: >-
            शुल्क किस चीज़ का लिया जाता है, उदाहरण के लिए
            `bank_data_connection_month`, `bank_verification`।
          example: bank_data_connection_month
        unit:
          type: string
          description: >-
            एक इकाई क्या है, उदाहरण के लिए `connection_month` या
            `completed_sign_in`।
          example: connection_month
        price_usd:
          type: string
          description: >-
            USD में एक इकाई की कीमत, 4 दशमलव वाली दशमलव स्ट्रिंग। उदाहरण में दी
            गई राशियाँ केवल उदाहरण हैं; किसी देश की कीमत मूल्य निर्धारण पेज पर
            दिखाई गई है।
          pattern: ^-?\d+(\.\d+)?$
          example: '0.9000'
      required:
        - meter
        - unit
        - price_usd
  responses:
    Unauthorized:
      description: अनधिकृत
      content:
        application/json:
          examples:
            Invalid API Key:
              summary: अमान्य API कुंजी
              value:
                detail: Invalid API Key.
    RateLimitedWrite:
      description: >-
        प्रति API कुंजी प्रति मिनट 300 अनुरोधों की साझा राइट सीमा पार हो गई।
        पुनः प्रयास से पहले `Retry-After` का पालन करें।
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RateLimitBudgetError'
          example:
            detail: >-
              Write request rate limit exceeded. You can make up to 300 requests
              per minute.
            reference: RL-00000000000040008000000000000001
            limit: 300
            remaining: 0
            reset: 1794358860
            window_seconds: 60
      headers:
        Retry-After:
          $ref: '#/components/headers/BudgetRetryAfter'
        X-RateLimit-Scope:
          $ref: '#/components/headers/BudgetXRateLimitScope'
        X-RateLimit-Limit:
          $ref: '#/components/headers/BudgetXRateLimitLimit'
        X-RateLimit-Remaining:
          $ref: '#/components/headers/BudgetXRateLimitRemaining'
        X-RateLimit-Reset:
          $ref: '#/components/headers/BudgetXRateLimitReset'
    BankDataInternalError:
      description: >-
        Didit की ओर से कुछ गड़बड़ हुई है। `/v3/bank/` के तहत कोई भी अप्रत्याशित
        त्रुटि बैंक त्रुटि संरचना में उत्तर देती है, कभी HTML पेज में नहीं:
        सहायता टीम को `request_id` बताएँ।
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            Internal error:
              summary: एक अनपेक्षित त्रुटि
              value:
                code: internal_error
                message: >-
                  Something went wrong on our side. Quote the request_id to
                  support.
                request_id: 3f6a1c8e92b54d07a1e38c4b7f0d2e59
                field: null
                next_action: contact_support
                retry_after: null
  headers:
    BudgetRetryAfter:
      description: >-
        प्रतीक्षा के सेकंड, जिन्हें अगली विंडो तक ऊपर की ओर राउंड किया गया है।
        मिडलवेयर बजट अस्वीकृतियों पर मौजूद होता है।
      schema:
        type: integer
    BudgetXRateLimitScope:
      description: वह दायरा जिसका बजट पार हुआ। मिडलवेयर बजट अस्वीकृतियों पर मौजूद होता है।
      schema:
        type: string
    BudgetXRateLimitLimit:
      description: >-
        सीमा से अधिक हुए दायरे का बजट; यह बॉडी लिमिट के बराबर है। यह middleware
        बजट अस्वीकृतियों में मौजूद होता है।
      schema:
        type: integer
    BudgetXRateLimitRemaining:
      description: >-
        शेष बजट, शून्य पर सीमित; body remaining के बराबर। मिडलवेयर बजट
        अस्वीकृतियों पर मौजूद।
      schema:
        type: integer
    BudgetXRateLimitReset:
      description: >-
        रीसेट का समय Unix सेकंड में; यह बॉडी के reset के बराबर होता है। मिडलवेयर
        बजट अस्वीकृतियों पर मौजूद होता है।
      schema:
        type: integer
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        आपकी एप्लिकेशन की API कुंजी, जो Business Console में Developers -> API
        keys से मिलती है। प्राथमिक कुंजी के पास पूर्ण पहुँच होती है। नामित कुंजी
        को सीमित किया जा सकता है: प्रति संसाधन कोई नहीं, read या write, कुछ
        वर्कफ़्लो या केवल स्वीकृत सत्रों तक सीमित, IP पतों की सूची तक सीमित, और
        समाप्ति तिथि के साथ। 401 का अर्थ है कि कुंजी गलत, रद्द या समय-सीमा
        समाप्त है; 403 का अर्थ है कि कोई कुंजी नहीं भेजी गई, कुंजी को इस संसाधन
        या कार्रवाई तक पहुँच नहीं है, या अनुरोध उसकी IP सूची के बाहर के पते से
        आया; सत्र रूट पर 404 का अर्थ है कि सत्र कुंजी के वर्कफ़्लो या स्थितियों
        के बाहर है। मीडिया पहुँच के बिना कुंजी को image, video और PDF URL null
        मिलते हैं, और sessions 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.