> ## 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. # SDK de KYC per a React Native: verificació mòbil > Didit: SDK de KYC per a React Native i Expo amb TypeScript, iOS i Android i NFC. Des de $0.33 per KYC complet, $10 gratis/mes, sense contractes. Prompt d'integració del SDK de React Native Copia el prompt al porta-retalls \

\`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`

\
Enganxa a Un SDK multiplataforma per a React Native que encapsula els SDK natius d'iOS i Android i ofereix una API unificada en TypeScript per a la verificació d'identitat.> [card] [Repositori de GitHub](https://github.com/didit-protocol/sdk-react-native) > > Consulta el codi font i els exemples a GitHub> [card] [Paquet npm](https://www.npmjs.com/package/@didit-protocol/sdk-react-native) > > @didit-protocol/sdk-react-native> [!NOTE] > > ### **SDK natiu**: Aquesta és l'opció recomanada per a aplicacions de React Native i Expo. El SDK encapsula els SDK natius d'iOS i Android per oferir la millor experiència d'usuari, una gestió optimitzada de la càmera i suport complet per a NFC.***## Requisits| Requisit | Versió mínima | | - | - | | React Native | 0.76+ (New Architecture / TurboModules) | | Node.js | 20+ | | TypeScript | 5+ |### Requisits de la plataforma| Plataforma | Versió mínima | Notes | | - | - | - | | iOS | 13.0+ | La lectura de passaports amb NFC requereix iOS 15.0+ | | Android | API 24+ (7.0) | Kotlin 1.9+, Java 17+ |> [!NOTE] > > **El consentiment biomètric necessita la versió 4.10.0 o posterior del SDK natiu.** Per a les persones cobertes per la llei de Illinois, Texas o Colorado, Didit pot demanar un [consentiment biomètric](https://docs.didit.me/ca/getting-started/biometric-consent.md) explícit abans de la primera captura facial. Una versió del SDK de React Native que fixa iOS i Android natius a la 4.10.0 o posterior mostra aquest pas. Les versions anteriors no poden mostrar-lo: les seves sessions s'executen com abans, i la decisió indica que el consentiment no s'ha recollit (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Actualitza si verifiques persones en aquests estats.***## Instal·lació### Expo (recomanat)```bash theme={null} npx expo install @didit-protocol/sdk-react-native ```Després, afegeix el plugin de configuració al teu `app.json` (o `app.config.js`). El NFC està habilitat per defecte:```json theme={null} { "expo": { "plugins": ["@didit-protocol/sdk-react-native"] } } ```El plugin configura automàticament totes dues plataformes:- **Android:** afegeix el repositori Maven de Didit a Gradle, estableix la propietat Gradle `diditSdkAndroidNfcEnabled` i aplica les regles de dependències i empaquetatge de BouncyCastle - **iOS:** afegeix el podspec de DiditSDK al Podfile (fixat a iOS 15 quan el NFC està habilitat)El plugin no modifica el `Info.plist`. Afegeix les [claus de permís d'iOS](#ios) i, per al NFC, els identificadors de selecció ISO7816 sota `ios.infoPlist` al mateix fitxer. `D392F000260100000001` permet que el SDK llegeixi la My Number Card del Japó mitjançant [JPKI](https://docs.didit.me/ca/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" ] } } } } ```#### Desactivar les dependències de NFCPer compilar sense suport de NFC (binari més petit, sense necessitat de la capacitat NFC), passa les opcions del plugin:```json theme={null} { "expo": { "plugins": [ [ "@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false } ] ] } } ```Quan el NFC està desactivat, no cal que tinguis la capacitat NFC d'iOS, els drets d'accés de NFC ni la configuració d'aprovisionament relacionada amb el NFC.> [!WARNING] > > Aquest SDK fa servir mòduls nadius (càmera, NFC) que **no estan disponibles a Expo Go**. Has d'utilitzar una [compilació de desenvolupament](https://docs.expo.dev/develop/development-builds/introduction/) o executar `npx expo prebuild` per generar els projectes nadius.### React Native CLI```bash theme={null} npm install @didit-protocol/sdk-react-native # or yarn add @didit-protocol/sdk-react-native ```#### Configuració d'iOSAfegeix el pod DiditSDK al teu `Podfile` (no està al CocoaPods trunk). El bloc següent té en compte la variable d'entorn `DIDIT_SDK_IOS_NFC_ENABLED`, així pots activar o desactivar el subspec sense NFC (`DiditSDK/Core`) durant la instal·lació:```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] > > L'etiqueta de la URL del podspec ha de coincidir amb `diditNativeSdkVersions.ios` de la versió del paquet instal·lada. > React Native `4.13.2` fixa la versió nativa d'iOS a `4.13.2` i la d'Android a `4.13.2`. No apuntis el podspec > a `main`: el paquet depèn exactament d'aquella versió nativa d'iOS, així que, en el moment que `main` avanci, CocoaPods veu dos requisits incompatibles per a > `DiditSDK` i cada `pod install` falla. El plugin de configuració d'Expo calcula aquesta URL per a tu; només cal escriure-la a mà en la ruta de React Native CLI pura.Després, instal·la les dependències:```bash theme={null} cd ios bundle exec pod install ```Per recompilar sense les dependències de NFC, neteja CocoaPods i torna a executar la instal·lació amb la variable d'entorn definida:```bash theme={null} cd ios rm -rf Pods Podfile.lock DIDIT_SDK_IOS_NFC_ENABLED=false bundle exec pod install ```#### Configuració d'AndroidAfegeix el repositori Maven de Didit al `settings.gradle` del projecte:```groovy theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" } } } ```Afegeix el següent al fitxer `android/app/build.gradle` de la teva aplicació (dins del bloc `android { ... }`) per resoldre els conflictes de classes duplicades de BouncyCastle i el duplicat de `MANIFEST.MF` d'OSGI que poden provocar les dependències transitives de DiditSDK:```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' } } } ```Per compilar sense les dependències de NFC d'Android (fa servir l'artefacte `me.didit:didit-sdk-core` en lloc de `me.didit:didit-sdk`), afegeix això a `android/gradle.properties`:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Elimina aquesta propietat, o estableix-la a `true`, per fer servir el SDK complet d'Android amb NFC.***## Permisos### iOSAfegeix les claus següents al `Info.plist` de la teva aplicació. Si falten les claus de privacitat obligatòries d'iOS, iOS tancarà l'aplicació en el moment en què el SDK accedeixi al recurs protegit corresponent.| Permís | Clau d'Info.plist | Descripció | Obligatori | | - | - | - | - | | Càmera | `NSCameraUsageDescription` | Escaneig de documents i verificació facial | Sí | | Micròfon | `NSMicrophoneUsageDescription` | Enregistrament de vídeo per a la prova de vida | Sí | | Biblioteca de fotos | `NSPhotoLibraryUsageDescription` | Pujada d'imatges de documents | Sí | | Ubicació | `NSLocationWhenInUseUsageDescription` | Geolocalització per a la prevenció del frau | Sí | | NFC | `NFCReaderUsageDescription` | Lectura de xips NFC en passaports i targetes d'identitat | Si s'utilitza 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. ```#### Configuració de NFCPer habilitar la lectura NFC de passaports i targetes d'identitat amb xip:1) **Afegeix la capacitat NFC** a Xcode: * Selecciona el teu target > **Signing & Capabilities** > **+ Capability** > **Near Field Communication Tag Reading** 2) **Afegeix els identificadors ISO7816** a `Info.plist`:```xml theme={null} com.apple.developer.nfc.readersession.iso7816.select-identifiers D23300000045737445494420763335 A0000002471001 A0000002472001 00000000000000 D392F000260100000001 ````D392F000260100000001` permet que el SDK llegeixi la My Number Card del Japó a través de [JPKI](https://docs.didit.me/ca/core-technology/nfc-verification/overview.md#japan-my-number-card-jpki): sense aquest identificador, iOS no informa el SDK sobre la targeta. La lectura de la My Number Card encara no està habilitada en producció, i l'identificador no canvia res per a la resta de documents, de manera que el pots afegir ara.3) **Afegeix un fitxer d'entitlements** amb la lectura d'etiquetes NFC habilitada:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Assegura't que el perfil d'aprovisionament de l'aplicació inclogui la capacitat NFC Tag Reading. Aquesta configuració NFC no és necessària quan NFC està desactivat.### AndroidEl SDK declara els permisos següents al seu `AndroidManifest.xml` i es fusionen automàticament:| Permís | Descripció | Obligatori | | - | - | - | | `INTERNET` | Accés a la xarxa per a la comunicació amb l'API | Sí | | `ACCESS_NETWORK_STATE` | Detecció de la disponibilitat de la xarxa | Sí | | `CAMERA` | Escaneig de documents i verificació facial | Sí | | `NFC` | Lectura de xips NFC en passaports i targetes d'identitat | Si s'utilitza NFC |Les funcionalitats de maquinari de càmera i NFC es declaren com a opcionals (`android:required="false"`), de manera que la teva aplicació es pot instal·lar en dispositius sense aquestes funcionalitats.***## Inici ràpid```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; } ```***## Mètodes d'integracióEl SDK admet dos mètodes d'integració:### Mètode 1: Token de sessió (recomanat per a producció)Crea una sessió al teu backend amb l'[API de creació de sessions de verificació](https://docs.didit.me/ca/sessions-api/create-session.md) i, després, passa el token al 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); ```Aquest enfocament et dóna control total sobre:- L'associació de les sessions amb els teus usuaris (`vendor_data`) - La definició de metadades personalitzades - La configuració de callbacks per sessió### Mètode 2: ID de flux de treball (integració més senzilla)Per a integracions més senzilles, el SDK pot crear sessions directament amb el teu ID de flux de treball:```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 }, }); ```***## ConfiguracióPersonalitza el comportament del SDK passant un objecte `DiditConfig`:```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 }); ```Per a `startVerificationWithWorkflow`, passa la configuració dins de `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, }, }); ```### Opcions de configuració| Propietat | Tipus | Valor per defecte | Descripció | | - | - | - | - | | `languageCode` | `string` | Configuració regional del dispositiu | Codi d'idioma ISO 639-1 (p. ex. `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `boolean` | `false` | Mostra el selector d'idioma d'estil web a la pantalla de benvinguda | | `fontFamily` | `string` | Tipografia del sistema | Nom de la família tipogràfica personalitzada (s'ha de registrar de forma nativa) | | `loggingEnabled` | `boolean` | `false` | Habilita el registre de depuració del SDK | | `showCloseButton` | `boolean` | `true` | Mostra el botó de tancar (X) a les pantalles dels passos de verificació | | `showExitConfirmation` | `boolean` | `true` | Mostra un diàleg de confirmació quan l'usuari intenta sortir | | `closeOnComplete` | `boolean` | `false` | Tanca automàticament la interfície de verificació en completar-se | | `defaultDocumentCamera` | `CameraLens?` | Valor per defecte natiu (`CameraLens.Back`) | Lent que s'utilitza quan s'obre la pantalla de captura del document | | `defaultLivenessCamera` | `CameraLens?` | Valor per defecte natiu (`CameraLens.Front`) | Lent que s'utilitza quan s'obre la pantalla de captura facial (prova de vida) | | `showDocumentCameraSwitchButton` | `boolean` | `true` | Mostra el selector de càmera durant la captura a la pantalla de captura del document | | `showLivenessCameraSwitchButton` | `boolean` | `true` | Mostra el selector de càmera durant la captura a la pantalla de captura facial |### Opcions de càmeraLes opcions de càmera coincideixen amb les [opcions de càmera del SDK web](https://docs.didit.me/ca/integration/web-sdks/javascript-sdk.md#opcions-de-càmera). Cada lent és `CameraLens.Front` o `CameraLens.Back`. Si el dispositiu no té la lent sol·licitada, el SDK utilitza la primera càmera que tingui. El selector de càmera també s'amaga en dispositius que només tenen una càmera. Defineix una opció de selector com a `false` per bloquejar l'usuari a la càmera per defecte d'aquest pas.```tsx theme={null} import { startVerification, CameraLens } from '@didit-protocol/sdk-react-native'; await startVerification('your-session-token', { defaultLivenessCamera: CameraLens.Back, showLivenessCameraSwitchButton: false, }); ```> [!NOTE] > > **Tema i colors**: els colors, els fons i la configuració de les pantalles d'introducció es configuren a través de la teva [configuració de marca blanca](https://business.didit.me) a Didit Console, no a la configuració del SDK. Així es garanteix una imatge de marca coherent a totes les plataformes.***## Suport d'idiomesEl SDK admet **54 idiomes**. Si no s'especifica cap idioma, el SDK utilitza la configuració regional del dispositiu, amb l'anglès com a alternativa.```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 }); ```**[Consulta tots els idiomes admesos →](https://docs.didit.me/ca/integration/supported-languages.md)*****## Opcions avançadesAquestes opcions només estan disponibles amb `startVerificationWithWorkflow`, quan el SDK crea la sessió en nom teu.### Dades de contacte (preemplenament i notificacions)Proporciona dades de contacte per precompletar els formularis de verificació i habilitar les notificacions per correu electrònic:```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 }, }); ```### Dades esperades (validació creuada)Proporciona les dades esperades de l'usuari perquè es validin automàticament amb les dades extretes del document:```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 }, }); ```Tots els camps de `ExpectedDetails` són opcionals. Consulta [`src/types.ts`](https://github.com/didit-protocol/sdk-react-native/blob/main/src/types.ts) per al tipus complet.### Metadades personalitzadesEmmagatzema metadades JSON personalitzades amb la sessió (no es mostren a l'usuari):```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', metadata: '{"internalId": "abc123", "source": "mobile-app"}', }); ```***## Gestió de resultatsTant `startVerification` com `startVerificationWithWorkflow` retornen un `Promise`. El resultat és una unió discriminada: utilitza el camp `type` per determinar el resultat.### Casos de resultat| Cas | Descripció | | - | - | | `completed` | Flux de verificació completat (consulta `session.status` per al resultat) | | `cancelled` | L'usuari ha cancel·lat el flux de verificació | | `failed` | S'ha produït un error durant la verificació |### Propietats de SessionData| Propietat | Tipus | Descripció | | - | - | - | | `sessionId` | `string` | Identificador únic de la sessió | | `status` | `VerificationStatus` | `Approved`, `Pending` o `Declined` |### Tipus d'error| Error | Descripció | | - | - | | `sessionExpired` | La sessió ha caducat | | `networkError` | Problema de connectivitat de xarxa | | `cameraAccessDenied` | No s'ha concedit el permís de la càmera | | `notInitialized` | SDK no inicialitzat (només Android) | | `apiError` | Ha fallat la sol·licitud a l'API | | `unknown` | Un altre error amb un missatge |### Connexió perdudaSi el dispositiu perd la connexió durant la verificació, el SDK mostra una pantalla «Sense connexió a Internet» en lloc de deixar un pas en càrrega. Continua comprovant la connexió en segon pla i tanca la pantalla automàticament tan aviat com Didit torni a ser accessible, i l'usuari continua des del pas on era. La pantalla ofereix **Torna-ho a provar** i, quan `showCloseButton` és `true` (el valor per defecte), **Surt de la verificació**. Sortir finalitza la verificació amb un resultat `failed` l'error del qual és `networkError`, de manera que la teva aplicació sap que l'usuari ha sortit per la connexió.### Exemple complet de gestió de resultats```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; } } ```***## Exemple complet de principi a fi (sessió al backend → SDK de React Native → webhook)La integració a punt per a producció: el teu backend crea la sessió, l'aplicació de React Native rep el `session_token` i el SDK executa el flux. La decisió final s'envia al teu backend mitjançant un webhook; mai no confiïs només en el resultat del client.### 1. Backend: crear la sessió```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: intercanviar el token i iniciar el SDK```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 (