# How to Tune the Tolerance Parameter for Face Comparison Accuracy in face_recognition

> Master the face_recognition tolerance parameter to fine-tune face comparison accuracy. Understand how threshold adjustments impact matching strictness for better results.

- Repository: [Adam Geitgey/face_recognition](https://github.com/ageitgey/face_recognition)
- Tags: how-to-guide
- Published: 2026-03-06

---

**The tolerance parameter controls how strictly two face encodings must match by setting a threshold on the Euclidean distance between them, where lower values enforce stricter matching and higher values allow more leniency.**

When working with the `ageitgey/face_recognition` library, tuning the tolerance parameter is essential for achieving accurate face comparison results across different lighting conditions, camera qualities, and facial poses. This parameter directly determines the balance between false positives and false negatives in your face recognition pipeline.

## What the Tolerance Parameter Controls

The tolerance parameter governs the **Euclidean distance threshold** used by the `compare_faces` function in [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py). 

First, the library calculates the Euclidean distance between a candidate face encoding and each known encoding via `face_distance`. Then, `compare_faces` checks whether each distance is **less than or equal to the tolerance value**. 

- A **lower tolerance** (e.g., 0.4) restricts the allowed distance, creating stricter matching that reduces false positives but may increase false negatives.
- A **higher tolerance** (e.g., 0.8) expands the allowed distance, creating looser matching that reduces false negatives but may increase false positives.

## Default Tolerance Value and Why It Matters

The default tolerance value is **0.6**, as defined in the command-line interface implementation in [`face_recognition/face_recognition_cli.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/face_recognition_cli.py) and the API defaults.

This value was chosen to offer the best overall trade-off for most general-purpose datasets, balancing the natural variations in human faces against the need for distinctiveness. However, depending on your specific image quality, lighting conditions, and security requirements, the default may not optimize accuracy for your use case.

## When to Adjust the Tolerance Parameter

You should tighten or loosen the tolerance based on specific error patterns in your results.

**Tighten the tolerance (0.4–0.5)** when you observe the same person being reported multiple times in one image, or when you need high-security matching that minimizes false positives.

**Loosen the tolerance (0.7–0.8)** when genuine matches are being missed due to lighting variations, pose changes, or low-resolution images, and you prioritize recall over precision.

## How to Find the Optimal Tolerance for Your Dataset

To determine the best tolerance for your specific data, analyze the distribution of face distances in a validation set.

Run your test images using the `--show-distance` flag in the CLI, which outputs the raw Euclidean distances alongside match results. Examine these distances to identify where "same-person" distances end and "different-person" distances begin. Select a tolerance value that sits cleanly between these clusters, then validate by re-running your test with the new tolerance value.

## Implementing Tolerance in Code

### API Usage with compare_faces

When using the Python API directly, pass the `tolerance` parameter to `compare_faces` in [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py):

```python
import face_recognition

# Load and encode faces

known_image = face_recognition.load_image_file("known.jpg")
unknown_image = face_recognition.load_image_file("unknown.jpg")

known_encodings = face_recognition.face_encodings(known_image)
unknown_encodings = face_recognition.face_encodings(unknown_image)

# Compare with strict tolerance to reduce false positives

matches = face_recognition.compare_faces(
    known_encodings,
    unknown_encodings[0],
    tolerance=0.45
)

print("Match result:", matches)

```

### CLI Usage with --tolerance

The command-line interface in [`face_recognition/face_recognition_cli.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/face_recognition_cli.py) exposes the `--tolerance` flag:

```bash

# Scan known people folder with looser tolerance for poor lighting conditions

face_recognition ./known_people ./test.jpg --tolerance 0.75 --show-distance

```

Example output:

```

known_person_1.jpg distance 0.48 match True
known_person_2.jpg distance 0.82 match False

```

### Analyzing Distances Programmatically

To programmatically determine an optimal tolerance based on your data, use `face_distance` from [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py):

```python
import face_recognition
import numpy as np

# Load reference and candidate encodings

known_encoding = face_recognition.face_encodings(
    face_recognition.load_image_file("known.jpg")
)[0]

candidate_encodings = face_recognition.face_encodings(
    face_recognition.load_image_file("group.jpg")
)

# Calculate all distances

distances = [
    face_recognition.face_distance([known_encoding], c)[0] 
    for c in candidate_encodings
]

print("All distances:", distances)

# Find threshold between matches and non-matches

# (Example logic: split between distances below and above 0.6)

true_matches = [d for d in distances if d < 0.6]
false_matches = [d for d in distances if d >= 0.6]

if true_matches and false_matches:
    optimal_tolerance = (max(true_matches) + min(false_matches)) / 2
    print(f"Suggested tolerance: {optimal_tolerance:.3f}")

```

## Summary

- The **tolerance** parameter in `face_recognition` sets the Euclidean distance threshold in `compare_faces`, where distances ≤ tolerance return `True`.
- The **default value of 0.6** works well for general use but should be adjusted based on your specific image quality and security requirements.
- **Lower tolerance (0.4–0.5)** reduces false positives for high-security applications, while **higher tolerance (0.7–0.8)** reduces false negatives for challenging lighting or low-resolution images.
- Use the **`--show-distance`** CLI flag or `face_distance` API to analyze raw distances and empirically determine the optimal threshold for your dataset.

## Frequently Asked Questions

### What is the best tolerance value for high-security face recognition systems?

For high-security applications, use a tolerance between **0.4 and 0.5**. This stricter threshold minimizes false positives (imposters being accepted) by requiring face encodings to be very similar before returning a match. However, be aware that this may increase false negatives, where legitimate users are occasionally rejected.

### How does the tolerance parameter affect face comparison performance?

The tolerance parameter does not significantly affect computational performance or processing speed. It is a simple numerical comparison applied after the Euclidean distance calculation in `face_distance`. Whether you set tolerance to 0.1 or 0.9, the underlying 128-dimensional face encoding comparison requires the same computational effort; only the final boolean threshold changes.

### Can I use different tolerance values for different known faces?

The `compare_faces` function in [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py) applies a single tolerance value to all comparisons in a single call. However, you can implement per-person tolerances by calling `face_distance` directly for each known encoding separately, then applying your own custom threshold logic for each individual. This approach requires manual iteration over your known faces rather than using the convenience `compare_faces` wrapper.

### Why am I getting false positives even with the default 0.6 tolerance?

False positives with the default tolerance typically occur due to low-quality images, extreme lighting variations, or very similar-looking individuals (twins or family members). If you encounter this issue, first use the `--show-distance` flag to inspect the actual distance values. If same-person distances are consistently below 0.6 but different-person distances are also clustering near that value, reduce your tolerance to 0.5 or 0.4 to create clearer separation between match and non-match decisions.