Workflow Integration

Integrate KYC workflows in Flutter apps using the ComplyCube SDK.

Overview

This guide walks you through integrating the Flutter SDK with ComplyCube workflows.

Integration flow

The Mobile SDK runs on your mobile application, but relies on your backend to create secure tokens. Here’s how it works:

Create a client

Generate an SDK token

Your backend requests a JWT token tied to that client.

Initialize the SDK in your mobile app

Pass the token and settings to the SDK initializer.

Capture data, documents, videos, and selfies

The SDK guides your customer through the required steps.

Perform checks

Captured data is securely sent to ComplyCube for verification checks, and results are delivered in real time through the API or webhooks.

Integration guide

Explore the source code and sample projects on our repository: .

Install the SDK

Install the ComplyCube Flutter package by running:
```
flutter pub add complycube
```

iOS

Complete the steps 1 and 2 in the iOS tabs.

Add the snippet below to your ios/PodFile and run the pod install command.

source 'https://github.com/CocoaPods/Specs.git'

platform :iOS, '13.0'

target 'Runner' do
  use_frameworks!
  use_modular_headers!
    ...
    ...
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['ENABLE_BITCODE'] = 'NO'
     config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
     config.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = 'arm64'
     config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '11.0'
   end
 end
end```

Complete Application permissions steps in the iOS tabs.

Android
1. Complete the steps in the Android tab.

iOS deployment targeting

If you’re targeting a specific iOS version above 13.0 for any of your dependencies, and you face the following error:

Compiling for iOS 13.0, but module 'CocoaLumberjack' has a minimum deployment target of iOS 15.0

You can use the snippet below in your PodFile post_install script.

post_install do |installer|
  ios_13_pods = [
    'Sentry',
    'Analytics',
    'Alamofire',
    'SwiftyJSON',
    'JWTDecode',
    'GooglePlaces',
    'lottie-ios'
  ]
  
  installer.pods_project.targets.each do |target|
      ....
      
      # Set deployment target based on pod name
      if ios_13_pods.any? { |pod_name| target.name.start_with?(pod_name) }
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '13.0'
        puts "Setting #{target.name} to iOS 13.0"
      else
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '15.0'
      end
      
      ....

Before using the ComplyCube SDK, install the CocoaPods plugin by running the following command in your terminal:
```
sudo gem install cocoapods
```

Add plugin repos and install the pod using your Podfile:

source 'https://github.com/CocoaPods/Specs.git'
…
platform :iOS, ’13.0’

target ‘YourApp’ do
    …
  pod 'ComplyCubeMobileSDK'
end

post_install do |installer|
    installer.pods_project.targets.each do |target|
        target.build_configurations.each do |build_configuration|
            build_configuration.build_settings['ENABLE_BITCODE'] = 'NO'
            build_configuration.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
            build_configuration.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '13.1'
            build_configuration.build_settings['ARCHS'] = ['$(ARCHS_STANDARD)', 'x86_64']
            build_configuration.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = ['arm64', 'arm64e', 'armv7', 'armv7s']
            build_configuration.build_settings['GENERATE_INFOPLIST_FILE'] = 'YES'
        end
    end
end

Application permissions

Our SDK uses the device camera and microphone for capture. You must add the following keys to your application Info.plist file.

NSCameraUsageDescription

<key>NSCameraUsageDescription</key>
<string>Used to capture facials biometrics and documents</string>

NSMicrophoneUsageDescription

<key>NSMicrophoneUsageDescription</key>
<string>Used to capture video biometrics</string>

No action required.

Create a client

Every verification flow starts with a client (i.e. customer). Use the API to create the client.

This must be done on your mobile app backend server, not the mobile app itself.

Example request

curl -X POST https://api.complycube.com/v1/clients \
     -H 'Authorization: <YOUR_API_KEY>' \
     -H 'Content-Type: application/json' \
     -d '{
          "type": "person",
          "email": "john.doe@example.com",
          "personDetails":{
               "firstName": "John",
               "lastName" :"Doe"
          }
        }'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const client = await complycube.client.create({
  type: "person",
  email: "john.doe@example.com",
  personDetails: {
    firstName: "John",
    lastName: "Doe"
  }
});

from complycube import ComplyCubeClient
cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

new_client = {
    'type':'person',
    'email':'john.doe@example.com',
    'personDetails': {
        'firstName':'John',
        'lastName':'Doe'
    }
}

client = cc_api.clients.create(**new_client)

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$result = $ccapi->clients()->create([
    'type' => 'person',
    'email' => 'john@doe.com',
    'personDetails' => [
        'firstName' => 'John',
        'lastName' => 'Doe'
    ]
]);

using ComplyCube.Net;
using ComplyCube.Net.Resources.Clients;

var clientApi = new ClientApi(new ComplyCubeClient("<YOUR_API_KEY>"));
var newClient = new ClientRequest {
  type = "person",
  email = "john@doe.com",
  personDetails = new PersonDetails {
    firstName = "John",
    lastName = "Doe"
  }
}

var client = await clientApi.CreateAsync(newClient);

Example response

The response will contain an id (the Client ID). It is required for the next step.

{
    "id": "5eb04fcd0f3e360008035eb1",
    "type": "person",
    "email": "john.doe@example.com",
    "personDetails": {
        "firstName": "John",
        "lastName": "Doe"
    },
    "createdAt": "2020-01-04T17:24:29.146Z",
    "updatedAt": "2020-01-04T17:24:29.146Z"
}

See Clients API Reference to learn more.

Generate an SDK token

Your backend must create an SDK token for each new flow. This token enables customers to send personal data securely from your mobile app to ComplyCube.

Tokens are short-lived and must not be reused.

Example request

curl -X POST https://api.complycube.com/v1/tokens \
     -H 'Authorization: <YOUR_API_KEY>' \
     -H 'Content-Type: application/json' \
     -d '{
           "clientId":"CLIENT_ID",
           "appId": "com.complycube.SampleApp"
         }'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const token = await complycube.token.generate("CLIENT_ID", {
    appId: "com.complycube.SampleApp"
});

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

token = cc_api.tokens.create('CLIENT_ID', appId='com.complycube.SampleApp')

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$token = $ccapi->tokens()->generate('CLIENT_ID', 'com.complycube.SampleApp');

using ComplyCube.Net;
using ComplyCube.Net.Resources.SDKTokens;

var sdkTokenApi = new SDKTokenApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var sdkTokenRequest = {
  clientId = "CLIENT_ID",
  appId = "com.complycube.SampleApp"
}

var sdkToken = await sdkTokenApi.GenerateToken(sdkTokenRequest);

Example response

{
    "token": "<CLIENT_TOKEN>"
}

See SDK Token API Reference to learn more.

Initialize the SDK

As part of initializing the SDK, you are required to specify a workflow template ID. The SDK will automatically run the active version of the selected workflow.

import 'package:complycube_flutter/ComplyCubeMobileSDK.dart';
// ...

final settings = {
  "clientID": "<CLIENT_ID>",
  "clientToken": "<CLIENT_TOKEN>",
  "workflowTemplateId": "<WORKFLOW_TEMPLATE_ID>",
  // ...
};

return MaterialApp(
  home: Scaffold(
    appBar: AppBar(
      title: Text('ComplyCube Integration'),
    ),
    body: Column(
      children: [
        ElevatedButton(
          onPressed: () async {
            await ComplyCube.start(settings);
          },
          child: const Text('Start verification'),
        ),
      ],
    ),
  ),
);

Perform verification

Once your customer starts the flow, a workflow session is automatically created. This session contains all captured data (documents, images, and videos) as well as progress tracking. You can view all of them through the workflow sessions page on the portal or through the API.

When the flow finishes, the SDK triggers the onSuccess callback. The callback provides a data object that includes the workflowSessionId. Your mobile backend should use this ID to notify ComplyCube that the workflow has completed, which in turn runs the verification checks defined in the workflow.

If you have set up webhooks as described in our webhooks guide, you will be notified once a workflow session completes.

Example of a complete workflow session request

curl -X POST https://api.complycube.com/v1/workflowSessions/{:wfSessionId}/complete \
     -H 'Authorization: <YOUR_API_KEY>' \
     -H 'Content-Type: application/json'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const wfSession = await complycube.workflowSession.complete("WORKFLOW_SESSION_ID");

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

workflow_session = cc_api.workflowsessions.complete('WORKFLOW_SESSION_ID')

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$workflowSession = $ccapi->workflowSessions()->complete('WORKFLOW_SESSION_ID');

using ComplyCube.Net;
using ComplyCube.Net.Resources.WorkflowSessions;

var wfSessionApi = new WorkflowSessionApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var workflowSession = await wfSessionApi.CompleteAsync("WORKFLOW_SESSION_ID");

Retrieve verification results

Your mobile backend can retrieve the workflow session details and associated check results using our API.

All our checks are asynchronous. If you have set up webhooks as described in our webhooks guide, you will be notified once a check completes.

You can retrieve the details of a workflow session by calling the retrieve workflow session request.

To retrieve the check results, you can perform a get check request.

Example of a workflow session retrieval request

curl -X GET https://api.complycube.com/v1/workflowSessions/{:workflowSessionId} \
     -H 'Authorization: <YOUR_API_KEY>'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const wfSession = await complycube.workflowSession.get("WORKFLOW_SESSION_ID");

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

workflow_session = cc_api.workflowsessions.get('WORKFLOW_SESSION_ID')

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$workflowSession = $ccapi->workflowSessions()->get('WORKFLOW_SESSION_ID');

using ComplyCube.Net;
using ComplyCube.Net.Resources.WorkflowSessions;

var wfSessionApi = new WorkflowSessionApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var workflowSession = await wfSessionApi.GetAsync("WORKFLOW_SESSION_ID");

Example of a check retrieval request

curl -X GET https://api.complycube.com/v1/checks/{:checkId} \
     -H 'Authorization: <YOUR_API_KEY>'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const check = await complycube.check.get("CHECK_ID");

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

check = cc_api.checks.get('CHECK_ID')

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$check = $ccapi->checks()->get('CHECK_ID');

using ComplyCube.Net;
using ComplyCube.Net.Resources.Checks;

var checkApi = new CheckApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var check = await checkApi.GetAsync("CHECK_ID");

NFC capture

The ComplyCube mobile SDK supports NFC-based RFID chip reading for identity documents equipped with embedded chips. This allows for secure data extraction and high-assurance document authentication.

Please get in touch with your Account Manager or support to get access to our NFC-enabled Mobile SDK.

Pre-requisites

To use this feature, your app must have the Near Field Communication Tag Reading capability enabled. To add this capability to your app, refer to Apple's guide here.

Install the CocoaPods Artifactory plugin by running the following command in your terminal:
```
gem install cocoapods-art
```
To add the library, copy your repository credentials into a .netrc file to your home directory and setup the repository:
```
pod repo-art add cc-cocoapods-release-local "https://complycuberepo.jfrog.io/artifactory/api/pods/cc-cocoapods-release-local"
```
Remember to fetch your credentials from JFrog using the Set Me Up button here.

Add plugin repos and install the pod using your Podfile:

 plugin 'cocoapods-art', :sources => [
   'cc-cocoapods-release-local',
   'trunk'
 ]
 ...
 platform :ios, '13.0' # Or above

 target 'YourApp' do
   use_frameworks!
   use_modular_headers!
   ...
   pod 'ComplyCubeMobileSDK', '2.0.x-nfc'
   ...
 en

You must add the following keys to your application Info.plist file:
```
<key>NFCReaderUsageDescription</key>
<string>Required to read from NFC enabled documents</string>
```

To read NFC tags correctly, you need to add the following entries to your app target's Info.plist file:

<key>com.apple.developer.nfc.readersession.felica.systemcodes</key>
<array>
  <string>12FC</string>
</array>
<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
<array>
  <string>A0000002471001</string>
  <string>A0000002472001</string>
  <string>00000000000000</string>
  <string>D2760000850101</string>
  <string>E80704007F00070302</string>
  <string>A000000167455349474E</string>
  <string>A00000045645444C2D3031</string>
</array>

Add the following in your Runner.entitlements file:

<key>com.apple.developer.nfc.readersession.formats</key>
<array><string>TAG</string></array>

To enable NFC when building your iOS app, pass the USE_CCNFC environment variable during the build:
```
USE_CCNFC=true flutter build ios
```
To keep this enabled for all iOS builds, add the following line near the top of your ios/Podfile:
```
ENV['USE_CCNFC'] ||= 'true'
```

Start by adding your access credentials for the ComplyCube NFC-Enabled SDK repository to the gradle.properties file of your mobile app:

USE_NFC=true
artifactory_contextUrl=https://complycuberepo.jfrog.io/artifactory/cc-gradle-release
artifactory_user=<YOUR_USERNAME>
artifactory_password=<YOUR_PASSWORD>

Replace <YOUR_USERNAME> and <YOUR_PASSWORD> with your ComplyCube Artifactory credentials. If you don’t have access, contact ComplyCube Support to request credentials.

Then, update your project level build.gradle or build.gradle.kts file with the ComplyCube SDK repository Maven settings:

repositories {
    google()
    mavenCentral()
    maven {
        url project.findProperty("artifactory_contextUrl")
        credentials {
            username = project.findProperty("artifactory_user")
            password = project.findProperty("artifactory_password")
        }
    }
}

repositories {
    google()
    mavenCentral()
    maven {
        url = uri(project.findProperty("artifactory_contextUrl") as String)
        credentials {
            username = project.findProperty("artifactory_user") as String?
            password = project.findProperty("artifactory_password") as String?
        }
    }
}

Branding

You can customise colours, logos, and other branding elements through the branding settings page, if available on your plan.

Localization

The SDK supports several languages, including those listed below.

Arabic - ar 🇦🇪
Chinese (Simplified) - zh 🇨🇳
Chinese (Traditional) - hk 🇨🇳
Dutch - nl 🇳🇱
English - en 🇺🇸
French - fr 🇫🇷
German - de 🇩🇪
Hindi - hi 🇮🇳
Indonesian - id 🇮🇩
Italian - it 🇮🇹

Japanese - ja 🇯🇵
Korean - ko 🇰🇷
Norwegian - no 🇳🇴
Polish - po 🇵🇱
Portuguese - pt 🇵🇹
Spanish - es 🇪🇸
Swedish - sv 🇸🇪
Thai - th 🇹🇭
Vietnamese - vi 🇻🇳
and more...

Result handling

To run a verification session, you must implement the success, cancelled, and error callbacks.

On a successful completion (onSuccess), you can trigger a workflow session complete requests from your backend using the workflow session ID returned in the result object.

If the user exits the flow before completion, the onCancelled callback is invoked with a descriptive reason indicating why the session was cancelled (e.g. user exit, timeout, permission denied)

In some cases, the customer may cancel the flow after completing one or more capture stages. If this occurs, any data captured prior to cancellation, such as documents or biometric media, may have already been uploaded to their client record.

If the SDK encounters an issue, the onError callback is triggered with a ComplyCubeError object containing the error type and message. Refer to the error codes (see below), for a full list of possible error cases.

void onSuccess(dynamic payload) {
  /*
    Handling successful results.
    The 'results' parameter will contain: 
      - "workflowSessionId": "xxxxx"
  */
}

void onSuccess(dynamic payload) {
  /*
    Handling successful results.
    The default flow (Identity Document + Live Photo + Proof of Address)
    delivers a payload shaped like:
      {
        "documentIds":  ["xxxxx"],
        "livePhotoIds": ["xxxxx"],
        "poaIds":       ["xxxxx"],
      }
  */
}

void onCancelled(ComplyCubeCancelled event) {
  // Handle cancellations (event.code, event.reason)
}

void onError(ComplyCubeError error) {
  // Handle errors (error.code, error.message, error.details)
}

// 1. Subscribe to events once (e.g. in initState).
ComplyCube.events.listen((event) {
  if (event is ComplyCubeSuccess)   onSuccess(event.payload);
  else if (event is ComplyCubeCancelled) onCancelled(event);
  else if (event is ComplyCubeError)     onError(event);
});

// 2. Launch the flow.
ComplyCube.start(settings);

Error codes

Error Type

Description

BiometricStageCount

The configuration includes duplicate selfie photo or selfie video stages.

Cancelled

The client cancelled the flow and exited the SDK (triggered the onCancelled callback).

Connectivity

A network error has occurred.

DocumentMandatory

A document stage is required based on the configured stages but has not been included.

ExpiredToken

The SDK token has expired. Generate a new token and restart the flow.

FlowError

An unrecoverable error occurred during the flow.

InvalidCountryCode

An invalid country code was provided.

JailBroken

The SDK cannot run on this device because it has been jailbroken or compromised.

NoDiskAccess

The client denied disk access permissions required by the SDK.

NoDocumentTypes

A document stage was initialized without specifying any document types.

NoResult

No result was returned to the callback. If this persists, please contact support.

NoUserConsent

The client has not provided consent to proceed with the SDK flow.

NotAuthorized

The SDK attempted to access an endpoint it is not authorized to use.

Unknown

An unexpected error occurred. If this happens repeatedly, contact support.

UnsupportedCountryTypeCombination

The selected country and document type combination is not supported.

UnsupportedDocumentType

The provided document type is not supported.

UploadError

An error occurred while uploading a document or selfie.

UploadRequireGuidance

If useLiveCaptureOnly is set to false, guidance must be enabled by setting isGuidanceEnabled to true.

Events tracking

The SDK tracks a range of events throughout the verification flow, covering all key user interactions across stages. See below for the list of events.

If you need to implement custom analytics, you can hook into these events and trigger your own tracking logic accordingly.

To incorporate your own tracking, define a function and apply it using the onCustomEvent property when initializing the Flutter widget:

void onCustomEvent(ComplyCubeCustomEvent event) {
  switch (event.name) {
    case 'BIOMETRICS_STAGE_SELFIE_CAMERA':
      print("The client reached capture camera for a selfie");
      break;
  }
}

ComplyCubeWidget(
  settings: settings,
  onCustomEvent: onCustomEvent,
  // ...
);

Events

Event

INTRO The client reached the intro screen.

CONSENT_STAGE The client reached the consent screen.

CONSENT_STAGE_WARNING The client attempted to exit without giving consent.

CAMERA_ACCESS_PERMISSION The client reached the camera permission request screen.

DOCUMENT_STAGE_CAPTURE_GUIDANCE The client reached the document capture guidance screen.

DOCUMENT_STAGE_DOCUMENT_TYPE The client has reached the document type selection screen for a document capture.

DOCUMENT_STAGE_SELECT_COUNTRY The client reached the country selection screen for a document capture.

DOCUMENT_STAGE_ONE_SIDE_CAMERA The client reached the capture camera stage for a one-sided ID document.

DOCUMENT_STAGE_ONE_SIDE_CAMERA_MANUAL_MODE The client reached the manual camera capture screen of a one-sided ID document.

DOCUMENT_STAGE_ONE_SIDE_CHECK_QUALITY The client reached the quality preview screen for a one-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CAMERA_FRONT The client reached the camera capture screen for the front side of a two-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CAMERA_FRONT_MANUAL_MODE The client reached the manual camera capture screen for the front side of a two-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CHECK_QUALITY_FRONT The client reached the quality preview screen for the front side of a two-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CAMERA_BACK The client reached the camera capture screen for the back side of a two-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CAMERA_BACK_MANUAL_MODE The client reached the manual camera capture screen for the back side of a two-sided ID document.

DOCUMENT_STAGE_TWO_SIDE_CHECK_QUALITY_BACK The client reached the quality preview screen for the back side of a two-sided ID document.

BIOMETRICS_STAGE_SELFIE_CAPTURE_GUIDANCE The client reached the selfie capture guidance screen.

BIOMETRICS_STAGE_SELFIE_CAMERA The client reached the selfie photo capture camera screen.

BIOMETRICS_STAGE_SELFIE_CAMERA_MANUAL_MODE The client reached the manual selfie photo capture camera screen.

BIOMETRICS_STAGE_SELFIE_CHECK_QUALITY The client reached the selfie capture photo review screen.

BIOMETRICS_STAGE_VIDEO_CAMERA The client reached the video selfie camera screen.

BIOMETRICS_STAGE_VIDEO_CAMERA_MANUAL_MODE The client reached the manual capture camera screen for a video selfie.

BIOMETRICS_STAGE_VIDEO_ACTION_ONE The client reached the first action in a video selfie capture.

BIOMETRICS_STAGE_VIDEO_ACTION_TWO The client reached the second action in a video selfie capture.

BIOMETRICS_STAGE_VIDEO_CHECK_QUALITY The client reached the manual selfie video capture camera screen.

PROOF_OF_ADDRESS_STAGE_CAPTURE_GUIDANCE The client reached the proof of address capture guidance screen.

PROOF_OF_ADDRESS_STAGE_DOCUMENT_TYPE The client reached the document type selection screen for a proof of address capture.

PROOF_OF_ADDRESS_STAGE_SELECT_COUNTRY The client reached the country selection screen for a proof of address capture.

PROOF_OF_ADDRESS_STAGE_ONE_SIDE_CAMERA The client reached the capture camera stage for a one-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_ONE_SIDE_CAMERA_MANUAL_MODE The client reached the manual capture camera stage for a one-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_ONE_SIDE_CHECK_QUALITY The client has reached the quality preview screen for a one-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CAMERA_FRONT The client reached the capture camera stage for the front side of a two-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CAMERA_FRONT_MANUAL_MODE The client reached the manual capture camera stage for the front side of a two-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CHECK_QUALITY_FRONT The client reached the quality preview screen for the front side of a two-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CAMERA_BACK The client reached the capture camera stage for the back side of a two-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CAMERA_BACK_MANUAL_MODE The client reached the manual capture camera stage for the back side of a two-sided proof of address document.

PROOF_OF_ADDRESS_STAGE_TWO_SIDE_CHECK_QUALITY_BACK The client reached the quality preview screen for the back side of a two-sided proof of address document.

COMPLETION_STAGE The client has reached the completion screen.

Token expiry handling

To handle token expiration gracefully, you can provide a callback function that generates a new SDK token when needed. This allows the flow to continue seamlessly without requiring the user to restart the session manually.

String onTokenExpiry(String token) {
  // Insert custom token renewal code here
  return "<NEW_CLIENT_TOKEN>";
}

ComplyCubeWidget(
  settings: settings,
  onTokenExpiry: onTokenExpiry,
  // ...
);