# FaceRecognition-Android: wiring the KBY-AI SDK into an Android app

> FaceRecognition-Android is a Kotlin demo application for the KBY-AI face recognition and liveness detection SDK, showing how to add the libfacesdk module, activate a licence key and initialise the SDK. The engine itself is a closed binary you license from the vendor, so what the repository teaches is integration, not the algorithm.

**kby-ai/FaceRecognition-Android** — Face Recognition FRVT, Face Liveness Detection, Face Recognition , Face Liveness, Face Identification, Face Compare, Face Matching, Face Pose, Face Expression, Face Attributes, Face Landmarks, Face Representation, Face Reconstruction

- Repository: https://github.com/kby-ai/FaceRecognition-Android
- Website: https://kby-ai.com/face-recognition-sdk/
- Stars: 729 · Forks: 243
- Language: Kotlin
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/kby-ai-facerecognition-android

## A demo app wrapped around a licensed binary SDK

The repository is presented as a demonstration of face liveness detection and face recognition technology developed by KBY-AI, integrated into the Android native platform. The README is explicit that it demonstrates both technologies, and the top level layout shows the shape of the thing: an app directory for the demo, a libfacesdk directory holding the SDK itself, and a libfotoapparat directory for camera work.

That division is the most important fact about the project. The recognition and liveness algorithms are not in this repository as source you can read. They arrive as the libfacesdk module, and the SDK section of the README states that you must activate the SDK with a licence you have received before anything works, with a contact address given for requesting one. The repository metadata does not name a licence for the code either.

So the value here is narrow and real: it shows the integration path. Which module goes where, how the licence key is passed, and what initialisation looks like. If you want to understand how a liveness check is implemented, this is not the place to look, and the README itself points to a separate Face Attribute repository for other capabilities and to the vendor product pages for the server side SDK.

## Two Gradle edits and a copied module folder

The setup instructions are numbered and short. Step one is to copy the SDK, the libfacesdk folder, to the root folder of your project. Step two is to register it in settings.gradle:

```bash
include ':libfacesdk'
```

Step three is to add the dependency in your build.gradle:

```bash
implementation project(path: ':libfacesdk')
```

That is the whole wiring. There is no repository to add, no version to resolve and no package to fetch, because the module travels with the source you copy in. The practical implication is that the SDK version is whatever folder you copied, so updating the engine means replacing the directory rather than changing a coordinate in a build file.

The demo app that ships alongside uses the same structure, so you can read how the module is referenced from a working project, and the app's build files show the expected Android configuration. The gradlew and gradlew.bat wrapper scripts at the root are there so the project builds with a pinned Gradle version rather than whatever happens to be on the machine.

## Activate first, initialise second, and check the return value

The runtime sequence is two calls, and the order matters. Step one is activation with the licence you received:

```kotlin
FaceSDK.setActivation("...")
```

If activation succeeds the return value is SDK_SUCCESS, and otherwise an error value is returned. Step two is initialisation:

```kotlin
FaceSDK.init(getAssets());
```

That call takes the assets, so the model files the engine needs are read from the application assets rather than from a path you supply. Again the return value is SDK_SUCCESS on success and an error value otherwise.

Both steps return a status you are expected to check, which is the pattern to copy into your own code. A failed activation followed by a successful init is not a state the SDK supports, so treat the two returns as a gate before any camera or detection code runs.

The README also links to the exact lines of the demo's MainActivity.kt where the licence is used, which is the fastest way to see how the key is stored and passed in a real application rather than guessing at the API.

## Three tiers, and the features that move between them

The SDK is sold in three tiers, and the tables in the README show what each one includes. The Basic tier covers face detection and face liveness detection. The Standard tier adds pose estimation and face recognition, and the repository you are reading is listed as the Standard SDK for Android. The Premium tier adds 68 points face landmark detection, face quality calculation, face occlusion detection, eye closure detection, and age and gender estimation.

The product list makes the same point across platforms. Face liveness detection exists as separate Android and iOS repositories at the Basic level, while face recognition plus liveness detection is offered for Android, iOS, Flutter, Ionic-Cordova and React-Native at the Standard level, and face attributes exist for Android, iOS and Flutter at the Premium level.

That spread is the practical alternative to this repository. If your requirement is only liveness, the Basic SDK repository is the smaller and cheaper dependency, and if you are shipping on Flutter, React-Native or Cordova rather than native Android, the same engine is delivered through those SDKs instead. Choosing this repository means committing to the native Android path.

## Vendor claims, the FRVT citation and what is not in the repository

The headline numbers come from the vendor, and the README states them as its own. It claims real-time processing under 200ms latency, a lightweight APK under 35MB, compliance with the ISO/IEC 30107-1 biometric standards, and all data processed locally with no cloud transmission. It also states that its facial recognition algorithm is globally top-ranked by NIST in the FRVT 1:1 leaderboards, with a link to the latest NIST FRVT evaluation report dated 2024-12-20, and describes the accuracy in the header as 99.9 percent.

Those are claims in a project README, and the repository contains nothing that would let you check them: no evaluation code, no accuracy script and no benchmark harness. The FRVT link is the one place where an outside party is involved, and even there the ranking is a property of the submitted algorithm rather than of this integration code.

The local processing claim is the one with the most practical weight, and the repository does support it in structure. There is a privacy directory at the top level, the SDK initialises from bundled assets rather than fetching models, and the demo runs on device. If you need to verify that, read what the privacy folder contains before you rely on the claim, since a demo app and a production data flow are not the same thing.

## A repository without releases, in a wider vendor product family

There are no GitHub releases in this repository, and the last push was on 2026-06-15. Since the SDK travels as a copied folder rather than as a versioned dependency, a missing release history costs less here than it would in a normal library, but it does mean there is no changelog and no upgrade path for the demo code itself.

The rest of the vendor's ecosystem is linked from the README, which is worth scanning to understand where this project sits. There is a Linux ID document liveness detection service hosted on the web, a Hugging Face organisation, a Product and Resources repository, a help centre at docs.kby-ai.com, a KYC Verification Demo for Android, and Docker Hub images under the kbyai account. A demo APK is published on Google Play under the package com.kbyai.facerecognition, and a YouTube video shows the demo running.

Taken together this is a commercial SDK with a sample application, not an open source project that happens to have a sample. The licence request goes through a set of support channels including an email address, Telegram, WhatsApp, Discord and Teams, and until that licence arrives the SDK returns an error rather than an identification result.

## Conclusion

Adopt this repository as an integration reference when you have decided to use the KBY-AI mobile SDK and want the exact module wiring, activation sequence and asset initialisation steps without reverse engineering them from a jar. Do not adopt it as an open source face recognition implementation, because the detection and recognition code lives in a licensed binary SDK and the repository carries no open source licence terms for it. Verify first that the licence you obtain covers the tier you need, since the README separates Basic, Standard and Premium feature sets, and confirm that the app's privacy folder and your own consent flow cover the on-device biometric processing before shipping anything to a store.

## FAQ

### How do I add the KBY-AI Face SDK to an Android project?

Copy the libfacesdk folder to the root of your project, include ':libfacesdk' in settings.gradle, and add implementation project(path: ':libfacesdk') to your build.gradle. The module is then used through the FaceSDK class.

### How is the KBY-AI SDK activated and initialised?

Call FaceSDK.setActivation with the licence you received, then FaceSDK.init(getAssets()) to load the bundled model assets. Both calls return SDK_SUCCESS on success and an error value otherwise, and the README links to the demo's MainActivity.kt for a working example.

### Does the KBY-AI SDK need a licence to work?

Yes. The README states that you need to activate the SDK with a licence that you have received, and gives contact channels for requesting one. The repository itself carries no open source licence terms for the SDK.

### What is the difference between the Basic, Standard and Premium SDK tiers?

Basic covers face detection and face liveness detection, Standard adds pose estimation and face recognition, and Premium adds 68 point landmarks, face quality calculation, occlusion detection, eye closure detection and age and gender estimation. This repository is listed as the Standard SDK for Android.

### Does the KBY-AI Android SDK send face data to a server?

The README states that all data is processed locally with no cloud transmission, and the SDK initialises from assets bundled in the application. The repository also carries a privacy directory at the top level, which is where to look for the detail behind that claim.

## Sources

- [Issues](https://github.com/kby-ai/FaceRecognition-Android/issues)
- [kby-ai/FaceRecognition-Android on GitHub](https://github.com/kby-ai/FaceRecognition-Android)
- [Project website](https://kby-ai.com/face-recognition-sdk/)
- [README](https://github.com/kby-ai/FaceRecognition-Android/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kby-ai-facerecognition-android