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

# अकाउंटिंग के लिए बैंक फ़ीड: बैलेंस और लेन-देन

> Didit के साथ अपने हर ग्राहक के लिए बैलेंस और लेन-देन की दैनिक फ़ीड बनाएँ: सतत लिंक, webhooks, cursor वाला परिवर्तन फ़ीड, रीसेट और सहमति समाप्ति।

एक सतत बैंक फ़ीड किसी अकाउंटिंग या बुककीपिंग उत्पाद को हर दिन, क्लाइंट को दोबारा साइन इन किए बिना, हर क्लाइंट के बैंक खातों के बैलेंस और लेन-देन उपलब्ध कराती है।

Didit के साथ आप सतत पहुँच वाला लिंक बनाते हैं, नया डेटा आने पर webhook प्राप्त करते हैं, cursor की मदद से केवल वही डेटा पढ़ते हैं जो बदला है, देखते हैं कि सहमति कब समाप्त होती है, और क्लाइंट के जाने पर इसे रोकते या हटाते हैं।

यह गाइड आपको शून्य से एक क्लाइंट के लिए रोज़ाना फ़ीड तक ले जाती है।
वही कोड हर क्लाइंट के लिए चलता है: हर क्लाइंट और बैंक के लिए एक कनेक्शन।

## आवश्यक चीज़ें

* आपकी सैंडबॉक्स एप्लिकेशन के लिए बैंक डेटा की अनुमति वाली एक API कुंजी। देखें [क्विकस्टार्ट](https://docs.didit.me/hi/core-technology/bank-verification/quickstart.md#चरण-1-bank-data-की-अनुमति-के-साथ-api-कुंजी-बनाएँ)।
* एक webhook गंतव्य जो `bank.*` webhook इवेंट प्राप्त करता है। देखें [बैंक webhooks](https://docs.didit.me/hi/core-technology/bank-verification/webhooks.md)।
* आपके डेटाबेस में हर ग्राहक के कनेक्शन आईडी, परिवर्तन फ़ीड कर्सर और सहमति की समाप्ति के लिए एक तालिका।

## चरण 1: सतत पहुँच के साथ लिंक बनाएँ

```bash theme={null}
curl -X POST https://verification.didit.me/v3/bank/links/ \
  -H "x-api-key: $DIDIT_API_KEY" -H "content-type: application/json" \
  -d '{
    "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": "http://localhost:3000/bank/return",
    "vendor_data": "client-7731"
  }'
```

* `access: ongoing` सहमति समाप्त होने तक पहुँच खुली रखता है। `consent_days` एक अनुरोध है: वास्तविक तिथि बैंक तय करता है, जो कनेक्शन पर दिखाई देती है।
* `history_from` किसी तिथि से इतिहास माँगता है, उदाहरण के लिए वर्ष की शुरुआत। यदि आप चाहें तो इसके बजाय `history_days` (1 से 365) का उपयोग करें, लेकिन दोनों एक साथ कभी नहीं। बैंक इससे कम डेटा दे सकता है: हर खाता अपना `history_coverage` बताता है।
* `ownership.compare: none` धारक की तुलना छोड़ देता है, इसलिए किसी संदर्भ पहचान की आवश्यकता नहीं होती। Didit में सत्यापित किसी कंपनी से धारक की तुलना करने के लिए `business` का उपयोग करें।
* `end_user.reference` ग्राहक के लिए आपकी ID है। इसे खोजा जा सकता है, और इससे Didit पहचान सकता है कि वही ग्राहक वही खाते फिर से जोड़ रहा है।
* ग्राहक को [होस्टेड सत्यापन पेज](https://docs.didit.me/hi/integration/bank-link/hosted-link.md) पर भेजें, और [रीडायरेक्ट URL](https://docs.didit.me/hi/integration/bank-link/return-to-your-site.md) के ज़रिए उन्हें अपने प्रोडक्ट पर वापस लाएँ।

लिंक का `id` ग्राहक के साथ सहेजें।

## चरण 2: कनेक्शन की प्रतीक्षा करें

जब क्लाइंट प्रक्रिया पूरी करता है, तो `connection_id` के साथ `bank.link.completed` आता है।
इसकी पुष्टि करें, क्योंकि ब्राउज़र पर कभी भरोसा नहीं किया जाता:

```bash theme={null}
curl https://verification.didit.me/v3/bank/links/$LINK_ID/ -H "x-api-key: $DIDIT_API_KEY"
```

`connection_id` सहेजें और `bank.connection.created` की प्रतीक्षा करें: इसके बाद खाते, बैलेंस और हाल के लेन-देन पढ़े जा सकते हैं (`sync.initial_status` का मान `succeeded` या `partial` होता है)।
जब बैकफ़िल समाप्त होता है, तब `bank.connection.history_complete` आता है।
हर खाते के लिए, `history_coverage.oldest_booking_date` बताता है कि बैंक ने वास्तव में कितने पीछे तक का डेटा दिया।

## चरण 3: पहली प्रति लोड करें

खाली कर्सर सभी मौजूदा लेन-देन को `added` के रूप में लौटाता है, जिसमें `reset: true` होता है।
इसके पेज दर पेज पढ़ें और कर्सर केवल अंत में सहेजें:

```bash theme={null}
curl "https://verification.didit.me/v3/bank/connections/$CONNECTION_ID/transactions/sync/?limit=500" \
  -H "x-api-key: $DIDIT_API_KEY"
```

```python theme={null}
cursor, page_token = stored_cursor or "", None
while True:
    params = {"limit": 500, "page_token": page_token} if page_token else {"cursor": cursor, "limit": 500}
    page = get(f"/v3/bank/connections/{connection_id}/transactions/sync/", params)
    if page["reset"] and not page_token:
        wipe_local_copy(connection_id)       # replace, never append
    apply(page["added"], page["modified"], page["removed"])
    if not page["has_more"]:
        store_cursor(connection_id, page["next_cursor"])
        break
    page_token = page["next_page_token"]
```

* पहली रीड एक वास्तविक स्नैपशॉट है: यह उन सभी लेन-देन को लौटाती है जो रीड शुरू होने के समय कनेक्शन में थे, हर एक ठीक एक बार `added` के रूप में, उनकी मौजूदा स्थिति में, भले ही आप पेज करते समय सिंक चल रहा हो।
* पेज करते समय हुए बदलाव `next_cursor` से अगली रीड में पहुँचते हैं: जो लेन-देन आप पहले प्राप्त कर चुके हैं, वह `modified` के रूप में फिर से आता है, और नया लेन-देन `added` के रूप में।
* `next_cursor` को केवल तब सहेजें जब रिस्पॉन्स में `has_more: false` हो।
* अगर पेजिंग बीच में विफल हो जाए, तो अपने सहेजे गए कर्सर से दोबारा शुरू करें।
* बैलेंस पढ़ने के लिए `GET /v3/bank/accounts/{account_id}/balances/` का उपयोग करें।

## चरण 4: हर webhook पर अद्यतन रहें

Didit हर सक्रिय सतत कनेक्शन को बैंक के अनुसार दिन में एक से चार बार अपने-आप सिंक करता है (`sync.frequency_per_day`)।
जब कोई सिंक बदलाव सहेजता है, तो webhook इवेंट `bank.data.updated` `connection_id`, `account_ids` और गिनती के साथ आता है।
सहेजे गए कर्सर के साथ परिवर्तन फ़ीड को कॉल करें:

* `added` नए लेन-देन हैं, जिनमें लंबित लेन-देन भी शामिल हैं।
* `modified` वे लेन-देन हैं जो बदल गए हैं और अपनी वर्तमान स्थिति में हैं। इनमें से हर एक को `id` के आधार पर upsert के रूप में लागू करें: जो लेन-देन आपके पास पहले से है, उसे अपडेट करें, और जो अभी आपके पास नहीं है, उसे जोड़ें।
* `removed` में `reason` होता है। जो `id` आपके पास नहीं है, उसे अनदेखा करें। जब कोई लंबित लेन-देन बुक हो जाता है, तो वह `pending_booked` के साथ `removed` में जाता है, और बुक हुआ लेन-देन `added` में आता है।

लेन-देन के `id` को अपनी कुंजी के रूप में उपयोग करें: यह रीड, सिंक और नवीनीकरण में एक जैसा रहता है।
`identity_quality` जाँचें: `derived` होने पर, बैंक के किसी सुधार को एक `removed` और एक `added` के रूप में दिखाया जा सकता है।
रीड पर कभी शुल्क नहीं लगता, लेकिन डेटा केवल तब बदलता है जब कोई सिंक चलता है, इसलिए हर webhook पर एक रीड पर्याप्त है।
जल्दी डेटा लाने के लिए Sync Now का उपयोग करें: [माँग पर बैंक डेटा ताज़ा करें](https://docs.didit.me/hi/use-cases/refresh-bank-data-on-demand.md)।

## चरण 5: रीसेट संभालें

जो cursor रीप्ले विंडो से पुराना है, उस पर `410 cursor_expired` और `bootstrap: true` के साथ उत्तर मिलता है।
चेंज लॉग 90 दिनों तक रीप्ले किया जा सकता है, इसलिए एक दैनिक जॉब के लिए यह बहुत कम होता है।
खाली cursor से फिर शुरू करें, और अपनी कॉपी को परिणाम से बदलें, उसमें जोड़ें नहीं।
खाली cursor से हर रीड के साथ `reset: true` आता है, इसलिए एक ही कोड पथ नए कनेक्शन और समाप्त हो चुके cursor, दोनों को संभालता है।

## चरण 6: सहमति की समाप्ति पर नज़र रखें

सहमति की एक समाप्ति तिथि होती है: `consent.expires_at`।
Didit `bank.connection.consent_expiring` इवेंट 14, 7 और 1 दिन पहले भेजता है।

नवीनीकरण करना चाहें तो [`renew_connection`](https://docs.didit.me/hi/standalone-apis/bank-connection-renew) कॉल करें। 30 दिन शेष रहने तक यह `409 renewal_not_needed` लौटाता है।
वह पेज जहाँ क्लाइंट नवीनीकरण पूरा करता है, अभी उपलब्ध नहीं है।

यदि क्लाइंट इसे समाप्त हो जाने देता है, तो कनेक्शन की स्थिति `renewal_required` होती है। फिर भी सिंक किया गया डेटा आप पढ़ सकते हैं।
विवरण [बैंक सहमति का नवीनीकरण करें](https://docs.didit.me/hi/use-cases/renew-bank-consent.md) में दिए गए हैं।

## Step 7: पहुँच बंद करें और डेटा हटाएँ

* क्लाइंट आपके प्रोडक्ट से बाहर निकलता है: तुरंत पढ़ना बंद करने के लिए [`revoke_connection`](https://docs.didit.me/hi/standalone-apis/bank-connection-revoke) को कॉल करें, या बंद करने और संग्रहीत डेटा हटाने के लिए [`delete_connection`](https://docs.didit.me/hi/standalone-apis/bank-connection-delete) को कॉल करें।
* क्लाइंट बैंक में साझा करना बंद कर देता है: webhook इवेंट `bank.connection.revoked` `ended_by` के साथ आता है। उस कनेक्शन के लिए अपना फ़ीड रोक दें।

## कीमत

सक्रिय कनेक्शन के हिसाब से हर महीने शुल्क लिया जाता है।
कीमत में कनेक्शन के सभी खाते, बैलेंस, लेन-देन, बैंक द्वारा उपलब्ध कराए जाने पर 365 दिनों तक का इतिहास, स्वचालित सिंक, बैंक की सीमाओं के भीतर लाइव सिंक, नवीनीकरण, webhook और सभी रीड शामिल हैं।
जिस लिंक को कोई पूरा नहीं करता, वह मुफ़्त है, और `renewal_required`, `paused` और `revoked` कनेक्शन भी मुफ़्त हैं।
देखें [मूल्य निर्धारण](https://docs.didit.me/hi/getting-started/bank-verification-pricing.md#बैंक-डेटा-और-निरंतर-पहुँच)।

## Checklist

* [ ] हर ग्राहक और बैंक के लिए एक कनेक्शन, जो अपने कर्सर और सहमति समाप्ति तिथि के साथ संग्रहीत हो।
* [ ] Webhook हैंडलर में आइडेम्पोटेंसी हो, जो इवेंट आईडी पर आधारित हो।
* [ ] `reset: true` आपकी प्रति को बदल देता है, कभी उसमें जोड़ता नहीं।
* [ ] `removed` को उसके कारण सहित संभाला गया हो।
* [ ] सहमति की याद दिलाने वाले संदेश आपकी उस सूचना से जुड़े हों जो आप ग्राहक को भेजते हैं।
* [ ] `bank.connection.revoked` फ़ीड को रोक देता है।
* [ ] [सैंडबॉक्स](https://docs.didit.me/hi/core-technology/bank-verification/sandbox.md#अच्छी-परीक्षण-योजना) में दिया गया सैंडबॉक्स प्लान पास हो जाता है।


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.