Mobile SDKs
With Verify, you can run backend-defined identity proofing journeys in your mobile application using a single Signicat-orchestrated mobile SDK flow.
Verify lets you set up an end-user's identity verification process from one backend-created session. Your backend system then creates the session, your mobile application launches the SDK with session-scoped values, and the SDK runs the identity verification process returned by Signicat.
During the identity verification, the SDK owns the native end-user flow. It fetches the session from Signicat, presents a hosted shell, starts each required step in order, synchronises progress with the backend, and returns control to your application when the process completes or encounters a terminal error.
Verify does not require your app to configure the end-user identity verification process directly. The process is resolved from the backend session and handled by the SDK.
How it works
The Verify flow has two main parts:
- Backend integration: Your backend system authenticates with Signicat, configures the verification profile, and creates a time-limited, session-scoped SDK token.
- Mobile SDK integration: The SDK consumes the session credentials and runs the hosted UI flow natively on the end-user's mobile device.
Here is a typical flow:
- Your backend system authenticates with Signicat.
- Your backend system creates an identity verification session for the end-user.
- Your backend system returns the
sessionIdandsdkTokento your mobile app. - Your mobile app starts the SDK with the session values.
- The SDK fetches the session from the Verify backend system.
- The SDK presents the hosted shell and waits for the user to start.
- The SDK runs each backend-defined step in order.
- The SDK reports step status and reads intermediate results when required.
- The SDK completes successfully or returns an SDK error.
- Your app or backend system checks the final session status.
Before you start
Before integrating the client SDKs, ensure you have:
- An active Signicat account with access to the Verify product.
- Registered API client credentials (
client_idandclient_secret) with appropriate permissions. - A secure backend service capable of requesting OAuth tokens and communicating with your client app.
For full API onboarding instructions, see the Connect to Signicat APIs guide.
Best practices
When setting up the complete flow, we recommend that you:
- Create the sessions in your backend system.
- Keep Signicat API client credentials out of the mobile app.
- Ensure your mobile app always communicates through your own server and never directly with the Verify API.
- Pass only session-scoped SDK values to the mobile app.
- Present the SDK as one full-screen validation flow.
- Keep the SDK presentation alive until completion or failure.
- Handle cancellation and provider failures explicitly.
- Query the backend after SDK completion to determine the final status.
Backend session setup
All Verify mobile flows (Android and iOS) require a valid sessionId and sdkToken generated by your backend system.
Never store or embed Signicat API client secrets within client-side mobile applications.
At a high level, your backend should:
- Request an access token from Signicat with
grant_type=client_credentialsandscope=signicat-api. - Select the profile or configuration that should be used for the end-user.
- Create a session token for the native SDK flow.
- Return only the SDK session values to the mobile app.
1. Retrieve an access token
Obtain a bearer token using the client credentials you received when connecting to the Signicat API (see Before you start):
POST https://<SIGNICAT_API_BASE_URL>/auth/open/connect/token
Content-Type: application/x-www-form-urlencoded
grant_type=client_credentials&
scope=signicat-api&
client_id=<CLIENT_ID>&
client_secret=<CLIENT_SECRET>
2. Inspect available profiles (optional)
Verify your available profiles:
GET https://<SIGNICAT_API_BASE_URL>/id-proofing/verify/plans/<PLAN_ID>/profiles
Authorization: Bearer <ACCESS_TOKEN>
Accept: application/json
3. Create a session token
The backend system should request an SDK session token scoped to the user's platform, either native (for native mobile apps) or web (for web content). Currently, only native is supported:
Your mobile app must always communicate through your own server and never directly with the Verify API.
POST https://<SIGNICAT_API_BASE_URL>/id-proofing/verify/sessions/token
Authorization: Bearer <ACCESS_TOKEN>
Content-Type: application/json
Accept: application/json
{
"profileId": "<PROFILE_ID>",
"platform": "<PLATFORM>",
"reference": "<YOUR_REFERENCE>"
}
Example response
Example response:
{
"sessionId": "<SESSION_ID>",
"sdkToken": "<SDK_TOKEN>"
}
Transmit sessionId and sdkToken securely to your mobile application.
The sdkToken is scoped to the SDK session. It is not the same as your backend API access token.
Common platform behaviour for the Android and iOS SDKs
Verify is designed as a shared product flow across mobile platforms. Platform-specific SDKs should expose the same product behaviour:
- Start one backend-created session.
- Keep the SDK-owned shell active for the full local validation flow.
- Run backend-defined steps in an ordered sequence.
- Return one completion result to the app.
- Leave final case status checks to the backend or a later API call.
Application metadata and analytics
During an identity proofing session, the SDK collects operational telemetry to support monitoring and troubleshooting.
No Personally Identifiable Information (PII) is logged.
To ensure your application is properly identified in analytics, the SDK automatically resolves your host app's name and version from your project configuration:
- Application name:
- iOS: Retrieved from
CFBundleDisplayName(display name in Xcode /Info.plist), falling back toCFBundleName(product name) if omitted or blank. - Android: Retrieved from
applicationInfo.loadLabel(packageManager)(android:labelon<application>inAndroidManifest.xml), falling back topackageName(applicationId) if blank.
- iOS: Retrieved from
- Application version:
- iOS: Retrieved from
CFBundleShortVersionString(marketing version in Xcode, e.g.1.2.0). - Android: Retrieved from
PackageInfo.versionName(versionNamein Gradle, e.g.1.2.0).
- iOS: Retrieved from
- Since the SDK resolves the user-facing display label (
CFBundleDisplayNameon iOS andandroid:labelon Android), make sure both platforms use the exact same name. - Avoid translating the application name if you want your iOS and Android traffic grouped under the same application in analytics.
Language
The following languages are supported across the SDK shell:
ennlesfrde
When you provide a supported language code, the SDK-owned shell and end-user identity verification steps use that language. When you provide an unsupported custom code, the SDK falls back to English. When you omit the language, the SDK uses the first supported device preferred language, then English.
Terminal state and final verification
A successful or finished SDK result indicates that the end-user completed all the required steps (e.g., photo capture, document scanning, NFC read). It does not guarantee that the user's identity is approved.
Some downstream checks can continue asynchronously after the native flow has completed. After the SDK returns successfully, your app or backend system should query the relevant Verify backend status to determine the session result.
Error handling
Each platform SDK reports validation failures through its native error model. The error surface should let the app distinguish between user cancellation, SDK setup or runtime failures, and downstream provider failures.
The SDK allows only one active validation at a time. If your app starts a second validation while another validation is still running, the second call fails with an SDK error.
Next step: Mobile native app integrations
Select the relevant SDK guide below to begin the native mobile app integration for Android and iOS: