Mobile SDKs (Android and iOS)

The aim of this topic is to help a developer integrating with the Assure API using VideoID's native mobile SDKs. This is a more detailed description of Use case 2 in the Integration guide.

Using the VideoIDs native SDKs means that the end-user will see Signicat VideoID's user interface when performing the identity verification on their mobile. For more information about the identity verification steps seen from the end user, see the About page.

Documentation scope

Please, keep in mind that the following descriptions do not contain all the necessary steps for production mode. In addition, you must add validations, tests and error handling, which is outside the scope of this documentation.

Before you start the SDK integration, we recommend to familiarise yourself with the general steps for integrating with the Assure API.

Requirements

Before you start the SDK integration, you should be aware of the following requirements for VideoID's mobile SDKs:

• We advise you to always use the latest VideoID SDK version:
  • Android: API level 24, Android 7
  • iOS: 10.0 and higher
• Check the supported device versions:
  • Android: 4.0 or later
  • iPhone: 5S or higher
• The app needs camera and microphone permission.
• Your app must always communicate with your own server and never directly with the Assure API (see Usage recommendations).
• Since you are integrating with the Assure API in a native app context, you should choose the eIDV generic flow.

Integration steps overview

The next sections describe all the necessary steps, including the integration with Assure before and after the VideoID SDK integration in step 3:

1. Create a dossier.
2. Create a process.
3. Integrate with the VideoID native mobile SDK to check the ID document, facial similarity and liveness.
4. Start verification.
5. Get result.

Note:

All the steps are similar for iOS and Android except the SDK integration in step 3, which is described below in for iOS and Android.

1. Create a dossier

Use the Create dossier endpoint to create a placeholder for all of your end-user's data:

curl -X POST \
  <ENVIRONMENT>/assure/dossiers \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer eyJh ... QifQ.eyJ ... hIOw' \
  -H 'Content-Type: application/json' \

Save the dossierId from the response body to use in the next requests.

Note

Ensure you use one dossier per end-user.

View the dossier contents

After creating a dossier, you can see all of its contents anytime you want to. To do that, use the Get dossier endpoint giving it the dossierId.

2. Create a process

To be able to create a process, you need to get some information from your mobile app, send it to your backend server and afterwards to the Assure API.

Here is an example request:

{
  "provider": "signicatvideoid",
  "processType": "substantialFullyAuto",
}

processType

The value depends on the checks you want to perform. You can choose between:

• high: A human agent will review the identity verification video asynchronously.
• substantialFullyAuto: Process verification is done automatically, meaning no human agent is involved.This is similar to substantial, but without any inconclusive status. This is the recommended process type (see more details on the About page)
• substantial: Process verification is done automatically, meaning no human agent is involved.

Here is a example response for Create process:

{
    "processId": "7a3a6648-4c8b-421f-a8c3-843677c3d398",
    "provider": "eid",
    "processType": "substantialFullyAuto",
    "status": "pending",
    "authorization": "IR3kAtY6-GDS0dBG-a3MAtVkIEZl4lOH5DEc2HJzSYytV57xGn3Ixa9wJLhV9Tt2_OxjCD3EOUpZTX7Dj-IeSacMpY_XhMWhv6iVIcSz9l8=",
    "providerApiUrl": "https://etrust-live.electronicid.eu/v2",
    "createdAt": "2025-11-14T11:48:36Z",
    "updatedAt": "2025-11-14T11:48:36Z"
}

Save the information from the response. You will need it in the next steps.

3. Integrate with the VideoID native mobile SDKs

To start the identity verification user flow, you must now integrate with the VideoID SDK for either Android or iOS:

Android

Import the SDK

The SDK is distributed as an .aar package from a public repository. Add the repository to your project's build.gradle file:

allprojects {
    repositories {
        maven { url "https://repo.electronicid.eu/repository/android-sdk-releases/" }
    }
}

Then, add the dependency:

dependencies {
    implementation 'eu.electronicid.android:sdk:1.+'
}

Initialise and run the SDK (Kotlin example)

You must send the authorization field that you received in the backend response to the mobile app.

To integrate the VideoID service, launch the VideoIDActivity. The result of the identification will be returned in the onActivityResult method.

// In a button click listener, for example
val intent = Intent(this, VideoIDActivity::class.java).apply {
    putExtra(
        VideoIDActivity.ENVIRONMENT,
        Environment(URL("https://<your_signicat_environment>/"), authorizationToken)
    )
    putExtra(VideoIDActivity.LANGUAGE, "en") // e.g., "es", "fr", "de"
}
startActivityForResult(intent, REQUEST_CODE)

// Handle the result
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {
            val videoId = data?.getStringExtra(VideoIdServiceActivity.RESULT_OK)
            // Process successful verification
        } else if (resultCode == Activity.RESULT_CANCELED) {
            val errorId = data?.getStringExtra(VideoIdServiceActivity.RESULT_ERROR_CODE)
            val errorMsg = data?.getStringExtra(VideoIdServiceActivity.RESULT_ERROR_MESSAGE)
            // Handle error
        }
    }
}

Proguard

If you use Proguard (minifyEnabled = true), add the following rules to your proguard file:

-keep class eu.electronicid.sdk.modules.api.model.** { *; }
-keep class eu.electronicid.sdk.domain.model.terms.** { *; }
-keep class eu.electronicid.sdk.domain.model.videoid.event.** { *; }
-keep class eu.electronicid.sdk.domain.model.errorreport.** { *; }
-keep class eu.electronicid.sdk.domain.model.scan.** { *; }
-keep class eu.electronicid.sdk.domain.model.Rectangle { *; }
-keep class eu.electronicid.sdk.domain.model.Size { *; }
-keep class eu.electronicid.sdk.h264encoder.X264Encoder { *; }
-keep class eu.electronicid.sdk.yuvutils.YuvUtils { *; }
-keep class eu.electronicid.sdk.videoid.model.** { *; }
-keep class eu.electronicid.sdk.videoid.control.model.** { *; }
-keep class eu.electronicid.sdk.videoid.control.communication.** { *; }
-keep class eu.electronicid.sdk.videoid.adhoc.model.FrameCaptureStart { *; }
-keep class eu.electronicid.sdk.videoid.webrtc.model.* { *; }
-keep class org.webrtc.**  { *; }
-keep class eu.electronicid.sdk.discriminator.api.model.Bandwidth { *; }
-keep class eu.electronicid.sdk.domain.model.Protocol { *; }

Verifying system requirements

The SDK provides a function to verify that the user's device meets all requirements, such as camera compatibility and network speed.

CheckRequirements.getInstance(this).checkVideoID(endpoint) { result ->
    if (result.passed) {
        // Requirements are met. Proceed with VideoID.
    } else {
        // Minimum requirements are not met. Fallback to an alternative.
    }
}

iOS

Import the SDK

You can integrate the VideoID SDK using Swift Package Manager: In your Xcode project, go to File > Add Packages and enter the repository URL: https://github.com/signicat/videoidskd-spm

Permissions

You must add keys to your app's Info.plist file for camera and microphone access, including a description of why your app needs them.

• Privacy - Camera Usage Description
• Privacy - Microphone Usage Description

Initialise and run the SDK (Swift)

Present the VideoIDSDKViewController modally. You will need the authorization token obtained from your backend.

import VideoIDSDK

// ... inside your ViewController

func startVideoID() {
    let environment = VideoIDSDK.SDKEnvironment(url: yourEndpointURL, authorization: authorizationToken)
    let videoIDVC = VideoIDSDK.VideoIDSDKViewController(
        environment: environment,
        docType: 0, // Optional: Specify document type
        language: "en", // Optional: e.g., "es", "fr"
        idDefault: "", // Optional: Specify default country
        biometricConsent: true
    )
    videoIDVC.modalPresentationStyle = .fullScreen
    videoIDVC.delegate = self
    self.present(videoIDVC, animated: true, completion: nil)
}

// MARK: - VideoIDDelegate
extension ViewController: VideoIDDelegate {
    func onComplete(videoID: String) {
        // Process successful verification
        print("VideoID: \(videoID)")
    }

    func onError(_ error: VideoIDSDK.VideoIDError) {
        // Handle error
        print("VideoID Error: \(error.localizedDescription)")
    }
}

Verifying system requirements

The iOS SDK also includes a function to verify system requirements before starting the flow.

VideoIDSDK.CheckRequirements().check(url: self.endpoint, service: .videoID, eager: false) { (checkResult) in
    DispatchQueue.main.async {
        if checkResult.passed {
            // Proceed with VideoID
        } else {
            // Handle unmet requirements
        }
    }
}

4. Start verification

Your server (backend) must request the Assure API to start performing the identity verification.

To do this, you just call the Start verification endpoint. No parameters are necessary.

5. Get result

After VideoID has analysed the images/videos, VideoID will send a callback to Assure API with the result.

Assure Events

It is recommended to subscribe to Assure Events to be notified when the result is available (either successfully or not). For more information, see Assure Events.

You can call the Get process endpoint to get the full information about the process.

For result examples, see Service Details for VideoID > Get process.

Download full result

You can also get a zip file with the packaged process by calling the Download full result endpoint.