# deepface
[](https://pepy.tech/project/deepface)
[](https://github.com/serengil/deepface/stargazers)
[](https://hub.docker.com/r/serengil/deepface)
[](https://github.com/serengil/deepface/blob/master/LICENSE)
[](https://doi.org/10.35378/gujs.1794891)
[](https://deepface.dev?source=deepface_repo)
[](https://news.ycombinator.com/item?id=48321158)
DeepFace is a lightweight [face recognition](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) and facial attribute analysis ([age](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [gender](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [emotion](https://sefiks.com/2018/01/01/facial-expression-recognition-with-keras/) and [race](https://sefiks.com/2019/11/11/race-and-ethnicity-prediction-in-keras/)) framework for python. It is a hybrid face recognition framework wrapping **state-of-the-art** models: [`VGG-Face`](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/), [`FaceNet`](https://sefiks.com/2018/09/03/face-recognition-with-facenet-in-keras/), [`OpenFace`](https://sefiks.com/2019/07/21/face-recognition-with-openface-in-keras/), [`DeepFace`](https://sefiks.com/2020/02/17/face-recognition-with-facebook-deepface-in-keras/), [`DeepID`](https://sefiks.com/2020/06/16/face-recognition-with-deepid-in-keras/), [`ArcFace`](https://sefiks.com/2020/12/14/deep-face-recognition-with-arcface-in-keras-and-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/), `SFace`, `GhostFaceNet`, `Buffalo_L`.
[A modern face recognition pipeline](https://sefiks.com/2020/05/01/a-gentle-introduction-to-face-recognition-in-deep-learning/) consists of 5 common stages: [detect](https://sefiks.com/2020/08/25/deep-face-detection-with-opencv-in-python/), [align](https://sefiks.com/2020/02/23/face-alignment-for-face-recognition-in-python-within-opencv/), [normalize](https://sefiks.com/2020/11/20/facial-landmarks-for-face-recognition-with-dlib/), [represent](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) and [verify](https://sefiks.com/2020/05/22/fine-tuning-the-threshold-in-face-recognition/). While DeepFace handles all these common stages in the background, you donβt need to acquire in-depth knowledge about all the processes behind it. You can just call its verification, find or analysis function with a single line of code.
[`Experiments`](https://github.com/serengil/deepface/tree/master/benchmarks) show that **human beings have 97.53% accuracy** on facial recognition tasks whereas those models already reached and passed that accuracy level.
## Installation [](https://pypi.org/project/deepface/)
The easiest way to install deepface is to download it from [`PyPI`](https://pypi.org/project/deepface/). It's going to install the library itself and its prerequisites as well.
```shell
$ pip install deepface
```
Alternatively, you can also install deepface from its source code. Source code may have new features not published in pip release yet.
```shell
$ git clone https://github.com/serengil/deepface.git
$ cd deepface
$ pip install -e .
```
Once you installed the library, then you will be able to import it and use its functionalities.
```python
from deepface import DeepFace
```
> π‘ Prefer not to install or manage infrastructure? You can use a managed API via [deepface.dev](https://deepface.dev?source=deepface_repo).
**Face Verification** - [`Demo`](https://youtu.be/KRCvkNCOphE)
This function determines whether two facial images belong to the same person or to different individuals. The function returns a dictionary, where the key of interest is `verified`: True indicates the images are of the same person, while False means they are of different people.
```python
result: dict = DeepFace.verify(img1_path = "img1.jpg", img2_path = "img2.jpg")
```
**Face recognition** - [`Tutorial`](https://sefiks.com/2026/01/01/introducing-brand-new-face-recognition-in-deepface/), [`Demo`](https://youtu.be/Hrjp-EStM_s)
[Face recognition](https://sefiks.com/2020/05/25/large-scale-face-recognition-for-deep-learning/) requires applying face verification many times. DeepFace provides an out-of-the-box `find` function that searches for the identity of an input image within a specified database path.
```python
dfs: List[pd.DataFrame] = DeepFace.find(img_path = "img1.jpg", db_path = "C:/my_db")
```
Here, the `find` function relies on a directory-based face datastore and stores embeddings on disk. Alternatively, DeepFace provides a database-backed [`search`](https://sefiks.com/2026/01/01/introducing-brand-new-face-recognition-in-deepface/) functionality where embeddings are explicitly registered and queried with [`approximate nearest neighbor`](https://sefiks.com/2023/12/31/a-step-by-step-approximate-nearest-neighbor-example-in-python-from-scratch/) support. Currently, [postgres](https://sefiks.com/2023/06/22/vector-similarity-search-in-postgresql/), [mongo](https://sefiks.com/2021/01/22/deep-face-recognition-with-mongodb/), [neo4j](https://sefiks.com/2021/04/03/deep-face-recognition-with-neo4j/), [pgvector](https://sefiks.com/2024/07/05/postgres-as-a-vector-database-billion-scale-vector-similarity-search-with-pgvector/), [pinecone](https://sefiks.com/2021/05/19/large-scale-face-recognition-with-pinecone-vector-database/) and weaviate are supported as backend databases.
```python
# register an image into the database
DeepFace.register(img = "img1.jpg")
# perform exact search
dfs: List[pd.DataFrame] = DeepFace.search(img = "target.jpg")
# perform approximate nearest neighbor search
dfs: List[pd.DataFrame] = DeepFace.search(img = "target.jpg", search_method = "ann")
```
**Facial Attribute Analysis** - [`Demo`](https://youtu.be/GT2UeN85BdA)
DeepFace also comes with a strong facial attribute analysis module including [`age`](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [`gender`](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [`facial expression`](https://sefiks.com/2018/01/01/facial-expression-recognition-with-keras/) (including angry, fear, neutral, sad, disgust, happy and surprise) and [`race`](https://sefiks.com/2019/11/11/race-and-ethnicity-prediction-in-keras/) (including asian, white, middle eastern, indian, latino and black) predictions.
```python
objs: List[dict] = DeepFace.analyze(
img_path = "img4.jpg", actions = ['age', 'gender', 'race', 'emotion']
)
```
Age model got Β± 4.65 MAE; gender model got 97.44% accuracy, 96.29% precision and 95.05% recall as mentioned in its [tutorial](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/).
**Real Time Analysis** - [`Demo`](https://youtu.be/-c9sSJcx6wI), [`React Demo part-i`](https://youtu.be/IXoah6rhxac), [`React Demo part-ii`](https://youtu.be/_waBA-cH2D4)
You can run deepface for real time videos as well. Stream function will access your webcam and apply both face recognition and facial attribute analysis. The function starts to analyze a frame if it can focus a face sequentially 5 frames. Then, it shows results 5 seconds.
```python
DeepFace.stream(db_path = "C:/database")
```
Even though face recognition is based on one-shot learning, you can use multiple face pictures of a person as well. You should rearrange your directory structure as illustrated below.
```bash
user
βββ database
β βββ Alice
β β βββ Alice1.jpg
β β βββ Alice2.jpg
β βββ Bob1.jpg
```
Here, you can also find some real time demos for various models:
| Task | Model | Demo |
| --- | --- | --- |
| Facial Recognition | DeepFace | [`Video`](https://youtu.be/YjYIMs5ZOfc) |
| Facial Recognition | FaceNet | [`Video`](https://youtu.be/vB1I5vWgTQg) |
| Facial Recognition | VGG-Face | [`Video`](https://youtu.be/tSU_lNi0gQQ) |
| Facial Recognition | OpenFace | [`Video`](https://youtu.be/-4z2sL6wzP8) |
| Age & Gender | Default | [`Video`](https://youtu.be/tFI7vZn3P7E) |
| Race & Ethnicity | Default | [`Video`](https://youtu.be/-ztiy5eJha8) |
| Emotion | Default | [`Video`](https://youtu.be/Y7DfLvLKScs) |
| Celebrity Look-Alike | Default | [`Video`](https://youtu.be/RMgIKU1H8DY) |
If you intend to perform face verification or analysis tasks directly from your browser, [`deepface-react-ui`](https://github.com/serengil/deepface-react-ui) is a separate repository built using ReactJS depending on deepface api.
**Embeddings** - [`Tutorial`](https://sefiks.com/2025/06/28/what-are-vector-embeddings-and-why-they-matter-in-ai/), [`Demo`](https://youtu.be/OYialFo7Qo4)
Face recognition models basically [represent](https://sefiks.com/2020/05/01/a-gentle-introduction-to-face-recognition-in-deep-learning/) facial images as multi-dimensional vectors. Sometimes, you need those embedding vectors directly. DeepFace comes with a dedicated representation function.
```python
embedding_objs: List[dict] = DeepFace.represent(img_path = "img.jpg")
```
**Face recognition models** - [`Demo`](https://youtu.be/eKOZawGR3y0)
DeepFace is a **hybrid** face recognition package. It currently wraps many **state-of-the-art** face recognition models: [`VGG-Face`](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) , [`FaceNet`](https://sefiks.com/2018/09/03/face-recognition-with-facenet-in-keras/), [`OpenFace`](https://sefiks.com/2019/07/21/face-recognition-with-openface-in-keras/), [`DeepFace`](https://sefiks.com/2020/02/17/face-recognition-with-facebook-deepface-in-keras/), [`DeepID`](https://sefiks.com/2020/06/16/face-recognition-with-deepid-in-keras/), [`ArcFace`](https://sefiks.com/2020/12/14/deep-face-recognition-with-arcface-in-keras-and-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/), `SFace`, `GhostFaceNet` and `Buffalo_L`. The default configuration uses VGG-Face model.
```python
models = [
"VGG-Face", "Facenet", "Facenet512", "OpenFace", "DeepFace",
"DeepID", "ArcFace", "Dlib", "SFace", "GhostFaceNet",
"Buffalo_L",
]
result = DeepFace.verify(
img1_path = "img1.jpg", img2_path = "img2.jpg", model_name = models[0]
)
dfs = DeepFace.find(
img_path = "img1.jpg", db_path = "C:/my_db", model_name = models[1]
)
embeddings = DeepFace.represent(
img_path = "img.jpg", model_name = models[2]
)
```
See [`BENCHMARKS`](https://github.com/serengil/deepface/tree/master/benchmarks) for their accuracies.
**Face Detection and Alignment** - [`Demo`](https://youtu.be/GZ2p2hj2H5k)
Face detection and alignment are important early stages of a modern face recognition pipeline. [Experiments](https://github.com/serengil/deepface/tree/master/benchmarks) show that detection increases the face recognition accuracy up to 42%, while alignment increases it up to 6%. [`OpenCV`](https://sefiks.com/2020/02/23/face-alignment-for-face-recognition-in-python-within-opencv/), [`Ssd`](https://sefiks.com/2020/08/25/deep-face-detection-with-opencv-in-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/), [`MtCnn`](https://sefiks.com/2020/09/09/deep-face-detection-with-mtcnn-in-python/), `Faster MtCnn`, [`RetinaFace`](https://sefiks.com/2021/04/27/deep-face-detection-with-retinaface-in-python/), [`MediaPipe`](https://sefiks.com/2022/01/14/deep-face-detection-with-mediapipe/), `Yolo`, `YuNet` and `CenterFace` detectors are wrapped in deepface.
All deepface functions accept optional detector backend and align input arguments. You can switch among those detectors and alignment modes with these arguments. OpenCV is the default detector and alignment is on by default.
```python
backends = [
'opencv', 'ssd', 'dlib', 'mtcnn', 'fastmtcnn',
'retinaface', 'mediapipe', 'yolov8n', 'yolov8m',
'yolov8l', 'yolov11n', 'yolov11s', 'yolov11m',
'yolov11l', 'yolov12n', 'yolov12s', 'yolov12m',
'yolov12l', 'yunet', 'centerface',
]
detector = backends[3]
align = True
obj = DeepFace.verify(
img1_path = "img1.jpg", img2_path = "img2.jpg", detector_backend = detector, align = align
)
dfs = DeepFace.find(
img_path = "img.jpg", db_path = "my_db", detector_backend = detector, align = align
)
embedding_objs = DeepFace.represent(
img_path = "img.jpg", detector_backend = detector, align = align
)
demographies = DeepFace.analyze(
img_path = "img4.jpg", detector_backend = detector, align = align
)
face_objs = DeepFace.extract_faces(
img_path = "img.jpg", detector_backend = detector, align = align
)
```
RetinaFace overperforms among all face detection models in the portfolio.
Running RetinaFace On The Yellow Angels - Fenerbahce Women's Volleyball Team
See [`BENCHMARKS`](https://github.com/serengil/deepface/tree/master/benchmarks) for their accuracies.
**Face Anti Spoofing** - [`Demo`](https://youtu.be/UiK1aIjOBlQ)
DeepFace also includes an anti-spoofing analysis module to understand given image is real or fake. To activate this feature, set the `anti_spoofing` argument to True in any DeepFace tasks.
```python
# anti spoofing test in face detection
face_objs = DeepFace.extract_faces(img_path="dataset/img1.jpg", anti_spoofing = True)
assert all(face_obj["is_real"] is True for face_obj in face_objs)
# anti spoofing test in real time analysis
DeepFace.stream(db_path = "C:/database", anti_spoofing = True)
```
**Similarity** - [`Demo`](https://youtu.be/1EPoS69fHOc)
Face recognition models are regular [convolutional neural networks](https://sefiks.com/2018/03/23/convolutional-autoencoder-clustering-images-with-neural-networks/) and they are responsible to represent faces as vectors. We expect that a face pair of same person should be [more similar](https://sefiks.com/2020/05/22/fine-tuning-the-threshold-in-face-recognition/) than a face pair of different persons.
Similarity could be calculated by different metrics such as [Cosine Similarity](https://sefiks.com/2018/08/13/cosine-similarity-in-machine-learning/), Angular Distance, Euclidean Distance or L2 normalized Euclidean. The default configuration uses cosine similarity. According to [experiments](https://github.com/serengil/deepface/tree/master/benchmarks), no distance metric is overperforming than other.
```python
metrics = ["cosine", "euclidean", "euclidean_l2", "angular"]
result = DeepFace.verify(
img1_path = "img1.jpg", img2_path = "img2.jpg", distance_metric = metrics[1]
)
dfs = DeepFace.find(
img_path = "img1.jpg", db_path = "C:/my_db", distance_metric = metrics[2]
)
```
**API** - [`Demo`](https://youtu.be/HeKCQ6U9XmI), [`Docker Demo`](https://youtu.be/9Tk9lRQareA)
DeepFace serves an API as well - see [`api folder`](https://github.com/serengil/deepface/tree/master/deepface/api/src) for more details. You can clone deepface source code and run the api with the following command. It will use gunicorn server to get a rest service up. In this way, you can call deepface from an external system such as mobile app or web.
```shell
# running the service directly
cd scripts && ./service.sh
# running the service via docker
cd scripts && ./dockerize.sh
```
Face verification, facial attribute analysis, vector representation and register & search functions are covered in the API. The API accepts images as file uploads (via form data), or as exact image paths, URLs, or base64-encoded strings (via either JSON or form data).
```shell
$ curl -X POST http://localhost:5005/represent \
-d '{"model_name":"Facenet", "img":"img1.jpg"}'
$ curl -X POST http://localhost:5005/verify \
-d '{"img1":"img1.jpg", "img2":"img3.jpg"}'
$ curl -X POST http://localhost:5005/analyze \
-d '{"img": "img2.jpg", "actions": ["age", "gender"]}'
$ curl -X POST http://localhost:5005/register \
-d '{"model_name":"Facenet", "img":"img18.jpg"}'
$ curl -X POST http://localhost:5005/search \
-d '{"img":"img1.jpg", "model_name":"Facenet"}'
```
**DeepFace Cloud** - [`Demo`](https://youtu.be/5o7ezk0MMqM)
Donβt want to host and scale DeepFace yourself? [`deepface.dev`](https://deepface.dev?source=deepface_repo) provides a managed API built on top of DeepFace.
- One API for verification, embeddings, and vector comparison
- Docs and machine-readable agent docs: [`docs.deepface.dev`](https://docs.deepface.dev?source=deepface_repo)
- MCP endpoint: `https://deepface.dev/mcp` using a dedicated MCP key
- Usage-based pricing that scales from testing to production
### Extended Applications
DeepFace isn't only for facial recognition, it can also be used for fun and insightful applications such as
**Find Your Celebrity Look-Alike** - [`Demo`](https://youtu.be/jaxkEn-Kieo), [`Real-Time Demo`](https://youtu.be/RMgIKU1H8DY), [`Tutorial`](https://sefiks.com/2019/05/05/celebrity-look-alike-face-recognition-with-deep-learning-in-keras/)
DeepFace can analyze your facial features and match them with celebrities, letting you discover which famous personality you resemble the most.
**Find Which Parent a Child Look More** - [`Demo`](https://youtu.be/nza4tmi9vhE), [`Tutorial`](https://sefiks.com/2022/12/22/decide-whom-your-child-looks-like-with-facial-recognition-mommy-or-daddy/)
DeepFace can also be used to compare a child's face to their parents' or relatives' faces to determine which one the child resembles more.
## Support
There are many ways to support a project - starringβοΈ the GitHub repo is just one π It really helps the project get discovered by more people.
If you do like this work, you can also support it financially on [Patreon](https://www.patreon.com/serengil?repo=deepface), [GitHub Sponsors](https://github.com/sponsors/serengil) or [Buy Me a Coffee](https://buymeacoffee.com/serengil).
## Citation
Please cite deepface in your publications if it helps your research. Here is its BibTex entry:
```BibTeX
@article{serengil2026boosted,
title = {Boosted LightFace: A Hybrid DNN and GBM Model for Boosted Facial Recognition},
author = {Serengil, Sefik Ilkin and Ozpinar, Alper},
journal = {Gazi University Journal of Science},
volume = {39},
number = {1},
pages = {452-466},
year = {2026},
doi = {10.35378/gujs.1794891},
url = {https://dergipark.org.tr/en/pub/gujs/article/1794891},
publisher = {Gazi University}
}
```
Also, if you use deepface in your GitHub projects, please add `deepface` in the `requirements.txt`.
## Licence
DeepFace is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/deepface/blob/master/LICENSE) for more details.
DeepFace wraps some external face recognition models: [VGG-Face](http://www.robots.ox.ac.uk/~vgg/software/vgg_face/), [Facenet](https://github.com/davidsandberg/facenet/blob/master/LICENSE.md) (both 128d and 512d), [OpenFace](https://github.com/iwantooxxoox/Keras-OpenFace/blob/master/LICENSE), [DeepFace](https://github.com/swghosh/DeepFace), [DeepID](https://github.com/Ruoyiran/DeepID/blob/master/LICENSE.md), [ArcFace](https://github.com/leondgarse/Keras_insightface/blob/master/LICENSE), [Dlib](https://github.com/davisking/dlib/blob/master/dlib/LICENSE.txt), [SFace](https://github.com/opencv/opencv_zoo/blob/master/models/face_recognition_sface/LICENSE), [GhostFaceNet](https://github.com/HamadYA/GhostFaceNets/blob/main/LICENSE) and
[Buffalo_L](https://github.com/deepinsight/insightface/blob/master/README.md). Besides, age, gender and race / ethnicity models were trained on the backbone of VGG-Face with transfer learning. Similarly, DeepFace wraps many face detectors: [OpenCv](https://github.com/opencv/opencv/blob/4.x/LICENSE), [Ssd](https://github.com/opencv/opencv/blob/master/LICENSE), [Dlib](https://github.com/davisking/dlib/blob/master/LICENSE.txt), [MtCnn](https://github.com/ipazc/mtcnn/blob/master/LICENSE), [Fast MtCnn](https://github.com/timesler/facenet-pytorch/blob/master/LICENSE.md), [RetinaFace](https://github.com/serengil/retinaface/blob/master/LICENSE), [MediaPipe](https://github.com/google/mediapipe/blob/master/LICENSE), [YuNet](https://github.com/ShiqiYu/libfacedetection/blob/master/LICENSE), [Yolo](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) and [CenterFace](https://github.com/Star-Clouds/CenterFace/blob/master/LICENSE). Finally, DeepFace is optionally using [face anti spoofing](https://github.com/minivision-ai/Silent-Face-Anti-Spoofing/blob/master/LICENSE) to determine the given images are real or fake. License types will be inherited when you intend to utilize those models. Please check the license types of those models for production purposes.
DeepFace [logo](https://thenounproject.com/term/face-recognition/2965879/) is created by [Adrien Coquet](https://thenounproject.com/coquet_adrien/) and it is licensed under [Creative Commons: By Attribution 3.0 License](https://creativecommons.org/licenses/by/3.0/).