light-mode-image
Learn
MobileSDKs

Getting started with the Verifier SDKs

Set up access to the MATTR Pi mDocs Verifier SDKs, configure SDK tethering, and initialize the SDK in your mobile application.

This guide walks you through the steps required to start building with the MATTR Pi mDocs Verifier SDKs. By the end, your mobile application will be ready to verify credential presentations. For the native iOS and Android Verifier SDKs, this includes tethering your application to a MATTR VII tenant. The React Native Verifier SDK is not tethered: for in-person (proximity) verification it does not require a MATTR VII tenant or platform configuration, and only needs a tenant for remote mobile (app-to-app) verification. React Native differences are called out at each step below.

Request SDK access

To access the MATTR Pi mDocs Verifier SDKs, complete the Get Started form with the following details:

  • Your organization name and contact information.
  • The platform(s) you plan to build for (iOS, Android, or React Native).
  • A brief description of your use case.

Once your request is reviewed, you will receive access to the relevant SDK packages and the MATTR Portal.

Create a MATTR VII tenant

The native iOS and Android Verifier SDKs require a MATTR VII tenant that serves as the backend for SDK operations including tethering and credential verification. For React Native, a tenant is only required for remote mobile (app-to-app) verification — in-person (proximity) verification needs no tenant. If you are building React Native for in-person verification only, you can skip this step.

  1. Log into the MATTR Portal.
  2. Create a new tenant to serve as the backend for your application.
  3. Note the tenant URL (e.g., https://your-tenant.vii.mattr.global) — you will need it when initializing the SDK.

Create a Verifier Application

SDK Tethering is required for the Verifier SDK, so you must create a Verifier Application on your MATTR VII tenant for each platform target. Tethering registers your app instances with the tenant, licenses the SDK, and lets you view registered app instances from your tenant.

For more details on SDK tethering and the capabilities it enables, see SDK Tethering.

SDK Tethering is required for the native iOS and Android Verifier SDKs. To enable it, create a Verifier Application on your MATTR VII tenant for each platform target (iOS and Android). This is a one-time setup process that registers your app with the tenant and allows app instances to obtain the necessary tokens for authentication and operation. The React Native Verifier SDK is not tethered — see the React Native tab below for when a Verifier Application is needed.

Make a request of the following structure to create an iOS Verifier Application configuration on your MATTR VII tenant:

Request
POST /v2/presentations/applications
Request body
{
    "name": "My iOS Verifier Application",
    "type": "ios",
    "bundleId": "com.yourcompany.verifierapp",
    "teamId": "YOUR_APPLE_TEAM_ID",
    "maxTimeOfflineInSecs": 864000,
    "appAttest": {
        "required": true,
        "environment": "production"
    }
}
  • name: A unique name to identify this Verifier Application.
  • type: Must be ios.
  • bundleId: The Bundle ID of your iOS app (must match your Xcode project configuration).
  • teamId: Your Apple Developer Team ID.
  • maxTimeOfflineInSecs: Maximum number of seconds the SDK can operate offline before requiring a new license token. Must be between 1 day (86400) and 30 days (2592000). Defaults to 7 days (604800).
  • appAttest: App Attest configuration for the iOS verifier application:
    • required: When true, the app instance must provide a valid App Attest attestation during registration and token renewal. When false, the app can fall back to assertion-only authentication. See Attestation vs Assertion for more details.
    • environment: The App Attest environment (development or production). Apple recommends using development for testing and production for distribution builds.

A successful response returns a 201 status code with the created Verifier Application:

Response
{
    "id": "1ef1f867-20b4-48ea-aec1-bea7aff4964c", 
    "name": "My iOS Verifier Application",
    "type": "ios",
    "bundleId": "com.yourcompany.verifierapp",
    "teamId": "YOUR_APPLE_TEAM_ID",
    "maxTimeOfflineInSecs": 864000,
    "appAttest": {
        "required": true,
        "environment": "production"
    }
}
  • id: A unique identifier for the Verifier Application (generated by the tenant). You must use this value when initializing the SDK so that it can correctly identify and authenticate your application.

Make a request of the following structure to create an Android Verifier Application configuration on your MATTR VII tenant:

Request
POST /v2/presentations/applications
Request body
{
    "name": "My Android Verifier Application",
    "type": "android",
    "packageName": "com.yourcompany.verifierapp",
    "packageSigningCertificateThumbprints": [
        "1232584B6F6A892D356899FB9576C5F226A179E6199F2B7A1D837B5C234C5A8E"
    ],
    "maxTimeOfflineInSecs": 864000,
    "keyAttestation": {
        "required": true
    }
}
  • name: A unique name to identify this Verifier Application.
  • type: Must be android.
  • packageName: The package name of your Android application.
  • packageSigningCertificateThumbprints: SHA-256 hex-encoded fingerprints of the signing key certificates used to sign your APK or app bundle. This ensures the tenant only accepts requests from known and trusted applications. Refer to Android app signing for more information.
  • maxTimeOfflineInSecs: Maximum number of seconds the SDK can operate offline before requiring a new license token. Must be between 1 day (86400) and 30 days (2592000). Defaults to 7 days (604800).
  • keyAttestation: Key Attestation configuration for the Android verifier application:
    • required: When true, the app instance must provide a valid Key Attestation during registration and token renewal. When false, the app can register and renew tokens using just an authentication assertion. See Attestation vs Assertion for more details.

A successful response returns a 201 status code with the created Verifier Application:

Response
{
    "id": "a82bfa46-72a0-4cde-b6cb-2a0de7e2f3c4", 
    "name": "My Android Verifier Application",
    "type": "android",
    "packageName": "com.yourcompany.verifierapp",
    "packageSigningCertificateThumbprints": [
        "1232584B6F6A892D356899FB9576C5F226A179E6199F2B7A1D837B5C234C5A8E"
    ],
    "maxTimeOfflineInSecs": 864000,
    "keyAttestation": {
        "required": true
    }
}
  • id: A unique identifier for the Verifier Application (generated by the tenant). You must use this value when initializing the SDK so that it can correctly identify and authenticate your application.

SDK Tethering does not apply to the React Native Verifier SDK. You only need to create a Verifier Application if you use remote mobile (app-to-app) verification, where the application id is passed to requestMobileCredentials per request — not at initialization. For in-person (proximity) verification with React Native, no Verifier Application or platform configuration is required.

If you use remote mobile (app-to-app) verification, create a Verifier Application for each platform you target by following the iOS and Android tabs above. You then pass the matching application id to requestMobileCredentials at runtime, selecting it based on Platform.OS:

Example
import { Platform } from "react-native";

const verifierApplicationId =
  Platform.OS === "ios"
    ? "YOUR_IOS_VERIFIER_APPLICATION_ID"
    : "YOUR_ANDROID_VERIFIER_APPLICATION_ID";
  • YOUR_IOS_VERIFIER_APPLICATION_ID : The id returned when you created the iOS Verifier Application.
  • YOUR_ANDROID_VERIFIER_APPLICATION_ID : The id returned when you created the Android Verifier Application.

Initialize the SDK

SDK Tethering is required for the native iOS and Android Verifier SDKs, so you must initialize them with a platform configuration once your Verifier Applications are created. This connects your app to the correct MATTR VII tenant and Verifier Application, registers the app instance, and obtains the license the SDK needs to operate. The React Native Verifier SDK is not tethered and can be initialized without any options for in-person verification — see the React Native tab below.

Initialize the SDK with your platform configuration. The initialize method is asynchronous, so call it from an asynchronous context:

Initialization
let platformConfig = PlatformConfiguration(
    tenantHost: URL(string: "https://your-tenant.vii.mattr.global")!,
    applicationId: "1ef1f867-20b4-48ea-aec1-bea7aff4964c"
)
try await MobileCredentialVerifier.shared.initialize(
    platformConfiguration: platformConfig
)
  • tenantHost: The URL of your MATTR VII tenant. This must be the tenant where your iOS Verifier Application is configured.
  • applicationId: The id of your configured iOS Verifier Application.

Initialize the SDK with your platform configuration:

Initialization
val platformConfig = PlatformConfiguration(
    tenantHost = URL("https://your-tenant.vii.mattr.global"),
    applicationId = "1ef1f867-20b4-48ea-aec1-bea7aff4964c"
)
MobileCredentialVerifier.initialize(context, platformConfig)
  • tenantHost: The URL of your MATTR VII tenant where your Android Verifier Application is configured.
  • applicationId: The id of your configured Android Verifier Application.

The React Native Verifier SDK is not tethered, so initialization does not register an app instance or require an applicationId. You can initialize without any options for in-person (proximity) verification:

Initialization
import { initialize } from "@mattrglobal/mobile-credential-verifier-react-native";

const result = await initialize();

if (result.isErr()) {
    console.error("Failed to initialize SDK:", result.error);
}

If you use remote mobile (app-to-app) verification, pass a platformConfiguration with your tenant host. The tenantHost is the only field, and it is required for requestMobileCredentials:

Initialization (remote mobile)
const result = await initialize({
    platformConfiguration: {
        tenantHost: "https://your-tenant.vii.mattr.global",
    },
});

if (result.isErr()) {
    console.error("Failed to initialize SDK:", result.error);
}

The verifier application id is passed per request to requestMobileCredentials, not at initialization. See the remote mobile verification tutorial for details.

Next steps

Your application is now initialized and tethered to your MATTR VII tenant, ready to verify credentials. Explore the following guides to start building:

How would you rate this page?

Last updated on

On this page