> ## 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 para React Native: Verificação Móvel > SDK KYC da Didit para React Native e Expo, com TypeScript, iOS/Android nativos e NFC. Desde $0.33 por KYC completo, $10 grátis/mês, sem contratos. Prompt de integração do SDK 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.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`

\
Colar em Um SDK multiplataforma para React Native que encapsula os SDK nativos do iOS e do Android, oferecendo uma API TypeScript unificada para verificação de identidade.> [card] [Repositório no GitHub](https://github.com/didit-protocol/sdk-react-native) > > Consulte o código-fonte e os 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 aplicações React Native e Expo. O SDK encapsula os SDK nativos do iOS e do Android para oferecer a melhor experiência ao utilizador, um tratamento otimizado da câmara e suporte NFC completo.***## Requisitos| Requisito | Versão mínima | | - | - | | React Native | 0.76+ (New Architecture / TurboModules) | | Node.js | 20+ | | TypeScript | 5+ |### Requisitos da plataforma| Plataforma | Versão mínima | Notas | | - | - | - | | iOS | 13.0+ | A leitura de passaportes por NFC requer iOS 15.0+ | | Android | API 24+ (7.0) | Kotlin 1.9+, Java 17+ |> [!NOTE] > > **O consentimento biométrico requer o SDK nativo 4.10.0 ou posterior.** Para pessoas abrangidas pela legislação do Illinois, do Texas ou do Colorado, a Didit pode pedir [consentimento biométrico](https://docs.didit.me/pt/getting-started/biometric-consent.md) explícito antes da primeira captura facial. Uma versão do React Native SDK que fixe os SDK nativos de iOS e Android 4.10.0 ou posterior apresenta esse passo. As versões anteriores não conseguem apresentá-lo: as respetivas sessões decorrem como antes, e a decisão indica que o consentimento não foi recolhido (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Atualize se verificar pessoas nesses estados.***## Instalação### Expo (recomendado)```bash theme={null} npx expo install @didit-protocol/sdk-react-native ```Em seguida, adicione o plugin de configuração ao seu `app.json` (ou `app.config.js`). O NFC está ativado por predefiniçã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ências 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 o NFC, os identificadores de seleção ISO7816 em `ios.infoPlist`, no mesmo ficheiro. O `D392F000260100000001` permite que o SDK leia o Japan My Number Card através do [JPKI](https://docs.didit.me/pt/core-technology/nfc-verification/overview.md#cartão-my-number-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 mais pequeno, sem necessidade da capacidade NFC), passe as opções do plugin:```json theme={null} { "expo": { "plugins": [ [ "@didit-protocol/sdk-react-native", { "iosNfcEnabled": false, "androidNfcEnabled": false } ] ] } } ```Quando o NFC está desativado, não precisa da capacidade NFC do iOS, dos direitos de NFC nem da configuração de provisionamento relacionada com o NFC.> [!WARNING] > > Este SDK usa módulos nativos (câmara, NFC) que **não estão disponíveis no Expo Go**. Tem de usar uma [compilação de desenvolvimento](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 DiditSDK ao seu `Podfile` (não está no CocoaPods trunk). O bloco abaixo respeita a variável de ambiente `DIDIT_SDK_IOS_NFC_ENABLED`, para que possa alternar, no momento da instalação, o subspec sem NFC (`DiditSDK/Core`):```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] > > A tag no URL do podspec tem de corresponder a `diditNativeSdkVersions.ios` na versão do pacote instalada. > O React Native `4.13.2` fixa o iOS nativo em `4.13.2` e o Android nativo em `4.13.2`. Não aponte o podspec > para `main`: o pacote depende exatamente dessa versão nativa do iOS, pelo que, assim que `main` avançar, o CocoaPods vê dois requisitos incompatíveis para > `DiditSDK` e todos os `pod install` falham. O plugin de configuração do Expo gera este URL por si; apenas o caminho do React Native CLI puro precisa de o escrever 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` 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` da sua aplicação (dentro do bloco `android { ... }`) para resolver os conflitos de classes duplicadas do BouncyCastle e a duplicação do `MANIFEST.MF` do OSGI que as dependências transitivas do DiditSDK podem provocar:```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 artefacto `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 seguintes chaves ao `Info.plist` da sua aplicação. A falta das chaves de privacidade obrigatórias do iOS fará com que o iOS termine a aplicação assim que o SDK aceder a esse recurso protegido.| Permissão | Chave do Info.plist | Descrição | Obrigatória | | - | - | - | - | | Câmara | `NSCameraUsageDescription` | Digitalização do documento e verificação facial | Sim | | Microfone | `NSMicrophoneUsageDescription` | Gravação de vídeo da prova de vida | Sim | | Biblioteca de fotos | `NSPhotoLibraryUsageDescription` | Carregar imagens do documento | Sim | | Localização | `NSLocationWhenInUseUsageDescription` | Geolocalização para prevenção de fraude | Sim | | NFC | `NFCReaderUsageDescription` | Ler chips NFC em passaportes/cartões de identificação | 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 cartões de identificação com chip:1) **Adicione a capacidade NFC** no Xcode: * Selecione o seu alvo > **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 ao SDK ler o Cartão My Number do Japão através do [JPKI](https://docs.didit.me/pt/core-technology/nfc-verification/overview.md#cartão-my-number-do-japão-jpki): sem este identificador, o iOS não comunica o cartão ao SDK. A leitura do Cartão My Number ainda não está ativada em produção, e o identificador não altera nada para os outros documentos, por isso pode adicioná-lo desde já.3) **Adicione um ficheiro de direitos (entitlements)** com a leitura de etiquetas NFC ativada:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Certifique-se de que o perfil de aprovisionamento da aplicação inclui a capacidade NFC Tag Reading. Esta configuração de NFC não é necessária quando o NFC está desativado.### AndroidAs seguintes permissões são declaradas no `AndroidManifest.xml` do SDK e integradas automaticamente:| Permissão | Descrição | Obrigatória | | - | - | - | | `INTERNET` | Acesso à rede para comunicação com a API | Sim | | `ACCESS_NETWORK_STATE` | Detetar a disponibilidade da rede | Sim | | `CAMERA` | Digitalização do documento e verificação facial | Sim | | `NFC` | Ler chips NFC em passaportes/cartões de identificação | Se usar NFC |As funcionalidades de hardware da câmara e de NFC são declaradas como opcionais (`android:required="false"`), pelo que a sua aplicação pode ser instalada em dispositivos sem estas funcionalidades.***## 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 suporta dois métodos de integração:### Método 1: token de sessão (recomendado para produção)Crie uma sessão no seu backend através da [API de criação de sessão de verificação](https://docs.didit.me/pt/sessions-api/create-session.md) e, em seguida, passe o token ao 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); ```Esta abordagem dá-lhe controlo total sobre:- Associar sessões aos seus utilizadores (`vendor_data`) - Definir metadados personalizados - Configurar os retornos de chamada por sessão### Método 2: ID do fluxo (integração mais simples)Para integrações mais simples, o SDK pode criar sessões diretamente com o ID do seu fluxo:```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 | Predefinição | Descrição | | - | - | - | - | | `languageCode` | `string` | Idioma do dispositivo | Código de idioma ISO 639-1 (por exemplo, `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `boolean` | `false` | Mostra o seletor de idioma do estilo web no ecrã de boas-vindas | | `fontFamily` | `string` | Tipo de letra do sistema | Nome de uma família de tipos de letra personalizada (tem de estar registada nativamente) | | `loggingEnabled` | `boolean` | `false` | Ativa o registo de depuração do SDK | | `showCloseButton` | `boolean` | `true` | Mostra o botão de fecho (X) nos ecrãs dos passos de verificação | | `showExitConfirmation` | `boolean` | `true` | Mostra uma caixa de confirmação quando o utilizador tenta sair | | `closeOnComplete` | `boolean` | `false` | Fecha automaticamente a interface de verificação quando concluída | | `defaultDocumentCamera` | `CameraLens?` | Predefinição nativa (`CameraLens.Back`) | Lente usada quando se abre o ecrã de captura do documento | | `defaultLivenessCamera` | `CameraLens?` | Predefinição nativa (`CameraLens.Front`) | Lente usada quando se abre o ecrã de captura facial (prova de vida) | | `showDocumentCameraSwitchButton` | `boolean` | `true` | Mostra o seletor de câmara durante a captura, no ecrã de captura do documento | | `showLivenessCameraSwitchButton` | `boolean` | `true` | Mostra o seletor de câmara durante a captura, no ecrã de captura facial |### Opções de câmaraAs opções de câmara correspondem às [opções de câmara do SDK Web](https://docs.didit.me/pt/integration/web-sdks/javascript-sdk.md#opções-de-câmara). Cada lente é `CameraLens.Front` ou `CameraLens.Back`. Se o dispositivo não tiver a lente pedida, o SDK usa a primeira câmara de que dispõe. O seletor de câmara também fica oculto em dispositivos que têm apenas uma câmara. Defina uma opção do seletor como `false` para impedir o utilizador de mudar da lente predefinida desse passo.```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**: As cores, os fundos e as definições do ecrã de introdução são configurados nas suas [definições de Marca branca](https://business.didit.me) na Didit Console, e não na configuração do SDK. Isto garante uma identidade visual consistente em todas as plataformas.***## Suporte a idiomasO SDK suporta **54 idiomas**. Se não for indicado nenhum idioma, o SDK usa o idioma do dispositivo, com o 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 suportados →](https://docs.didit.me/pt/integration/supported-languages.md)*****## Opções avançadasEstas opções só estão disponíveis com `startVerificationWithWorkflow`, em que o SDK cria a sessão em seu nome.### Dados de contacto (pré-preenchimento e notificações)Indique os dados de contacto para pré-preencher 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)Indique os dados esperados do utilizador 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 personalizadosGuarde metadados JSON personalizados com a sessão (não são apresentados ao utilizador):```tsx theme={null} const result = await startVerificationWithWorkflow('your-workflow-id', { vendorData: 'user-123', metadata: '{"internalId": "abc123", "source": "mobile-app"}', }); ```***## Gestão de resultadosTanto `startVerification` como `startVerificationWithWorkflow` devolvem uma `Promise`. O resultado é uma união discriminada: utilize o campo `type` para determinar o resultado.### Casos de resultado| Caso | Descrição | | - | - | | `completed` | O fluxo de verificação foi concluído (consulte `session.status` para ver o resultado) | | `cancelled` | O utilizador cancelou o fluxo de verificação | | `failed` | Ocorreu um erro durante a verificação |### Propriedades de SessionData| Propriedade | Tipo | Descrição | | - | - | - | | `sessionId` | `string` | Identificador exclusivo da sessão | | `status` | `VerificationStatus` | `Approved`, `Pending` ou `Declined` |### Tipos de erro| Erro | Descrição | | - | - | | `sessionExpired` | A sessão expirou | | `networkError` | Problema de conectividade da rede | | `cameraAccessDenied` | A permissão para utilizar a câmara não foi concedida | | `notInitialized` | O SDK não foi inicializado (apenas Android) | | `apiError` | O pedido à API falhou | | `unknown` | Outro erro com uma mensagem |### Ligação perdidaSe o dispositivo perder a ligação durante a verificação, o SDK apresenta um ecrã com a mensagem «Sem ligação à Internet», em vez de deixar um passo a carregar. Continua a verificar a ligação em segundo plano e fecha automaticamente o ecrã assim que o Didit volta a estar acessível; o utilizador prossegue a partir do passo em que estava. O ecrã disponibiliza **Tentar novamente** e, quando `showCloseButton` é `true` (o valor predefinido), **Sair da verificação**. Ao sair, a verificação termina com um resultado `failed` cujo erro é `networkError`, para que a sua aplicação saiba que o utilizador saiu devido à perda de ligação.### Exemplo completo de gestão 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 do React Native → webhook)A integração pronta para produção: o seu backend cria a sessão, a sua aplicação RN recebe o `session_token` e o SDK executa o fluxo. A decisão final é enviada para o seu backend através de um 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 (