> ## 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 dell'identità mobile in Dart > SDK Flutter di Didit per KYC: iOS e Android nativi, rilevamento vitalità, passaporto NFC. Da $0.33 a verifica, $10 gratis/mese, senza contratti. Prompt di integrazione SDK Flutter Copia il prompt negli appunti \

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

\
Incolla in Un plugin Flutter multipiattaforma che incapsula gli SDK nativi per iOS e Android, offrendo un'API Dart unificata per la verifica dell'identità.> [card] [Repository GitHub](https://github.com/didit-protocol/sdk-flutter) > > Visualizza il codice sorgente e gli esempi su GitHub> [card] [Pacchetto pub.dev](https://pub.dev/packages/didit_sdk) > > didit\_sdk> [!NOTE] > > ### **SDK nativo**: È l'approccio consigliato per le app Flutter. L'SDK incapsula gli SDK nativi per iOS e Android tramite i canali della piattaforma, per offrire la migliore esperienza utente, una gestione ottimizzata della fotocamera e il pieno supporto NFC.***## Requisiti| Requisito | Versione minima | | - | - | | Flutter | 3.3+ | | Dart | 3.11+ |### Requisiti della piattaforma| Piattaforma | Versione minima | Note | | - | - | - | | iOS | 13.0+ | La lettura del passaporto NFC richiede iOS 15.0+ | | Android | API 23+ (6.0) | Java 17+ |> [!NOTE] > > **Il consenso biometrico richiede la versione nativa 4.10.0 o successiva.** Per le persone soggette alle leggi dell'Illinois, del Texas o del Colorado, Didit può chiedere un [consenso biometrico](https://docs.didit.me/it/getting-started/biometric-consent.md) esplicito prima della prima acquisizione del volto. Una release dell'SDK Flutter che fissa gli SDK nativi iOS e Android alla versione 4.10.0 o successiva mostra questo passaggio. Le versioni precedenti non possono mostrarlo: le loro sessioni proseguono come prima, e la decisione riporta il consenso come non raccolto (`biometric_consent.reason: "BIOMETRIC_CONSENT_UNSUPPORTED_SDK"`). Esegui l'aggiornamento se verifichi persone in questi stati.***## Installazione```bash theme={null} flutter pub add didit_sdk ```Oppure aggiungilo manualmente al tuo `pubspec.yaml`:```yaml theme={null} dependencies: didit_sdk: ^4.13.2 ```Poi esegui:```bash theme={null} flutter pub get ```### Varianti dell'SDK nativo`didit_sdk` include l'SDK nativo completo. Per ottenere un binario più leggero, dipendi invece da un pacchetto alternativo: espone esattamente la stessa API Dart e fissa l'SDK nativo corrispondente su entrambe le piattaforme:| Pacchetto | Acquisizione automatica | Lettura del passaporto NFC | iOS minimo | | - | - | - | - | | `didit_sdk` (predefinito) | Sì | Sì | 15.0 | | `didit_sdk_core` | No | No | 13.0 | | `didit_sdk_autodetection` | Sì | No | 13.0 | | `didit_sdk_nfc` | No | Sì | 15.0 |```yaml theme={null} dependencies: didit_sdk_core: ^4.13.2 ```Dichiara una dipendenza da uno solo di questi pacchetti e importa da quello che hai scelto, ad esempio `package:didit_sdk_core/sdk_flutter.dart`.### Configurazione iOSIl plugin supporta entrambi i gestori di dipendenze iOS di Flutter: Swift Package Manager e CocoaPods.#### Swift Package ManagerSe la tua versione di Flutter ha il supporto a Swift Package Manager abilitato (attivalo esplicitamente con `flutter config --enable-swift-package-manager` su Flutter 3.24+), il plugin viene utilizzato automaticamente come pacchetto Swift. Non serve alcuna configurazione del Podfile: la dipendenza nativa DiditSDK viene risolta autonomamente da GitHub. Imposta il deployment target iOS della tua app in Xcode (target Runner e progetto) al minimo previsto per il pacchetto scelto: 15.0 per `didit_sdk` e `didit_sdk_nfc`, 13.0 per `didit_sdk_core` e `didit_sdk_autodetection`.#### CocoaPodsCon `didit_sdk`, il plugin seleziona la variante dell'SDK nativo iOS da `$DiditSdkIosVariant`, una variabile globale Ruby che imposti nel file `ios/Podfile` della tua app (il pod DiditSDK non è disponibile su 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 utilizzi un pacchetto alternativo (`didit_sdk_core`, `didit_sdk_autodetection`, `didit_sdk_nfc`), esso fissa direttamente il proprio subspec nativo e ignora `$DiditSdkIosVariant`: mantieni la riga `pod` del tuo Podfile e il deployment target allineati a quella variante (ad esempio `pod 'DiditSDK/Core', :podspec => ...` con `platform :ios, '13.0'`).> [!NOTE] > > Le varianti `all` e `nfc` richiedono un deployment target iOS 15.0+; `core` e `autodetection` possono avere come target iOS 13.0. Quando cambi variante, pulisci prima CocoaPods (`rm -rf Pods Podfile.lock`) in modo che la variante SDK precedente non venga riutilizzata.> [!WARNING] > > Il tag nell'URL del podspec deve corrispondere alla versione dell'SDK nativo iOS fissata dalla tua release di `didit_sdk` > (`4.13.2` fissa l'SDK nativo `4.13.2`). Se l'URL punta a un tag più vecchio, `pod install` non riesce a risolvere la dipendenza: > CocoaPods trova un podspec che dichiara quella versione più vecchia, mentre il plugin richiede una corrispondenza esatta. > Quando aggiorni `didit_sdk`, aggiorna il tag in questo URL alla stessa versione.### Configurazione AndroidPer impostazione predefinita il plugin dipende dall'SDK Android completo, NFC incluso. Per compilare senza NFC, aggiungi questa riga a `android/gradle.properties`:```properties theme={null} diditSdkAndroidNfcEnabled=false ```Questo sostituisce la dipendenza da `me.didit:didit-sdk` con `me.didit:didit-sdk-core`, rimuovendo il modulo di lettura NFC e le sue dipendenze JMRTD/SCUBA/BouncyCastle.Quando l'NFC è abilitato (impostazione predefinita), aggiungi questa regola di packaging a `android/app/build.gradle.kts` per risolvere un file di metadati duplicato di BouncyCastle:```kotlin theme={null} android { packaging { resources { pickFirsts += "META-INF/versions/9/OSGI-INF/MANIFEST.MF" } } } ```Senza questa regola la compilazione fallisce con un errore `mergeDebugJavaResource`. La regola non serve quando `diditSdkAndroidNfcEnabled=false`.> [!NOTE] > > L'SDK nativo Android viene risolto da un repository Maven remoto su GitHub (dalla versione 3.4.0 del plugin): nella tua app non serve alcuna configurazione Maven manuale.***## Permessi### iOSAggiungi le seguenti chiavi al file `Info.plist` della tua app:| Autorizzazione | Chiave Info.plist | Descrizione | Obbligatorio | | - | - | - | - | | Fotocamera | `NSCameraUsageDescription` | Scansione dei documenti e verifica del volto | Sì | | Microfono | `NSMicrophoneUsageDescription` | Registrazione video per il rilevamento della vitalità | Sì | | Libreria foto | `NSPhotoLibraryUsageDescription` | Caricamento di documenti dalla galleria del dispositivo | Sì | | NFC | `NFCReaderUsageDescription` | Lettura dei chip NFC in passaporti e carte d'identità | Se si usa NFC | | Posizione | `NSLocationWhenInUseUsageDescription` | Geolocalizzazione per la prevenzione delle frodi | Facoltativo |> [!WARNING] > > Se manca una qualsiasi chiave obbligatoria relativa alla privacy di iOS, iOS termina l'app non appena l'SDK tenta di accedere a quella risorsa protetta. Ad esempio, se manca `NSCameraUsageDescription`, l'app si blocca quando l'utente tocca il pulsante di scatto della fotocamera per i documenti.#### Configurazione NFCPer abilitare la lettura NFC di passaporti e carte d'identità dotati di chip:1) **Aggiungi la funzionalità NFC** in Xcode: * Seleziona il tuo target > **Signing & Capabilities** > **+ Capability** > **Near Field Communication Tag Reading** 2) **Aggiungi gli identificatori ISO7816** a `Info.plist`:```xml theme={null} com.apple.developer.nfc.readersession.iso7816.select-identifiers D23300000045737445494420763335 A0000002471001 A0000002472001 00000000000000 D392F000260100000001 ````D392F000260100000001` consente all'SDK di leggere la Japan My Number Card tramite [JPKI](https://docs.didit.me/it/core-technology/nfc-verification/overview.md#japan-my-number-card-jpki): senza questo identificatore, iOS non segnala la carta all'SDK. La lettura della My Number Card non è ancora abilitata in produzione e l'identificatore non modifica nulla per gli altri documenti, quindi puoi aggiungerlo fin da ora.3) **Aggiungi un file di entitlements** con la lettura dei tag NFC abilitata:```xml theme={null} com.apple.developer.nfc.readersession.formats TAG ```Assicurati che il profilo di provisioning dell'app includa la funzionalità NFC Tag Reading. Se il bundle ID non è configurato per NFC nel tuo account Apple Developer, Xcode non riuscirà a firmare l'app e segnalerà un entitlement `com.apple.developer.nfc.readersession.formats` mancante.Questa configurazione NFC non è necessaria per le varianti `core` o `autodetection` (`$DiditSdkIosVariant`), né per i pacchetti `didit_sdk_core` / `didit_sdk_autodetection`: nessuno di questi legge i chip.### AndroidL'SDK dichiara i seguenti permessi nel proprio `AndroidManifest.xml` e vengono uniti automaticamente:| Autorizzazione | Descrizione | Obbligatorio | | - | - | - | | `INTERNET` | Accesso alla rete per la comunicazione con le API | Sì | | `ACCESS_NETWORK_STATE` | Rilevamento della disponibilità della rete | Sì | | `CAMERA` | Scansione dei documenti e verifica del volto | Sì | | `NFC` | Lettura dei chip NFC in passaporti e carte d'identità | Se si usa NFC |Le funzionalità hardware di fotocamera e NFC sono dichiarate come facoltative (`android:required="false"`), quindi la tua app può essere installata anche su dispositivi privi di queste funzionalità. Quando `diditSdkAndroidNfcEnabled=false`, l'SDK non aggiunge l'autorizzazione e la funzionalità NFC di Android.#### Autorizzazioni di runtimeL'SDK gestisce automaticamente le richieste di autorizzazione di runtime di Android. Quando l'utente arriva a un passaggio che richiede l'accesso alla fotocamera:1) L'SDK chiede l'autorizzazione ad accedere alla fotocamera se non è già stata concessa 2) Se l'utente **nega** il permesso, viene mostrato un messaggio di errore con un pulsante **Try Again** 3) Se l'utente **concede** il permesso, il flusso di verifica prosegueNon è necessario richiedere l'autorizzazione ad accedere alla fotocamera nel codice della tua app prima di chiamare `startVerification()`: l'SDK se ne occupa internamente.***## Avvio rapido```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}'); } ```***## Metodi di integrazioneL'SDK supporta due metodi di integrazione:### Metodo 1: Session Token (consigliato per la produzione)Crea una sessione sul tuo backend con l'[API Create Verification Session](https://docs.didit.me/it/sessions-api/create-session.md), poi passa il token all'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); ```Questo approccio ti offre il pieno controllo su:- Associazione delle sessioni ai tuoi utenti (`vendor_data`) - Impostazione di metadati personalizzati - Configurazione dei callback per ogni sessione### Metodo 2: Workflow ID (integrazione più semplice)Per integrazioni più semplici, l'SDK può creare le sessioni direttamente con il tuo workflow ID, senza bisogno di un 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] > > I parametri avanzati della sessione (`contact_details`, `expected_details`, `metadata`) sono supportati **solo** con il metodo Session Token, in cui il tuo backend chiama l'[API Create Session](https://docs.didit.me/it/sessions-api/create-session.md) con il supporto completo dei parametri. Passa il `session_token` restituito a `DiditSdk.startVerification()`.***## ConfigurazionePersonalizza il comportamento dell'SDK passando un oggetto `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 ), ); ```Per `startVerificationWithWorkflow`, passa `config` come parametro denominato:```dart theme={null} final result = await DiditSdk.startVerificationWithWorkflow( 'your-workflow-id', vendorData: 'user-123', config: const DiditConfig( languageCode: 'es', showLanguageSelector: true, loggingEnabled: true, ), ); ```### Opzioni di configurazione| Proprietà | Tipo | Predefinito | Descrizione | | - | - | - | - | | `languageCode` | `String?` | Lingua del dispositivo | Codice lingua ISO 639-1 (ad esempio `"en"`, `"fr"`, `"ar"`) | | `showLanguageSelector` | `bool` | `false` | Mostra il selettore della lingua in stile web nella schermata di benvenuto | | `fontFamily` | `String?` | Carattere di sistema | Nome della famiglia di caratteri personalizzata (deve essere registrata a livello nativo) | | `loggingEnabled` | `bool` | `false` | Attiva il logging di debug dell'SDK | | `showCloseButton` | `bool` | `true` | Mostra il pulsante di chiusura (X) nelle schermate dei passaggi di verifica | | `showExitConfirmation` | `bool` | `true` | Mostra una finestra di conferma quando l'utente tenta di uscire | | `closeOnComplete` | `bool` | `false` | Chiude automaticamente l'interfaccia di verifica al completamento | | `defaultDocumentCamera` | `CameraLens?` | Predefinito nativo (`CameraLens.back`) | Obiettivo usato quando si apre la schermata di acquisizione del documento | | `defaultLivenessCamera` | `CameraLens?` | Predefinito nativo (`CameraLens.front`) | Obiettivo usato quando si apre la schermata di acquisizione del volto (vitalità) | | `showDocumentCameraSwitchButton` | `bool` | `true` | Mostra il selettore della fotocamera durante l'acquisizione nella schermata del documento | | `showLivenessCameraSwitchButton` | `bool` | `true` | Mostra il selettore della fotocamera durante l'acquisizione nella schermata del volto |### Opzioni della fotocameraLe opzioni della fotocamera corrispondono alle [opzioni della fotocamera del Web SDK](https://docs.didit.me/it/integration/web-sdks/javascript-sdk.md#opzioni-della-fotocamera). Ogni obiettivo è `CameraLens.front` o `CameraLens.back`. Se il dispositivo non dispone dell'obiettivo richiesto, l'SDK usa la prima fotocamera disponibile. Il selettore della fotocamera è inoltre nascosto sui dispositivi che hanno una sola fotocamera. Imposta un'opzione del selettore su `false` per bloccare l'utente sull'obiettivo predefinito di quel passaggio.```dart theme={null} config: const DiditConfig( defaultLivenessCamera: CameraLens.back, showLivenessCameraSwitchButton: false, ), ```> [!NOTE] > > **Tema e colori**: i colori, gli sfondi e le impostazioni della schermata introduttiva si configurano tramite le tue [impostazioni White label](https://business.didit.me) nella Didit Console, non nella configurazione dell'SDK. Così l'identità del marchio resta coerente su tutte le piattaforme.***## Supporto linguisticoL'SDK supporta **54 lingue**. Se non viene specificata alcuna lingua, l'SDK usa la lingua del dispositivo, con l'inglese come lingua di ripiego.```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), ); ```**[Visualizza tutte le lingue supportate →](https://docs.didit.me/it/integration/supported-languages.md)*****## Parametri avanzati della sessioneI parametri come `contact_details`, `expected_details` e `metadata` sono supportati **solo** tramite il metodo con session token. Il tuo backend chiama [`POST /v3/session/`](https://docs.didit.me/it/sessions-api/create-session) con il supporto completo dei parametri, poi passa il `session_token` restituito all'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] > > Il metodo Dart `startVerificationWithWorkflow` accetta solo `workflowId`, `vendorData` e `config`. Le versioni precedenti alla 3.4.0 esponevano i parametri `contactDetails`, `expectedDetails` e `metadata`, ma sono stati rimossi perché l'endpoint Unilink non li rispetta.***## Gestione dei risultatiSia `startVerification` sia `startVerificationWithWorkflow` restituiscono un `Future`. Il risultato è una classe sealed: usa il pattern matching per determinare l'esito.### Casi del risultato| Caso | Descrizione | | - | - | | `VerificationCompleted` | Il flusso di verifica è stato completato (controlla `session.status` per il risultato) | | `VerificationCancelled` | L'utente ha annullato il flusso di verifica | | `VerificationFailed` | Si è verificato un errore durante la verifica |### Proprietà di SessionData| Proprietà | Tipo | Descrizione | | - | - | - | | `sessionId` | `String` | Identificativo univoco della sessione | | `status` | `VerificationStatus` | `approved`, `pending` o `declined` |### Tipi di erroreL'enum `VerificationErrorType` espone i seguenti casi:| Errore | Descrizione | | - | - | | `sessionExpired` | La sessione è scaduta | | `networkError` | Problema di connettività di rete | | `cameraAccessDenied` | Autorizzazione alla fotocamera non concessa | | `notInitialized` | SDK non inizializzato (solo Android) | | `apiError` | Richiesta API non riuscita | | `retryBlocked` | Superato il numero massimo di nuovi tentativi per il passaggio corrente | | `unknown` | Altro errore: controlla `error.message` per i dettagli |### Connessione persaSe il dispositivo perde la connessione durante la verifica, l'SDK mostra una schermata "Nessuna connessione a Internet" al posto del flusso, invece di lasciare un passaggio in caricamento. Continua a controllare in background e chiude automaticamente la schermata appena Didit torna raggiungibile, e l'utente prosegue dal passaggio in cui si trovava. La schermata offre **Riprova** e, se il pulsante di chiusura non è disattivato, **Esci dalla verifica**. Uscire termina la verifica con un risultato `VerificationFailed` il cui tipo di errore è `networkError`, così la tua app sa che l'utente è uscito a causa della connessione.### Esempio completo di gestione dei risultati```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 } } ```***## Esempio end-to-end (sessione backend → Flutter SDK → webhook)Questa è l'integrazione pronta per la produzione: il tuo backend crea la sessione, la tua app Flutter riceve il `session_token` e l'SDK esegue il flusso. La decisione finale viene inviata al tuo backend tramite webhook: non fidarti mai del solo risultato lato client.### 1. Backend: crea la sessione```ts theme={null} // Node.js / Express example. Run on your server. NEVER ship DIDIT_API_KEY to the device. import express from "express"; const app = express(); app.use(express.json()); app.post("/api/verification/start", async (req, res) => { const response = await fetch("https://verification.didit.me/v3/session/", { method: "POST", headers: { "x-api-key": process.env.DIDIT_API_KEY!, "Content-Type": "application/json", }, body: JSON.stringify({ workflow_id: process.env.DIDIT_WORKFLOW_ID, vendor_data: req.body.userId, // your stable user id }), }); if (!response.ok) { return res.status(500).json({ error: `Didit ${response.status}` }); } const { session_id, session_token } = await response.json(); // Persist session_id <-> userId so you can match the webhook later. res.json({ session_id, session_token }); }); ```### 2. Flutter: scambia il token e avvia l'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: ricevi la decisione finale tramite 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); }); ```Consulta la [guida ai webhook](https://docs.didit.me/it/integration/webhooks.md) per i dettagli sulla verifica della firma HMAC.***## Esempio 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.