किसी यूज़र या बिज़नेस को एक बार वेरिफाई करें। परिणाम पार्टनर के साथ शेयर करें, वे उसी व्यक्ति को तुरंत ऑनबोर्ड कर लेते हैं। कोई दूसरा फ़्लो नहीं, कोई दूसरी सेल्फ़ी नहीं। KYC और KYB दोनों के लिए काम करता है। बैंकिंग-एज़-ए-सर्विस, मल्टी-ब्रांड ग्रुप्स, एम्बेडेड फ़ाइनेंस और सब-प्लेटफ़ॉर्म वाले मार्केटप्लेस के लिए बनाया गया है।
Robinhood Ventures
पार्टनर इकोसिस्टम के लिए बनाया गया
आपका यूज़र आपके ऐप में एक बार वेरिफाई करता है। आपके पार्टनर, आपका BaaS स्पॉन्सर, आपका सिस्टर ब्रांड, आपका डाउनस्ट्रीम मार्केटप्लेस, को वही रिकॉर्ड चाहिए। उन्हें एक वन-टाइम शेयर टोकन भेजें। वे इसे रिडीम करते हैं और पूरा वेरिफिकेशन खींच लेते हैं। यूज़र को दूसरा फ़्लो कभी नहीं दिखता।
कोई भी पूरा किया गया वेरिफिकेशन चुनें, अप्रूव्ड, डिक्लाइंड या अंडर रिव्यू, और Didit से शेयर टोकन मांगें। टोकन डिफ़ॉल्ट रूप से एक घंटे में एक्सपायर हो जाता है; आप इसे एक मिनट से लेकर पूरे एक दिन तक बढ़ा सकते हैं।
टोकन अपने बैकएंड के ज़रिए अपने पार्टनर को दें, एक वेबहुक, एक क्यू, एक REST कॉल। टोकन केवल उसी पार्टनर के लिए काम करता है जिसका नाम आपने इसे बनाते समय दिया था। कोई और इसे रिडीम नहीं कर सकता।
आपका पार्टनर टोकन रिडीम करता है और चुनता है कि यूज़र को कैसे ऑनबोर्ड करना है, आपके फ़ैसले पर भरोसा करें और तुरंत अप्रूव करें, या डेटा को रॉ रूप में खींचें और अपनी कंप्लायंस टीम को फ़ैसला लेने दें।
Didit पूरे रिकॉर्ड को, डॉक्यूमेंट्स, सेल्फ़ी, फ़ेस मैच, AML, रजिस्ट्री डेटा, UBOs, आपके पार्टनर के वर्कस्पेस में क्लोन कर देता है। यह एक नए वेरिफिकेशन जैसा ही होता है, जिसमें ओरिजिनल तक एक साफ़ ऑडिट ट्रेल होता है।
POST /v3/session/[id]/share/
POST /v3/session/import-shared/
इंस्टेंट ऑनबोर्डिंग · या आपकी अपनी समीक्षा
session_kind: यूज़र | बिज़नेस
यूज़र · KYC
बिज़नेस · KYB
जहाँ एक वेरिफिकेशन कई काम करता है
केवल समाप्त · आइडम्पोटेंट · ऑडिट-ग्रेड
$ curl -X POST https://verification.didit.me/v3/session/$SID/share/ \
-H "x-api-key: $DIDIT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"for_application_id": "partner-app-uuid",
"ttl_in_seconds": 3600
}'{ "share_token": "eyJhbGciOi…" }$ curl -X POST https://verification.didit.me/v3/session/import-shared/ \
-H "x-api-key: $DIDIT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"share_token": "eyJhbGciOi…",
"workflow_id": "wf_partner_kyc",
"vendor_data": "partner-user-42",
"trust_review": true
}'{ "status": "Approved", "session_kind": "user" }# Didit B2B Reusable KYC — partner-to-partner KYC sharing
You are integrating Didit's B2B Reusable Know Your Customer (KYC) into <my_stack>. The recipe is server-to-server: one Didit application (Service X) mints a short-lived JSON Web Token (JWT) share token for a finished session; a partner Didit application (Service Y) imports the token and Didit clones the full verified session into Service Y. Works for both KYC and Know Your Business (KYB) sessions.
Built for Banking-as-a-Service (BaaS) sponsor banks, multi-brand financial groups, embedded finance through partner banks, marketplaces with regional or vertical sub-platforms, on-ramp + exchange ecosystems, white-label resellers, and B2B KYB consortia where the same legal entity onboards once and serves many. Every URL, header, and enum value below is canonical — do not paraphrase or "improve" them.
## 1. Provision both applications
- Sign up: https://business.didit.me (no credit card required).
- Or provision programmatically: POST https://apx.didit.me/auth/v2/programmatic/register/
- Create TWO applications in your Didit organisation. One acts as Service X (mints share tokens), the other as Service Y (imports them). In production these will usually live in different organisations — one per partner.
- Each application has its own `x-api-key`. Service X uses its own key to mint; Service Y uses its own key to import.
## 2. Service X — mint a share token
Service X picks a finished session it owns and posts to the share endpoint:
POST https://verification.didit.me/v3/session/{sessionId}/share/
Headers:
x-api-key: <Service X api key>
Content-Type: application/json
Body:
{
"for_application_id": "<partner-application-uuid>",
"ttl_in_seconds": 3600
}
Bounds on `ttl_in_seconds`: min 60, max 86400, default 3600.
Requirements:
- The session must be in a FINISHED status: "Approved", "Declined", or "In Review".
- The API key must hold the `write:sessions` privilege.
- `for_application_id` must be a real Didit application uuid — usually the partner's app.
Response: 201 Created with the JWT in the `share_token` field plus `for_application_id` and `session_kind` ("user" or "business" — Didit detects this from the source session and embeds it in the token):
{
"share_token": "eyJhbGciOiJIUzI1NiJ9...",
"for_application_id": "partner-app-uuid",
"session_kind": "user"
}
## 3. Transmit the token to Service Y
Service X transmits the `share_token` to Service Y over a pre-arranged backend channel — REST, message queue, signed webhook, anything you control. The token is scoped to Service Y's application and useless to any other application.
## 4. Service Y — import the shared session
Service Y posts the token to the import endpoint:
POST https://verification.didit.me/v3/session/import-shared/
Headers:
x-api-key: <Service Y api key>
Content-Type: application/json
Body:
{
"share_token": "<jwt from step 2>",
"workflow_id": "<Service Y's own workflow id>",
"vendor_data": "<Service Y's internal user id>",
"trust_review": true
}
`trust_review`:
- `true` → the imported session preserves the original status ("Approved" / "Declined" / "In Review"). Service Y onboards the user instantly. Use when Service Y fully trusts Service X's decision (sister brand, regulated partner with a signed data-sharing agreement).
- `false` → the imported session lands in "In Review" so Service Y's compliance team makes its own call. Safe default for new partner relationships.
Response: 201 Created with a brand-new session in Service Y's application:
{
"session_id": "<new uuid>",
"session_number": <int>,
"session_kind": "user" | "business",
"status": "Approved" | "In Review" | "Declined",
"shared_from_session": "<original session uuid in Service X>",
"vendor_data": "<Service Y's internal user id>",
"id_verifications": [...],
"liveness_checks": [...],
"face_matches": [...],
"aml_screenings": [...],
"database_validations": [...],
"proof_of_address": [...],
"phone_verifications": [...],
"email_verifications": [...]
}
For a `session_kind: "business"` token Didit clones the KYB shape instead. KYB session statuses are UPPER_SNAKE_CASE (not Title Case like KYC):
{
"session_id": "<new uuid>",
"session_kind": "business",
"status": "APPROVED",
"shared_from_session": "<original business session uuid>",
"vendor_data": "<Service Y's internal business id>",
"registry_checks": [...],
"key_people_checks": [...],
"document_verifications": [...],
"aml_screenings": [...],
"questionnaires": [...]
}
A new User or Business entity is auto-created in Service Y if one with the supplied `vendor_data` doesn't already exist.
## 5. Idempotency, expiration, errors
| Status | Reason |
|--------|--------|
| 401 | Share token invalid or past `exp` — request a new one. |
| 403 | Token not intended for your application, OR session already imported into your app. |
| 404 | Original session no longer exists. |
| 404 | `workflow_id` not found in your application. |
The duplicate-import check is enforced against the (share_token, partner application) pair.
## 6. Webhooks (optional, only when Service Y wants async updates)
Service Y can register a webhook destination once via:
POST https://verification.didit.me/v3/webhook/destinations/
Body: url, subscribed_events: ["status.updated"]
Every webhook delivery carries an `X-Signature-V2` header you MUST verify before trusting the payload. HMAC-SHA256 verification MUST run against the raw body bytes (the raw payload as Didit sent it) BEFORE any JSON parsing — re-serialising the parsed body changes whitespace and key order, which invalidates the signature.
Algorithm:
1. sortKeys(payload) recursively
2. shortenFloats (truncate trailing zeros after the decimal point)
3. JSON.stringify the result
4. HMAC-SHA256 with the secret_shared_key
5. Hex-encode, compare to the X-Signature-V2 header.
## 7. Hard rules — do not change
- Base URL for /v3/* endpoints is verification.didit.me (NOT apx.didit.me).
- Auth header is x-api-key (lowercase, hyphenated).
- Webhook signature header is X-Signature-V2 (NOT X-Signature).
- Status casing matches exactly: "Approved", "Declined", "In Review", "Not Finished" (Title Case With Spaces — KYC convention).
- session_kind is lowercase: "user" or "business".
- The share API is BUSINESS-to-BUSINESS sharing. Service X and Service Y are responsible for the data-sharing legal basis under General Data Protection Regulation (GDPR), UK GDPR, and any cross-border transfer rules. Didit ships the technical capability; you ship the data-sharing agreement.
## 8. Pricing reference (public)
- Service X already paid for the original verification (full KYC bundle is $0.30 or KYB session starts at $2.00; see didit.me/pricing).
- Service Y pays nothing on the import side — `POST /v3/session/import-shared/` is included with every plan.
- 500 free verifications every month on every account (applies to fresh captures, not imports).
## 9. Verify your integration
- Sandbox starts on signup at https://business.didit.me — no separate flag.
- Create two sandbox applications: one as Service X (issuer), the other as Service Y (importer). Use Service X's API key to mint a token for a finished sandbox session, hand the token off, use Service Y's API key to import.
- Switch to live: flip each application's environment toggle in console.
When in doubt:
- https://docs.didit.me/sessions-api/share-session/overview
- https://docs.didit.me/sessions-api/share-session/share
- https://docs.didit.me/sessions-api/share-session/import
- https://docs.didit.me/core-technology/reusable-kyc/share-kyc-via-api
$0 / महीना। क्रेडिट कार्ड की ज़रूरत नहीं।
आप जितना उपयोग करते हैं, केवल उसी का भुगतान करें। 25+ मॉड्यूल। प्रति-मॉड्यूल सार्वजनिक मूल्य निर्धारण, कोई मासिक न्यूनतम शुल्क नहीं।
कस्टम MSA और SLA। बड़ी मात्रा और विनियमित कार्यक्रमों के लिए।
मुफ़्त में शुरू करें → केवल चेक चलने पर भुगतान करें → कस्टम कॉन्ट्रैक्ट, SLA, या डेटा रेज़िडेंसी के लिए एंटरप्राइज़ अनलॉक करें।
Didit आइडेंटिटी और फ्रॉड के लिए इंफ्रास्ट्रक्चर है, वह प्लेटफ़ॉर्म जिसकी हमें खुद प्रोडक्ट बनाते समय ज़रूरत महसूस हुई थी: ओपन, फ्लेक्सिबल, और डेवलपर-फ्रेंडली, ताकि यह आपके स्टैक के एक वास्तविक हिस्से के रूप में काम करे, न कि एक ब्लैक बॉक्स के रूप में जिसे आप इंटीग्रेट करते हैं।
एक API लोगों को वेरिफाई करने (KYC, अपने ग्राहक को जानें), बिज़नेस को वेरिफाई करने (KYB, अपने बिज़नेस को जानें), क्रिप्टो वॉलेट्स की स्क्रीनिंग करने (KYT, अपने ट्रांज़ैक्शन को जानें), और रियल टाइम में ट्रांज़ैक्शन की निगरानी करने को कवर करता है, एक ऐसे स्टैक पर जो इस तरह से बनाया गया है:
इसके नीचे का फुटप्रिंट: 48+ भाषाओं में 14,000+ डॉक्यूमेंट टाइप, 1,000+ डेटा सोर्स, और हर सेशन पर 200+ फ्रॉड सिग्नल। Didit इंफ्रास्ट्रक्चर हर सेशन से डायनामिक रूप से सीखता है और हर दिन बेहतर होता जाता है।
B2B रियूजेबल KYC एक बिज़नेस को एक वेरिफाइड यूज़र या कंपनी को दूसरे बिज़नेस को सौंपने की सुविधा देता है, ताकि पार्टनर वेरिफिकेशन को फिर से चलाए बिना उसी व्यक्ति को ऑनबोर्ड कर सके।
यह दो चरणों में काम करता है:
आपका पार्टनर ऑनबोर्डिंग स्पीड चुनता है। अपने निर्णय पर भरोसा करें और यूज़र को तुरंत अप्रूव करें, या डेटा को रॉ खींचें और अपनी कंप्लायंस टीम को निर्णय लेने दें।
अपने ग्राहक को जानें (KYC) और अपने बिज़नेस को जानें (KYB) दोनों के लिए काम करता है, एक ही कॉल, दोनों आकार।
पूरा संदर्भ: docs.didit.me/sessions-api/share-session।
कोई भी बिज़नेस मॉडल जहाँ एक प्लेटफ़ॉर्म एक यूज़र को एक बार ऑनबोर्ड करता है और कई पार्टनर प्लेटफ़ॉर्म को उसी वेरिफिकेशन की ज़रूरत होती है:
यदि आप अपने पार्टनर के साथ डेटा-शेयरिंग एग्रीमेंट लिख सकते हैं, तो यह API तकनीकी हिस्से को शिप करता है।
पूरा फ्लो सामान्यतः एंड-टू-एंड 30 सेकंड से कम लेता है, ID उठाएं, डॉक्यूमेंट की तस्वीर लें, सेल्फ़ी लें, हो गया। यह मार्केट में सबसे तेज़ है। लेगेसी KYC प्रोवाइडर्स को उसी फ्लो के लिए आमतौर पर 90 सेकंड से ज़्यादा लगते हैं।
बैक एंड पर, Didit p99 पर दो सेकंड से कम में परिणाम देता है, यूज़र के सेल्फ़ी खत्म करने के क्षण से लेकर आपके वेबहुक के फायर होने के क्षण तक मापा जाता है। मोबाइल कैप्चर धीमे फ़ोन और धीमे नेटवर्क के लिए ट्यून किया गया है: प्रोग्रेसिव इमेज कंप्रेशन, लेज़ी सॉफ्टवेयर डेवलपमेंट किट लोड, और यदि यूज़र वेब पर शुरू करता है तो QR कोड के माध्यम से डेस्कटॉप से फ़ोन पर एक-टैप हैंड-ऑफ।
POST /v3/session/import-shared/ आपके एप्लिकेशन में एक ब्रांड-न्यू सेशन के साथ 201 Created रिटर्न करता है, नया session_id और session_number, पूरा पेलोड सोर्स से क्लोन किया गया।
मुख्य फ़ील्ड्स:
status, Approved / Declined / In Review (trust_review: true होने पर संरक्षित, trust_review: false होने पर In Review पर मजबूर)।session_kind, user (KYC) या business (KYB)।shared_from_session, सोर्स एप्लिकेशन में मूल सेशन की ओर इशारा करता है। यह कैनोनिकल सिग्नल कि यह सेशन इम्पोर्ट किया गया था, ताज़ा कैप्चर नहीं किया गया था।vendor_data, वह इंटरनल यूज़र / बिज़नेस ID जो आपने इम्पोर्ट कॉल पर पास की थी।id_verifications, liveness_checks, face_matches, aml_screenings, database_validations, proof_of_address, location_checks, phone_verifications, email_verifications।registry_checks, key_people_checks (उनके नेस्टेड KYCs के साथ), document_verifications, aml_screenings, questionnaires।एक ताज़ा सेशन के समान आकार, आपका मौजूदा वेबहुक हैंडलर इसे उसी तरह पढ़ता है।
हर सेशन सात स्पष्ट स्टेटस में से एक पर आता है, ताकि आपका कोड हमेशा जानता हो कि क्या करना है:
Approved, हर चेक पास हो गया। यूज़र को आगे बढ़ाएं।Declined, एक या एक से ज़्यादा चेक फेल हो गए। आप यूज़र को विशिष्ट फेल हुए स्टेप को फिर से सबमिट करने की अनुमति दे सकते हैं (उदाहरण के लिए, सेल्फ़ी फिर से लें) पूरे फ्लो को फिर से चलाए बिना।In Review, कंप्लायंस रिव्यू के लिए फ़्लैग किया गया। कंसोल में केस खोलें, हर सिग्नल देखें, अप्रूव या डिक्लाइन करने का निर्णय लें।In Progress, यूज़र मिड-फ्लो में है।Not Started, लिंक भेजा गया, यूज़र ने अभी तक इसे नहीं खोला है। यदि यह बहुत देर तक रहता है तो एक रिमाइंडर भेजें।Abandoned, यूज़र ने लिंक खोला लेकिन समय पर खत्म नहीं किया। फिर से एंगेज करें या एक्सपायर करें।Expired, सेशन लिंक की समय सीमा समाप्त हो गई। एक नया सेशन बनाएं।हर स्टेटस चेंज पर एक साइंड वेबहुक फायर होता है, ताकि आपका डेटाबेस हमेशा सिंक में रहे। अबैंडन्ड और डिक्लाइन किए गए सेशन मुफ्त हैं।
प्रोडक्शन डेटा डिफ़ॉल्ट रूप से यूरोपीय संघ में प्रोसेस और स्टोर किया जाता है, अमेज़न वेब सर्विसेज पर। एंटरप्राइज़ कॉन्ट्रैक्ट्स उन ज्यूरिसडिक्शन के लिए वैकल्पिक क्षेत्रों का अनुरोध कर सकते हैं जिनके नियामकों को इसकी आवश्यकता होती है।
हर जगह एन्क्रिप्शन। हर डेटाबेस, ऑब्जेक्ट स्टोर और बैकअप में AES-256 एट रेस्ट। हर API कॉल, वेबहुक और बिज़नेस कंसोल सेशन पर ट्रांज़िट में ट्रांसपोर्ट लेयर सिक्योरिटी 1.3। बायोमेट्रिक डेटा एक अलग कस्टमर मास्टर की के तहत एन्क्रिप्ट किया गया है।
रिटेंशन आपके नियंत्रण में है। डिफ़ॉल्ट रिटेंशन अनिश्चित (असीमित) है जब तक कि आप छोटा कॉन्फ़िगर नहीं करते, प्रति एप्लिकेशन 30 दिन और 10 साल के बीच, और आप डैशबोर्ड या API से किसी भी समय किसी भी व्यक्तिगत सेशन को हटा सकते हैं।
प्रमाणन: SOC 2 टाइप 1 (टाइप 2 ऑडिट प्रगति पर है), ISO/IEC 27001:2022, iBeta लेवल 1 PAD, और स्पेन के टेसोरो / SEPBLAC / CNMV से एक सार्वजनिक प्रमाणन कि Didit का रिमोट आइडेंटिटी वेरिफिकेशन किसी व्यक्ति को व्यक्तिगत रूप से वेरिफाई करने से ज़्यादा सुरक्षित है। पूरी रिपोर्ट /security-compliance पर।
Didit डिफ़ॉल्ट रूप से उन नियामकों के लिए कंप्लायंट है जो आइडेंटिटी इंफ्रास्ट्रक्चर के लिए महत्वपूर्ण हैं:
विस्तृत मेमो, हर सर्टिफिकेट, हर रेगुलेटर लेटर: /security-compliance।
तीन इंटीग्रेशन पाथ, जो भी आपके स्टैक के लिए सही हो उसे चुनें:
तीनों के लिए एक ही डैशबोर्ड, एक ही बिलिंग, एक ही पे-पर-सक्सेस प्राइस। स्टेप-बाय-स्टेप गाइड docs.didit.me/integration/integration-prompt पर।
KYC, KYB, ट्रांज़ैक्शन मॉनिटरिंग और वॉलेट स्क्रीनिंग के लिए एक API। 5 मिनट में इंटीग्रेट करें।