> ## 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. # React Native KYC-SDK: Mobile Verifizierung > Didit React-Native- und Expo-KYC-SDK mit TypeScript, nativem iOS/Android und NFC-Pass. Ab $0.33 pro KYC-Prüfung, $10 gratis/Monat, keine Verträge. Integrations-Prompt für das React-Native-SDK Prompt in die Zwischenablage kopieren \

\`Integrate Didit identity verification into my React Native app using the native SDK.

\## Requirements
\- React Native 0.76+ (New Architecture / TurboModules)
\- Node.js 20+, TypeScript 5+
\- iOS 13.0+ (NFC requires iOS 15+)
\- Android API 24+ (Android 7.0), Kotlin 1.9+, Java 17+
\- New Architecture (TurboModules) only - package is published as @didit-protocol/sdk-react-native v4.x (latest 4.13.2)

\## Installation

\### Expo (recommended)
npx expo install @didit-protocol/sdk-react-native

Add to app.json (NFC is enabled by default):
\{
"expo": {
"plugins": ["@didit-protocol/sdk-react-native"]
}
}

To opt out of NFC dependencies:
\{
"expo": {
"plugins": [["@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false }]]
}
}

The config plugin automatically adds the Didit Maven repo (Android), the DiditSDK podspec (iOS),
and BouncyCastle packaging rules for Android. This SDK requires a development build — it does not work in Expo Go.
The plugin does not edit Info.plist: add the iOS permission keys and, for NFC, the ISO7816 select identifiers
(including D392F000260100000001 for the Japan My Number Card) under expo.ios.infoPlist in app.json.

\### React Native CLI
npm install @didit-protocol/sdk-react-native

iOS — add this block to ios/Podfile inside the app target (NFC-aware; pins to iOS 15 when NFC is on):
didit_sdk_ios_nfc_enabled = ENV.fetch('DIDIT_SDK_IOS_NFC_ENABLED', 'true').downcase != 'false'
didit_sdk_ios_pod = didit_sdk_ios_nfc_enabled ? 'DiditSDK' : 'DiditSDK/Core'
pod didit_sdk_ios_pod, :podspec => 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/4.13.2/DiditSDK.podspec'
The tag in that URL must equal diditNativeSdkVersions.ios in the package (4.13.2); do not use 'main', because the package requires that exact version and every pod install fails when the URL resolves to a different one.
Then: cd ios && bundle exec pod install

Android — add to settings.gradle (dependencyResolutionManagement.repositories):
maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" }
To disable NFC, add diditSdkAndroidNfcEnabled=false to android/gradle.properties.

\## 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 React Native app (never expose DIDIT_API_KEY to the device).

\## Integration
import { startVerification, VerificationStatus } from '@didit-protocol/sdk-react-native';

// Option A: With session token from your backend (recommended)
const result = await startVerification('session-token-from-backend');

// Option B: With workflow ID (SDK creates session internally)
const result = await startVerificationWithWorkflow('your-workflow-id', {
vendorData: 'user-123',
});

// Handle result
switch (result.type) {
case 'completed':
if (result.session.status === VerificationStatus.Approved) { /* grant access */ }
break;
case 'cancelled':
// User dismissed the verification flow
break;
case 'failed':
// SDK error — show result.error.message
break;
}

\## Result Statuses (VerificationStatus enum)
\- 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 app)
\- DIDIT_API_KEY — from Didit Console > API & Webhooks
\- DIDIT_WORKFLOW_ID — from Didit Console > Workflows

\## Docs
\- React Native SDK: https://docs.didit.me/integration/native-sdks/react-native-sdk
\- GitHub: https://github.com/didit-protocol/sdk-react-native
\- npm: https://www.npmjs.com/package/@didit-protocol/sdk-react-native
\- Webhooks: https://docs.didit.me/integration/webhooks
\- API Reference: https://docs.didit.me/api-reference/overview`

\
Einfügen in Ein plattformübergreifendes React-Native-SDK, das die nativen iOS- und Android-SDKs kapselt und eine einheitliche TypeScript-API für die Identitätsverifizierung bereitstellt.> [card] [GitHub-Repository](https://github.com/didit-protocol/sdk-react-native) > > Quellcode und Beispiele auf GitHub ansehen> [card] [npm-Paket](https://www.npmjs.com/package/@didit-protocol/sdk-react-native) > > @didit-protocol/sdk-react-native> [!NOTE] > > ### **Natives SDK**: Dies ist der empfohlene Ansatz für React-Native- und Expo-Apps. Das SDK kapselt die nativen iOS- und Android-SDKs für das bestmögliche Nutzererlebnis, eine optimierte Kamerasteuerung und volle NFC-Unterstützung.***## Anforderungen| Anforderung | Mindestversion | | - | - | | React Native | 0.76+ (New Architecture / TurboModules) | | Node.js | 20+ | | TypeScript | 5+ |### Plattformanforderungen| Plattform | Mindestversion | Hinweise | | - | - | - | | iOS | 13.0+ | Das Auslesen von NFC-Reisepässen erfordert iOS 15.0+ | | Android | API 24+ (7.0) | Kotlin 1.9+, Java 17+ |> [!NOTE] > > **Die biometrische Einwilligung erfordert eine native SDK-Version von 4.10.0 oder neuer.** Bei Personen, die den Gesetzen von Illinois, Texas oder Colorado unterliegen, kann Didit vor der ersten Gesichtsaufnahme eine ausdrückliche [biometrische Einwilligung](https://docs.didit.me/de/getting-started/biometric-consent.md) einholen. Eine React-Native-SDK-Version, die native iOS- und Android-Versionen 4.10.0 oder neuer festlegt, zeigt diesen Schritt an. Frühere Versionen können diesen Schritt nicht anzeigen: Ihre Sitzungen laufen wie bisher weiter, und die Entscheidung meldet die Einwilligung als nicht erfasst (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Aktualisieren Sie, wenn Sie Personen in diesen Bundesstaaten verifizieren.***## Installation### Expo (empfohlen)```bash theme={null} npx expo install @didit-protocol/sdk-react-native ```Fügen Sie anschließend das Konfigurations-Plugin zu Ihrer `app.json` (oder `app.config.js`) hinzu. NFC ist standardmäßig aktiviert:```json theme={null} { "expo": { "plugins": ["@didit-protocol/sdk-react-native"] } } ```Das Plugin konfiguriert beide Plattformen automatisch:- **Android:** Fügt das Didit-Maven-Repository zu Gradle hinzu, setzt die Gradle-Property `diditSdkAndroidNfcEnabled` und wendet die Abhängigkeits- und Paketierungsregeln für BouncyCastle an - **iOS:** Fügt das DiditSDK-Podspec zum Podfile hinzu (auf iOS 15 fixiert, wenn NFC aktiviert ist)Das Plugin bearbeitet `Info.plist` nicht. Fügen Sie die [iOS-Berechtigungsschlüssel](#ios) hinzu und bei NFC zusätzlich die ISO7816-Select-Identifier unter `ios.infoPlist` in derselben Datei. `D392F000260100000001` ermöglicht dem SDK das Auslesen der Japan My Number Card über [JPKI](https://docs.didit.me/de/core-technology/nfc-verification/overview.md#japan-my-number-card-jpki):```json theme={null} { "expo": { "ios": { "infoPlist": { "NFCReaderUsageDescription": "NFC is used to read passport chip data for identity verification.", "com.apple.developer.nfc.readersession.iso7816.select-identifiers": [ "D23300000045737445494420763335", "A0000002471001", "A0000002472001", "00000000000000", "D392F000260100000001" ] } } } } ```#### NFC-Abhängigkeiten deaktivierenUm ohne NFC-Unterstützung zu bauen (kleinere Binärdatei, keine NFC-Funktion erforderlich), übergeben Sie Plugin-Optionen:```json theme={null} { "expo": { "plugins": [ [ "@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false } ] ] } } ```Wenn NFC deaktiviert ist, benötigen Sie weder die iOS-NFC-Capability, NFC-Berechtigungen noch die NFC-bezogene Bereitstellungskonfiguration.> [!WARNING] > > Dieses SDK verwendet native Module (Kamera, NFC), die **in Expo Go nicht verfügbar sind**. Sie müssen einen [Entwicklungs-Build](https://docs.expo.dev/develop/development-builds/introduction/) verwenden oder `npx expo prebuild` ausführen, um die nativen Projekte zu erzeugen.### React Native CLI```bash theme={null} npm install @didit-protocol/sdk-react-native # or yarn add @didit-protocol/sdk-react-native ```#### iOS-EinrichtungFügen Sie den DiditSDK-Pod zu Ihrem `Podfile` hinzu (er ist nicht im CocoaPods-Trunk verfügbar). Der folgende Block berücksichtigt die Umgebungsvariable `DIDIT_SDK_IOS_NFC_ENABLED`, sodass Sie bei der Installation zwischen dem Subspec ohne NFC (`DiditSDK/Core`) umschalten können:```ruby theme={null} # In your ios/Podfile — at the top, before the target block: didit_sdk_ios_nfc_enabled = ENV.fetch('DIDIT_SDK_IOS_NFC_ENABLED', 'true').downcase != 'false' def max_ios_version(*versions) versions.map(&:to_s).max_by { |version| Gem::Version.new(version) } end platform :ios, didit_sdk_ios_nfc_enabled ? max_ios_version(min_ios_version_supported, '15.0') : min_ios_version_supported # Inside your app target: didit_sdk_ios_pod = didit_sdk_ios_nfc_enabled ? 'DiditSDK' : 'DiditSDK/Core' pod didit_sdk_ios_pod, :podspec => 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/4.13.2/DiditSDK.podspec' ```> [!WARNING] > > Der Tag in der Podspec-URL muss mit `diditNativeSdkVersions.ios` in der installierten Paketversion übereinstimmen. > React Native `4.13.2` verwendet das native iOS-SDK `4.13.2` und das native Android-SDK `4.13.2`. Verweisen Sie das Podspec nicht auf `main`: Das Paket hängt von genau dieser nativen iOS-Version ab. Sobald `main` eine höhere Version enthält, sieht CocoaPods zwei inkompatible Anforderungen für `DiditSDK`, und jedes `pod install` schlägt fehl. Das Expo-Konfigurations-Plugin leitet diese URL für Sie ab; nur der reine React-Native-CLI-Pfad muss sie manuell angeben.Installieren Sie danach die Abhängigkeiten:```bash theme={null} cd ios bundle exec pod install ```Um ohne NFC-Abhängigkeiten neu zu bauen, bereinigen Sie CocoaPods und führen Sie den Befehl mit gesetzter Umgebungsvariable erneut aus:```bash theme={null} cd ios rm -rf Pods Podfile.lock DIDIT_SDK_IOS_NFC_ENABLED=false bundle exec pod install ```#### Android-EinrichtungFügen Sie das Didit-Maven-Repository zu Ihrer projektweiten `settings.gradle` hinzu:```groovy theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" } } } ```Fügen Sie Folgendes in Ihre `android/app/build.gradle` ein (innerhalb des Blocks `android { ... }`), um BouncyCastle-Konflikte durch doppelte Klassen und das doppelte OSGI-`MANIFEST.MF` aufzulösen, die durch transitive Abhängigkeiten des DiditSDK ausgelöst werden können:```groovy theme={null} android { configurations.configureEach { exclude group: 'org.bouncycastle', module: 'bcprov-jdk15to18' exclude group: 'org.bouncycastle', module: 'bcutil-jdk15to18' exclude group: 'org.bouncycastle', module: 'bcpkix-jdk15to18' exclude group: 'org.bouncycastle', module: 'bcprov-jdk15on' } packaging { resources { pickFirsts += ['org/bouncycastle/**'] excludes += 'META-INF/versions/9/OSGI-INF/MANIFEST.MF' } } } ```Um ohne Android-NFC-Abhängigkeiten zu bauen (verwendet das Artefakt `me.didit:didit-sdk-core` statt `me.didit:didit-sdk`), fügen Sie Folgendes zu `android/gradle.properties` hinzu:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Entfernen Sie diese Property oder setzen Sie sie auf `true`, um das vollständige Android-SDK mit NFC zu verwenden.***## Berechtigungen### iOSFügen Sie die folgenden Schlüssel zur `Info.plist` Ihrer App hinzu. Fehlen erforderliche iOS-Datenschutzschlüssel, beendet iOS die App, sobald das SDK auf die geschützte Ressource zugreift.| Berechtigung | Info.plist-Schlüssel | Beschreibung | Erforderlich | | - | - | - | - | | Kamera | `NSCameraUsageDescription` | Dokumentenscan und Gesichtsverifizierung | Ja | | Mikrofon | `NSMicrophoneUsageDescription` | Aufnahme des Liveness-Videos | Ja | | Fotomediathek | `NSPhotoLibraryUsageDescription` | Hochladen von Dokumentenbildern | Ja | | Standort | `NSLocationWhenInUseUsageDescription` | Geolokalisierung zur Betrugsprävention | Ja | | NFC | `NFCReaderUsageDescription` | Auslesen von NFC-Chips in Reisepässen/Ausweisen | Bei Verwendung von NFC |```xml theme={null} NSCameraUsageDescription Camera access is required to scan your identity documents for verification. NSMicrophoneUsageDescription Microphone access is required to record video for liveness verification. NSPhotoLibraryUsageDescription Photo library access is required to upload document images. NFCReaderUsageDescription NFC is used to read passport chip data for identity verification. NSLocationWhenInUseUsageDescription Location access is used to detect your country for identity verification. ```#### NFC-KonfigurationSo aktivieren Sie das NFC-Auslesen von Reisepässen und Ausweisen mit Chip:1) **NFC-Capability hinzufügen** in Xcode: * Wählen Sie Ihr Target > **Signing & Capabilities** > **+ Capability** > **Near Field Communication Tag Reading** 2) **ISO7816-Identifikatoren** zu `Info.plist` hinzufügen:```xml theme={null} com.apple.developer.nfc.readersession.iso7816.select-identifiers D23300000045737445494420763335 A0000002471001 A0000002472001 00000000000000 D392F000260100000001 ```Mit `D392F000260100000001` kann das SDK die japanische My Number Card über [JPKI](https://docs.didit.me/de/core-technology/nfc-verification/overview.md#japan-my-number-card-jpki) lesen: Ohne diesen Identifikator meldet iOS die Karte nicht an das SDK. Das Lesen der My Number Card ist in der Produktion noch nicht aktiviert, und der Identifikator wirkt sich nicht auf andere Dokumente aus, sodass Sie ihn schon jetzt hinzufügen können.3) **Eine Entitlements-Datei hinzufügen**, in der das Lesen von NFC-Tags aktiviert ist:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Stellen Sie sicher, dass das Provisioning-Profil der App die Capability NFC Tag Reading enthält. Diese NFC-Konfiguration ist nicht erforderlich, wenn NFC deaktiviert ist.### AndroidDie folgenden Berechtigungen sind in der `AndroidManifest.xml` des SDK deklariert und werden automatisch zusammengeführt:| Berechtigung | Beschreibung | Erforderlich | | - | - | - | | `INTERNET` | Netzwerkzugriff für die API-Kommunikation | Ja | | `ACCESS_NETWORK_STATE` | Erkennung der Netzwerkverfügbarkeit | Ja | | `CAMERA` | Dokumentenscan und Gesichtsverifizierung | Ja | | `NFC` | Auslesen von NFC-Chips in Reisepässen/Ausweisen | Bei Verwendung von NFC |Kamera- und NFC-Hardwarefunktionen sind als optional deklariert (`android:required="false"`), sodass Ihre App auch auf Geräten ohne diese Funktionen installiert werden kann.***## Schnellstart```tsx theme={null} import { startVerification, VerificationStatus } from '@didit-protocol/sdk-react-native'; // Start verification with a session token from your backend const result = await startVerification('your-session-token'); switch (result.type) { case 'completed': if (result.session.status === VerificationStatus.Approved) { console.log('Identity verified!'); } break; case 'cancelled': console.log('User cancelled'); break; case 'failed': console.log('Error:', result.error.message); break; } ```***## IntegrationsmethodenDas SDK unterstützt zwei Integrationsmethoden:### Methode 1: Session-Token (für die Produktion empfohlen)Erstellen Sie auf Ihrem Backend über die [Create Verification Session API](https://docs.didit.me/de/sessions-api/create-session.md) eine Sitzung und übergeben Sie dann das Token an das SDK:```tsx theme={null} import { startVerification } from '@didit-protocol/sdk-react-native'; // Your backend creates a session and returns the token const sessionToken = await yourBackend.createVerificationSession(userId); // Pass the token to the SDK const result = await startVerification(sessionToken); ```Dieser Ansatz gibt Ihnen die volle Kontrolle über:- Zuordnung der Sitzungen zu Ihren Benutzern (`vendor_data`) - Festlegen benutzerdefinierter Metadaten - Konfiguration der Callbacks pro Sitzung### Methode 2: Workflow-ID (einfachere Integration)Für einfachere Integrationen kann das SDK Sitzungen direkt mit Ihrer Workflow-ID erstellen:```tsx theme={null} import { startVerificationWithWorkflow } from '@didit-protocol/sdk-react-native'; const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', contactDetails: { email: 'user@example.com' }, config: { loggingEnabled: true }, }); ```***## KonfigurationPassen Sie das Verhalten des SDK an, indem Sie ein `DiditConfig`-Objekt übergeben:```tsx theme={null} const result = await startVerification('your-session-token', { languageCode: 'es', // Force Spanish language showLanguageSelector: true, // Let the user change language fontFamily: 'Avenir', // Custom font (must be registered natively) loggingEnabled: true, // Enable debug logging showCloseButton: true, // Show close (X) button on step screens showExitConfirmation: true, // Confirm before exit closeOnComplete: false, // Auto-dismiss UI on completion }); ```Übergeben Sie für `startVerificationWithWorkflow` die Konfiguration innerhalb von `options.config`:```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', config: { languageCode: 'es', showLanguageSelector: true, loggingEnabled: true, showCloseButton: true, showExitConfirmation: true, }, }); ```### Konfigurationsoptionen| Eigenschaft | Typ | Standard | Beschreibung | | - | - | - | - | | `languageCode` | `string` | Gerätesprache | ISO-639-1-Sprachcode (z. B. `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `boolean` | `false` | Web-Sprachauswahl auf dem Begrüßungsbildschirm anzeigen | | `fontFamily` | `string` | Systemschrift | Name einer benutzerdefinierten Schriftfamilie (muss nativ registriert sein) | | `loggingEnabled` | `boolean` | `false` | SDK-Debug-Logging aktivieren | | `showCloseButton` | `boolean` | `true` | Schließen-Schaltfläche (X) auf den Bildschirmen der Verifizierungsschritte anzeigen | | `showExitConfirmation` | `boolean` | `true` | Bestätigungsdialog anzeigen, wenn der Benutzer die Verifizierung beenden möchte | | `closeOnComplete` | `boolean` | `false` | Verifizierungsoberfläche nach Abschluss automatisch schließen | | `defaultDocumentCamera` | `CameraLens?` | Nativer Standardwert (`CameraLens.Back`) | Objektiv, das beim Öffnen des Dokumentenaufnahmebildschirms verwendet wird | | `defaultLivenessCamera` | `CameraLens?` | Nativer Standardwert (`CameraLens.Front`) | Objektiv, das beim Öffnen des Gesichtsaufnahmebildschirms (Liveness) verwendet wird | | `showDocumentCameraSwitchButton` | `boolean` | `true` | Kamerawechsler während der Aufnahme auf dem Dokumentenaufnahmebildschirm anzeigen | | `showLivenessCameraSwitchButton` | `boolean` | `true` | Kamerawechsler während der Aufnahme auf dem Gesichtsaufnahmebildschirm anzeigen |### KameraoptionenDie Kameraoptionen entsprechen den [Kameraoptionen des Web SDK](https://docs.didit.me/de/integration/web-sdks/javascript-sdk.md#kameraoptionen). Jedes Objektiv ist `CameraLens.Front` oder `CameraLens.Back`. Wenn das Gerät das angeforderte Objektiv nicht hat, verwendet das SDK die erste verfügbare Kamera. Der Kamerawechsler wird auch auf Geräten mit nur einer Kamera ausgeblendet. Setzen Sie eine Option für den Kamerawechsler auf `false`, damit der Benutzer auf das Standardobjektiv dieses Schritts beschränkt wird.```tsx theme={null} import { startVerification, CameraLens } from '@didit-protocol/sdk-react-native'; await startVerification('your-session-token', { defaultLivenessCamera: CameraLens.Back, showLivenessCameraSwitchButton: false, }); ```> [!NOTE] > > **Design und Farben**: Farben, Hintergründe und Einstellungen des Intro-Bildschirms werden über Ihre [White-Label-Einstellungen](https://business.didit.me) in der Didit Console konfiguriert, nicht in der SDK-Konfiguration. So bleibt das Branding auf allen Plattformen einheitlich.***## Unterstützte SprachenDas SDK unterstützt **54 Sprachen**. Wenn keine Sprache angegeben ist, verwendet das SDK die Gerätesprache und greift als Fallback auf Englisch zurück.```tsx theme={null} // Use device locale (default) await startVerification(token); // Force specific language await startVerification(token, { languageCode: 'fr' }); // Let the user change language on the welcome screen await startVerification(token, { showLanguageSelector: true }); ```**[Alle unterstützten Sprachen anzeigen →](https://docs.didit.me/de/integration/supported-languages.md)*****## Erweiterte OptionenDiese Optionen sind nur mit `startVerificationWithWorkflow` verfügbar, bei dem das SDK die Sitzung in Ihrem Auftrag erstellt.### Kontaktdaten (Vorausfüllung & Benachrichtigungen)Geben Sie Kontaktdaten an, um Verifizierungsformulare vorauszufüllen und E-Mail-Benachrichtigungen zu aktivieren:```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { contactDetails: { email: 'user@example.com', sendNotificationEmails: true, // Send status update emails emailLang: 'en', // Email language (ISO 639-1) phone: '+14155552671', // E.164 format }, }); ```### Erwartete Angaben (Kreuzvalidierung)Geben Sie erwartete Benutzerdaten für die automatische Kreuzvalidierung mit den aus dem Dokument extrahierten Daten an:```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { expectedDetails: { firstName: 'John', lastName: 'Doe', dateOfBirth: '1990-05-15', // YYYY-MM-DD format gender: 'M', nationality: 'USA', // ISO 3166-1 alpha-3 country: 'USA', address: '1 Market St, San Francisco, CA', identificationNumber: 'A1234567', ipAddress: '203.0.113.42', portraitImage: 'https://...', // URL or base64 reference image }, }); ```Alle Felder von `ExpectedDetails` sind optional. Den vollständigen Typ finden Sie in [`src/types.ts`](https://github.com/didit-protocol/sdk-react-native/blob/main/src/types.ts).### Benutzerdefinierte MetadatenSpeichern Sie benutzerdefinierte JSON-Metadaten mit der Sitzung (werden dem Benutzer nicht angezeigt):```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', metadata: '{"internalId": "abc123", "source": "mobile-app"}', }); ```***## Ergebnisse verarbeitenBeide Methoden, `startVerification` und `startVerificationWithWorkflow`, geben ein `Promise` zurück. Das Ergebnis ist eine diskriminierte Union. Den Ausgang bestimmen Sie über das Feld `type`.### Ergebnisfälle| Fall | Beschreibung | | - | - | | `completed` | Verifizierungsablauf abgeschlossen (Ergebnis in `session.status` prüfen) | | `cancelled` | Benutzer hat den Verifizierungsablauf abgebrochen | | `failed` | Bei der Verifizierung ist ein Fehler aufgetreten |### SessionData-Eigenschaften| Eigenschaft | Typ | Beschreibung | | - | - | - | | `sessionId` | `string` | Eindeutige Sitzungs-ID | | `status` | `VerificationStatus` | `Approved`, `Pending` oder `Declined` |### Fehlertypen| Fehler | Beschreibung | | - | - | | `sessionExpired` | Die Sitzung ist abgelaufen | | `networkError` | Problem mit der Netzwerkverbindung | | `cameraAccessDenied` | Kamerazugriff wurde nicht erteilt | | `notInitialized` | SDK nicht initialisiert (nur Android) | | `apiError` | API-Anfrage fehlgeschlagen | | `unknown` | Sonstiger Fehler mit Meldung |### VerbindungsverlustWenn das Gerät während der Verifizierung die Verbindung verliert, zeigt das SDK einen Bildschirm mit „Keine Internetverbindung“ an, der den Ablauf überlagert, statt einen Schritt weiterhin im Ladezustand zu belassen. Es prüft im Hintergrund weiter und schließt den Bildschirm automatisch, sobald Didit wieder erreichbar ist. Der Benutzer setzt die Verifizierung dann ab dem Schritt fort, an dem er zuletzt war. Der Bildschirm bietet **Erneut versuchen** und, wenn `showCloseButton` auf `true` gesetzt ist (Standardwert), **Verifizierung beenden**. Beim Beenden endet die Verifizierung mit dem Ergebnis `failed`, dessen Fehler `networkError` ist. Ihre App erkennt so, dass der Benutzer wegen der Verbindung abgebrochen hat.### Vollständiges Beispiel zur Ergebnisverarbeitung```tsx theme={null} import { startVerification, VerificationStatus, type VerificationResult, } from '@didit-protocol/sdk-react-native'; async function verify(token: string) { const result: VerificationResult = await startVerification(token); switch (result.type) { case 'completed': switch (result.session.status) { case VerificationStatus.Approved: console.log('Approved! Session:', result.session.sessionId); // User is verified — grant access break; case VerificationStatus.Pending: console.log('Under review. Session:', result.session.sessionId); // Show "verification in progress" UI break; case VerificationStatus.Declined: console.log('Declined. Session:', result.session.sessionId); // Handle declined verification break; } break; case 'cancelled': console.log('User cancelled the verification.'); // Maybe show retry option break; case 'failed': console.log(`Error [${result.error.type}]: ${result.error.message}`); // Handle error — show retry or contact support break; } } ```***## End-to-End-Beispiel (Backend-Sitzung → React-Native-SDK → Webhook)Die produktionsreife Integration funktioniert so: Ihr Backend erstellt die Sitzung, Ihre React-Native-App erhält das `session_token`, und das SDK führt den Ablauf aus. Die endgültige Entscheidung wird per Webhook an Ihr Backend zugestellt. Vertrauen Sie niemals allein dem clientseitigen Ergebnis.### 1. Backend: Sitzung erstellen```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. React Native: Token austauschen und SDK starten```tsx theme={null} import { useCallback, useState } from 'react'; import { Button, View } from 'react-native'; import { startVerification, VerificationStatus, type VerificationResult, } from '@didit-protocol/sdk-react-native'; export function VerifyButton({ userId }: { userId: string }) { const [loading, setLoading] = useState(false); const onPress = useCallback(async () => { setLoading(true); try { const r = await fetch('https://your-backend.example.com/api/verification/start', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ userId }), }); const { session_token } = await r.json(); const result: VerificationResult = await startVerification(session_token); switch (result.type) { case 'completed': if (result.session.status === VerificationStatus.Approved) { // Optimistic UI; rely on the webhook delivered to your backend as the source of truth. } break; case 'cancelled': // User dismissed the flow break; case 'failed': // Show retry — result.error.type / result.error.message break; } } finally { setLoading(false); } }, [userId]); return (