InsightFace: a face analysis toolbox with a split license
State-of-the-art 2D and 3D Face Analysis Project
At a glance
- What is it?
- DeepInsight's InsightFace ships detection, recognition, alignment, parsing and generation models plus a Python package and a self-hosted server, with MIT licensing on the code and research-only terms on most pretrained weights.
- Who is it for?
- InsightFace is the rare face project where the code is genuinely open and the weights are not, and any evaluation has to start there. What the repository does settle is the algorithm story: SCRFD for detection, Partial FC and ArcFace for recognition, with paper links and challenge results for both.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 33 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 20, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What the repository tree actually contains
InsightFace started as a research toolbox and grew into a shipped product, and the directory layout shows both halves surviving. The algorithm side sits in directories named after the paper that introduced each piece: `detection/` for SCRFD, `recognition/` for the ArcFace and Partial FC work, `alignment/`, `attribute/`, `parsing/`, `generation/` and `reconstruction/` for gaze and 3D face work. `benchmarks/` and `challenges/` hold the evaluation side, including the masked face recognition and anti-spoofing challenges the team ran.
detection/
recognition/
alignment/
generation/
python-package/
cpp-package/
server/On top of that sit three distribution shapes. `python-package/` is the pip-installable surface people actually use, `cpp-package/` holds the InspireFace C/C++ SDK released in 2024, and `server/` is the self-hosted web service added in 2026. `web-demos/` points at hosted demos for localization, recognition and swapping, and `examples/` holds the runnable scripts that most tutorials are copied from.
The core dependencies are declared in a single file rather than in a package manifest:
Cython>=0.29.28
cmake>=3.22.3
numpy>=1.22.3That short list is itself informative. It says the default path builds or loads ONNX models rather than training anything, and that the C++ extensions are compiled locally. The 2026-05-23 changelog entry notes that InsightFace 1.0 added a cross-platform desktop GUI and a lighter default Python install that removes the C++ build requirement, which is the version to want if you are not going to swap code into a runtime.
The licensing split that decides whether you can ship this
This is the part of the README that deserves to be read twice. The code is MIT licensed with no stated limit on academic or commercial use. The training data and every model trained on it are for non-commercial research purposes only, and the README states that rule applies both to models you download by hand from the GitHub repo and to models the Python library fetches for you automatically. Automatic download does not buy you a different license, which trips people up more often than it should.
Three model families now require an email rather than a download. The `inswapper` face swap series, including the separate inswapper-512-live repository, goes through `[email protected]`. Open-sourced recognition models such as the `buffalo_l` package go through `[email protected]`. The InspireFace SDK and its models go through the main contact address.
That means a commercial face recognition product built on `buffalo_l` starts life as a licensing conversation, not an install step. The model zoo release from 2026-09-03 centralizes official model packs, and it is explicit that model versions move independently: an update to one pack says nothing about the others, and mirrored legacy files are unchanged unless a note says otherwise. Practical consequence: pin your model pack version deliberately, because the library will not warn you that a download changed underneath you.
SCRFD and Partial FC are the two results worth reading the papers for
The changelog is a compact history of where the accuracy claims come from. SCRFD, published in `detection/scrfd` and accepted at ICLR-2022 on 2022-02-23, is the detector. It replaced a heavier cascade in most InsightFace pipelines, and it is the component you will feel most in latency.
Partial FC, accepted at CVPR-2022 on 2022-03-30, is the recognition contribution, with an arXiv link in the README. The same work took first place on the VISA track of NIST-FRVT 1:1 on 2021-10-29, credited to Xiang An, Jiankang Deng and Jia Guo, which is the sort of independent evaluation that actually tells you something. A separate 3D line of work, monocular identity-conditioned facial reflectance reconstruction, was accepted at CVPR-2024 on 2024-04-17.
The one-line face swap came earlier, in the 0.7 Python package on 2022-11-28, with a worked example under `examples/in_swapper`. A mask renderer sits beside it at `examples/mask_renderer.py`, and `examples/mxnet_to_onnx.py` exists because the project was originally MXNet-based and now runs on PyTorch and ONNX, with MXNet and OneFlow still listed among the topics.
Worth noting for anyone benchmarking: the repository publishes challenge leaderboards rather than a single accuracy table, so the honest comparison path runs through `benchmarks/` and the workshop pages, not through a number in the README.
InsightFace Server as a Rekognition substitute
Added on 2026-07-27, InsightFace Server is the newest and least documented part of the project. The README describes it as a self-hosted web UI with a snake_case REST API and a Python client, covering detection, optional liveness checks, comparison, registration and person search. `server/docs/user-guide.md` is where the detail lives.
The deployment claim is specific: a single Linux x86_64 container, CPU or NVIDIA GPU, running local ONNX Runtime inference with SQLite storage, using operator-supplied models verified against a manifest. The two numbers attached to it are INT8 embedding quantization described as accuracy-preserving, and 50M-plus image search on one RTX 5090. Those are the project's own claims and there is no benchmark script in the tree to reproduce them, so treat them as directional.
The 2026-09-09 entry adds an optional RGB liveness addon with `normal` and `observe` modes, per-face scores and explicit input-rejection reasons, plus model installation and activation from the server web interface. Rejection reasons are the detail that makes an liveness feature debuggable rather than a black box.
Compared with AWS Rekognition, the argument is data locality and model choice. The argument against is that you now own the GPU, the SQLite file, the model manifest and the upgrade path.
PrivateFrame blurs video on your own machine
The other half of the InsightFace 2.0 update is PrivateFrame, documented at `python-package/insightface/app/privateframe/README.md`. It handles local video face blur and mosaic, lets you pick a reference photo for selective redaction, and writes an editable analysis JSON. The workflows are desktop, CLI and Python.
Two implementation details matter for whether you would use it. The JSON is reusable, so you can re-render the analysis without running inference again, which is the difference between a one-minute job and a one-hour job on a long file. And the default is Fast mode, with a target of 15 analysis frames per second.
That target is a design choice rather than a promise. It tells you the tool is aimed at batch redaction of recorded video where you want the file back quickly, not at real-time conferencing. If you need live blur, the 2026-09-09 entry's local detection and tracking work moves in that direction, but 15 FPS remains the documented default.
The model side of the Python package also gained `raccoon_s` and `raccoon_l` packs, automatic CoreML, CUDA and CPU provider selection, and reusable CoreML compilation caches. Provider selection in particular removes a class of configuration guessing on macOS.
What the README decides and what it hands off
The README is organized as update notes, then licensing, then a long dated changelog, and it stops partway through the introduction section. That is a deliberate shape for a project with this many users: the top of the page answers what changed and what you are allowed to do with it, and everything else is a link out.
What it settles well is provenance. Dates, paper venues, arXiv links, challenge results and license terms are all stated with sources, which is better than most research repositories manage. A reader can tell that SCRFD is ICLR-2022 and Partial FC is CVPR-2022 without leaving the page.
What it hands off is everything operational. Installation lives in `python-package/README.md`, server deployment in `server/docs/user-guide.md`, liveness details behind an anchor in each of those, and the desktop app has its own section. The website at insightface.ai carries the rest. With 1270 open issues on the tracker, part of the practical experience of this project is that the issue queue doubles as the documentation, which is not a criticism so much as a fact about how fast the field moves.
The maintainers named at the top are Jia Guo and Jiankang Deng, and the changelog is written in the first person plural by them. The project is run by people with day jobs who still ship roughly monthly, judging by the 2026 entries.
Editorial conclusion
InsightFace is the rare face project where the code is genuinely open and the weights are not, and any evaluation has to start there. What the repository does settle is the algorithm story: SCRFD for detection, Partial FC and ArcFace for recognition, with paper links and challenge results for both. What it does not settle is how to run any of it, because the README hands off to subdirectories before it reaches an install command. The last push was on 2026-09-09 and the `model-zoo` release tag dates from 2026-09-03, so both the code and the model distribution are moving. Start in `python-package/README.md` for the package surface, and email the addresses in the license section before you plan a product around it.
Frequently asked questions
What does InsightFace do?
It is a 2D and 3D face analysis toolbox covering detection, face alignment, recognition, attribute prediction, face parsing, generation and 3D reconstruction. The recognition side is ArcFace and Partial FC, the detector is SCRFD, and the results are distributed as ONNX models through the Python package, a C/C++ SDK, or the self-hosted InsightFace Server.
Is InsightFace open source?
The code is, under MIT with no stated limit on commercial use. The models are not, in the general case. The README says training data and models trained on it are for non-commercial research purposes only, applies that to automatic model downloads as well as manual ones, and requires an email request for the inswapper swap series, for open-sourced recognition models such as buffalo_l, and for the InspireFace SDK.
What are the differences between InsightFace and FaceNet?
The repository does not publish a FaceNet comparison, so this is worth checking against the papers rather than a table here. What InsightFace documents about itself is SCRFD for detection at ICLR-2022 and Partial FC for recognition at CVPR-2022, the latter placing first on the VISA track of NIST-FRVT 1:1 in 2021. FaceNet predates both and is an older Inception-based embedding pipeline, so the practical gap is embedding design plus a modern detector.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/deepinsight-insightface)