> ## 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 Flutter: verificação mobile em Dart

> SDK KYC da Didit para Flutter com iOS e Android nativos, liveness e NFC de passaporte. Desde $0.33 por KYC completo, $10 grátis/mês, sem contrato.



Prompt de integração do SDK para Flutter
        Copiar o prompt para a área de transferência



      
      

\<pre>

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

\## Requirements
\- Flutter 3.3+, Dart 3.11+
\- iOS 13.0+ (NFC requires iOS 15+)
\- Android API 23+ (Android 6.0)

\## Installation
flutter pub add didit_sdk

iOS — the plugin picks the native variant from the $DiditSdkIosVariant Ruby global in ios/Podfile (or the DIDIT_SDK_IOS_VARIANT env var); valid values are 'all' (default), 'core', 'autodetection', 'nfc'. At the top of ios/Podfile:
$DiditSdkIosVariant = 'all'
platform :ios, ['all', 'nfc'].include?($DiditSdkIosVariant) ? '15.0' : '13.0'
Inside the target block, add the matching subspec:
pod 'DiditSDK/All', :podspec => 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/4.9.1/DiditSDK.podspec'
The tag in that URL must equal the native iOS SDK version the didit_sdk release pins (4.9.1 pins 4.9.1); do not use 'main', because the plugin requires that exact version and pod install fails when the URL resolves to a different one.
'all' and 'nfc' require platform :ios, '15.0'; 'core' and 'autodetection' run on iOS 13.0+.
Then: cd ios && pod install
Info.plist must include NSCameraUsageDescription, NSMicrophoneUsageDescription, NSPhotoLibraryUsageDescription (required) and NFCReaderUsageDescription if using NFC.

Android — for no-NFC builds add to android/gradle.properties:
diditSdkAndroidNfcEnabled=false
For NFC-enabled (default), add to android/app/build.gradle.kts inside android block:
packaging {
  resources {
      pickFirsts += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
  }
}

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

\## Integration
import 'package:didit_sdk/sdk_flutter.dart';

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

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

// Handle result
switch (result) {
case VerificationCompleted(:final session):
if (session.status == VerificationStatus.approved) { /* grant access */ }
case VerificationCancelled():
// User dismissed the verification flow
case VerificationFailed(:final error):
// SDK error — show error.message
}

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

\## Error Types (VerificationErrorType enum)
sessionExpired, networkError, cameraAccessDenied, notInitialized, apiError, retryBlocked, unknown

\## Advanced Session Parameters
contact_details, expected_details, and metadata are only available via the Session Token method (your backend creates the session). The Dart startVerificationWithWorkflow API only accepts workflowId, vendorData, and config.

\## 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
\- Flutter SDK: https://docs.didit.me/integration/native-sdks/flutter-sdk
\- GitHub: https://github.com/didit-protocol/sdk-flutter
\- pub.dev: https://pub.dev/packages/didit_sdk
\- Webhooks: https://docs.didit.me/integration/webhooks
\- API Reference: https://docs.didit.me/api-reference/overview`

\</pre>



      
      

Colar em

Um plugin Flutter multiplataforma que encapsula os SDKs nativos de iOS e Android e oferece uma API Dart unificada para verificação de identidade.> [card] [Repositório no GitHub](https://github.com/didit-protocol/sdk-flutter)
>
> Veja o código-fonte e exemplos no GitHub> [card] [Pacote no pub.dev](https://pub.dev/packages/didit_sdk)
>
> didit\_sdk> [!NOTE]
>
> ### **SDK nativo**: esta é a abordagem recomendada para apps Flutter. O SDK encapsula os SDKs nativos de iOS e Android por meio de platform channels, 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 |
| - | - |
| Flutter | 3.3+ |
| Dart | 3.11+ |### Requisitos de plataforma| Plataforma | Versão mínima | Observações |
| - | - | - |
| iOS | 13.0+ | A leitura de passaporte por NFC requer iOS 15.0+ |
| Android | API 23+ (6.0) | Java 17+ |> [!NOTE]
>
> **O consentimento biométrico requer o SDK nativo 4.10.0 ou posterior.** Para pessoas abrangidas 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 Flutter que fixa os SDKs nativos de iOS e Android na versão 4.10.0 ou posterior exibe essa etapa. Versões anteriores não conseguem exibir a etapa: as 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```bash theme={null}
flutter pub add didit_sdk
```Ou adicione-o manualmente ao seu `pubspec.yaml`:```yaml theme={null}
dependencies:
  didit_sdk: ^4.9.1
```Em seguida, execute:```bash theme={null}
flutter pub get
```### Variantes do SDK nativoO `didit_sdk` inclui o SDK nativo completo.
Para distribuir um binário menor, use como dependência um pacote de variante. Ele expõe exatamente a mesma API Dart e fixa o SDK nativo correspondente nas duas plataformas:| Pacote | Captura automática | Leitura de passaporte por NFC | iOS mínimo |
| - | - | - | - |
| `didit_sdk` (padrão) | Sim | Sim | 15.0 |
| `didit_sdk_core` | Não | Não | 13.0 |
| `didit_sdk_autodetection` | Sim | Não | 13.0 |
| `didit_sdk_nfc` | Não | Sim | 15.0 |```yaml theme={null}
dependencies:
  didit_sdk_core: ^4.9.1
```Use como dependência exatamente um desses pacotes e faça os imports a partir do pacote escolhido, por exemplo `package:didit_sdk_core/sdk_flutter.dart`.### Configuração no iOSO plugin é compatível com os dois gerenciadores de dependências do Flutter para iOS: Swift Package Manager e CocoaPods.#### Swift Package ManagerSe a sua versão do Flutter tiver o suporte ao Swift Package Manager ativado (ative com `flutter config --enable-swift-package-manager` no Flutter 3.24+), o plugin é usado automaticamente como um pacote Swift.
Nenhuma configuração no Podfile é necessária: a dependência nativa DiditSDK é resolvida a partir do GitHub por conta própria.
Defina o deployment target de iOS do seu app no Xcode (target do Runner e projeto) com o mínimo exigido pelo pacote escolhido: 15.0 para `didit_sdk` e `didit_sdk_nfc`, 13.0 para `didit_sdk_core` e `didit_sdk_autodetection`.#### CocoaPodsCom o `didit_sdk`, o plugin seleciona a variante do SDK nativo de iOS a partir de `$DiditSdkIosVariant`, uma variável global Ruby que você define no `ios/Podfile` do seu app (o pod DiditSDK não está no trunk do CocoaPods):```ruby theme={null}
# Pick one: 'all', 'core', 'autodetection', 'nfc'
$DiditSdkIosVariant = 'all'

didit_sdk_ios_deployment_target = ['all', 'nfc'].include?($DiditSdkIosVariant) ? '15.0' : '13.0'
platform :ios, didit_sdk_ios_deployment_target

didit_sdk_ios_pod = case $DiditSdkIosVariant
                    when 'all' then 'DiditSDK/All'
                    when 'core' then 'DiditSDK/Core'
                    when 'autodetection' then 'DiditSDK/AutoDetection'
                    when 'nfc' then 'DiditSDK/NFC'
                    end
didit_sdk_ios_podspec = 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/4.9.1/DiditSDK.podspec'

target 'Runner' do
  use_frameworks!

  pod didit_sdk_ios_pod, :podspec => didit_sdk_ios_podspec

  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
end

post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
      config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = didit_sdk_ios_deployment_target
    end
  end
end
```Se você usa um pacote de variante (`didit_sdk_core`, `didit_sdk_autodetection`, `didit_sdk_nfc`), ele fixa diretamente o seu subspec nativo e ignora `$DiditSdkIosVariant`. Mantenha a linha `pod` e o deployment target do seu Podfile de acordo com essa variante (por exemplo, `pod 'DiditSDK/Core', :podspec => ...` com `platform :ios, '13.0'`).> [!NOTE]
>
> As variantes `all` e `nfc` exigem deployment target iOS 15.0+; `core` e `autodetection` podem usar iOS 13.0. Ao trocar de variante, limpe o CocoaPods antes (`rm -rf Pods Podfile.lock`) para que a variante anterior do SDK não seja reutilizada.> [!WARNING]
>
> A tag na URL do podspec deve corresponder à versão do SDK nativo de iOS fixada pela sua versão do `didit_sdk`
> (`4.9.1` fixa o SDK nativo `4.9.1`). Se a URL apontar para uma tag mais antiga, o `pod install` não consegue resolver a dependência:
> o CocoaPods encontra um podspec que declara essa versão mais antiga, enquanto o plugin exige uma correspondência exata.
> Ao atualizar o `didit_sdk`, altere a tag nessa URL para a mesma versão.### Configuração no AndroidPor padrão, o plugin depende do SDK completo para Android, incluindo NFC. Para compilar sem NFC, adicione isto ao `android/gradle.properties`:```properties theme={null}
diditSdkAndroidNfcEnabled=false
```Isso troca a dependência de `me.didit:didit-sdk` para `me.didit:didit-sdk-core`, removendo o módulo de leitura por NFC e as suas dependências JMRTD/SCUBA/BouncyCastle.Quando o NFC está ativado (padrão), adicione esta regra de empacotamento ao `android/app/build.gradle.kts` para resolver um arquivo de metadados duplicado do BouncyCastle:```kotlin theme={null}
android {
    packaging {
        resources {
            pickFirsts += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
        }
    }
}
```Sem essa regra, a compilação falha com um erro `mergeDebugJavaResource`. A regra não é necessária quando `diditSdkAndroidNfcEnabled=false`.> [!NOTE]
>
> O SDK nativo para Android é resolvido a partir de um repositório Maven remoto no GitHub (desde o plugin 3.4.0), e nenhuma configuração manual do Maven é necessária no seu app.***## Permissões### iOSAdicione as seguintes chaves ao `Info.plist` do seu app:| 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 para verificações de prova de vida | Sim |
| Biblioteca de fotos | `NSPhotoLibraryUsageDescription` | Envio de documentos da galeria do dispositivo | Sim |
| NFC | `NFCReaderUsageDescription` | Leitura de chips NFC em passaportes e documentos de identidade | Se usar NFC |
| Localização | `NSLocationWhenInUseUsageDescription` | Geolocalização para prevenção de fraudes | Opcional |> [!WARNING]
>
> Se faltar alguma chave de privacidade obrigatória do iOS, o iOS encerra o app assim que o SDK tenta acessar o recurso protegido correspondente. Por exemplo, a ausência de `NSCameraUsageDescription` causa uma falha quando o usuário toca no botão de tirar foto da câmera de documentos.#### Configuração de NFCPara habilitar 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}
<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
<array>
    <string>D23300000045737445494420763335</string>
    <string>A0000002471001</string>
    <string>A0000002472001</string>
    <string>00000000000000</string>
    <string>D392F000260100000001</string>
</array>
````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 informa o cartão ao SDK. A leitura do My Number Card ainda não está habilitada em produção, e o identificador não altera nada para outros documentos, então você já pode adicioná-lo.3) **Adicione um arquivo de entitlements** com a leitura de tags NFC habilitada:```xml theme={null}
<key>com.apple.developer.nfc.readersession.formats</key>
<array>
    <string>TAG</string>
</array>
```Verifique se o provisioning profile do app inclui a capability NFC Tag Reading. Se o bundle ID não estiver configurado para NFC na sua conta Apple Developer, o Xcode vai falhar na assinatura do app por falta do entitlement `com.apple.developer.nfc.readersession.formats`.Essa configuração de NFC não é necessária para as variantes `core` ou `autodetection` (`$DiditSdkIosVariant`), nem para os pacotes `didit_sdk_core` / `didit_sdk_autodetection`, pois nenhum deles lê chips.### AndroidAs seguintes permissões 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` | Detecção de 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. Quando `diditSdkAndroidNfcEnabled=false`, o SDK não adiciona a permissão nem o recurso de NFC do Android.#### Permissões em tempo de execuçãoO SDK trata automaticamente as solicitações de permissão em tempo de execução do Android. Quando o usuário chega a uma etapa que exige acesso à câmera:1) O SDK solicita a permissão de câmera, caso ela ainda não tenha sido concedida
2) Se o usuário **negar** a permissão, uma mensagem de erro é exibida com um botão **Try Again**
3) Se o usuário **conceder** a permissão, o fluxo de verificação continuaVocê não precisa solicitar a permissão de câmera no código do seu app antes de chamar `startVerification()`: o SDK cuida disso internamente.***## Início rápido```dart theme={null}
import 'package:didit_sdk/sdk_flutter.dart';

// Start verification with a session token from your backend
final result = await DiditSdk.startVerification('your-session-token');

switch (result) {
  case VerificationCompleted(:final session):
    if (session.status == VerificationStatus.approved) {
      print('Identity verified!');
    }
  case VerificationCancelled():
    print('User cancelled');
  case VerificationFailed(:final error):
    print('Error: ${error.message}');
}
```***## 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:```dart theme={null}
import 'package:didit_sdk/sdk_flutter.dart';

// Your backend creates a session and returns the token
final sessionToken = await yourBackend.createVerificationSession(userId);

// Pass the token to the SDK
final result = await DiditSdk.startVerification(sessionToken);
```Essa abordagem oferece 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 fluxo (integração mais simples)Em integrações mais simples, o SDK pode criar sessões diretamente usando o ID do seu fluxo de verificação (workflow), sem necessidade de backend:```dart theme={null}
import 'package:didit_sdk/sdk_flutter.dart';

final result = await DiditSdk.startVerificationWithWorkflow(
  'your-workflow-id',
  vendorData: 'user-123',
  config: const DiditConfig(loggingEnabled: true),
);
```> [!NOTE]
>
> Os parâmetros avançados de sessão (`contact_details`, `expected_details`, `metadata`) são suportados **somente** pelo método de token de sessão, em que o seu backend chama a [API Create Session](https://docs.didit.me/pt-br/sessions-api/create-session.md) com suporte a todos os parâmetros. Passe o `session_token` retornado para `DiditSdk.startVerification()`.***## ConfiguraçãoPersonalize o comportamento do SDK passando um objeto `DiditConfig`:```dart theme={null}
final result = await DiditSdk.startVerification(
  'your-session-token',
  config: const DiditConfig(
    languageCode: 'es',       // Force Spanish language
    showLanguageSelector: true, // Let the user change language
    fontFamily: 'Avenir',     // Custom font
    loggingEnabled: true,     // Enable debug logging
  ),
);
```Em `startVerificationWithWorkflow`, passe `config` como parâmetro nomeado:```dart theme={null}
final result = await DiditSdk.startVerificationWithWorkflow(
  'your-workflow-id',
  vendorData: 'user-123',
  config: const DiditConfig(
    languageCode: 'es',
    showLanguageSelector: true,
    loggingEnabled: true,
  ),
);
```### Opções de configuração| Propriedade | Tipo | Padrão | Descrição |
| - | - | - | - |
| `languageCode` | `String?` | Localidade do dispositivo | Código de idioma ISO 639-1 (por exemplo, `"en"`, `"fr"`, `"ar"`) |
| `showLanguageSelector` | `bool` | `false` | Exibe o seletor de idioma no estilo da versão web na tela de boas-vindas |
| `fontFamily` | `String?` | Fonte do sistema | Nome de uma família de fontes personalizada (deve estar registrada nativamente) |
| `loggingEnabled` | `bool` | `false` | Ativa os logs de depuração do SDK |
| `showCloseButton` | `bool` | `true` | Exibe o botão de fechar (X) nas telas das etapas de verificação |
| `showExitConfirmation` | `bool` | `true` | Exibe uma caixa de diálogo de confirmação quando o usuário tenta sair |
| `closeOnComplete` | `bool` | `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 do rosto (prova de vida) é aberta |
| `showDocumentCameraSwitchButton` | `bool` | `true` | Exibe o alternador de câmera durante a captura na tela de captura do documento |
| `showLivenessCameraSwitchButton` | `bool` | `true` | Exibe o alternador de câmera durante a captura na tela de captura do rosto |### Opções de câmeraAs opções de câmera correspondem às [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 fixar o usuário na lente padrão daquela etapa.```dart theme={null}
config: const DiditConfig(
  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 configuração regional do dispositivo, com inglês como alternativa.```dart theme={null}
// Use device locale (default)
await DiditSdk.startVerification(token);

// Force specific language
await DiditSdk.startVerification(token,
  config: const DiditConfig(languageCode: 'fr'),
);

// Let the user change language on the welcome screen
await DiditSdk.startVerification(token,
  config: const DiditConfig(showLanguageSelector: true),
);
```**[Ver todos os idiomas compatíveis →](https://docs.didit.me/pt-br/integration/supported-languages.md)*****## Parâmetros avançados de sessãoParâmetros como `contact_details`, `expected_details` e `metadata` são aceitos **somente** pelo método de token de sessão. Seu backend chama [`POST /v3/session/`](https://docs.didit.me/pt-br/sessions-api/create-session) com suporte completo a parâmetros e, em seguida, passa o `session_token` retornado para o SDK.```dart theme={null}
// Your backend handles the full session creation:
// POST /v3/session/ with contact_details, expected_details, metadata, etc.
final sessionToken = await yourBackend.createSession(userId);

// The SDK only needs the token
final result = await DiditSdk.startVerification(sessionToken);
```> [!NOTE]
>
> O método Dart `startVerificationWithWorkflow` aceita apenas `workflowId`, `vendorData` e `config`. Versões anteriores à 3.4.0 expunham os parâmetros `contactDetails`, `expectedDetails` e `metadata`, mas eles foram removidos porque o endpoint Unilink não os aceita.***## Tratamento de resultadosTanto `startVerification` quanto `startVerificationWithWorkflow` retornam um `Future<VerificationResult>`. O resultado é uma classe selada: use pattern matching para identificar o desfecho.### Casos de resultado| Caso | Descrição |
| - | - |
| `VerificationCompleted` | O fluxo de verificação foi concluído (verifique `session.status` para obter o resultado) |
| `VerificationCancelled` | O usuário cancelou o fluxo de verificação |
| `VerificationFailed` | 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 erroO enum `VerificationErrorType` expõe os seguintes casos:| 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 |
| `retryBlocked` | O número máximo de tentativas foi excedido para a etapa atual |
| `unknown` | Outro erro: consulte `error.message` para mais detalhes |### Perda de conexãoSe o dispositivo perder a conexão durante a verificação, o SDK exibe uma tela de "Sem conexão com a internet" 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 a partir da etapa em que estava.
A tela oferece **Tentar novamente** e, a menos que o botão de fechar esteja desativado, **Sair da verificação**.
Sair encerra a verificação com um resultado `VerificationFailed` cujo tipo de erro é `networkError`, para que seu app saiba que o usuário saiu devido à perda de conexão.### Exemplo completo de tratamento de resultados```dart theme={null}
import 'package:didit_sdk/sdk_flutter.dart';

Future<void> verify(String token) async {
  final result = await DiditSdk.startVerification(token);

  switch (result) {
    case VerificationCompleted(:final session):
      switch (session.status) {
        case VerificationStatus.approved:
          print('Approved! Session: ${session.sessionId}');
          // User is verified — grant access
        case VerificationStatus.pending:
          print('Under review. Session: ${session.sessionId}');
          // Show "verification in progress" UI
        case VerificationStatus.declined:
          print('Declined. Session: ${session.sessionId}');
          // Handle declined verification
      }

    case VerificationCancelled(:final session):
      print('User cancelled.');
      if (session != null) {
        print('Session: ${session.sessionId}');
      }
      // Maybe show retry option

    case VerificationFailed(:final error):
      print('Error [${error.type}]: ${error.message}');
      // Handle error — show retry or contact support
  }
}
```***## Exemplo de ponta a ponta (sessão no backend → Flutter SDK → webhook)A integração pronta para produção: seu backend cria a sessão, seu app Flutter recebe o `session_token` e o SDK executa o fluxo. A decisão final é entregue ao seu backend via 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. Flutter: trocar o token e iniciar o SDK```dart theme={null}
import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'package:didit_sdk/sdk_flutter.dart';

class VerifyButton extends StatefulWidget {
  const VerifyButton({super.key, required this.userId});
  final String userId;

  @override
  State<VerifyButton> createState() => _VerifyButtonState();
}

class _VerifyButtonState extends State<VerifyButton> {
  bool _loading = false;

  Future<void> _verify() async {
    setState(() => _loading = true);
    try {
      final resp = await http.post(
        Uri.parse('https://your-backend.example.com/api/verification/start'),
        headers: const {'Content-Type': 'application/json'},
        body: jsonEncode({'userId': widget.userId}),
      );
      final sessionToken = (jsonDecode(resp.body) as Map)['session_token'] as String;

      final result = await DiditSdk.startVerification(sessionToken);

      switch (result) {
        case VerificationCompleted(:final session):
          if (session.status == VerificationStatus.approved) {
            // Optimistic UI; rely on the webhook delivered to your backend as the source of truth.
          }
        case VerificationCancelled():
          // User dismissed the flow
          break;
        case VerificationFailed(:final error):
          // Show retry — error.type / error.message
          break;
      }
    } finally {
      if (mounted) setState(() => _loading = false);
    }
  }

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: _loading ? null : _verify,
      child: Text(_loading ? 'Starting...' : 'Verify identity'),
    );
  }
}
```### 3. Backend: receber a decisão final via webhook```ts theme={null}
app.post("/api/webhooks/didit", express.raw({ type: "application/json" }), (req, res) => {
  // 1. Verify the X-Signature header (see Webhooks docs)
  // 2. Parse the body
  const event = JSON.parse(req.body.toString());
  if (event.webhook_type === "status.updated") {
    // event.session_id, event.status ("Approved" | "Declined" | "In Review" | ...)
    // Look up the user by session_id and update their verification state.
  }
  res.sendStatus(200);
});
```Consulte o [guia de webhooks](https://docs.didit.me/pt-br/integration/webhooks.md) para ver os detalhes da verificação de assinatura HMAC.***## Exemplo completo```dart theme={null}
import 'package:flutter/material.dart';
import 'package:didit_sdk/sdk_flutter.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Didit SDK Example',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: const Color(0xFF1A1A1A)),
        useMaterial3: true,
      ),
      home: const VerificationScreen(),
    );
  }
}

class VerificationScreen extends StatefulWidget {
  const VerificationScreen({super.key});

  @override
  State<VerificationScreen> createState() => _VerificationScreenState();
}

class _VerificationScreenState extends State<VerificationScreen> {
  final _tokenController = TextEditingController();
  bool _loading = false;

  @override
  void dispose() {
    _tokenController.dispose();
    super.dispose();
  }

  Future<void> _startVerification() async {
    final token = _tokenController.text.trim();
    if (token.isEmpty) {
      _showAlert('Error', 'Please enter a session token.');
      return;
    }

    setState(() => _loading = true);

    try {
      final result = await DiditSdk.startVerification(
        token,
        config: const DiditConfig(loggingEnabled: true),
      );

      switch (result) {
        case VerificationCompleted(:final session):
          _showAlert(
            'Verification Complete',
            'Status: ${session.status.name}\nSession: ${session.sessionId}',
          );
        case VerificationCancelled():
          _showAlert('Cancelled', 'The user cancelled the verification.');
        case VerificationFailed(:final error):
          _showAlert('Failed', '${error.type.name}: ${error.message}');
      }
    } catch (e) {
      _showAlert('Error', 'Unexpected error: $e');
    } finally {
      setState(() => _loading = false);
    }
  }

  void _showAlert(String title, String message) {
    showDialog(
      context: context,
      builder: (ctx) => AlertDialog(
        title: Text(title),
        content: Text(message),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(ctx),
            child: const Text('OK'),
          ),
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: SafeArea(
        child: Padding(
          padding: const EdgeInsets.all(24),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: [
              TextField(
                controller: _tokenController,
                decoration: InputDecoration(
                  hintText: 'Enter session token...',
                  border: OutlineInputBorder(
                    borderRadius: BorderRadius.circular(8),
                  ),
                ),
                autocorrect: false,
              ),
              const SizedBox(height: 16),
              ElevatedButton(
                onPressed: _loading ? null : _startVerification,
                style: ElevatedButton.styleFrom(
                  backgroundColor: const Color(0xFF1A1A1A),
                  foregroundColor: Colors.white,
                  padding: const EdgeInsets.symmetric(vertical: 16),
                  shape: RoundedRectangleBorder(
                    borderRadius: BorderRadius.circular(8),
                  ),
                ),
                child: _loading
                    ? const SizedBox(
                        height: 20,
                        width: 20,
                        child: CircularProgressIndicator(
                          strokeWidth: 2,
                          color: Colors.white,
                        ),
                      )
                    : const Text(
                        'Start Verification',
                        style: TextStyle(fontWeight: FontWeight.w600),
                      ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}
```***


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.