> ## 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 para React Native: verificação no celular > SDK de KYC da Didit para React Native e Expo: TypeScript, iOS/Android nativos e NFC. A partir de $0.33 por KYC completo, $10 grátis/mês, sem contrato. Prompt de integração do SDK para React Native Copiar o prompt para a área de transferência \

\`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.9.1)

\## 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.9.1/DiditSDK.podspec'
The tag in that URL must equal diditNativeSdkVersions.ios in the package (4.9.1); 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`

\
Colar em Um SDK multiplataforma para React Native que encapsula os SDKs nativos de iOS e Android e oferece uma API TypeScript unificada para verificação de identidade.> [card] [Repositório no GitHub](https://github.com/didit-protocol/sdk-react-native) > > Veja o código-fonte e exemplos no GitHub> [card] [Pacote npm](https://www.npmjs.com/package/@didit-protocol/sdk-react-native) > > @didit-protocol/sdk-react-native> [!NOTE] > > ### **SDK nativo**: esta é a abordagem recomendada para apps React Native e Expo. O SDK encapsula os SDKs nativos de iOS e Android para oferecer a melhor experiência ao usuário, gerenciamento otimizado da câmera e suporte completo a NFC.***## Requisitos| Requisito | Versão mínima | | - | - | | React Native | 0.76+ (New Architecture / TurboModules) | | Node.js | 20+ | | TypeScript | 5+ |### Requisitos de plataforma| Plataforma | Versão mínima | Observações | | - | - | - | | iOS | 13.0+ | A leitura de passaporte por NFC exige iOS 15.0+ | | Android | API 24+ (7.0) | Kotlin 1.9+, Java 17+ |> [!NOTE] > > **O consentimento biométrico exige a versão nativa 4.10.0 ou posterior.** Para pessoas amparadas pelas leis de Illinois, Texas ou Colorado, a Didit pode solicitar [consentimento biométrico](https://docs.didit.me/pt-br/getting-started/biometric-consent.md) explícito antes da primeira captura facial. Uma versão do SDK para React Native que fixa as versões nativas de iOS e Android 4.10.0 ou posteriores exibe essa etapa. Versões anteriores não conseguem exibir a etapa: suas sessões funcionam como antes, e a decisão informa que o consentimento não foi coletado (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Atualize se você verifica pessoas nesses estados.***## Instalação### Expo (recomendado)```bash theme={null} npx expo install @didit-protocol/sdk-react-native ```Em seguida, adicione o config plugin ao seu `app.json` (ou `app.config.js`). O NFC vem ativado por padrão:```json theme={null} { "expo": { "plugins": ["@didit-protocol/sdk-react-native"] } } ```O plugin configura automaticamente as duas plataformas:- **Android:** adiciona o repositório Maven da Didit ao Gradle, define a propriedade Gradle `diditSdkAndroidNfcEnabled` e aplica as regras de dependência e empacotamento do BouncyCastle - **iOS:** adiciona o podspec do DiditSDK ao Podfile (fixado no iOS 15 quando o NFC está ativado)O plugin não edita o `Info.plist`. Adicione as [chaves de permissão do iOS](#ios) e, para NFC, os identificadores de seleção ISO7816 em `ios.infoPlist` no mesmo arquivo. `D392F000260100000001` permite que o SDK leia o My Number Card do Japão por meio do [JPKI](https://docs.didit.me/pt-br/core-technology/nfc-verification/overview.md#my-number-card-do-japão-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" ] } } } } ```#### Desativar as dependências de NFCPara compilar sem suporte a NFC (binário menor, sem exigir a capacidade de NFC), passe opções ao plugin:```json theme={null} { "expo": { "plugins": [ [ "@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false } ] ] } } ```Com o NFC desativado, você não precisa da capacidade de NFC do iOS, dos entitlements de NFC nem da configuração de provisionamento relacionada a NFC.> [!WARNING] > > Este SDK usa módulos nativos (câmera, NFC) que **não estão disponíveis no Expo Go**. Você deve usar um [development build](https://docs.expo.dev/develop/development-builds/introduction/) ou executar `npx expo prebuild` para gerar os projetos nativos.### React Native CLI```bash theme={null} npm install @didit-protocol/sdk-react-native # or yarn add @didit-protocol/sdk-react-native ```#### Configuração do iOSAdicione o pod do DiditSDK ao seu `Podfile` (ele não está no trunk do CocoaPods). O bloco abaixo respeita a variável de ambiente `DIDIT_SDK_IOS_NFC_ENABLED`, para que você possa alternar para o subspec sem NFC (`DiditSDK/Core`) no momento da instalação:```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.9.1/DiditSDK.podspec' ```> [!WARNING] > > A tag na URL do podspec deve corresponder a `diditNativeSdkVersions.ios` na versão instalada do pacote. > O React Native `4.9.1` fixa o iOS nativo `4.9.1` e o Android nativo `4.9.1`. Não aponte o podspec > para `main`: o pacote depende exatamente dessa versão nativa do iOS, então, assim que `main` for atualizado, o CocoaPods encontra dois requisitos incompatíveis para > `DiditSDK` e todo `pod install` falha. O config plugin do Expo gera essa URL para você; somente o > caminho com o React Native CLI puro exige que ela seja escrita manualmente.Em seguida, instale as dependências:```bash theme={null} cd ios bundle exec pod install ```Para recompilar sem as dependências de NFC, limpe o CocoaPods e execute novamente com a variável de ambiente definida:```bash theme={null} cd ios rm -rf Pods Podfile.lock DIDIT_SDK_IOS_NFC_ENABLED=false bundle exec pod install ```#### Configuração do AndroidAdicione o repositório Maven da Didit ao `settings.gradle` no nível do projeto:```groovy theme={null} dependencyResolutionManagement { repositories { google() mavenCentral() maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" } } } ```Adicione o seguinte ao `android/app/build.gradle` do seu app (dentro do bloco `android { ... }`) para resolver os conflitos de classes duplicadas do BouncyCastle e o arquivo duplicado `MANIFEST.MF` do OSGI que as dependências transitivas do DiditSDK podem causar:```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' } } } ```Para compilar sem as dependências de NFC do Android (usa o artefato `me.didit:didit-sdk-core` em vez de `me.didit:didit-sdk`), adicione isto ao `android/gradle.properties`:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Remova essa propriedade, ou defina-a como `true`, para usar o SDK completo do Android com NFC.***## Permissões### iOSAdicione as chaves a seguir ao `Info.plist` do seu app. Se faltar alguma chave de privacidade obrigatória do iOS, o iOS encerrará o app assim que o SDK acessar o recurso protegido correspondente.| Permissão | Chave do Info.plist | Descrição | Obrigatória | | - | - | - | - | | Câmera | `NSCameraUsageDescription` | Leitura de documentos e verificação facial | Sim | | Microfone | `NSMicrophoneUsageDescription` | Gravação de vídeo da prova de vida | Sim | | Biblioteca de fotos | `NSPhotoLibraryUsageDescription` | Envio de imagens de documentos | Sim | | Localização | `NSLocationWhenInUseUsageDescription` | Geolocalização para prevenção de fraudes | Sim | | NFC | `NFCReaderUsageDescription` | Leitura de chips NFC em passaportes e documentos de identidade | Se usar 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. ```#### Configuração de NFCPara ativar a leitura NFC de passaportes e documentos de identidade com chip:1) **Adicione a capability de NFC** no Xcode: * Selecione o seu target > **Signing & Capabilities** > **+ Capability** > **Near Field Communication Tag Reading** 2) **Adicione os identificadores ISO7816** ao `Info.plist`:```xml theme={null} com.apple.developer.nfc.readersession.iso7816.select-identifiers D23300000045737445494420763335 A0000002471001 A0000002472001 00000000000000 D392F000260100000001 ````D392F000260100000001` permite que o SDK leia o My Number Card do Japão por meio do [JPKI](https://docs.didit.me/pt-br/core-technology/nfc-verification/overview.md#my-number-card-do-japão-jpki): sem ele, o iOS não disponibiliza o cartão ao SDK. A leitura do My Number Card ainda não está ativada em produção, e o identificador não altera nada para os demais documentos, então você já pode adicioná-lo.3) **Adicione um arquivo de entitlements** com a leitura de tags NFC ativada:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Verifique se o provisioning profile do app inclui a capability NFC Tag Reading. Essa configuração de NFC não é necessária quando o NFC está desativado.### AndroidAs permissões a seguir são declaradas no `AndroidManifest.xml` do SDK e mescladas automaticamente:| Permissão | Descrição | Obrigatória | | - | - | - | | `INTERNET` | Acesso à rede para comunicação com a API | Sim | | `ACCESS_NETWORK_STATE` | Detectar a disponibilidade de rede | Sim | | `CAMERA` | Leitura de documentos e verificação facial | Sim | | `NFC` | Leitura de chips NFC em passaportes e documentos de identidade | Se usar NFC |Os recursos de hardware de câmera e NFC são declarados como opcionais (`android:required="false"`), para que o seu app possa ser instalado em dispositivos sem esses recursos.***## Início rápido```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étodos de integraçãoO SDK oferece dois métodos de integração:### Método 1: token de sessão (recomendado para produção)Crie uma sessão no seu backend usando a [API Create Verification Session](https://docs.didit.me/pt-br/sessions-api/create-session.md) e, em seguida, passe o token para o 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); ```Essa abordagem dá a você controle total sobre:- A associação das sessões aos seus usuários (`vendor_data`) - A definição de metadados personalizados - A configuração de callbacks por sessão### Método 2: ID do workflow (integração mais simples)Para integrações mais simples, o SDK pode criar sessões diretamente usando o ID do seu fluxo de verificação (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 }, }); ```***## ConfiguraçãoPersonalize o comportamento do SDK passando um objeto `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 }); ```Para `startVerificationWithWorkflow`, passe a configuração dentro 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, }, }); ```### Opções de configuração| Propriedade | Tipo | Padrão | Descrição | | - | - | - | - | | `languageCode` | `string` | Idioma do dispositivo | Código de idioma ISO 639-1 (por exemplo, `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `boolean` | `false` | Exibe o seletor de idioma no estilo web na tela de boas-vindas | | `fontFamily` | `string` | Fonte do sistema | Nome da família de fontes personalizada (deve ser registrada nativamente) | | `loggingEnabled` | `boolean` | `false` | Ativa os logs de depuração do SDK | | `showCloseButton` | `boolean` | `true` | Exibe o botão de fechar (X) nas telas das etapas de verificação | | `showExitConfirmation` | `boolean` | `true` | Exibe uma caixa de confirmação quando o usuário tenta sair | | `closeOnComplete` | `boolean` | `false` | Fecha automaticamente a interface de verificação ao concluir | | `defaultDocumentCamera` | `CameraLens?` | Padrão nativo (`CameraLens.Back`) | Lente usada quando a tela de captura do documento é aberta | | `defaultLivenessCamera` | `CameraLens?` | Padrão nativo (`CameraLens.Front`) | Lente usada quando a tela de captura facial (prova de vida) é aberta | | `showDocumentCameraSwitchButton` | `boolean` | `true` | Exibe o alternador de câmera durante a captura na tela de captura do documento | | `showLivenessCameraSwitchButton` | `boolean` | `true` | Exibe o alternador de câmera durante a captura na tela de captura facial |### Opções de câmeraAs opções de câmera são as mesmas das [opções de câmera do Web SDK](https://docs.didit.me/pt-br/integration/web-sdks/javascript-sdk.md#opções-de-câmera). Cada lente é `CameraLens.Front` ou `CameraLens.Back`. Se o dispositivo não tiver a lente solicitada, o SDK usa a primeira câmera disponível. O alternador de câmera também fica oculto em dispositivos que têm apenas uma câmera. Defina uma opção de alternador como `false` para restringir o usuário à lente padrão daquela etapa.```tsx theme={null} import { startVerification, CameraLens } from '@didit-protocol/sdk-react-native'; await startVerification('your-session-token', { defaultLivenessCamera: CameraLens.Back, showLivenessCameraSwitchButton: false, }); ```> [!NOTE] > > **Temas e cores**: cores, fundos e as configurações da tela de introdução são definidos nas suas [configurações de White Label](https://business.didit.me) no Didit Console, e não na configuração do SDK. Isso garante uma identidade visual consistente em todas as plataformas.***## Suporte a idiomasO SDK oferece suporte a **54 idiomas**. Se nenhum idioma for especificado, o SDK usa a localidade do dispositivo, com inglês como 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 }); ```**[Ver todos os idiomas compatíveis →](https://docs.didit.me/pt-br/integration/supported-languages.md)*****## Opções avançadasEstas opções estão disponíveis apenas com `startVerificationWithWorkflow`, em que o SDK cria a sessão em seu nome.### Dados de contato (preenchimento prévio e notificações)Forneça dados de contato para preencher previamente os formulários de verificação e ativar as notificações por e-mail:```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 }, }); ```### Dados esperados (validação cruzada)Forneça os dados esperados do usuário para a validação cruzada automática com os dados extraídos do 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 }, }); ```Todos os campos de `ExpectedDetails` são opcionais. Consulte [`src/types.ts`](https://github.com/didit-protocol/sdk-react-native/blob/main/src/types.ts) para ver o tipo completo.### Metadados personalizadosArmazene metadados JSON personalizados com a sessão (não exibidos ao usuário):```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', metadata: '{"internalId": "abc123", "source": "mobile-app"}', }); ```***## Tratamento de resultadosTanto `startVerification` quanto `startVerificationWithWorkflow` retornam uma `Promise`. O resultado é uma união discriminada: use o campo `type` para identificar o desfecho.### Casos de resultado| Caso | Descrição | | - | - | | `completed` | O fluxo de verificação foi concluído (consulte `session.status` para ver o resultado) | | `cancelled` | O usuário cancelou o fluxo de verificação | | `failed` | Ocorreu um erro durante a verificação |### Propriedades de SessionData| Propriedade | Tipo | Descrição | | - | - | - | | `sessionId` | `string` | Identificador único da sessão | | `status` | `VerificationStatus` | `Approved`, `Pending` ou `Declined` |### Tipos de erro| Erro | Descrição | | - | - | | `sessionExpired` | A sessão expirou | | `networkError` | Problema de conectividade de rede | | `cameraAccessDenied` | A permissão de câmera não foi concedida | | `notInitialized` | SDK não inicializado (somente Android) | | `apiError` | A requisição à API falhou | | `unknown` | Outro erro, com mensagem |### Perda de conexãoSe o dispositivo perder a conexão durante a verificação, o SDK exibe uma tela "No internet connection" em vez de deixar uma etapa carregando. Ele continua verificando em segundo plano e fecha a tela sozinho assim que a Didit volta a ficar acessível, e o usuário continua da etapa em que estava. A tela oferece **Try Again** e, quando `showCloseButton` é `true` (o padrão), **Exit Verification**. Sair encerra a verificação com um resultado `failed` cujo erro é `networkError`, para que seu app saiba que o usuário saiu por causa da conexão.### Exemplo completo de tratamento de resultados```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; } } ```***## Exemplo de ponta a ponta (sessão no backend → SDK React Native → webhook)A integração pronta para produção: seu backend cria a sessão, seu app RN recebe o `session_token` e o SDK executa o fluxo. A decisão final é entregue ao seu backend por webhook. Nunca confie apenas no resultado do lado do cliente.### 1. Backend: criar a sessão```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: trocar o token e iniciar o 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 (