Skip to content

IDLive Face Plus → MiSnap Facial Capture Migration Guide

Overview

This guide covers migrating facial capture with IAD on iOS from IDLive Face Plus 2.6.0 → MiSnap 5.12.0

The IAD Server does not change — only the iOS capture client changes. Upload remains POST /check_capture_liveness with a binary IAD bundle.

For detailed parameter and API mapping, see API mapping reference.

Prerequisites

  • MiSnap license — obtain from your Mitek representative and register your app's bundle ID in the license
  • MiSnap SDK access — Swift Package Manager or manual integration from MiSnap-iOS
  • IAD Server — base URL and encryption key (see custom encryption key)
  • Client/server compatibility — confirm versions before production (see API mapping § Server)
  • iOS 13.0+ — same minimum as IDLive Face Plus 2.6.0

Migration checklist

Step Area Changes?
1 Dependencies Yes — swap xcframeworks / SPM packages
2 License Yes
3 Capture configuration Yes
4 Present + delegate + IAD bundle Yes
5 Server upload No — same POST /check_capture_liveness

Step 1 — Dependencies

Installation methods

Method Facial capture IAD
SPM MiSnapFacialCapture, MiSnapFacialCaptureUX MiSnapIAD
Manual MiSnapCore, MiSnapAssetManager, MiSnapFacialCapture, MiSnapFacialCaptureUX MiSnapIAD, IADCommon

Repository: https://github.com/Mitek-Systems/MiSnap-iOS.git

Remove IDLive Face Plus frameworks from your project:

  • IDLiveFaceCamera.xcframework
  • IDLiveFaceDetection.xcframework
  • IDLiveFaceIAD.xcframework

Add MiSnap frameworks, link + embed (Embed & Sign):

MiSnapCore.xcframework
MiSnapAssetManager.xcframework
MiSnapIAD.xcframework
IADCommon.xcframework
MiSnapFacialCapture.xcframework
MiSnapFacialCaptureUX.xcframework

Add UX strings to Copy Bundle Resources (required at runtime). The MiSnap SDK ships MiSnapFacialCaptureLocalizable.strings — add it from your MiSnap SDK distribution to your app target's Copy Bundle Resources build phase (one .lproj folder per language you support).

Bundle ID: Register your app's bundle ID in your MiSnap license before you run or ship.

IAD minimum iOS: 13.0+ (same as IDLive Face Plus).

Troubleshooting: If aiBasedRtsEnabled = true but MiSnapIAD / IADCommon is not linked, the SDK raises an exception when capture is configured or presented. Add MiSnapIAD (SPM) or IADCommon.xcframework (manual) — see the Add list above.


Step 2 — Set license (setLicense)

IDLive Face Plus:

import IDLiveFaceCamera
import IDLiveFaceDetection

let licenseKey = "<your IDLive license key>"

func setLicense() {
    do {
        try IDLFDLicense.setLicense(licenseKey)
    } catch {
        print("IDLFD license error: \(error)")
    }

    do {
        try License.setLicense(licenseKey, licenseType: .faceDetector)
    } catch {
        print("IDLiveFaceDetector set license error: \(error)")
    }
}

MiSnap:

import MiSnapCore

let licenseKey = "<your MiSnap license key>"

func setLicense() {
    MiSnapLicenseManager.shared.setLicenseKey(licenseKey)
}

Replace placeholder keys with your own licenses.


Step 3 — Configure capture

IDLive Face Plus — mutates IDCameraController after instantiate:

private func configureCapture(_ controller: IDCameraController) {
    controller.prepareForIAD()
    controller.captureMode = yourCaptureMode  // .auto or .manual
    controller.allowToPreviewBeforeSending = true
    //...
}

MiSnap — returns configuration before instantiate:

private func configureCapture() -> MiSnapFacialCaptureConfiguration {
    MiSnapFacialCaptureConfiguration()
        .withCustomParameters { parameters in
            parameters.aiBasedRtsEnabled = true
            parameters.mode = yourCaptureMode  // .auto or .manual
            parameters.aiBasedRtsEncryptionKey = yourBase64DERPublicKey
        }
        .withCustomUxParameters { uxParameters in
            uxParameters.showReviewScreen = true
        }
        //...
}

Set yourBase64DERPublicKey to the base64 DER public key from your IAD Server encryption configuration. If omitted, the SDK uses a built-in default — liveness will fail until the key matches your server.

!!! warning "Breaking default: payload size" IDLive Face Plus 2.6.0 defaults to .normal when payloadSize is omitted. MiSnap defaults to .small. Set aiBasedRtsPayloadSize explicitly if you relied on IDLive defaults. See Payload size and API mapping § IAD bundle.

Sample-relevant mappings: prepareForIAD() → aiBasedRtsEnabled = true; captureMode → parameters.mode. For auto_and_manual, payload size, review screen, landmarks, and other tuning, see API mapping reference.


Step 4 — Present capture + handle result

Present

IDLive Face Plus

IDCameraController.requestAccess { ... }
let controller = IDCameraController.instantiate()
controller.delegate = self
configureCapture(controller)
present(controller, animated: true)

MiSnap:

MiSnapFacialCaptureViewController.checkCameraPermission { granted in
    DispatchQueue.main.async {
        guard granted else {
            // Show permission-denied UI
            return
        }
        let configuration = configureCapture()
        let controller = MiSnapFacialCaptureViewController(with: configuration, delegate: self)
        present(controller, animated: true)
    }
}

The permission callback may run off the main thread — UIKit presentation must be on the main queue.

Delegate

Replace IDCameraControllerDelegate with MiSnapFacialCaptureViewControllerDelegate. Implement miSnapFacialCaptureSuccess, miSnapFacialCaptureCancelled, and miSnapFacialCaptureLicenseStatus (required). With default uxParameters.autoDismiss = true, the SDK dismisses capture after success, cancel, or invalid license. If autoDismiss = false, you must dismiss the capture view controller yourself — the SDK calls miSnapFacialCaptureShouldBeDismissed() instead.

Full IDLive ↔ MiSnap callback mapping, optional delegates, and IQA behavior: API mapping § Delegate mapping.

Handle capture success

In the delegate success callback, extract the IAD bundle and POST it to your server (Step 5). The snippets below show only the SDK-specific parts.

Extract IAD bundle

IDLive Face Plus — in cameraController(_:didCaptureImage:) (IDCameraControllerDelegate):

func cameraController(_ controller: IDCameraControllerBase, didCaptureImage image: IDImage) {
    let iadBundle: Data
    if let keyData = yourEncryptionKeyData {  // DER Data from server config
        iadBundle = try controller.createIADBundle(key: keyData)
    } else {
        iadBundle = try controller.createIADBundle()  // IDLive library default when no custom key
    }
    // POST iadBundle to /check_capture_liveness (Step 5)
}

Configure yourEncryptionKeyData from your IAD Server encryption configuration, or leave it unset to use the IDLive library default. See API mapping § IAD bundle for the MiSnap equivalent.

MiSnap — in miSnapFacialCaptureSuccess(_:) (MiSnapFacialCaptureViewControllerDelegate):

func miSnapFacialCaptureSuccess(_ result: MiSnapFacialCaptureResult) {
    guard
        let aiBasedRts = result.aiBasedRts,
        let iadBundle = Data(base64Encoded: aiBasedRts)
    else { ... }
    // POST iadBundle to /check_capture_liveness (Step 5)
}

Step 5 — Submit for liveness

Server contract unchanged. Your backend still accepts POST /check_capture_liveness with Content-Type: application/octet-stream and the raw IAD bundle bytes.

See check_capture_liveness for the endpoint specification.

MiSnap-specific step: decode result.aiBasedRts (base64 String) to Data before upload:

var request = URLRequest(url: URL(string: "\(livenessServerURL)/check_capture_liveness")!)
request.httpMethod = "POST"
request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
request.httpBody = iadBundle
// Send request; parse capture_liveness.probability from the JSON response

Use HTTPS in production. For local development over HTTP, configure App Transport Security in your app's Info.plist (for example, NSAllowsLocalNetworking for local network hosts).

Endpoint, response shape, and compatibility notes: API mapping § Server.


Verify your migration

  1. License valid — capture UI opens with no miSnapFacialCaptureLicenseStatus error
  2. Capture flow — auto and manual modes behave as expected
  3. IAD bundle — bundle extracts successfully and POST /check_capture_liveness returns capture_liveness.probability
  4. Encryption — if you use a custom key, liveness passes (does not fail silently due to a key mismatch)
  5. Regression — compare behavior with your previous IDLive integration (review screen, timeout, localization)

Troubleshooting

Symptom Likely cause Fix
Exception when configuring or presenting capture with aiBasedRtsEnabled = true MiSnapIAD / IADCommon not linked Add MiSnapIAD (SPM) or IADCommon.xcframework (manual) — see Step 1
Capture UI does not appear or crashes on present Permission callback used off main thread Present on DispatchQueue.main — see Step 4
Liveness fails after successful capture Payload size or encryption key mismatch Set aiBasedRtsPayloadSize explicitly; align aiBasedRtsEncryptionKey with server config
Data(base64Encoded:) returns nil Invalid or empty result.aiBasedRts Confirm aiBasedRtsEnabled = true and capture completed successfully
miSnapFacialCaptureLicenseStatus fires immediately Invalid license or unregistered bundle ID Verify license key and register your app's bundle ID with Mitek
Missing on-screen strings UX strings not in app bundle Add MiSnapFacialCaptureLocalizable.strings to Copy Bundle Resources — see Step 1