What is Video KYC? Complete Guide to Build Video KYC Verification [2026]

Video verification in banking is a paperless process that verifies customer identity. This cuts off financial fraud and money laundering that can happen online. Customers are asked to complete this verification step when applying for a credit card, opening a savings account, or requesting online services.

That said, in this guide, we will cover: the basics, video KYC architecture, types of KYC, eligibility, use cases, and how to build video KYC verification using Java.

Let’s start.

What Is a Video KYC?

Video KYC is a remote process that banks/financial institutions use to verify their customers’ identities. The technologies involved are optical character recognition, liveness detection, and facial recognition.

The bank agents help customers complete their video verification successfully in real time. Here is the step-by-step process.

 

Want to build a white-label Video KYC App Using Custom Video API?

Contact Sales

Video KYC Verification Process in Banks

A web or mobile app with a camera, a video chat server, a verification layer, and a data storage layer is involved when someone initiates KYC. Here is what the customer does and behind the scenes.

What happens in the backend of a Video KYC platform:

Customer KYC Process	Backend Technology
Step 1: The customer should enable camera, microphone, and location sharing settings on their device. If not enabled, the web app asks the customer to give access before video verification. It monitors the network quality to ensure a smooth process.	The browser or app requests camera and microphone access using getUserMedia(). WebRTC’s getStats() API monitors the network to assess call quality.
Step 2: Customer agrees to share their identity by ticking the checkbox. Then the bank agent sends a video invitation link to join.	A backend REST API records user consent. The signed JWT tokens are used for invite authentication.
Step 3: The agent checks the customer’s background and lighting during the video call. This helps them capture the photo and document clearly. Then, both parties talk to get to know the specific banking services.	A WebRTC media server based on an SFU architecture facilitates media routing for audio and video calling.
Step 4: In this step, identity verification is carried out. The agent asks for the legitimate ID and documents to show on their back cam. To detect liveness and prevent fraud, agents ask the customer to perform some actions. (blink eyes, read on-screen number, smile, etc.)	AI ‘optical character recognition’ checks the identity and detects if it’s fake or not. ‘Face matching and liveness detection’ confirm if the person is real or not.
Step 5: Now that the video KYC is complete, the customer data and information are stored for regulatory and audit purposes. Within the next 48 hours, the KYC status is updated to the customer via email or phone.	The customer data is stored in cloud/on-premise along with audit logging. Webhooks plus email/SMS gateway services send the service request update to the customer.

Now, if you’re curious to create a bank video KYC, the next section will help you figure out the right approach.

Building Video KYC: From Scratch vs Self-hosted Video API

Developers should evaluate their approach when building video verification for banks. Building from scratch takes a lot of time, up to 12 months. Whereas a custom video KYC API offers pre-built features to integrate into Android, iOS, and web apps quickly.

Build From Scratch vs Self Hosted Video API (Detailed Comparison)

Building from scratch	Self hosted Video API
Internal teams build every feature	Access to pre-built video KYC features
You control the servers, database, and   network routing	You get full data ownership and control
Takes 6 to 12 months based on complexity	Deploy and launch in 48 hours
Limited flexibility at initial stage	Allows 100% customization
Requires infrastructure setup and maintenance	Flexible on-premises chat server or a cloud server
Needs additional effort for integration and migration	Dedicated team is available for integration and migration support
Comes with a huge development cost ranging $100k	Offers a one-time perpetual license for enterprises
Complete branding control with manual implementation	Low-code solution comes with a white-labeling option

Banks, enterprises, and finance teams choose a self-hosted video KYC API for maximum privacy and customization.

Build A Video KYC App Using a White-label Video Solution

We have explained the build process with the MirrorFly video call SDK for Android using Java 7 or higher version in this section. It involves 5 easy steps:

Step 1: Add the Video Calling SDK
Step 2: Initialize the Video SDK
Step 3: User Registration
Step 4: Configure Connection
Step 5: Make & Receive Video Call

First you have to create an account with MirrorFly by getting their license key. Then proceed the below steps.

Video Tutorial to Integrate the Video Calling SDK for Android App

Check the GitHub guide on MirrorFly Android SDK For Video Chat & Calls.

Step 1: Add the Video Calling SDK

Add this below code to the app’s build.gradle file:

dependencies {
    implementation 'com.mirrorfly.sdk:mirrorflysdk:7.13.16'
 }

Now add this in your gradle.properties:

android.enableJetifier=true

Step 2: Initialize the Video SDK

In order to get this done, add it in your application class:

ChatManager.initializeSDK("LICENSE_KEY", (isSuccess, throwable, data) -> {
            if(isSuccess){
                Log.d("TAG", "initializeSDK success ");
            }else {
                Log.d("TAG", "initializeSDK failed with reason "+data.get("message"));
            }
        });

Now to your AndroidManifest.xml, add the below code:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.uikitapplication">

    <application
        android:name=".MyApplication"  // Add this line.
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                ...
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

Step 3: User Registration

After initialization is success, you have to register the user:

FlyCore.registerUser(USER_IDENTIFIER, (isSuccess, throwable, data ) -> {
        if(isSuccess) {
            Boolean isNewUser = (Boolean) data.get("is_new_user");  // true - if the current user is different from the previous session's logged-in user, false - if the same user is logging in again
            String userJid = (String) data.get("userJid"); //Ex. 12345678@xmpp-preprod-sandbox.mirrorfly.com (USER_IDENTIFIER+@+domain of the chat server)
            JSONObject responseObject = (JSONObject) data.get("data");
            String username = responseObject.getString("username");
        } else {
           // Register user failed print throwable to find the exception details.
        }
   });

Step 4: Configure Connection

Now the next step is to establish and monitor the connection with the video backend

This ensures the app can handle network interruptions and connection failures without disrupting the verification process. Add the code to monitor the SDK connection:

ChatManager.setConnectionListener(new ChatConnectionListener() {
    @Override
    public void onConnected() {
        // Write your success logic here to navigate Profile Page or
        // To start your one-on-one chat
    }

    @Override
    public void onDisconnected() {
        // Connection disconnected
    }

    @Override
    public void onConnectionFailed(@NonNull FlyException e) {
        // Connection Not authorized or Unable to establish connection with server
    }

    @Override
    public void onReconnecting() {
        // Automatic reconnection enabled
    }
});

Now set up the CallManager to handle the functionality such as call activity, missed call notifications, and caller display names.

@Override
public void onCreate() {
super.onCreate();

//set your call activity
CallManager.setCallActivityClass(CALL_UI_ACTIVITY.class);
CallManager.setMissedCallListener((isOneToOneCall, userJid, groupId, callType, userList,CallMetaData[] callMetaDataArray) -> {
  //show missed call notification
});

CallManager.setCallHelper(new CallHelper() {
      @NonNull
      @Override
      public String getNotificationContent(@NonNull String callDirection,CallMetaData[] callMetaDataArray) {
          return CallNotificationHelper.getNotificationMessage();
      }

  });

CallManager.setCallNameHelper(new CallNameHelper() {
      @NonNull
      @Override
      public String getDisplayName(@NonNull String jid,CallMetaData[] callMetaDataArray) {
          return ContactManager.getDisplayName(jid);
      }
  });
}

The call interface activity should be specified in your manifest so the SDK can launch and manage the call screen. Add this to register the call activity:

<activity
            android:name="YOUR_CALL_ACTIVITY"
            android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"
            android:excludeFromRecents="true"
            android:launchMode="singleTask"
            android:resizeableActivity="false"
            android:screenOrientation="portrait"
            android:supportsPictureInPicture="true"
            android:showOnLockScreen="true"
            android:turnScreenOn="true"
            android:taskAffinity="call.video"
            tools:targetApi="o_mr1" />

Next, configure the call activity to connect it with the video SDK. Add the required SDK methods to the appropriate lifecycle methods:

 CallManager.configureCallActivity(ACTIVITY);

Configure the call service according to the SDK’s recommended activity lifecycle implementation.

CallManager.unbindCallService();

The SDK uses a JID to identify users during video calls. So, generate the unique JID from the registered username using this method:

FlyUtils.getJid(USER_NAME)

Step 5: Make & Receive Video Call

Make Call: Once the connection is configured, you can initiate, receive, answer, decline, and end video calls using the SDK. Add this code.

CallManager.makeVoiceCall("TO_JID",CALL_METADATA, (isSuccess, flyException) -> {
            if(isSuccess){
                 //SDK will take care of presenting the Call UI. It will present the activity that is passed using the method `CallManager.setCallActivityClass()`
                Log.d("MakeCall","call success");
            }else {
                if(flyException!=null){
                    String errorMessage = flyException.getMessage();
                    Log.d("MakeCall","Call failed with error: "+errorMessage);
                    //toast error message
                }
            }
        });

Receive Call: When you get a video call from another SDK user, the call SDK will show a notification if your device is running Android 10 (API level 29) or higher.

If your device has an older Android version, the call screen you set using the CallManager.setCallActivityClass() method during SDK setup will open with the call details. 

A sample call UI is also available for easy integration.

Answer the Call: When the user taps the Accept button in your call UI, you should call the following SDK method to answer the call and notify the caller.

CallManager.answerCall((isSuccess, flyException) -> {
            if(isSuccess){
                Log.d("AnswerCall","call answered success");
            }else {
                if(flyException!=null){
                    String errorMessage = flyException.getMessage();
                    Log.d("AnswerCall","Call answered failed with error: "+errorMessage);
                    //toast error message
                }
            }
        });

Decline the Call: When the user taps the Decline button in your call UI, you should call the following SDK method to reject the video call and notify the caller.

CallManager.declineCall();

Disconnect Ongoing Call: If you make a video call to another SDK user and want to disconnect it before it connects or end an ongoing call, you need to call the following SDK method.

 CallManager.disconnectCall();

For other video call features, you can check the official MirrorFly document.

These SDK methods simplify the video calling workflow and allow you to build a video KYC platform without coding from scratch.

Features to Add in a Video KYC Platform

The following are the features your video KYC app should have apart from the 1-on-1 video chat feature.

• Screen Sharing: It allows users to share their entire screen for document verification.
• Video Recording: It captures and stores the customer audio and video for identity verification.
• Multi-Agent Support: This enables multiple agents to join the video verification session.
• End-to-End Encryption: The video chats are encrypted so only the sender and recipient can access them.
• AI Chat Moderation: It reviews customer information and rejects fraudulent information.

Now, let’s see what industries rely on this video KYC platform.

Explore 1000+ chat features and video call features to integrate into any app.

Use Cases Of Video KYC

Whatever business you may run, video KYC is important for verifying your customer’s identity, onboarding or hiring processes. Here are some of the common use cases of a Video KYC platform: 

• Banks and financial sectors depend on video KYC to streamline customer onboarding and verify their identities.
• Insurance companies verify their customers virtually as they work on providing policy claims.
• E-commerce businesses rely on video KYC services to pay their merchants within their platform. 
• Trading companies verify online investors and ensure no fraudsters are involved during payouts.
• HR verifies employees during the remote hiring and onboarding process to confirm their true identity.

Now, let’s see their advantages.

Enterprise Benefits of Building a Custom Video KYC Platform

Building your own custom video KYC app improves regulatory compliance and enhances customer onboarding experience. Here are the advantages:

• Complete Data Ownership: You can manage user data like video recordings and KYC docs without any third-party claim.
• Build Custom Security: It allows customizing security workflows such as Gmail login, Face ID, and thumbprint, etc., based on the unique needs.
• White-labelling Option: Use your business name, logo, or colors on the video KYC platform to deliver a consistent branding experience.
• Low-latency Integration: You can embed chat, video, audio, or other verification capabilities into any app with minimal delays.
• Fraud Prevention: It helps mitigate the risk of data theft and threats to user accounts by completing the video verification.
• Self-hosting Flexibility: Developers and enterprise owners can deploy and manage their white-label chat software in their own data centers or private cloud.
• One-time Perpetual License: This reduces long-term software costs by avoiding recurring subscription fees.

Wrapping Up

Any business that deals with online payments or transactions should protect itself from fraud attempts. So, customer KYC verification is a process businesses cannot skip in recent years.

If you agree the same and is interested in building your own KYC platform, we’ve got experts who can guide where to begin with – Contact our experts.

Share it on