IDV & Biometrics

Introduction

FrankieOne’s Identity Verification (IDV) and Biometrics services offer a comprehensive and secure solution for verifying user identities. By combining advanced document verification with cutting-edge biometric authentication, these services enable businesses to establish trust, enhance security, and meet stringent Know Your Customer (KYC) compliance requirements.

This guide provides an overview of FrankieOne’s IDV and Biometrics capabilities, highlighting their key features and offering step-by-step instructions for seamless integration using the FrankieOne API and OneSDK.

Key Features

• Global Document Verification: Validate a wide range of government-issued identity documents, including passports, driver’s licenses, and national ID cards, from around the world.
• Biometric Authentication: Strengthen fraud prevention with advanced biometric technologies, such as facial recognition and liveness detection, ensuring a secure and user-friendly experience.
• Real-time Results: Receive fast and accurate verification outcomes, enabling efficient onboarding and decision-making processes.
• Customizable Workflows: Adapt verification processes to align with your organization’s risk policies, compliance standards, and user experience goals.
• Data Security and Privacy: Ensure the highest level of data protection with FrankieOne’s adherence to industry-leading security practices and privacy regulations.
• Streamlined Integration: Simplify the implementation of IDV and Biometrics workflows with the FrankieOne OneSDK, offering pre-built components and robust APIs for web and mobile platforms.

IDV Process

The Identity Verification (IDV) process is a multi-step workflow designed to authenticate a user’s identity by verifying their personal information and documents. Below are the key steps involved in the IDV process:

1. User Registration: The user provides their personal details during registration on your platform.
2. Document Submission: The user uploads a government-issued identity document, such as a passport or driver’s license, for verification.
3. Document Analysis: The uploaded document undergoes Optical Character Recognition (OCR) and other validation checks to confirm its authenticity and extract relevant data.
4. Biometric Capture: The user captures a selfie or live photo for biometric verification.
5. Facial Comparison: The captured biometric data is compared with the photo on the submitted document to ensure the user’s identity matches.
6. Verification Outcome: The user is notified of the verification result, whether successful or requiring additional steps.
7. Secure Data Storage: Verified data is securely stored in compliance with privacy and security standards for future reference.

Biometrics Process

The biometrics process focuses on capturing and verifying a user’s unique biometric data to enhance security and prevent fraud. Here are the key steps involved:

1. Biometric Data Capture: The user captures their biometric data, such as a fingerprint or facial image, using a compatible device.
2. Data Encryption: The captured biometric data is encrypted to ensure its security during transmission.
3. Data Transmission: The encrypted biometric data is securely transmitted to the server for processing.
4. Biometric Matching: The transmitted biometric data is compared against stored biometric records to verify the user’s identity.
5. Verification Outcome: The user is informed of the verification result, whether successful or requiring further action.
6. Secure Data Storage: Verified biometric data is securely stored in compliance with data protection regulations for future use.

By combining IDV and biometrics, you can create a robust identity verification process that enhances security, improves user experience, and ensures compliance with regulatory requirements.

Integrating With OneSDK

The FrankieOne SDK is the recommended solution for integrating IDV and Biometrics services into your application. Designed to simplify the implementation process, the SDK abstracts the complexities of API interactions, providing a streamlined and efficient way to access FrankieOne’s identity verification capabilities. Available for both web and mobile platforms, the SDK includes pre-built components and APIs that enable developers to quickly and securely implement IDV and Biometrics workflows.

Why Use the FrankieOne SDK?

• Simplified Integration: The SDK eliminates the need for direct API calls, reducing development time and effort.
• Seamless User Experience: Pre-built UI components ensure a consistent and intuitive user journey for document capture and biometric authentication.
• Enhanced Data Accuracy: Optimized workflows for capturing high-quality document images and biometric data improve verification success rates.
• Robust Error Management: Built-in error handling and reporting mechanisms simplify troubleshooting and enhance reliability.
• Continuous Updates and Support: The SDK is actively maintained by FrankieOne, ensuring compatibility with the latest features and security standards.

Steps to Integrate the FrankieOne SDK:

1. Install the SDK: Follow the installation instructions provided in the SDK Documentation to add the SDK to your project.
2. Initialize the SDK: Configure the SDK with your FrankieOne API credentials and any required settings. Refer to the documentation for platform-specific initialization details.
3. Start the Verification Process: Use the SDK’s methods to initiate the IDV and Biometrics workflows, specifying the required verification types and user context.
4. Guide User Interaction: Leverage the SDK’s built-in UI components to guide users through document capture and biometric authentication steps.
5. Track Progress: Monitor the verification process using the SDK’s event listeners or callbacks to handle status updates and results.
6. Process Results: Once verification is complete, retrieve the results from the SDK and integrate them into your application’s business logic.

By using the FrankieOne SDK, you can ensure a secure, efficient, and user-friendly implementation of IDV and Biometrics services, allowing you to focus on delivering value to your users.

Implementation Steps

1. Obtain a Session Token: Securely fetch a session token from the FrankieOne backend before initializing OneSDK. This involves making a POST request to the authentication endpoint using your CUSTOMER_ID and API_KEY. Ensure this step is performed server-side to protect your API credentials.

   1
   import fetch from 'node-fetch';
   2
   3
   const CUSTOMER_ID = 'YOUR_CUSTOMER_ID';
   4
   const API_KEY = 'YOUR_API_KEY';
   5
   const AUTH_ENDPOINT = 'https://backend.kycaml.uat.frankiefinancial.io/auth/v2/machine-session';
   6
   7
   async function fetchSessionToken() {
   8
     try {
   9
       const response = await fetch(AUTH_ENDPOINT, {
   10
         method: 'POST',
   11
         headers: {
   12
           authorization: 'machine ' + Buffer.from(`${CUSTOMER_ID}:${API_KEY}`).toString('base64'),
   13
           'Content-Type': 'application/json',
   14
         },
   15
         body: JSON.stringify({
   16
           permissions: {
   17
             preset: 'one-sdk',
   18
             reference: "your-unique-customer-reference",
   19
           },
   20
         }),
   21
       });
   22
   23
       if (!response.ok) {
   24
         console.error('Failed to fetch session token:', response.status);
   25
         return null;
   26
       }
   27
   28
       return await response.json();
   29
     } catch (error) {
   30
       console.error('Error fetching session token:', error);
   31
       return null;
   32
     }
   33
   }

2. Initialize OneSDK: Use the session token to initialize OneSDK in your application. Configure the SDK with the desired mode (e.g., sandbox or production) and any specific settings, such as OCR or biometric options.

   1
   import OneSDK from '@frankieone/one-sdk';
   2
   3
   async function initializeOneSdk() {
   4
     const sessionTokenResult = await fetchSessionToken();
   5
   6
     if (sessionTokenResult && sessionTokenResult.session) {
   7
       const oneSdk = await OneSDK({
   8
         session: sessionTokenResult,
   9
         mode: "production",
   10
         recipe: {
   11
           ocr: {
   12
             maxDocumentCount: 3,
   13
           },
   14
         },
   15
       });
   16
       return oneSdk;
   17
     } else {
   18
       console.error('Failed to initialize OneSDK due to missing session token.');
   19
       return null;
   20
     }
   21
   }
   22
   23
   initializeOneSdk().then(oneSdkInstance => {
   24
     if (oneSdkInstance) {
   25
       console.log('OneSDK initialized successfully:', oneSdkInstance);
   26
     }
   27
   });

3. Present the Verification UI: Use the initialized OneSDK instance to present the user interface for document capture and biometric authentication. The SDK provides pre-built UI components to guide users through the verification process.

4. Handle Verification Events and Results: Monitor the events emitted by OneSDK to track the progress and outcome of the verification process. Implement appropriate callbacks to handle success, errors, or user exits. Refer to the OneSDK documentation for detailed event handling instructions.

SDKs and Libraries

FrankieOne offers a range of SDKs tailored for different platforms and programming languages, designed to streamline the integration of IDV and Biometrics services. These SDKs provide pre-built components, robust APIs, and comprehensive documentation to help developers implement secure and efficient identity verification workflows with ease. For a complete list of supported SDKs and step-by-step integration guides, visit our SDK Documentation.

IDV and Biometrics Service Flows (Handled by the SDK)

The FrankieOne SDK simplifies the implementation of IDV and Biometrics service flows by handling the following processes:

• Document Capture and Validation: Ensures accurate extraction and verification of identity document data.
• Selfie Capture and Facial Comparison: Matches the user’s selfie with the document photo to confirm identity.
• Liveness Detection: Verifies that the submitted selfie or video is from a live individual, preventing spoofing attempts.
• Seamless Integration with IDV Providers: Manages communication with underlying IDV and Biometrics providers, abstracting away API complexities.

By leveraging the SDK, developers can focus on building their core application while ensuring a secure, efficient, and user-friendly identity verification experience.

API Endpoints (Abstracted by the SDK)

The FrankieOne SDK abstracts the complexities of interacting with backend API endpoints, streamlining the IDV and Biometrics processes for developers. While direct interaction with these endpoints is generally unnecessary when using the SDK, understanding their functionality can provide deeper insights into the verification workflows. For comprehensive details on these endpoints and their usage, refer to the KYC API Reference.

Manage Hosted URL

The hosted OneSDK URL endpoint enables the creation and management of a hosted session for the IDV process, tailored to a specific customer entity. This endpoint allows you to generate a unique URL for users to complete actions such as onboarding or retrying verification steps. By leveraging this feature, you can provide a seamless and customizable user experience during the identity verification process.

$
POST /v2/individuals/hostedUrl

1
{
2
    "applicationRef": "app-12345",
3
    "channelRef": "web-portal",
4
    "consent": true,
5
    "customerRef": "cust-67890",
6
    "entityId": "entity-abc123",
7
    "errorRedirectURL": "https://example.com/error",
8
    "oneSDKFlowId": "flow-xyz789",
9
    "phoneCode": "+61",
10
    "phoneNumber": "+61412345678",
11
    "recipientName": "John Doe",
12
    "sendSMS": true,
13
    "successRedirectURL": "https://example.com/success",
14
    "comment": {
15
        "text": "Customer confirmed details over the phone."
16
    }
17
}

Get Token (Advanced)

Generates a token required to initialize the IDV provider’s SDK. This token enables the provider’s SDK to be instantiated and is a prerequisite for initiating the IDV or OCR processes. It ensures secure communication and proper configuration for the verification workflow.

$
POST /v2/individuals/{entityId}/actions/idv/token

1
{
2
  "applicantId": "412e8c806fdfb0bb19b5",
3
  "applicationId": "94d9a75a5072444c",
4
  "country": "AUS",
5
  "documentType": "DRIVER_LICENCE",
6
  "referrer": "https://example.com",
7
  "relayState": "412e8c806fdfb0bb19b5",
8
  "provider": "provider_name",
9
  "products": "idv",
10
  "comment": {
11
    "text": "Update after speaking to customer over phone directly"
12
  }
13
}

Submit OCR (Advanced)

Submit an identity document photo for OCR (Optical Character Recognition) processing. The results will include extracted data from the document, such as name, document number, and expiry date, populated into an identity document object. If the OCR process is successful and no additional images are required, the status will be updated to COMPLETE_OCR. The image can be uploaded or captured using a vendor SDK after obtaining the IDV token or submitted directly as fileData. This step ensures accurate data extraction and verification for identity documents.

$
POST /v2/individuals/{entityId}/actions/idv/ocr

1
{
2
  "digital": true,
3
  "documentId": "string",
4
  "fileData": {
5
    "attachmentId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
6
    "filename": "string",
7
    "mimeType": "string",
8
    "pageNumber": 0,
9
    "side": "FRONT",
10
    "type": "string",
11
    "location": "string",
12
    "data": {
13
      "uri": "https://s3.amazonaws.com/dev/41963bc5feff322020137de233c3be0fac6/croppedFrontID/38d54232-b840-431d-b248-152345fe214.jpg"
14
    },
15
    "lastMalwareScanAt": "2025-05-05T05:07:25.617Z"
16
  },
17
  "token": "41cf9401f0f889616bef"
18
}

Process IDV (Advanced)

At the conclusion of the IDV data capture process, including all required photos and videos, notify the IDV provider to initiate the analysis and verification process. If this call is successful, the entity will be updated with any provided details, such as a name, if they are not already present.

$
POST /v2/individuals/{entityId}/actions/idv/process

1
{
2
  "providerReferenceId": "41cf9401f0f889616bef",
3
  "token": "41cf9401f0f889616bef",
4
  "comment": {
5
    "text": "Update after speaking to customer over phone directly"
6
  }
7
}

Update IDV Results (Advanced)

Manually update the status of IDV process results to either CLEAR or REJECTED, providing flexibility for handling edge cases or overriding automated outcomes.

$
POST /v2/individuals/{entityId}/results/idv

1
{
2
  "processResults": [
3
    "string"
4
  ],
5
  "manualStatus": "CLEAR",
6
  "comment": {
7
    "text": "Update after speaking to customer over phone directly"
8
  }
9
}

Best Practices

1. Consult the OneSDK Documentation: Familiarize yourself with the available methods, configuration options, UI customization capabilities, and event handling mechanisms in the official OneSDK documentation.

2. Securely Manage API Keys and Secrets: Protect your CUSTOMER_ID and API_KEY. Never expose them directly in client-side code. Use secure server-side mechanisms to fetch session tokens.

3. Implement Robust Error Handling: Implement comprehensive error handling to gracefully manage potential issues during SDK initialization, UI presentation, and verification processes. Log errors for debugging and provide informative feedback to users.

4. Provide Clear User Guidance: Ensure your application provides clear instructions to users during the IDV and Biometrics verification flow. Guide them on document capture, selfie requirements, and what to expect during the process.

5. Test Thoroughly in Different Environments: Test your OneSDK integration in both sandbox and production environments. Pay attention to different device types and network conditions to ensure proper functionality.

6. Handle Verification Callbacks and Events: Implement the necessary callbacks or event listeners provided by the OneSDK to track the status of the verification process and handle results appropriately.

7. Consider UI Customization (If Needed): Explore options to customize the user interface to align with your application’s branding and user experience for a seamless integration.

8. Monitor Verification Performance: Analyze completion rates, error occurrences, and user feedback to identify areas for optimization once the integration is live.

9. Stay Updated with SDK Releases: Keep track of updates to the OneSDK for new features, bug fixes, and performance improvements. Update your integration accordingly to benefit from the latest enhancements.

10. Follow Security Best Practices: Ensure your application adheres to security best practices to protect user data during the IDV and Biometrics verification process.

Implementing IDV and Biometrics in your KYC processes can significantly enhance the security and efficiency of your identity verification procedures. By following the steps outlined in this guide, you can successfully integrate these technologies into your existing systems and provide a seamless experience for your users.

Additional Resources

• FrankieOne Documentation
• FrankieOne API Reference
• FrankieOne Support