How to integrate a face
recognition SDK in Flutter

For developers building cross-platform apps with Flutter, adding face recognition typically requires a dedicated SDK that works with the app’s camera and provides the necessary biometric capabilities.

Choosing and integrating the right SDK can be challenging. Different solutions vary in the face recognition features they support, their compatibility with Android and iOS, processing performance, integration requirements, and licensing models.

In this guide, we’ll look at how to integrate a face recognition SDK into a Flutter app, compare open-source and commercial plugins, and discuss the most common technical challenges developers may encounter along the way.

Face recognition is a biometric technology that uses computer vision and machine learning to detect, identify, or verify a person based on facial features captured from an image or camera feed.

The process typically involves detecting a face, locating key facial landmarks, assessing the quality of the facial image, generating a biometric template, and comparing it with stored templates.

Depending on the use case, face recognition can perform 1:1 verification to confirm a person’s identity or 1:N identification to find a matching identity in a database.

As mobile security becomes increasingly critical, integrating face recognition into apps is becoming increasingly important.

Flutter, with its cross-platform capabilities and unified codebase, can simplify this integration, enabling developers to implement face recognition functionality once and deploy it across both Android and iOS devices.

Here’s what makes face recognition in Flutter a smart move:

It’s what users expect
Face recognition can provide a fast, touch-free way for users to authenticate themselves, whether they’re logging into an app or confirming an action.

Security and fraud prevention
Face recognition can help prevent unauthorized access and reduce identity fraud, particularly when combined with liveness and deepfake detection. This makes it useful for banking, fintech, and other industries that handle sensitive data.

Cross-platform support, one codebase
Flutter allows you to build for both Android and iOS from a single codebase. When paired with a cross-platform face recognition SDK, you get consistent biometric functionality across devices without having to build separate implementations for each platform.

Integrating face recognition into Flutter apps isn't always straightforward. Here are a few real-world challenges we've encountered — and how we solve them.

Immutable objects and image conversion performance
Object immutability is a core concept for Flutter’s core language, Dart, meaning developers typically can't modify objects without creating a copy.

While this has benefits for stability and predictability, it can seriously impact performance when working with images—especially during conversions from camera formats to RGB.

To address this, we often rely on native (C++) image conversion implemented directly within our Face SDK when working in Flutter.

This approach significantly optimizes image processing operations. In particular, using the C++ version of image conversion has helped us boost FPS several times over.

Using Dart isolates for heavy processing
Heavy processing — including Face SDK inference — can often interfere with app performance, especially the UI.

This can lead to lags, stutters, or even app freezes in more extreme cases. To avoid these issues, we recommend using Dart Isolates to offload demanding tasks to separate threads.

To make this easier for developers, we’ve already integrated Isolate support directly into our Flutter plugin.

Here’s a less obvious but equally important scenario:

In some apps, you may need to save cropped face images — for example, to display them as thumbnails in a database of registered users. However, converting an RGB image to JPEG can take up to 200–250 ms.

If you attempt this without using Isolates, the camera preview may freeze or stop working entirely. With Isolates, the app stays responsive.

Handling YUV_420_888 to RGB conversion on Android
When working with android.hardware.camera2 — the standard package for camera interaction on Android — the image format YUV_420_888 is commonly used. However, for neural network processing, we often need to convert these images to RGB.

As mentioned earlier, we handle this conversion in native code using our custom implementation. This generally works well — but on some devices (such as the Honor X8b), the image data doesn’t fully comply with the expected format.

As a result, the converted RGB image becomes corrupted, and the processing pipeline fails.

That’s why we continuously maintain and update our Flutter Face SDK to ensure compatibility across a wide range of smartphones.

3DiVi Face SDK is a cross-platform face recognition SDK with Flutter support that addresses all three integration challenges discussed above, from image conversion and heavy processing to device-specific camera compatibility.

Native image processing, Dart isolate support, along with continuous SDK updates help developers avoid these bottlenecks and build more responsive and reliable face recognition apps.

Easy integration for Flutter developers
3DiVi Face SDK provides Flutter tutorials, sample applications, and detailed documentation to help developers add face recognition functionality without implementing the underlying computer vision pipeline themselves.

Flexible face recognition pipeline
3DiVi Face SDK for Flutter offers a versatile face recognition pipeline, capable of handling a variety of tasks, including:

• Face Detection: Detect faces in images and camera streams, even in challenging conditions like low light or occlusions.
• Face Verification: Perform 1:1 matching to verify a claimed identity.
• Face Identification: Perform 1:N matching to identify a person against a database.
• Liveness Detection: Strengthen security with liveness checks to confirm the user is a real person, not a spoofed image or video.
• Deepfake Detection: Detect synthetic or manipulated facial content to help protect biometric verification workflows.
• Image Quality Assessment: Evaluate facial image quality before recognition.

Dart isolate support
3DiVi Face SDK includes Dart Isolate support for moving compute-intensive biometric operations away from the main isolate. This helps keep the UI responsive while face detection and recognition are running, including on devices with more limited resources.

Regular updates and technical support
Mobile camera implementations and device-specific behavior can affect face recognition integration.

3DiVi regularly updates the Face SDK for Flutter to address compatibility issues, improve performance, and support new devices and platform versions.

Developers also have access to updated documentation, tutorials, samples, and technical support.