> ## 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. # Android पहचान सत्यापन SDK: Kotlin KYC > Didit का नेटिव Android Kotlin SDK: पहचान सत्यापन, लाइवनेस, NFC पासपोर्ट रीडिंग। प्रति KYC जाँच $0.33 से, $10 निःशुल्क/माह, कोई अनुबंध नहीं। Android SDK इंटीग्रेशन प्रॉम्प्ट प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें \

\`Integrate Didit identity verification into my Android app using the native Kotlin SDK.

\## Requirements
\- Android API 23+ (Android 6.0 Marshmallow). ML-based auto-detection (document/face) requires API 24+ and falls back to manual capture below that.
\- Kotlin 1.9+
\- NFC reading requires NFC-capable device hardware

\## Installation

\### Step 1: Add Maven Repository
In settings.gradle.kts:
dependencyResolutionManagement {
repositories {
    google()
    mavenCentral()
    maven { url = uri("https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository") }
}
}

\### Step 2: Add Dependency
(!) Regarding the version ensure you check the [GitHub repository](https://github.com/didit-protocol/sdk-android) for the latest version.
In app/build.gradle.kts:
dependencies {
implementation("me.didit:didit-sdk:4.13.2")
}

\### Step 3: Add Packaging Exclusion (required to avoid build conflicts)
In the android { } block of app/build.gradle.kts:
android {
packaging {
    resources {
        excludes += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
    }
}
}

\## Permissions (auto-merged from SDK manifest)
\- INTERNET (required) — API communication
\- ACCESS_NETWORK_STATE (required) — Network availability
\- CAMERA (required) — Document scanning and face verification
\- NFC (optional) — Read NFC chips in passports/IDs

Camera and NFC are declared as optional features (android:required="false"), so the app installs on all devices.

\## Initialization (required)
In your Application class:
import me.didit.sdk.DiditSdk

class MyApp : Application() {
override fun onCreate() {
    super.onCreate()
    DiditSdk.initialize(this)
}
}

Register in AndroidManifest.xml:
\

\## Backend: Create Session (your server)
POST https://verification.didit.me/v3/session/
Headers: { "x-api-key": DIDIT_API_KEY, "Content-Type": "application/json" }
Body: { "workflow_id": DIDIT_WORKFLOW_ID, "vendor_data": "user-id" }
Response: { "session_id": "uuid", "session_token": "short-token", "url": "https://verify.didit.me/session/short-token", "status": "Not Started" }
Send session_token to the Android app (never expose DIDIT_API_KEY to the device).

\## Jetpack Compose Integration
import me.didit.sdk.DiditSdk
import me.didit.sdk.DiditSdkState
import me.didit.sdk.VerificationResult

// Observe SDK state and launch UI when ready
LaunchedEffect(Unit) {
DiditSdk.state.collect { state ->
    when (state) {
        is DiditSdkState.Ready -> DiditSdk.launchVerificationUI(activity)
        is DiditSdkState.Error -> Log.e("Didit", "Error: state.message")
        else -> { /* Loading, Idle, CreatingSession */ }
    }
}
}

// Start verification with session token from backend
import me.didit.sdk.VerificationStatus

fun startVerification(token: String) {
DiditSdk.startVerification(token = token) { result ->
    when (result) {
        is VerificationResult.Completed -> when (result.session.status) {
            VerificationStatus.APPROVED -> { /* grant access */ }
            VerificationStatus.DECLINED -> { /* show retry */ }
            VerificationStatus.PENDING  -> { /* under review */ }
        }
        is VerificationResult.Cancelled -> { /* user cancelled */ }
        is VerificationResult.Failed    -> { /* show error: result.error.message */ }
    }
}
}

\## Result Statuses (VerificationStatus enum; .rawValue gives "Approved" / "Pending" / "Declined")
\- VerificationStatus.APPROVED — user identity verified, grant access
\- VerificationStatus.DECLINED — verification failed, show retry or contact support
\- VerificationStatus.PENDING  — needs manual review by your compliance team

\## Full Verification Results
The SDK only returns the status. Full decision data (document fields, face match scores, AML hits, etc.) arrives via webhook to your backend.
Set up webhooks: https://docs.didit.me/integration/webhooks

\## Rate Limits (session creation)
\- 600 session-create requests / minute per x-api-key (see https://docs.didit.me/integration/rate-limiting)
\- On 429, retry honouring Retry-After / X-RateLimit-* headers

\## Environment Variables (backend only — never expose in the Android app)
\- DIDIT_API_KEY — from Didit Console > API & Webhooks
\- DIDIT_WORKFLOW_ID — from Didit Console > Workflows

\## Docs
\- Android SDK: https://docs.didit.me/integration/native-sdks/android-sdk
\- GitHub: https://github.com/didit-protocol/sdk-android
\- Webhooks: https://docs.didit.me/integration/webhooks
\- API Reference: https://docs.didit.me/api-reference/overview`

\
यहाँ पेस्ट करें न्यूनतम कॉन्फ़िगरेशन की ज़रूरत वाला एक हल्का, सर्वर-संचालित Android SDK, जो पहचान सत्यापन के लिए है।> [card] [GitHub रिपॉज़िटरी](https://github.com/didit-protocol/sdk-android) > > GitHub पर सोर्स कोड और उदाहरण देखें> [!NOTE] > > ### **नेटिव SDK**: Android ऐप्स के लिए यही अनुशंसित तरीका है। नेटिव SDK सबसे अच्छा उपयोगकर्ता अनुभव, अनुकूलित कैमरा हैंडलिंग और पूर्ण NFC समर्थन देते हैं।***## आवश्यकताएँ| आवश्यकता | न्यूनतम संस्करण | | - | - | | Android API | 23+ (Android 6.0 Marshmallow)। ML स्वतः पहचान के लिए API 24+ आवश्यक है (नीचे देखें)। | | Kotlin | 1.9+ | | Jetpack Compose | ट्रांज़िटिव डिपेंडेंसी के रूप में शामिल |> [!NOTE] > > **API स्तर के अनुसार सुविधा उपलब्धता**: दस्तावेज़ और चेहरे की स्वतः पहचान के लिए API 24+ आवश्यक है (Didit के अपने हल्के डिटेक्टर, जो `didit-sdk-core` में शामिल हैं)। API 23 डिवाइस पर SDK टाइमर वाले शटर बटन के साथ मैन्युअल कैप्चर पर वापस चला जाता है। अन्य सभी सुविधाएँ API 23+ की पूरी रेंज में काम करती हैं।> [!NOTE] > > **बायोमेट्रिक सहमति के लिए नेटिव 4.10.0 या उसके बाद का संस्करण चाहिए।** Illinois, Texas या Colorado के कानून के अधीन आने वाले लोगों के लिए Didit पहले चेहरे के कैप्चर से पहले स्पष्ट [बायोमेट्रिक सहमति](https://docs.didit.me/hi/getting-started/biometric-consent.md) मांग सकता है। Android SDK 4.10.0 और उसके बाद के संस्करण यह चरण दिखाते हैं। पुराने संस्करण यह चरण नहीं दिखा सकते: उनके सत्र पहले की तरह चलते हैं, और निर्णय में सहमति एकत्र न होने की जानकारी दर्ज होती है (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`)। यदि आप उन राज्यों में लोगों की पहचान सत्यापित करते हैं, तो अपग्रेड करें।***## इंस्टॉलेशन### चरण 1: रिपॉज़िटरी जोड़ेंअपनी `settings.gradle.kts` फ़ाइल के `repositories` ब्लॉक में Didit Maven रिपॉज़िटरी जोड़ें:```kotlin theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url = uri("https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository") } } } ```या यदि आप `settings.gradle` (Groovy) का उपयोग करते हैं:```groovy theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" } } } ```### चरण 2: डिपेंडेंसी जोड़ेंअपने ऐप की `build.gradle.kts` फ़ाइल में SDK डिपेंडेंसी जोड़ें: (!) संस्करण के बारे में, नवीनतम संस्करण के लिए [GitHub रिपॉज़िटरी](https://github.com/didit-protocol/sdk-android) देखना सुनिश्चित करें।```kotlin theme={null} dependencies { implementation("me.didit:didit-sdk:4.13.2") } ```या यदि आप `build.gradle` (Groovy) का उपयोग करते हैं:```groovy theme={null} dependencies { implementation "me.didit:didit-sdk:4.13.2" } ```#### SDK वेरिएंटAndroid SDK अलग-अलग आर्टिफ़ैक्ट के रूप में आता है, इसलिए आपका ऐप केवल उन सुविधाओं की बाइनरी लागत चुकाता है जिनका वह उपयोग करता है। ऊपर दिया गया `me.didit:didit-sdk` पूरा बंडल है। अपने ऐप के अनुरूप एक चुनें:| आर्टिफ़ैक्ट | ऑटो-डिटेक्शन (ML) | NFC चिप रीडिंग | कब उपयोग करें | | - | :-: | :-: | - | | `me.didit:didit-sdk-core` | ✓ | – | सबसे छोटा बिल्ड; Didit के अपने डिटेक्टरों से स्वचालित कैप्चर, पासपोर्ट/ID चिप रीडिंग के बिना | | `me.didit:didit-sdk-autodetection` | ✓ | – | 4.11.0 से अप्रचलित और खाली; केवल `didit-sdk-core` पर निर्भर है, इसलिए इसके बजाय `didit-sdk-core` उपयोग करें | | `me.didit:didit-sdk-nfc` | ✓ | ✓ | `didit-sdk-core` के अतिरिक्त चिप रीडिंग | | `me.didit:didit-sdk` | ✓ | ✓ | हर सुविधा (पूरा बंडल) |`4.6.0` से, नेटिव WalletConnect वॉलेट-साइनिंग अपने अलग वैकल्पिक ऐड-ऑन, `me.didit:didit-sdk-wallet` के रूप में आता है। पूरे `me.didit:didit-sdk` बंडल में यह पहले से शामिल है, इसलिए यदि आप बंडल इंस्टॉल करते हैं तो कुछ नहीं बदलता। यदि आप छोटे आर्टिफ़ैक्ट में से कोई एक उपयोग करते हैं और चाहते हैं कि वॉलेट-स्वामित्व की पुष्टि आपके ऐप के भीतर नेटिव रूप से चले, तो उसके साथ `me.didit:didit-sdk-wallet` जोड़ें; ऐड-ऑन के बिना SDK वॉलेट-स्वामित्व एक सुरक्षित ब्राउज़र फ़्लो के माध्यम से पूरा करता है, इसलिए सुविधा दोनों तरह से काम करती रहती है। WalletConnect को `didit-sdk-core` से बाहर ले जाने से उन सभी बिल्ड से, जिन्हें इनकी ज़रूरत नहीं है, वॉलेट डिपेंडेंसी के कई मेगाबाइट भी हट गए।सभी आर्टिफ़ैक्ट एक ही संस्करण पर प्रकाशित होते हैं, इसलिए उन्हें `4.13.2` पर रखें।#### डाउनलोड का आकार छोटा रखनाऑटो-कैप्चर के लिए उपयोग होने वाले डिटेक्शन मॉडल रनटाइम पर डाउनलोड होते हैं और कैश किए जाते हैं, इसलिए वे कभी आपके ऐप के आकार में नहीं गिने जाते। ऑटो-कैप्चर आपके ऐप में ML रनटाइम की नेटिव लाइब्रेरी जोड़ता है, और यह लागत प्रति CPU आर्किटेक्चर अलग होती है: `arm64-v8a` के लिए लगभग 10 MB, `armeabi-v7a` के लिए 7 MB, और दो x86 एमुलेटर आर्किटेक्चर में से प्रत्येक के लिए 13 MB।यह लागत केवल एक बार चुकाने के लिए:1) **Android App Bundle (AAB) प्रकाशित करें।** Google Play केवल डिवाइस का अपना आर्किटेक्चर और भाषाएँ भेजता है, इसलिए arm64 फ़ोन में लगभग 10 MB नेटिव कोड इंस्टॉल होता है (संपीड़ित डाउनलोड लगभग 4 MB)। इसके विपरीत, यूनिवर्सल APK में चारों आर्किटेक्चर पैक होते हैं, जो 40 MB से अधिक है, और आकार के अप्रत्याशित रूप से अधिक होने का यह सबसे आम कारण है। 2) **यदि आप एक ही APK वितरित करते हैं** और आपके उपयोगकर्ता ARM फ़ोन और टैबलेट हैं, तो बंडल किए गए आर्किटेक्चर सीमित करें: ```kotlin theme={null} android { defaultConfig { ndk { abiFilters += listOf("arm64-v8a", "armeabi-v7a") } } } ``` अपने उपयोगकर्ताओं द्वारा वास्तव में चलाए जाने वाले हर ABI को रखें; यदि आप Chromebook या अन्य x86 डिवाइस को लक्षित करते हैं तो `x86_64` जोड़ें, या प्रति-ABI APK स्प्लिट प्रकाशित करें ताकि कोई भी डिवाइस समर्थन न खोए। 3) **R8 सक्षम करें**: अपने रिलीज़ बिल्ड टाइप में `isMinifyEnabled = true` और `isShrinkResources = true` सेट करें (यदि आप Groovy `build.gradle` उपयोग करते हैं तो `minifyEnabled true` / `shrinkResources true`)। SDK अपने साथ अपने कंज़्यूमर नियम लेकर आता है, इसलिए उपयोग न होने वाला SDK कोड बिना किसी अतिरिक्त कॉन्फ़िगरेशन के हटा दिया जाता है। 4) **बंडल की गई भाषाएँ सीमित करें** `resConfigs(...)` से, यदि आपको APK बिल्ड में SDK के सभी 48 लोकेल की ज़रूरत नहीं है; AAB भाषा स्प्लिट Google Play पर यह अपने-आप संभाल लेते हैं।### चरण 3: पैकेजिंग अपवर्जन जोड़ेंबिल्ड टकराव से बचने के लिए इसे अपने ऐप के `android` ब्लॉक में जोड़ें:```kotlin theme={null} android { packaging { resources { excludes += "META-INF/versions/9/OSGI-INF/MANIFEST.MF" } } } ```बस इतना ही! Gradle सभी ट्रांज़िटिव डिपेंडेंसी अपने-आप हल कर देगा।***## अनुमतियाँSDK को निम्नलिखित अनुमतियों की आवश्यकता है। ये SDK के `AndroidManifest.xml` में घोषित हैं और आपके ऐप के मैनिफ़ेस्ट में अपने-आप मर्ज हो जाएँगी:| अनुमति | स्रोत AAR | विवरण | आवश्यक | | - | - | - | - | | `INTERNET` | `didit-sdk-core` | API संचार के लिए नेटवर्क एक्सेस | हाँ | | `ACCESS_NETWORK_STATE` | `didit-sdk-core` | नेटवर्क उपलब्धता का पता लगाना | हाँ | | `CAMERA` | `didit-sdk-core` | दस्तावेज़ स्कैनिंग और चेहरा सत्यापन | हाँ | | `NFC` | `didit-sdk-nfc` | पासपोर्ट/ID कार्ड की NFC चिप्स पढ़ना | `didit-sdk-nfc` से अपने-आप मर्ज (`me.didit:didit-sdk` की ट्रांज़िटिव डिपेंडेंसी) |### कैमरा और NFC सुविधाएँSDK `android.hardware.camera` और `android.hardware.nfc` को वैकल्पिक सुविधाओं (`android:required="false"`) के रूप में घोषित करता है। इससे आपका ऐप उन डिवाइसों पर इंस्टॉल हो सकता है जिनमें कैमरा या NFC हार्डवेयर नहीं है। रनटाइम पर SDK अनुपलब्ध हार्डवेयर को सुचारु रूप से संभाल लेगा।***## त्वरित शुरुआत### चरण 1: SDK को आरंभ करेंअपने `Application.onCreate()` में SDK को आरंभ करें:```kotlin theme={null} import me.didit.sdk.DiditSdk class MyApp : Application() { override fun onCreate() { super.onCreate() DiditSdk.initialize(this) } } ```### चरण 2: सत्यापन शुरू करें और परिणाम संभालें```kotlin theme={null} import me.didit.sdk.DiditSdk import me.didit.sdk.DiditSdkState import me.didit.sdk.VerificationResult class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Observe SDK state to launch UI when ready lifecycleScope.launch { DiditSdk.state.collect { state -> when (state) { is DiditSdkState.Ready -> DiditSdk.launchVerificationUI(this@MainActivity) is DiditSdkState.Error -> Log.e("Didit", "Error: ${state.message}") else -> { /* Loading, Idle, CreatingSession */ } } } } } private fun startVerification() { // Method 1: UniLink (no backend required) DiditSdk.startVerification( workflowId = "your-workflow-id", vendorData = "user-123" ) { result -> handleResult(result) } // Method 2: Backend Session (recommended for production) // DiditSdk.startVerification( // token = "your-session-token" // ) { result -> // handleResult(result) // } } private fun handleResult(result: VerificationResult) { when (result) { is VerificationResult.Completed -> { Log.d("Didit", "Session: ${result.session.sessionId}") Log.d("Didit", "Status: ${result.session.status}") } is VerificationResult.Cancelled -> { Log.d("Didit", "User cancelled") } is VerificationResult.Failed -> { Log.e("Didit", "Failed: ${result.error.message}") } } } } ```***## एकीकरण के तरीकेSDK दो एकीकरण विधियों का समर्थन करता है:### विधि 1: UniLink (सबसे सरल)कोई बैकएंड आवश्यक नहीं है। SDK, Didit Console के आपके वर्कफ़्लो ID का उपयोग करके सीधे सत्र बनाता है। यह केवल `vendorData` तक सीमित है।```kotlin theme={null} DiditSdk.startVerification( workflowId = "your-workflow-id", vendorData = "user-123" ) { result -> handleResult(result) } ```### विधि 2: बैकएंड सत्र (प्रोडक्शन के लिए अनुशंसित)आपका बैकएंड [Create Verification Session API](https://docs.didit.me/hi/sessions-api/create-session.md) (`POST /v3/session/`) के माध्यम से सत्र बनाता है, जिसमें पूर्ण पैरामीटर समर्थन (`contact_details`, `expected_details`, `metadata`, `callback` आदि) है। फिर वह `session_token` को SDK को पास करता है।```kotlin theme={null} // Your backend creates a session and returns the token val sessionToken = yourBackend.createVerificationSession(userId = currentUser.id) // Pass the token to the SDK DiditSdk.startVerification( token = sessionToken ) { result -> handleResult(result) } ```यह तरीका आपको इन पर पूरा नियंत्रण देता है:- उपयोगकर्ताओं के साथ सत्रों को जोड़ना (`vendor_data`) - कस्टम मेटाडेटा सेट करना - प्रति सत्र कॉलबैक कॉन्फ़िगर करना - क्रॉस-सत्यापन के लिए संपर्क विवरण और अपेक्षित विवरण प्रदान करना***## कॉन्फ़िगरेशनSDK के व्यवहार को अनुकूलित करें:```kotlin theme={null} import me.didit.sdk.Configuration import me.didit.sdk.core.localization.SupportedLanguage val configuration = Configuration( languageLocale = SupportedLanguage.SPANISH, // Force Spanish language showLanguageSelector = true, // Let the user change language fontFamily = "my_custom_font", // Custom font (must be in res/font/) loggingEnabled = true // Enable debug logging ) DiditSdk.startVerification( token = "your-session-token", configuration = configuration ) { result -> handleResult(result) } ```### कॉन्फ़िगरेशन विकल्प| प्रॉपर्टी | प्रकार | डिफ़ॉल्ट | विवरण | | - | - | - | - | | `languageLocale` | `SupportedLanguage?` | डिवाइस लोकेल | किसी विशेष भाषा को बाध्य करें | | `showLanguageSelector` | `Boolean` | `false` | स्वागत स्क्रीन पर वेब-शैली भाषा चयनकर्ता दिखाएँ | | `fontFamily` | `String?` | सिस्टम फ़ॉन्ट | कस्टम फ़ॉन्ट संसाधन का नाम (`res/font/` से) | | `loggingEnabled` | `Boolean` | `false` | SDK डीबग लॉगिंग सक्षम करें | | `showCloseButton` | `Boolean` | `true` | सत्यापन चरण की स्क्रीन पर बंद करने (X) बटन दिखाएँ | | `showExitConfirmation` | `Boolean` | `true` | जब उपयोगकर्ता बाहर निकलने का प्रयास करे, तब पुष्टि डायलॉग दिखाएँ | | `closeOnComplete` | `Boolean` | `false` | पूरा होने पर सत्यापन UI अपने-आप बंद करें (Web SDK समकक्ष: `closeModalOnComplete`) | | `defaultDocumentCamera` | `CameraLens` | `CameraLens.BACK` | दस्तावेज़ कैप्चर स्क्रीन खुलने पर उपयोग किया जाने वाला लेंस | | `defaultLivenessCamera` | `CameraLens` | `CameraLens.FRONT` | चेहरे (लाइवनेस) कैप्चर स्क्रीन खुलने पर उपयोग किया जाने वाला लेंस | | `showDocumentCameraSwitchButton` | `Boolean` | `true` | दस्तावेज़ कैप्चर स्क्रीन पर कैप्चर के दौरान कैमरा स्विचर दिखाएँ | | `showLivenessCameraSwitchButton` | `Boolean` | `true` | चेहरा कैप्चर स्क्रीन पर कैप्चर के दौरान कैमरा स्विचर दिखाएँ |### कैमरा विकल्पकैमरा विकल्प [Web SDK कैमरा विकल्पों](https://docs.didit.me/hi/integration/web-sdks/javascript-sdk.md#कैमरा-विकल्प) से मेल खाते हैं। प्रत्येक लेंस `CameraLens.FRONT` या `CameraLens.BACK` है। यदि डिवाइस में माँगा गया लेंस नहीं है, तो SDK पहले उपलब्ध कैमरे का उपयोग करता है। कैमरा स्विचर उन डिवाइसों पर भी छिपा रहता है जिनमें केवल एक कैमरा है। उपयोगकर्ता को उस चरण के डिफ़ॉल्ट लेंस तक सीमित रखने के लिए किसी स्विचर विकल्प को `false` पर सेट करें।```kotlin theme={null} val configuration = Configuration( defaultLivenessCamera = CameraLens.BACK, showLivenessCameraSwitchButton = false ) ```> [!NOTE] > > विकल्प `showLanguageSelector`, `showCloseButton`, `showExitConfirmation`, और `closeOnComplete` Web SDK के `DiditSdkConfiguration` से मेल खाते हैं। मोबाइल-विशिष्ट विकल्प `languageLocale` और `fontFamily` इसलिए हैं क्योंकि मोबाइल SDK पूरा सत्यापन UI नेटिव रूप से रेंडर करता है (जबकि Web SDK iframe के अंदर होस्टेड फ़्रंटएंड को सौंपता है)।> [!NOTE] > > **थीम और रंग**: रंग, बैकग्राउंड और इंट्रो स्क्रीन की सेटिंग SDK कॉन्फ़िगरेशन में नहीं, बल्कि Didit Console में आपकी [व्हाइट लेबल सेटिंग्स](https://business.didit.me) से तय होती है। इससे सभी प्लेटफ़ॉर्म पर एक जैसी ब्रांडिंग सुनिश्चित होती है।***## भाषा समर्थनSDK **54 भाषाओं** का समर्थन करता है। यदि कोई भाषा निर्दिष्ट नहीं है, तो SDK डिवाइस लोकेल का उपयोग करता है और भाषा उपलब्ध न होने पर अंग्रेज़ी पर फ़ॉलबैक करता है।```kotlin theme={null} // Use device locale (default) val config = Configuration() // Force specific language val config = Configuration(languageLocale = SupportedLanguage.FRENCH) // Let the user change language on the welcome screen val config = Configuration(showLanguageSelector = true) ```**[सभी समर्थित भाषाएँ देखें →](https://docs.didit.me/hi/integration/supported-languages.md)*****## उन्नत विकल्पउन्नत सत्र पैरामीटर (`contact_details`, `expected_details`, `metadata`, `callback`) के लिए **बैकएंड सत्र** विधि का उपयोग करें। आपका बैकएंड पूर्ण पैरामीटर के साथ [Create Verification Session API](https://docs.didit.me/hi/sessions-api/create-session.md) को कॉल करता है, फिर `session_token` को SDK को पास करता है।***## परिणामों को संभालना`VerificationResult` sealed class सत्यापन का परिणाम देती है:### परिणाम के मामले| केस | विवरण | | - | - | | `Completed(session)` | सत्यापन प्रवाह पूरा हुआ (परिणाम के लिए `session.status` देखें) | | `Cancelled(session)` | उपयोगकर्ता ने सत्यापन प्रवाह रद्द किया | | `Failed(error, session)` | सत्यापन के दौरान एक त्रुटि हुई |### SessionData गुण| गुण | प्रकार | विवरण | | - | - | - | | `sessionId` | `String` | अद्वितीय सत्र पहचानकर्ता | | `status` | `VerificationStatus` | `APPROVED`, `PENDING`, या `DECLINED` |### त्रुटि प्रकारसभी त्रुटियाँ `me.didit.sdk.VerificationError` की sealed subclasses हैं:| त्रुटि | विवरण | | - | - | | `SessionExpired` | सत्र की समय-सीमा समाप्त हो गई है | | `NetworkError` | नेटवर्क कनेक्टिविटी की समस्या | | `CameraAccessDenied` | कैमरे की अनुमति नहीं दी गई है | | `NotInitialized` | SDK आरंभ नहीं हुआ है: पहले `DiditSdk.initialize(context)` कॉल करें | | `ApiError` | बैकएंड ने त्रुटि प्रतिक्रिया लौटाई | | `RetryBlocked` | सत्यापन दोबारा नहीं किया जा सकता (उदाहरण के लिए, अधिकतम प्रयास पूरे हो चुके हैं) | | `Unknown(message)` | संदेश के साथ अन्य त्रुटि |### कनेक्शन टूटनासत्यापन के दौरान यदि डिवाइस का कनेक्शन टूट जाता है, तो SDK प्रवाह को "No internet connection" स्क्रीन से ढक देता है, न कि किसी चरण को लोड होते हुए छोड़ता है। यह पृष्ठभूमि में लगातार जाँच करता रहता है और Didit से फिर से संपर्क होते ही स्क्रीन को अपने आप बंद कर देता है। उपयोगकर्ता जिस चरण पर था, वहीं से आगे बढ़ता है। इस स्क्रीन पर **Try Again** और, जब `showCloseButton` `true` हो (डिफ़ॉल्ट मान), **Exit Verification** विकल्प दिखते हैं। बाहर निकलने पर सत्यापन `VerificationResult.Failed(error = VerificationError.NetworkError, session = ...)` के साथ समाप्त होता है, ताकि आपका ऐप जान सके कि उपयोगकर्ता कनेक्शन की वजह से बाहर गया।### परिणाम संभालने का पूरा उदाहरण```kotlin theme={null} DiditSdk.startVerification(token = "your-token") { result -> when (result) { is VerificationResult.Completed -> { when (result.session.status) { VerificationStatus.APPROVED -> { Log.d("Didit", "Approved! Session: ${result.session.sessionId}") // User is verified - grant access } VerificationStatus.PENDING -> { Log.d("Didit", "Under review. Session: ${result.session.sessionId}") // Show "verification in progress" UI } VerificationStatus.DECLINED -> { Log.d("Didit", "Declined. Session: ${result.session.sessionId}") // Handle declined verification } } } is VerificationResult.Cancelled -> { Log.d("Didit", "Cancelled: ${result.session?.sessionId ?: "unknown"}") // User chose to cancel - maybe show retry option } is VerificationResult.Failed -> { Log.e("Didit", "Error: ${result.error.message}") // Handle error - show retry or contact support } } } ```***## SDK स्थिति का अवलोकनकस्टम लोडिंग UI के लिए आप SDK स्थिति का अवलोकन कर सकते हैं:```kotlin theme={null} lifecycleScope.launch { DiditSdk.state.collect { state -> when (state) { is DiditSdkState.Idle -> { // Ready to start verification } is DiditSdkState.CreatingSession -> { // Show "Creating session..." progress } is DiditSdkState.Loading -> { // Show loading indicator } is DiditSdkState.Ready -> { // Verification UI is ready - launch it DiditSdk.launchVerificationUI(this@MainActivity) } is DiditSdkState.Error -> { // Show error message Log.e("Didit", "Error: ${state.message}") } } } } ```***## ProGuard / R8SDK में अपने consumer ProGuard नियम शामिल हैं। किसी अतिरिक्त कॉन्फ़िगरेशन की ज़रूरत नहीं है।यदि आप R8 full mode इस्तेमाल करते हैं, तो आपको अपनी `gradle.properties` में यह जोड़ना पड़ सकता है:```properties theme={null} android.enableR8.fullMode=false ```***## एंड-टू-एंड उदाहरण (बैकएंड सत्र → Android SDK → परिणाम)यह पैटर्न प्रोडक्शन के लिए तैयार इंटीग्रेशन है। आपका बैकएंड सत्र बनाता है, आपका Android ऐप `session_token` प्राप्त करता है, और SDK प्रवाह चलाता है।### 1. बैकएंड: सत्र बनाएँ```ts theme={null} // Node.js / Express example. Run on your server. NEVER ship DIDIT_API_KEY to the device. import express from "express"; const app = express(); app.use(express.json()); app.post("/api/verification/start", async (req, res) => { const response = await fetch("https://verification.didit.me/v3/session/", { method: "POST", headers: { "x-api-key": process.env.DIDIT_API_KEY!, "Content-Type": "application/json", }, body: JSON.stringify({ workflow_id: process.env.DIDIT_WORKFLOW_ID, vendor_data: req.body.userId, // your stable user id }), }); if (!response.ok) { return res.status(500).json({ error: `Didit ${response.status}` }); } const { session_id, session_token } = await response.json(); // Persist session_id <-> userId so you can match the webhook later. res.json({ session_id, session_token }); }); ```### 2. Android: एक्सचेंज करें और SDK शुरू करें```kotlin theme={null} import android.app.Activity import androidx.lifecycle.lifecycleScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import me.didit.sdk.DiditSdk import me.didit.sdk.VerificationResult import me.didit.sdk.VerificationStatus import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.RequestBody.Companion.toRequestBody import okhttp3.MediaType.Companion.toMediaType import org.json.JSONObject class VerificationFlow(private val activity: ComponentActivity) { private val http = OkHttpClient() private val json = "application/json".toMediaType() fun start(userId: String) { activity.lifecycleScope.launch { val token = withContext(Dispatchers.IO) { val body = JSONObject().put("userId", userId).toString().toRequestBody(json) val req = Request.Builder() .url("https://your-backend.example.com/api/verification/start") .post(body) .build() http.newCall(req).execute().use { resp -> JSONObject(resp.body!!.string()).getString("session_token") } } DiditSdk.startVerification(token = token) { result -> when (result) { is VerificationResult.Completed -> when (result.session.status) { VerificationStatus.APPROVED -> { /* optimistic UI; rely on webhook for source of truth */ } VerificationStatus.PENDING -> { /* show "under review" */ } VerificationStatus.DECLINED -> { /* show retry/contact support */ } } is VerificationResult.Cancelled -> { /* user cancelled */ } is VerificationResult.Failed -> { /* show error: result.error.message */ } } } } } } ```### 3. बैकएंड: webhook के ज़रिए अंतिम निर्णय प्राप्त करेंSDK का परिणाम UI फ़ीडबैक के लिए सुविधाजनक है, लेकिन अंतिम और प्रामाणिक परिणाम webhook के ज़रिए आता है। HMAC सत्यापन के लिए [Webhooks गाइड](https://docs.didit.me/hi/integration/webhooks.md) देखें।```ts theme={null} app.post("/api/webhooks/didit", express.raw({ type: "application/json" }), (req, res) => { // 1. Verify the X-Signature header (see Webhooks docs) // 2. Parse the body const event = JSON.parse(req.body.toString()); if (event.webhook_type === "status.updated") { // event.session_id, event.status ("Approved" | "Declined" | "In Review" | ...) // Look up the user by session_id and update their verification state. } res.sendStatus(200); }); ```***## पूरा उदाहरण```kotlin theme={null} import android.os.Bundle import android.util.Log import androidx.activity.ComponentActivity import androidx.lifecycle.lifecycleScope import kotlinx.coroutines.launch import me.didit.sdk.Configuration import me.didit.sdk.DiditSdk import me.didit.sdk.DiditSdkState import me.didit.sdk.VerificationResult import me.didit.sdk.VerificationStatus import me.didit.sdk.core.localization.SupportedLanguage class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Observe SDK state lifecycleScope.launch { DiditSdk.state.collect { state -> when (state) { is DiditSdkState.Ready -> DiditSdk.launchVerificationUI(this@MainActivity) is DiditSdkState.Error -> Log.e("Didit", "Error: ${state.message}") else -> { /* Idle, Loading, CreatingSession */ } } } } } fun startVerification() { val config = Configuration( languageLocale = SupportedLanguage.ENGLISH, loggingEnabled = true ) // Method 1: UniLink (no backend required) DiditSdk.startVerification( workflowId = "your-workflow-id", vendorData = "user-123", configuration = config ) { result -> handleResult(result) } // Method 2: Backend Session (recommended for production) // DiditSdk.startVerification( // token = "your-session-token", // configuration = config // ) { result -> // handleResult(result) // } } private fun handleResult(result: VerificationResult) { when (result) { is VerificationResult.Completed -> { when (result.session.status) { VerificationStatus.APPROVED -> { Log.d("Didit", "Approved! Session: ${result.session.sessionId}") } VerificationStatus.PENDING -> { Log.d("Didit", "Under review") } VerificationStatus.DECLINED -> { Log.d("Didit", "Declined") } } } is VerificationResult.Cancelled -> { Log.d("Didit", "Cancelled: ${result.session?.sessionId ?: "unknown"}") } is VerificationResult.Failed -> { Log.e("Didit", "Error: ${result.error.message}") } } } } ```*** This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.