> ## 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 Flutter: verificação móvel em Dart > Didit: SDK KYC Flutter/Dart com iOS e Android nativos, prova de vida e NFC. Desde $0.33 por verificação completa, $10 grátis/mês, sem contratos. Prompt de integração do SDK Flutter Copiar o prompt para a área de transferência \

\`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.13.2/DiditSDK.podspec'
The tag in that URL must equal the native iOS SDK version the didit_sdk release pins (4.13.2 pins 4.13.2); 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`

\
Colar em Um plugin Flutter multiplataforma que encapsula os SDK nativos de iOS e Android, oferecendo uma API Dart unificada para verificação de identidade.> [card] [Repositório no GitHub](https://github.com/didit-protocol/sdk-flutter) > > Consulte o código-fonte e os exemplos no GitHub> [card] [Pacote no pub.dev](https://pub.dev/packages/didit_sdk) > > didit\_sdk> [!NOTE] > > ### **SDK nativo**: Esta é a abordagem recomendada para aplicações Flutter. O SDK encapsula os SDK nativos de iOS e Android através de canais de plataforma, para oferecer a melhor experiência ao utilizador, com gestão otimizada da câmara e suporte total a NFC.***## Requisitos| Requisito | Versão mínima | | - | - | | Flutter | 3.3+ | | Dart | 3.11+ |### Requisitos da plataforma| Plataforma | Versão mínima | Notas | | - | - | - | | iOS | 13.0+ | A leitura de passaportes 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 pela legislação do Illinois, do Texas ou do Colorado, a Didit pode pedir um [consentimento biométrico](https://docs.didit.me/pt/getting-started/biometric-consent.md) explícito antes da primeira captura facial. Uma versão do Flutter SDK que fixe o SDK nativo de iOS e Android na versão 4.10.0 ou posterior apresenta essa etapa. As versões anteriores não conseguem apresentá-la: 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```bash theme={null} flutter pub add didit_sdk ```Ou adicione-o manualmente ao seu `pubspec.yaml`:```yaml theme={null} dependencies: didit_sdk: ^4.13.2 ```Depois execute:```bash theme={null} flutter pub get ```### Variantes do SDK nativo`didit_sdk` inclui o SDK nativo completo. Para obter um binário mais pequeno, declare como dependência um pacote de variante: expõe exatamente a mesma API Dart e fixa o SDK nativo correspondente em ambas as plataformas.| Pacote | Captura automática | Leitura do passaporte por NFC | iOS mínimo | | - | - | - | - | | `didit_sdk` (predefinido) | 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.13.2 ```Declare apenas um destes pacotes como dependência e importe a partir do que escolheu, por exemplo `package:didit_sdk_core/sdk_flutter.dart`.### Configuração do iOSO plugin suporta os dois gestores de dependências do iOS do Flutter: Swift Package Manager e CocoaPods.#### Swift Package ManagerSe a sua versão do Flutter tiver o suporte ao Swift Package Manager ativado (ative-o com `flutter config --enable-swift-package-manager` no Flutter 3.24+), o plugin é consumido automaticamente como pacote Swift. Não é necessária nenhuma configuração do Podfile: a dependência nativa DiditSDK é resolvida automaticamente a partir do GitHub. Defina o destino de implementação do iOS da sua aplicação no Xcode (o destino Runner e o projeto) com o valor 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 `didit_sdk`, o plugin seleciona a variante do SDK nativo para iOS a partir de `$DiditSdkIosVariant`, uma variável global Ruby que define no `ios/Podfile` da sua aplicação (o pod DiditSDK não está no CocoaPods trunk):```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.13.2/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 usar um pacote de variante (`didit_sdk_core`, `didit_sdk_autodetection`, `didit_sdk_nfc`), este fixa diretamente o respetivo subspec nativo e ignora `$DiditSdkIosVariant`. Mantenha a linha `pod` do Podfile e o destino de implementação alinhados com essa variante (por exemplo `pod 'DiditSDK/Core', :podspec => ...` com `platform :ios, '13.0'`).> [!NOTE] > > As variantes `all` e `nfc` exigem um destino de implementação iOS 15.0+; `core` e `autodetection` podem ter como alvo o iOS 13.0. Ao mudar de variante, limpe primeiro o CocoaPods (`rm -rf Pods Podfile.lock`) para que a variante anterior do SDK não seja reutilizada.> [!WARNING] > > A tag no URL do podspec tem de corresponder à versão do SDK nativo para iOS que a sua versão de `didit_sdk` fixa (`4.13.2` fixa o SDK nativo na versão `4.13.2`). Se o URL apontar para uma tag mais antiga, o `pod install` falha ao resolver: 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`, atualize a tag deste URL para a mesma versão.### Configuração do AndroidPor predefinição, o plugin depende do SDK completo para Android, incluindo NFC. Para compilar sem NFC, adicione o seguinte a `android/gradle.properties`:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Isto altera a dependência de `me.didit:didit-sdk` para `me.didit:didit-sdk-core`, removendo o módulo de leitura NFC e as respetivas dependências JMRTD/SCUBA/BouncyCastle.Quando o NFC está ativado (predefinição), adicione esta regra de empacotamento a `android/app/build.gradle.kts` para resolver um ficheiro de metadados duplicado do BouncyCastle:```kotlin theme={null} android { packaging { resources { pickFirsts += "META-INF/versions/9/OSGI-INF/MANIFEST.MF" } } } ```Sem esta 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): não é necessária nenhuma configuração manual do Maven na sua aplicação.***## Permissões### iOSAdicione as seguintes chaves ao ficheiro `Info.plist` da sua aplicação:| Permissão | Chave do Info.plist | Descrição | Obrigatória | | - | - | - | - | | Câmara | `NSCameraUsageDescription` | Digitalização de documentos e verificação facial | Sim | | Microfone | `NSMicrophoneUsageDescription` | Gravação de vídeo para as verificações de prova de vida | Sim | | Biblioteca de fotos | `NSPhotoLibraryUsageDescription` | Carregamento de documentos a partir da galeria do dispositivo | Sim | | NFC | `NFCReaderUsageDescription` | Leitura de chips NFC em passaportes e cartões de identidade | Se usar NFC | | Localização | `NSLocationWhenInUseUsageDescription` | Geolocalização para prevenção de fraude | Opcional |> [!WARNING] > > Se alguma chave de privacidade obrigatória do iOS estiver em falta, o iOS termina a aplicação assim que o SDK tentar aceder a esse recurso protegido. Por exemplo, a falta de `NSCameraUsageDescription` provoca uma falha quando o utilizador toca no botão de tirar foto da câmara de documentos.#### Configuração de NFCPara ativar a leitura de NFC em passaportes e cartões de identidade com chip:1) **Adicione a capacidade 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 Cartão Individual de Número (My Number Card) do Japão através da [JPKI](https://docs.didit.me/pt/core-technology/nfc-verification/overview.md#cartão-my-number-do-japão-jpki): sem ele, o iOS não comunica o cartão ao SDK. A leitura do My Number Card ainda não está ativa em produção, e o identificador não altera nada nos outros documentos, por isso pode adicioná-lo desde já.3) **Adicione um ficheiro de direitos (entitlements)** com a leitura de tags 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. Se o Bundle ID não estiver configurado para NFC na sua conta do Apple Developer, o Xcode falha ao assinar devido à ausência do direito `com.apple.developer.nfc.readersession.formats`.Esta 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`, uma vez que nenhum deles lê chips.### AndroidAs seguintes permissões estão declaradas no `AndroidManifest.xml` do SDK e são integradas automaticamente:| Permissão | Descrição | Obrigatória | | - | - | - | | `INTERNET` | Acesso à rede para comunicação com a API | Sim | | `ACCESS_NETWORK_STATE` | Deteção da disponibilidade da rede | Sim | | `CAMERA` | Digitalização de documentos e verificação facial | Sim | | `NFC` | Leitura de chips NFC em passaportes e cartões de identidade | Se usar NFC |As funcionalidades de hardware de câmara e NFC estão declaradas como opcionais (`android:required="false"`), pelo que a sua aplicação pode ser instalada em dispositivos sem essas funcionalidades. Quando `diditSdkAndroidNfcEnabled=false`, o SDK não adiciona a permissão nem a funcionalidade NFC do Android.#### Permissões em tempo de execuçãoO SDK trata dos pedidos de permissões em tempo de execução do Android automaticamente. Quando o utilizador chega a um passo que requer acesso à câmara:1) O SDK pede a permissão da câmara, caso ainda não tenha sido concedida 2) Se o utilizador **recusar** a permissão, é apresentada uma mensagem de erro com o botão **Tentar novamente** 3) Se o utilizador **conceder** a permissão, o fluxo de verificação continuaNão é necessário pedir a permissão da câmara no código da sua aplicação antes de chamar `startVerification()`, uma vez que o SDK gere isto 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 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 com a [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 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); ```Esta abordagem dá-lhe controlo total sobre:- A associação das sessões aos seus utilizadores (`vendor_data`) - A definição de metadados personalizados - A configuração de chamadas de retorno 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 seu ID de fluxo, 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 **apenas** através do método de token de sessão, em que o seu backend chama a [API de criação de sessão](https://docs.didit.me/pt/sessions-api/create-session.md) com suporte total a parâmetros. Passe o `session_token` devolvido 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 ), ); ```Para `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 | Predefinição | Descrição | | - | - | - | - | | `languageCode` | `String?` | Idioma do dispositivo | Código de idioma ISO 639-1 (por exemplo, `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `bool` | `false` | Mostra o seletor de idioma, no estilo da versão web, no ecrã de boas-vindas | | `fontFamily` | `String?` | Tipo de letra do sistema | Nome da família de tipos de letra personalizada (tem de estar registada nativamente) | | `loggingEnabled` | `bool` | `false` | Ativa o registo de depuração do SDK | | `showCloseButton` | `bool` | `true` | Mostra o botão de fecho (X) nos ecrãs dos passos de verificação | | `showExitConfirmation` | `bool` | `true` | Mostra uma caixa de confirmação quando o utilizador tenta sair | | `closeOnComplete` | `bool` | `false` | Fecha automaticamente a interface de verificação quando esta estiver concluída | | `defaultDocumentCamera` | `CameraLens?` | Predefinição nativa (`CameraLens.back`) | Objetiva usada quando abre o ecrã de captura do documento | | `defaultLivenessCamera` | `CameraLens?` | Predefinição nativa (`CameraLens.front`) | Objetiva usada quando abre o ecrã de captura facial (prova de vida) | | `showDocumentCameraSwitchButton` | `bool` | `true` | Mostra o seletor de câmara durante a captura, no ecrã de captura do documento | | `showLivenessCameraSwitchButton` | `bool` | `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 objetiva é `CameraLens.front` ou `CameraLens.back`. Se o dispositivo não tiver a objetiva 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 de seletor como `false` para fixar o utilizador na objetiva predefinida desse passo.```dart theme={null} config: const DiditConfig( 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 através das suas [definições de marca branca](https://business.didit.me) na Didit Console, e não na configuração do SDK. Assim, a identidade visual é consistente em todas as plataformas.***## Suporte de 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.```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 suportados →](https://docs.didit.me/pt/integration/supported-languages.md)*****## Parâmetros avançados da sessãoParâmetros como `contact_details`, `expected_details` e `metadata` são suportados **apenas** através do método de token de sessão. O seu backend chama [`POST /v3/session/`](https://docs.didit.me/pt/sessions-api/create-session) com suporte total dos parâmetros e, depois, transmite o `session_token` devolvido ao 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`. As versões anteriores à 3.4.0 expunham os parâmetros `contactDetails`, `expectedDetails` e `metadata`, mas estes foram removidos porque o endpoint Unilink não os respeita.***## Tratamento dos resultadosTanto `startVerification` como `startVerificationWithWorkflow` devolvem um `Future`. O resultado é uma classe selada, por isso use a correspondência de padrões para determinar o resultado.### Casos de resultado| Caso | Descrição | | - | - | | `VerificationCompleted` | O fluxo de verificação foi concluído (consulte `session.status` para o resultado) | | `VerificationCancelled` | O utilizador 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 erroA enumeração `VerificationErrorType` expõe os seguintes casos:| Erro | Descrição | | - | - | | `sessionExpired` | A sessão expirou | | `networkError` | Problema de conectividade de rede | | `cameraAccessDenied` | A permissão da câmara não foi concedida | | `notInitialized` | SDK não inicializado (apenas Android) | | `apiError` | O pedido à API falhou | | `retryBlocked` | Número máximo de tentativas excedido para o passo atual | | `unknown` | Outro erro: consulte `error.message` para mais detalhes |### Ligação perdidaSe o dispositivo perder a ligação durante a verificação, o SDK cobre o fluxo com um ecrã «Sem ligação à Internet», em vez de deixar um passo a carregar. Continua a verificar em segundo plano e fecha o ecrã automaticamente assim que a Didit voltar a estar acessível, e o utilizador prossegue a partir do passo em que estava. O ecrã oferece **Tentar novamente** e, a menos que o botão de fecho esteja desativado, **Sair da verificação**. Ao sair, a verificação termina com um resultado `VerificationFailed` cujo tipo de erro é `networkError`, para que a sua aplicação saiba que o utilizador saiu por causa da ligação.### Exemplo completo de tratamento de resultados```dart theme={null} import 'package:didit_sdk/sdk_flutter.dart'; Future 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 → SDK Flutter → webhook)A integração pronta para produção: o seu backend cria a sessão, a sua aplicação Flutter recebe o `session_token` e o SDK executa o fluxo. A decisão final é enviada 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. 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 createState() => _VerifyButtonState(); } class _VerifyButtonState extends State { bool _loading = false; Future _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 por 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/integration/webhooks.md) para os detalhes da verificação da 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 createState() => _VerificationScreenState(); } class _VerificationScreenState extends State { final _tokenController = TextEditingController(); bool _loading = false; @override void dispose() { _tokenController.dispose(); super.dispose(); } Future _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.