> ## 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 KYC per React Native: verifica mobile > SDK KYC per React Native ed Expo di Didit con TypeScript e NFC. Da $0.33 per verifica KYC completa, $10 gratis al mese, senza contratti. Prompt di integrazione dell'SDK React Native Copia il prompt negli appunti \

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

\
Incolla in Un SDK React Native multipiattaforma che incapsula gli SDK nativi iOS e Android, offrendo un'API TypeScript unificata per la verifica dell'identità.> [card] [Repository GitHub](https://github.com/didit-protocol/sdk-react-native) > > Visualizza il codice sorgente e gli esempi su GitHub> [card] [Pacchetto npm](https://www.npmjs.com/package/@didit-protocol/sdk-react-native) > > @didit-protocol/sdk-react-native> [!NOTE] > > ### **SDK nativo**: questo è l'approccio consigliato per le app React Native ed Expo. L'SDK incapsula gli SDK nativi iOS e Android per la migliore esperienza utente, una gestione della fotocamera ottimizzata e il pieno supporto NFC.***## Requisiti| Requisito | Versione minima | | - | - | | React Native | 0.76+ (New Architecture / TurboModules) | | Node.js | 20+ | | TypeScript | 5+ |### Requisiti di piattaforma| Piattaforma | Versione minima | Note | | - | - | - | | iOS | 13.0+ | La lettura del passaporto via NFC richiede iOS 15.0+ | | Android | API 24+ (7.0) | Kotlin 1.9+, Java 17+ |> [!NOTE] > > **Il consenso biometrico richiede la versione 4.10.0 o successiva degli SDK nativi.** Per le persone soggette alle leggi dell'Illinois, del Texas o del Colorado, Didit può chiedere un [consenso biometrico](https://docs.didit.me/it/getting-started/biometric-consent.md) esplicito prima della prima acquisizione del volto. Una versione dell'SDK React Native che fissa iOS e Android nativi alla versione 4.10.0 o successiva mostra questo passaggio. Le versioni precedenti non possono mostrarlo: le loro sessioni proseguono come prima, e la decisione riporta il consenso come non raccolto (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Aggiorna se verifichi persone in questi stati.***## Installazione### Expo (consigliato)```bash theme={null} npx expo install @didit-protocol/sdk-react-native ```Poi aggiungi il plugin di configurazione al tuo `app.json` (o `app.config.js`). NFC è attivo per impostazione predefinita:```json theme={null} { "expo": { "plugins": ["@didit-protocol/sdk-react-native"] } } ```Il plugin configura automaticamente entrambe le piattaforme:- **Android:** aggiunge il repository Maven di Didit a Gradle, imposta la proprietà Gradle `diditSdkAndroidNfcEnabled` e applica le regole di dipendenze e packaging per BouncyCastle - **iOS:** aggiunge il podspec di DiditSDK al Podfile (fissato a iOS 15 quando NFC è attivo)Il plugin non modifica `Info.plist`. Aggiungi le [chiavi di autorizzazione iOS](#ios) e, per NFC, gli identificatori di selezione ISO7816 in `ios.infoPlist` nello stesso file. `D392F000260100000001` consente all'SDK di leggere la Japan My Number Card tramite [JPKI](https://docs.didit.me/it/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" ] } } } } ```#### Disattivare le dipendenze NFCPer compilare senza supporto NFC (binario più piccolo, nessuna funzionalità NFC richiesta), passa le opzioni del plugin:```json theme={null} { "expo": { "plugins": [ [ "@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false } ] ] } } ```Quando NFC è disattivato, non ti servono la funzionalità NFC di iOS, gli entitlement NFC né la configurazione di provisioning relativa a NFC.> [!WARNING] > > Questo SDK usa moduli nativi (fotocamera, NFC) che **non sono disponibili in Expo Go**. Devi usare una [build di sviluppo](https://docs.expo.dev/develop/development-builds/introduction/) oppure eseguire `npx expo prebuild` per generare i progetti nativi.### React Native CLI```bash theme={null} npm install @didit-protocol/sdk-react-native # or yarn add @didit-protocol/sdk-react-native ```#### Configurazione iOSAggiungi il pod DiditSDK al tuo `Podfile` (non è su CocoaPods trunk). Il blocco seguente rispetta la variabile d'ambiente `DIDIT_SDK_IOS_NFC_ENABLED`, così puoi attivare o disattivare la subspec senza NFC (`DiditSDK/Core`) al momento dell'installazione:```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] > > Il tag nell'URL del podspec deve corrispondere a `diditNativeSdkVersions.ios` nella versione del pacchetto installata. > React Native `4.13.2` fissa la versione nativa iOS su `4.13.2` e quella nativa Android su `4.13.2`. Non puntare il podspec a `main`: il pacchetto dipende da quella specifica versione nativa per iOS, quindi appena `main` avanza CocoaPods vede due requisiti incompatibili per > `DiditSDK` e ogni `pod install` fallisce. Il plugin di configurazione Expo ricava questo URL per te; solo il percorso React Native CLI puro deve scriverlo a mano.Poi installa le dipendenze:```bash theme={null} cd ios bundle exec pod install ```Per ricompilare senza dipendenze NFC, pulisci CocoaPods e riesegui con la variabile d'ambiente impostata:```bash theme={null} cd ios rm -rf Pods Podfile.lock DIDIT_SDK_IOS_NFC_ENABLED=false bundle exec pod install ```#### Configurazione AndroidAggiungi il repository Maven di Didit al `settings.gradle` a livello di progetto:```groovy theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" } } } ```Aggiungi quanto segue al file `android/app/build.gradle` (dentro il blocco `android { ... }`) per risolvere i conflitti di classi duplicate di BouncyCastle e il duplicato di `MANIFEST.MF` OSGI che le dipendenze transitive di DiditSDK possono causare:```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 compilare senza le dipendenze NFC Android (usa l'artefatto `me.didit:didit-sdk-core` invece di `me.didit:didit-sdk`), aggiungi questo a `android/gradle.properties`:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Rimuovi quella proprietà, oppure impostala su `true`, per usare l'SDK Android completo con NFC.***## Permessi### iOSAggiungi le seguenti chiavi al file `Info.plist` della tua app. Se mancano le chiavi obbligatorie per la privacy di iOS, iOS termina l'app non appena l'SDK accede a quella risorsa protetta.| Permesso | Chiave Info.plist | Descrizione | Obbligatorio | | - | - | - | - | | Fotocamera | `NSCameraUsageDescription` | Scansione del documento e verifica del volto | Sì | | Microfono | `NSMicrophoneUsageDescription` | Registrazione video per il rilevamento della vitalità | Sì | | Libreria foto | `NSPhotoLibraryUsageDescription` | Caricamento delle immagini del documento | Sì | | Posizione | `NSLocationWhenInUseUsageDescription` | Geolocalizzazione per la prevenzione delle frodi | Sì | | NFC | `NFCReaderUsageDescription` | Lettura dei chip NFC in passaporti e carte d'identità | Se si usa 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. ```#### Configurazione NFCPer abilitare la lettura NFC di passaporti e carte d'identità con chip:1) **Aggiungi la capability NFC** in Xcode: * Seleziona il tuo target > **Signing & Capabilities** > **+ Capability** > **Near Field Communication Tag Reading** 2) **Aggiungi gli identificatori ISO7816** a `Info.plist`:```xml theme={null} com.apple.developer.nfc.readersession.iso7816.select-identifiers D23300000045737445494420763335 A0000002471001 A0000002472001 00000000000000 D392F000260100000001 ````D392F000260100000001` consente all'SDK di leggere la My Number Card giapponese tramite [JPKI](https://docs.didit.me/it/core-technology/nfc-verification/overview.md#japan-my-number-card-jpki): senza di esso, iOS non segnala la carta all'SDK. La lettura della My Number Card non è ancora abilitata in produzione e l'identificatore non cambia nulla per gli altri documenti, quindi puoi aggiungerlo fin da ora.3) **Aggiungi un file di entitlements** con la lettura dei tag NFC abilitata:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Assicurati che il provisioning profile dell'app includa la capability NFC Tag Reading. Questa configurazione NFC non è necessaria quando NFC è disabilitato.### AndroidI seguenti permessi sono dichiarati nel file `AndroidManifest.xml` dell'SDK e vengono uniti automaticamente:| Permesso | Descrizione | Obbligatorio | | - | - | - | | `INTERNET` | Accesso alla rete per la comunicazione con le API | Sì | | `ACCESS_NETWORK_STATE` | Rileva la disponibilità della rete | Sì | | `CAMERA` | Scansione del documento e verifica del volto | Sì | | `NFC` | Lettura dei chip NFC in passaporti e carte d'identità | Se si usa NFC |Le funzionalità hardware della fotocamera e dell'NFC sono dichiarate come facoltative (`android:required="false"`), quindi la tua app può essere installata anche su dispositivi privi di queste funzionalità.***## Avvio rapido```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; } ```***## Metodi di integrazioneL'SDK supporta due metodi di integrazione:### Metodo 1: token di sessione (consigliato per la produzione)Crea una sessione sul tuo backend usando l'[API per la creazione di una sessione di verifica](https://docs.didit.me/it/sessions-api/create-session.md), poi passa il token all'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); ```Questo approccio ti dà pieno controllo su:- Associazione delle sessioni ai tuoi utenti (`vendor_data`) - Impostazione di metadati personalizzati - Configurazione dei callback per sessione### Metodo 2: ID del workflow (integrazione più semplice)Per integrazioni più semplici, l'SDK può creare sessioni direttamente usando il tuo ID del workflow:```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 }, }); ```***## ConfigurazionePersonalizza il comportamento dell'SDK passando un oggetto `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 `startVerificationWithWorkflow`, passa la configurazione in `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, }, }); ```### Opzioni di configurazione| Proprietà | Tipo | Predefinito | Descrizione | | - | - | - | - | | `languageCode` | `string` | Lingua del dispositivo | Codice lingua ISO 639-1 (ad esempio `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `boolean` | `false` | Mostra il selettore della lingua in stile web nella schermata di benvenuto | | `fontFamily` | `string` | Font di sistema | Nome della famiglia di font personalizzata (deve essere registrato nativamente) | | `loggingEnabled` | `boolean` | `false` | Attiva il logging di debug dell'SDK | | `showCloseButton` | `boolean` | `true` | Mostra il pulsante di chiusura (X) nelle schermate dei vari passaggi della verifica | | `showExitConfirmation` | `boolean` | `true` | Mostra una finestra di conferma quando l'utente tenta di uscire | | `closeOnComplete` | `boolean` | `false` | Chiude automaticamente l'interfaccia di verifica al completamento | | `defaultDocumentCamera` | `CameraLens?` | Predefinito nativo (`CameraLens.Back`) | Obiettivo usato all'apertura della schermata di acquisizione del documento | | `defaultLivenessCamera` | `CameraLens?` | Predefinito nativo (`CameraLens.Front`) | Obiettivo usato all'apertura della schermata di acquisizione del volto (rilevamento della vitalità) | | `showDocumentCameraSwitchButton` | `boolean` | `true` | Mostra il selettore della fotocamera durante l'acquisizione del documento | | `showLivenessCameraSwitchButton` | `boolean` | `true` | Mostra il selettore della fotocamera durante l'acquisizione del volto |### Opzioni della fotocameraLe opzioni della fotocamera corrispondono alle [opzioni della fotocamera dell'SDK Web](https://docs.didit.me/it/integration/web-sdks/javascript-sdk.md#opzioni-della-fotocamera). Ogni obiettivo è `CameraLens.Front` o `CameraLens.Back`. Se il dispositivo non dispone dell'obiettivo richiesto, l'SDK usa la prima fotocamera disponibile. Il selettore di fotocamera è inoltre nascosto sui dispositivi con una sola fotocamera. Imposta un'opzione del selettore su `false` per bloccare l'utente sull'obiettivo predefinito di quel passaggio.```tsx theme={null} import { startVerification, CameraLens } from '@didit-protocol/sdk-react-native'; await startVerification('your-session-token', { defaultLivenessCamera: CameraLens.Back, showLivenessCameraSwitchButton: false, }); ```> [!NOTE] > > **Tema e colori**: colori, sfondi e impostazioni della schermata introduttiva si configurano tramite le tue [impostazioni White label](https://business.didit.me) nella Didit Console, non nella configurazione dell'SDK. Così il branding resta coerente su tutte le piattaforme.***## Supporto linguisticoL'SDK supporta **54 lingue**. Se non viene specificata alcuna lingua, l'SDK usa la lingua del dispositivo, con l'inglese come lingua di riserva.```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 }); ```**[Visualizza tutte le lingue supportate →](https://docs.didit.me/it/integration/supported-languages.md)*****## Opzioni avanzateQueste opzioni sono disponibili solo con `startVerificationWithWorkflow`, quando l'SDK crea la sessione per tuo conto.### Dettagli di contatto (precompilazione e notifiche)Fornisci i dettagli di contatto per precompilare i moduli di verifica e abilitare le notifiche email:```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 }, }); ```### Dettagli attesi (validazione incrociata)Fornisci i dati attesi dell'utente per la validazione incrociata automatica con i dati estratti dal documento:```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 }, }); ```Tutti i campi di `ExpectedDetails` sono facoltativi. Consulta [`src/types.ts`](https://github.com/didit-protocol/sdk-react-native/blob/main/src/types.ts) per il tipo completo.### Metadati personalizzatiMemorizza metadati JSON personalizzati con la sessione (non visualizzati all'utente):```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', metadata: '{"internalId": "abc123", "source": "mobile-app"}', }); ```***## Gestione dei risultatiSia `startVerification` sia `startVerificationWithWorkflow` restituiscono una `Promise`. Il risultato è un'unione discriminata: usa il campo `type` per determinare l'esito.### Casi di risultato| Caso | Descrizione | | - | - | | `completed` | Flusso di verifica completato (controlla `session.status` per l'esito) | | `cancelled` | L'utente ha annullato il flusso di verifica | | `failed` | Si è verificato un errore durante la verifica |### Proprietà di SessionData| Proprietà | Tipo | Descrizione | | - | - | - | | `sessionId` | `string` | Identificatore univoco della sessione | | `status` | `VerificationStatus` | `Approved`, `Pending` o `Declined` |### Tipi di errore| Errore | Descrizione | | - | - | | `sessionExpired` | La sessione è scaduta | | `networkError` | Problema di connettività di rete | | `cameraAccessDenied` | Autorizzazione della fotocamera non concessa | | `notInitialized` | SDK non inizializzato (solo Android) | | `apiError` | Richiesta API non riuscita | | `unknown` | Altro errore con messaggio |### Connessione persaSe il dispositivo perde la connessione durante la verifica, l'SDK sovrappone al flusso una schermata "Nessuna connessione Internet" invece di lasciare un passaggio in caricamento. Continua a controllare in background e chiude la schermata da sola non appena Didit torna raggiungibile, e l'utente prosegue dal passaggio in cui si trovava. La schermata offre **Riprova** e, quando `showCloseButton` è `true` (il valore predefinito), **Esci dalla verifica**. Uscire termina la verifica con un risultato `failed` il cui errore è `networkError`, così la tua app sa che l'utente è uscito a causa della connessione.### Esempio completo di gestione dei risultati```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; } } ```***## Esempio dall'inizio alla fine (sessione backend → SDK React Native → Webhook)L'integrazione pronta per la produzione: il tuo backend crea la sessione, la tua app React Native riceve il `session_token` e l'SDK esegue il flusso. La decisione finale arriva al tuo backend tramite webhook: non fidarti mai del solo risultato lato client.### 1. Backend: crea la sessione```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: scambia il token e avvia l'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 (