> ## 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 का Refresh a Bank Connection endpoint अभी सिंक करता है: 202 के साथ sync_id, या 25 सेकंड तक प्रतीक्षा करने पर 200 के साथ पूरा सिंक।

Didit का "बैंक कनेक्शन रीफ़्रेश करें" endpoint अभी sync का अनुरोध करता है और `sync_id` के साथ `202` लौटाता है।
25 सेकंड तक इंतज़ार करने और एक ही कॉल में पूरा हुआ sync पाने के लिए `"wait": true` भेजें। इसके लिए कोई अतिरिक्त शुल्क नहीं लगता।
बैंक बिना देखरेख की पहुँच को सीमित करता है, इसलिए कॉल `Retry-After` के साथ `429 refresh_limit_reached` का जवाब दे सकती है।
देखें: [मांग पर बैंक डेटा रीफ़्रेश करें](https://docs.didit.me/hi/use-cases/refresh-bank-data-on-demand.md)।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/bank/connections/{id}/refresh/
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/connections/{id}/refresh/:
    post:
      tags:
        - Bank Data
      summary: बैंक कनेक्शन रीफ़्रेश करें
      description: >-
        अभी सिंक करें: बैंक से किसी भी समय नया डेटा पढ़ता है। `202` के साथ
        `sync_id` लौटता है; यदि सिंक पहले से चल रहा हो, तो वही `sync_id` मिलता
        है, दूसरा जॉब नहीं बनता। बॉडी में `"wait": true` देने पर, या हेडर
        `Prefer: wait=<seconds>` (अधिकतम 25) भेजने पर, कॉल अधिकतम 25 सेकंड तक
        रुकती है और पूरा सिंक लौटाकर `200` देती है (`outcome`, खाते के अनुसार
        गिनती और `balances_changed`), ताकि एक ही अनुरोध में ताज़ा डेटा मिल जाए।
        यदि उतने समय में बैंक ने जवाब नहीं दिया, तो `202` लौटता है: `sync_id` के
        साथ `get_sync_run` से सिंक पढ़ें, या `bank.sync.completed` की सदस्यता
        लें। `bank.data.updated` तभी आता है जब सिंक में बदलाव सहेजे जाते हैं।


        लाइव सिंक, स्वचालित सिंक की तरह, कनेक्शन के मासिक मूल्य में शामिल हैं:
        कोई अतिरिक्त शुल्क नहीं लगता। एकमात्र सीमा बैंक की है। बैंक, व्यक्ति की
        उपस्थिति के बिना होने वाले रीड्स को सीमित करते हैं, उदाहरण के लिए दिन
        में चार तक (सैंडबॉक्स में Didit Test Bank भी यही करता है)। दिन के
        स्वचालित सिंक (`sync.frequency_per_day`) पहले अलग रखे जाते हैं, और बाकी
        आपके लिए उपलब्ध रहते हैं, इसलिए `sync.budgets` बताता है कि कितना बचा है
        और `sync.live_syncs_left_today` बताता है कि आज कितने लाइव सिंक बचे हैं।
        स्वचालित शेड्यूल कभी दिन के आखिरी दो रीड्स का उपयोग नहीं करता, इसलिए दो
        लाइव सिंक हमेशा बचे रहते हैं। जब बजट खत्म हो जाता है, तो कॉल
        `Retry-After` के साथ `429 refresh_limit_reached` लौटाती है (बजट रीसेट
        होने तक के सेकंड, 1 से 86400) और उसमें `live_syncs_left_today` और
        `budgets` वाला `sync` ऑब्जेक्ट होता है। यह सीमा बैंक द्वारा तय की गई
        ऊपरी सीमा है, सिंक की किसी निश्चित संख्या का वादा नहीं।


        जब सिंक में बदलाव सहेजे जाते हैं, तो `bank.data.updated` आपको बताता है;
        फिर परिवर्तन फ़ीड पढ़ें।


        इस ऑपरेशन के लिए Bank data अनुमति (`bank-data`) वाली API कुंजी चाहिए: यह
        ऑपरेशन कुछ बदलता है, इसलिए इसके लिए write अनुमति चाहिए। पूर्ण एक्सेस
        वाली कुंजी में यह शामिल नहीं होती: कुंजी बनाते समय इसे स्पष्ट रूप से
        दें, नहीं तो कॉल `403 bank_data_access_denied` का जवाब देगी।


        हटाए गए कनेक्शन को रिफ़्रेश करने पर `409 connection_not_active` मिलता
        है।
      operationId: refreshBankConnection
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: कनेक्शन आईडी।
        - $ref: '#/components/parameters/IdempotencyKey'
        - name: Prefer
          in: header
          required: false
          schema:
            type: string
            example: wait=25
          description: >-
            `wait=<seconds>` कॉल को अधिकतम उतने सेकंड तक रोके रखता है, जो 25 से
            अधिक नहीं हो सकते, जैसे बॉडी में `wait: true`।
      requestBody:
        required: false
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankRefreshRequest'
            examples:
              Wait for the result:
                summary: परिणाम की प्रतीक्षा करें
                value:
                  wait: true
      responses:
        '200':
          description: सिंक 25 सेकंड के भीतर पूरा हुआ।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankSyncCompleted'
              examples:
                Finished:
                  summary: एक पूरा हुआ लाइव सिंक
                  value:
                    id: d4a9e7b2-1c58-4f03-96ab-5e2d8c7f0b14
                    connection_id: 5e1d2a70-6b3c-4f8e-a1d9-0c7b2e4f8a36
                    trigger: requested
                    status: succeeded
                    started_at: '2026-11-21T12:30:02Z'
                    finished_at: '2026-11-21T12:30:09Z'
                    results:
                      - account_id: a71f0c2e-4d85-4b1a-9e63-2f8c0d5b7a14
                        resource: transactions
                        outcome: succeeded
                        added: 3
                        modified: 0
                        removed: 1
                        error: null
                    outcome: succeeded
                    balances_changed: true
                    error: null
        '202':
          description: >-
            रीफ़्रेश स्वीकार किया गया: कतार में या पहले से चल रहा है। `wait` के
            साथ, बैंक ने 25 सेकंड में जवाब नहीं दिया: `sync_id` से सिंक पढ़ें।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshAccepted'
              examples:
                Queued:
                  summary: एक सिंक कतार में डाला गया
                  value:
                    sync_id: d4a9e7b2-1c58-4f03-96ab-5e2d8c7f0b14
                    status: queued
                    next_refresh_at: null
        '400':
          description: >-
            बॉडी मान्य नहीं है, उदाहरण के लिए `wait` एक बूलियन नहीं है। `field`
            इसका नाम बताता है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Invalid request:
                  summary: अमान्य अनुरोध
                  value:
                    code: invalid_request
                    message: The request is not valid.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: wait
                    next_action: null
                    retry_after: null
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/BankDataAccessDenied'
        '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
        '409':
          description: >-
            कनेक्शन रीफ़्रेश नहीं किया जा सकता: `connection_not_active` (रद्द,
            रोका गया, विफल या हटाया गया) या `consent_expired` (पहले इसे नवीनीकृत
            करें)।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not active:
                  summary: सक्रिय नहीं
                  value:
                    code: connection_not_active
                    message: This connection is not active.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: create_link
                    retry_after: null
                Consent expired:
                  summary: सहमति की समय-सीमा समाप्त हो गई
                  value:
                    code: consent_expired
                    message: The consent ended. Renew the connection to sync again.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: renew_connection
                    retry_after: null
        '429':
          description: >-
            व्यक्ति की उपस्थिति के बिना डेटा लाने के लिए बैंक का बजट समाप्त हो
            गया है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshLimitError'
              examples:
                Refresh limit reached:
                  summary: रीफ़्रेश सीमा पूरी हो गई
                  value:
                    code: refresh_limit_reached
                    message: >-
                      The bank's limit on fetches without the person present is
                      used up for today.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: retry_later
                    retry_after: 3600
                    sync:
                      live_syncs_left_today: 0
                      budgets:
                        - scope: connection
                          resource: all
                          limit: 4
                          remaining: 0
                          resets_at: '2026-11-22T00:00:00Z'
          headers:
            Retry-After:
              description: फिर से पूछने से पहले प्रतीक्षा के सेकंड।
              schema:
                type: integer
        '500':
          $ref: '#/components/responses/BankDataInternalError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/bank/connections/5e1d2a70-3b94-4c1f-8a6e-d2f07b9c1e35/refresh/'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.refresh_connection(
                "11111111-2222-3333-4444-555555555555",
                wait=True,
            )
            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.refreshConnection("11111111-2222-3333-4444-555555555555",
            {
              wait: true,
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.RefreshConnection(ctx, \"11111111-2222-3333-4444-555555555555\", didit.BankRefreshConnectionParams{\n\tBody: didit.BankRefreshRequest{\n\t\tWait: didit.Bool(true),\n\t},\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.BankRefreshConnectionParams;

            import me.didit.types.BankRefreshRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().refreshConnection("11111111-2222-3333-4444-555555555555",
            BankRefreshConnectionParams.builder()
                    .wait_(true)
                    .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->refreshConnection('11111111-2222-3333-4444-555555555555',
            [
                'wait' => true,
            ]);

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.bank.refresh_connection(
              "11111111-2222-3333-4444-555555555555",
              wait: true
            )
            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.RefreshConnectionAsync("11111111-2222-3333-4444-555555555555",
            new BankRefreshRequest

            {
                Wait = true,
            });

            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:
    BankRefreshRequest:
      type: object
      description: रीफ़्रेश का वैकल्पिक अनुरोध बॉडी।
      properties:
        wait:
          type: boolean
          default: false
          description: >-
            `true` होने पर कॉल अधिकतम 25 सेकंड तक रुकी रहती है और सिंक पूरा होने
            पर `200` के साथ जवाब देती है, ताकि एक ही अनुरोध में ताज़ा डेटा मिल
            जाए। यदि इतने समय में बैंक ने जवाब नहीं दिया, तो कॉल `202` देती है:
            `sync_id` का उपयोग करके `get_sync_run` से सिंक पढ़ें, या
            `bank.sync.completed` की सदस्यता लें। `bank.data.updated` तभी आता है
            जब सिंक में बदलाव सहेजे जाते हैं। हेडर `Prefer: wait=<seconds>`
            (अधिकतम 25) भी यही काम करता है।
    BankSyncCompleted:
      allOf:
        - $ref: '#/components/schemas/BankSyncRun'
        - type: object
          properties:
            outcome:
              type: string
              enum:
                - succeeded
                - partial
                - failed
              description: सिंक कैसे समाप्त हुआ।
            balances_changed:
              type: boolean
              description: यह कि कोई बैलेंस बदला है या नहीं।
          required:
            - outcome
            - balances_changed
      description: >-
        `wait` के साथ रिफ़्रेश से लौटा एक पूरा हुआ सिंक: सिंक रन अपने `outcome`
        के साथ, और `results` तथा `balances_changed` में हर खाते की गिनती।
    BankRefreshAccepted:
      type: object
      description: >-
        रिफ़्रेश स्वीकार किया गया। सिंक चलते समय दूसरी कॉल वही `sync_id` लौटाती
        है।
      properties:
        sync_id:
          type: string
          description: वह सिंक जो कतार में लगाया गया, या जो पहले से चल रहा है।
          format: uuid
        status:
          type: string
          enum:
            - queued
            - running
        next_refresh_at:
          type: string
          description: >-
            सबसे पहला क्षण जब नया रिफ़्रेश माँगा जा सकता है। जब तक कोई बजट पूरा
            खर्च न हो गया हो, तब तक यह `null` रहता है।
          format: date-time
          nullable: true
      required:
        - sync_id
        - status
        - next_refresh_at
    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
    BankRefreshLimitError:
      allOf:
        - $ref: '#/components/schemas/BankDataError'
        - type: object
          properties:
            sync:
              type: object
              description: कनेक्शन की वर्तमान सिंक सीमाएँ।
              properties:
                live_syncs_left_today:
                  type: integer
                  nullable: true
                  minimum: 0
                budgets:
                  type: array
                  items:
                    $ref: '#/components/schemas/BankSyncBudget'
              required:
                - live_syncs_left_today
                - budgets
          required:
            - sync
      description: >-
        कनेक्शन की `sync` सीमाओं वाली रिफ़्रेश सीमा की त्रुटि। `Retry-After` में
        वे सेकंड होते हैं जब तक बजट रीसेट होगा, जो 1 से 86400 के बीच होते हैं।
    BankSyncRun:
      type: object
      description: >-
        कनेक्शन का एक सिंक्रोनाइज़ेशन। केवल प्रारंभिक, निर्धारित और अनुरोधित
        सिंक सूचीबद्ध होते हैं।
      properties:
        id:
          type: string
          format: uuid
        connection_id:
          type: string
          format: uuid
        trigger:
          type: string
          enum:
            - initial
            - scheduled
            - requested
        status:
          type: string
          enum:
            - queued
            - running
            - succeeded
            - partial
            - failed
        started_at:
          type: string
          format: date-time
          nullable: true
        finished_at:
          type: string
          format: date-time
          nullable: true
        results:
          type: array
          items:
            $ref: '#/components/schemas/BankSyncRunResult'
          description: रन ने क्या किया, प्रति खाता और संसाधन के अनुसार।
        error:
          type: object
          nullable: true
          description: >-
            पूरा रन क्यों विफल हुआ। विफल न होने पर `null`। अलग-अलग खातों और
            संसाधनों की त्रुटियाँ `results` में होती हैं।
          properties:
            code:
              type: string
            message:
              type: string
            at:
              type: string
              format: date-time
          required:
            - code
            - message
            - at
      required:
        - id
        - connection_id
        - trigger
        - status
        - started_at
        - finished_at
        - results
        - error
    BankSyncBudget:
      type: object
      description: >-
        बैंक की उस सीमा का एक हिस्सा, जो व्यक्ति के मौजूद न होने पर डेटा लाने
        (fetch) पर लागू होती है।
      properties:
        scope:
          type: string
          enum:
            - connection
            - account
          description: वह चीज़ जिसके विरुद्ध बैंक बजट गिनता है।
        resource:
          type: string
          enum:
            - all
            - accounts
            - balances
            - transactions
        account_id:
          type: string
          description: खाता, जब `scope` `account` हो।
          format: uuid
          nullable: true
        limit:
          type: integer
          description: >-
            दिन में कितनी बार Didit व्यक्ति की उपस्थिति के बिना बैंक से डेटा
            प्राप्त कर सकता है, जैसा बैंक परिभाषित करता है। यह बैंक द्वारा तय की
            गई सीमा है, कोई वादा नहीं।
        remaining:
          type: integer
          description: >-
            आपके रिफ़्रेश के लिए वर्तमान विंडो में बचे फ़ेच। स्वचालित सिंक के
            लिए रखे गए रीड पहले ही घटा दिए गए हैं, और कोई स्वचालित सिंक दिन के
            अंतिम दो रीड नहीं लेता, इसलिए मांग पर किए जाने वाले दो रिफ़्रेश
            हमेशा उपलब्ध रहते हैं।
        resets_at:
          type: string
          description: जब विंडो रीसेट होती है।
          format: date-time
      required:
        - scope
        - resource
        - limit
        - remaining
        - resets_at
    BankSyncRunResult:
      type: object
      properties:
        account_id:
          type: string
          description: पूरे कनेक्शन के परिणाम के लिए `null`।
          format: uuid
          nullable: true
        resource:
          type: string
          enum:
            - accounts
            - balances
            - transactions
        outcome:
          type: string
          enum:
            - succeeded
            - failed
            - skipped
        added:
          type: integer
        modified:
          type: integer
        removed:
          type: integer
        error:
          allOf:
            - $ref: '#/components/schemas/BankSyncError'
          nullable: true
          description: जब `outcome` `failed` हो, तब आवश्यक।
      required:
        - account_id
        - resource
        - outcome
        - added
        - modified
        - removed
        - error
    BankSyncError:
      type: object
      description: सिंक विफल होने का कारण।
      properties:
        code:
          type: string
          description: Didit एरर कोड।
        message:
          type: string
          description: सरल भाषा में स्पष्टीकरण।
        at:
          type: string
          description: यह कब हुआ। प्रति-खाता परिणाम पर `null`।
          format: date-time
          nullable: true
      required:
        - code
        - message
        - at
  responses:
    Unauthorized:
      description: अनधिकृत
      content:
        application/json:
          examples:
            Invalid API Key:
              summary: अमान्य API कुंजी
              value:
                detail: Invalid API Key.
    BankDataAccessDenied:
      description: >-
        API कुंजी में Bank data अनुमति (`bank-data`) नहीं है, या, लाइव एप्लिकेशन
        में कच्चे बैंक डेटा के लिए, एप्लिकेशन सेटिंग "Bank data in the API" बंद
        है। Bank data पूर्ण एक्सेस का हिस्सा नहीं है: पूर्ण एक्सेस वाली कुंजी,
        केवल अन्य संसाधनों तक सीमित कुंजी, और API कुंजी के बिना (client
        credentials से, कच्चे डेटा पर) प्रमाणित अनुरोध, सभी को इसी बॉडी के साथ
        मना किया जाता है, इसलिए कुंजी बनाएँ और उसे स्पष्ट रूप से अनुमति दें। यह
        इनकार किसी भी लुकअप से पहले होता है, इसलिए यह नहीं बताता कि ऑब्जेक्ट
        मौजूद है या नहीं।
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            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
    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
  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.