Faceplugin Open Source Face Recognition SDK: On-Premise Python Face Analysis

What problem this SDK addresses

Cloud-based face recognition APIs send image data to an external server for processing. For applications in regulated industries, private environments, or airgapped deployments, that is a non-starter. Faceplugin's Open Source Face Recognition SDK runs the full inference pipeline on the local machine.

The README describes it as 100% on-premise, meaning all processing happens locally with no data leaving the device. This makes it relevant for access control systems, employee time-and-attendance, and any application where biometric data must stay within a controlled environment.

The SDK targets Python developers building on Windows or Linux. The two core operations are extracting face information from an image and computing a similarity score between two face embeddings. Everything else in the pipeline, from detection through landmark extraction to comparison, is exposed through two Python methods.

Installing the SDK with conda and PyTorch

The README recommends Anaconda for dependency management. The setup is four steps:

conda create -n facesdk python=3.9
conda activate facesdk

Then install the Python dependencies:

pip install -r requirements.txt

The requirements.txt pins these packages:

- numpy 1.26.4 - opencv-python (unpinned) - pillow 10.4.0 - torch 2.4.1 - torchaudio 2.4.1 - torchvision 0.19.1

After installation, test with:

python run.py

The PyTorch 2.4.1 dependency means the SDK will download several hundred megabytes of PyTorch packages on a fresh environment. The README notes that GPU is optional and the SDK works on CPU-only systems, but it does not document whether a CUDA-enabled GPU is detected and used automatically or whether a configuration change is needed to enable GPU acceleration.

The API: GetImageInfo and get_similarity

The SDK exposes two primary methods through the FaceRecognition class.

GetImageInfo extracts face data from an image file:

from face_recognition_sdk import FaceRecognition

face_sdk = FaceRecognition()
image_path = "path/to/your/image.jpg"
face_info = face_sdk.GetImageInfo(image_path, faceMaxCount=10)

It returns a list of dictionaries. Each dictionary contains three keys: bbox (the bounding box coordinates), landmarks (the facial landmark points), and embedding (the feature embedding vector). The faceMaxCount parameter limits how many faces are extracted per image.

get_similarity compares two embeddings:

image1 = "test/1.jpg"
image2 = "test/2.png"

faces1 = face_sdk.GetImageInfo(image1, faceMaxCount=1)
faces2 = face_sdk.GetImageInfo(image2, faceMaxCount=1)

if faces1 and faces2:
    similarity = face_sdk.get_similarity(faces1[0]['embedding'], faces2[0]['embedding'])
    print(f"Similarity: {similarity}%")
    is_same_person = similarity >= 75
    print(f"Same person: {is_same_person}")

The similarity score runs from 0 to 100. The default threshold documented in the README is 75: scores at or above 75 are treated as the same person. That threshold is not configurable through a constructor argument in the examples shown; it is a comparison performed in application code against the returned score.

Supported image formats are JPG, PNG, BMP, and TIFF.

Repository structure and what lives in each directory

The top-level repository contains six source directories: face_detect/, face_feature/, face_landmark/, face_pose/, face_util/, and test/. The names suggest that detection, feature extraction, landmark computation, and pose estimation are implemented as separate modules, with a utility module for shared helpers.

The run.py file at the root is the entry point the README points to for testing the installation. The requirements.txt is also at the root.

The face_pose/ directory suggests pose estimation may be available in the source, though the README's Quick Start and API Reference sections document only GetImageInfo and get_similarity. The face_detect/ and face_feature/ directories correspond directly to the two documented operations. The README's description lists additional capabilities in the project description: face detection, face landmarks, face compare, face matching, face pose, face expression, face attributes, face templates extraction. Not all of these appear in the documented API, and the README does not document methods for face expression or face attributes beyond the core two.

What this SDK does not include: liveness detection

Liveness detection, which checks whether a face in front of a camera belongs to a live person rather than a photograph or screen, is not part of this open-source release. The README lists it as a separate commercial product in the Faceplugin catalog under Face Liveness Detection, described as detecting presentation attacks during face verification and authentication.

This is a significant gap for any application where anti-spoofing is a security requirement. Without liveness detection, the face comparison feature can potentially be defeated by holding a photograph in front of the camera. An access control or biometric authentication system built on this SDK would need to implement liveness checks separately or upgrade to the commercial Faceplugin SDK.

The README also notes that mobile targets (Android, iOS, Flutter, React Native) and .NET targets require commercial SDKs from separate Faceplugin repositories. This open-source SDK covers only Windows and Linux with Python.

License status: no recognized SPDX identifier

The repository is listed with an unknown license type. The README describes the SDK as completely free and open source with no licensing fees, but the repository does not carry an SPDX license identifier that a tool like FOSSA or license scanners would recognize.

For personal use, research, and evaluation this is unlikely to be a barrier. For commercial production deployments where a legal team needs to review the license terms before approval, the absence of a recognized license identifier means that review process cannot proceed from the GitHub license tab alone. The license file or terms would need to be located directly in the repository and reviewed manually.

Faceplugin offers commercial biometric SDKs with presumably explicit license terms. The distinction between the open-source offering and the commercial offering should be confirmed directly with Faceplugin before any commercial deployment.

Comparison with DeepFace

DeepFace is a Python face recognition library that wraps multiple models including VGG-Face, FaceNet, ArcFace, and DeepID. It is MIT-licensed, maintained by an individual contributor, and available on PyPI. DeepFace supports multiple backends and can run locally without sending data to external APIs.

Both libraries run on-device and provide face detection plus similarity scoring. DeepFace has a clearly identified MIT license and supports a broader set of recognition models that can be swapped in the same API. Faceplugin's SDK uses a single Faceplugin-built deep learning model and focuses on an on-premise deployment story. DeepFace is the stronger choice for researchers who need to compare multiple recognition models or who need an MIT-licensed library that is accepted by automated license scanners. Faceplugin's SDK may be better suited for production deployment if Faceplugin provides integration support and the commercial SDK path is part of the plan.

Maintenance and license

The repository is not archived. The last push was on 2026-09-04. There are no GitHub releases. The license is not identified by a recognized SPDX identifier in the repository metadata, despite the README describing the SDK as open source and free.

Faceplugin is a commercial company that offers paid biometric SDKs for Android, iOS, Flutter, React Native, Docker, Windows, and .NET alongside this open-source Python release.

Editorial conclusion

This SDK suits developers building on-premise face verification or face comparison features on Windows or Linux who want a Python library that avoids cloud API calls. It is a poor fit for production systems that require liveness detection (which is only in Faceplugin's commercial SDK), for iOS or Android targets (separate commercial repositories exist for those), or for teams that need a clearly identified open-source license before legal review can approve adoption. Before using it in production, read the repository's license terms carefully since the repository does not carry a recognized SPDX license identifier despite the README describing it as open source.

Frequently asked questions

Official sources

1. Faceplugin-ltd/Open-Source-Face-Recognition-SDK on GitHub
2. Issues
3. Project website
4. README