Skip to content

Frigate Notebook Proof of Concept

Frigate Notebook Proof of Concept — Person, Face and Number Plate Detection

Section titled “Frigate Notebook Proof of Concept — Person, Face and Number Plate Detection”

Purpose: Test Frigate on a Windows notebook before buying a dedicated roadside ANPR camera
Platform: Windows 11 notebook
Goal: Verify that the software stack can detect people, optionally recognize a known face, and recognize licence plates from a camera/video source
Status: Proof of Concept (POC)
Date: October 2026


  1. Introduction
  2. What This Proof of Concept Is Testing
  3. What This POC Is Not Testing
  4. POC Architecture
  5. Recommended Test Order
  6. Hardware and Software Requirements
  7. Important Note About Windows and Frigate
  8. Step 1 — Install Docker Desktop
  9. Step 2 — Create the Frigate Project Folder
  10. Step 3 — Create Docker Compose
  11. Step 4 — Start Frigate
  12. Step 5 — Prepare a Camera Stream
  13. Option A — Use the Notebook Webcam
  14. Option B — Use a Recorded Vehicle Video
  15. Option C — Use an IP / RTSP Camera
  16. Step 6 — Add the Camera to Frigate
  17. Step 7 — Test Person Detection
  18. Step 8 — Enable Face Recognition
  19. Step 9 — Train a Known Face
  20. Step 10 — Enable Licence Plate Recognition
  21. Step 11 — Test Licence Plate Recognition
  22. Recommended Frigate LPR Settings
  23. How to Test New Zealand Number Plates
  24. How to Measure Accuracy
  25. Suggested POC Test Matrix
  26. Expected Limitations
  27. Troubleshooting
  28. POC Success Criteria
  29. What to Do After the POC
  30. Recommended Folder Structure
  31. Useful Commands
  32. Privacy Notes
  33. Reference Links
  34. Final Recommended Workflow

This proof of concept is the first software experiment for a larger roadside vehicle-security project.

The longer-term project is intended to create one or more remote roadside camera nodes that can:

  • detect vehicles;
  • read number plates;
  • record the time and direction of travel;
  • detect people near an incident;
  • optionally retain useful face images;
  • allow searches after a vehicle theft or other security incident.

The eventual roadside system may use:

ANPR camera
+ optional overview/person camera
+ solar panel
+ LiFePO4 battery
+ 4G/LTE router
+ weatherproof enclosure
+ central server

However, buying and building all of that hardware before testing the software would create unnecessary cost and risk.

The purpose of this notebook POC is therefore to answer:

Can Frigate successfully detect a person, optionally recognize a known face, and recognize a licence plate using simple test camera/video inputs?

This POC deliberately uses an existing notebook before purchasing the final ANPR camera.


The POC tests three separate functions.

The system should detect:

person

when somebody walks in front of the test camera.

Expected output:

Person detected
Timestamp recorded
Event appears in Frigate
Snapshot available

This is optional and should only be tested after person detection works.

The POC should determine whether Frigate can:

Person detected
|
Face detected
|
Face embedding
|
Known person?

Example:

Harry
Confidence: 92%

or:

Unknown

For the POC, use only your own face or the face of another person who has agreed to participate.


The system should process a vehicle image or video and attempt to produce:

ABC123

together with a recognition confidence.

The first licence-plate test does not need to use a real roadside ANPR camera.

It can use:

  • a recorded vehicle video;
  • a phone video;
  • an IP camera;
  • later, the dedicated ANPR camera.

The notebook POC is not a reliable test of final roadside camera performance.

A notebook webcam does not reproduce:

30–50 km/h moving vehicles
night-time conditions
headlights
retroreflective plates
10–30 metre capture distance
rain
roadside mounting angle
850 nm IR illumination

Therefore:

Successful software detection on the notebook proves that the software pipeline works. It does not prove that the future roadside camera will capture readable plates at night.

The dedicated roadside ANPR camera will require a separate optical test later.


The overall notebook POC is:

WINDOWS 11 NOTEBOOK
|
+----------+----------+
| |
v v
Docker Desktop MediaMTX
| |
v |
Frigate <-------- RTSP --+
|
+-------+--------+--------+
| | |
v v v
Person Face LPR
Detection Recognition

Possible video sources:

Notebook webcam
Recorded MP4
IP / RTSP camera

Do the tests in this order:

1. Install Docker Desktop
|
2. Start Frigate
|
3. Create an RTSP test stream
|
4. Confirm live video
|
5. Confirm person detection
|
6. Enable face recognition
|
7. Test your own known face
|
8. Feed a vehicle video
|
9. Enable LPR
|
10. Compare detected plate with actual plate

Do not begin with all features enabled at the same time.


Suggested minimum:

Windows 11 notebook
4 GB RAM minimum for LPR
8 GB+ RAM preferable
Modern x86-64 CPU
AVX + AVX2 support
Webcam or test video
Internet for initial model downloads

A GPU is useful but is not required for this first POC.

Frigate can use a CPU detector for testing, although dedicated acceleration is preferable for a permanent installation.


Install:

Docker Desktop
WSL2
Frigate
FFmpeg
MediaMTX

Optional:

VLC
Visual Studio Code

7. Important Note About Windows and Frigate

Section titled “7. Important Note About Windows and Frigate”

Frigate is primarily designed to run as a Docker container and performs best on a bare-metal Debian-based Linux system.

For a temporary software POC, Docker Desktop on Windows is acceptable.

However, Windows Docker is not the preferred final production platform.

The eventual production system should probably use:

Debian / Ubuntu
+
Docker Engine
+
Frigate

or another supported Linux host.

Another Windows-specific issue is the notebook webcam.

Passing a Windows USB webcam directly into a Linux Docker container can be awkward.

The easiest POC approach is therefore:

Windows webcam
|
FFmpeg
|
MediaMTX
|
RTSP
|
Frigate

This makes the webcam look like a normal IP camera to Frigate.


Download and install Docker Desktop for Windows.

During installation:

  • enable WSL2 integration;
  • allow Docker to use the WSL2 backend;
  • restart Windows if requested.

Verify from PowerShell:

Terminal window
docker --version

Then:

Terminal window
docker compose version

Expected result:

Docker version ...
Docker Compose version ...

9. Step 2 — Create the Frigate Project Folder

Section titled “9. Step 2 — Create the Frigate Project Folder”

Example:

Terminal window
mkdir C:\Users\harry\MyWorks\frigate-poc
cd C:\Users\harry\MyWorks\frigate-poc
mkdir config
mkdir storage

Result:

frigate-poc/
│
├── docker-compose.yml
├── config/
│ └── config.yml
│
└── storage/

Create:

docker-compose.yml

with:

services:
frigate:
container_name: frigate
restart: unless-stopped
stop_grace_period: 30s
image: ghcr.io/blakeblackshear/frigate:stable
shm_size: "512mb"
volumes:
- ./config:/config
- ./storage:/media/frigate
tmpfs:
- /tmp/cache:size=1000000000
ports:
- "8971:8971"
- "8554:8554"
- "8555:8555/tcp"
- "8555:8555/udp"
environment:
FRIGATE_RTSP_PASSWORD: "change-this-password"

For the POC this is intentionally simple.

Do not expose Frigate directly to the public Internet.


From PowerShell:

Terminal window
cd C:\Users\harry\MyWorks\frigate-poc
docker compose up -d

Check status:

Terminal window
docker ps

Check Frigate log:

Terminal window
docker logs frigate

On the first run, Frigate creates an admin login.

Open:

https://localhost:8971

Your browser may warn about the locally generated HTTPS certificate.

For a local POC, this is expected.

Use the administrator credentials shown in the container log.


Frigate normally expects a network video stream.

For this POC, there are three easy choices:

A. Notebook webcam
B. Recorded MP4
C. Existing IP / RTSP camera

Option C is the closest to the final setup.

Option A is convenient for person and face testing.

Option B is ideal for repeatable licence-plate testing.


Install FFmpeg for Windows and ensure:

Terminal window
ffmpeg -version

works.


Download the Windows build of MediaMTX.

Extract it somewhere such as:

C:\Tools\mediamtx\

MediaMTX is a lightweight local media server.

It allows FFmpeg to publish your webcam as RTSP.


Run:

Terminal window
ffmpeg -list_devices true -f dshow -i dummy

Look for something similar to:

Integrated Camera

or:

USB2.0 HD UVC WebCam

Copy the exact device name.


Open:

mediamtx.yml

and configure a path like:

paths:
webcam:
runOnInit: ffmpeg -f dshow -i video="Integrated Camera" -c:v libx264 -pix_fmt yuv420p -preset ultrafast -b:v 1500k -f rtsp rtsp://localhost:$RTSP_PORT/$MTX_PATH
runOnInitRestart: yes

Replace:

Integrated Camera

with the actual device name.


Run:

Terminal window
mediamtx.exe

The webcam stream should become:

rtsp://localhost:8554/webcam

Open VLC:

Media
→ Open Network Stream

Enter:

rtsp://localhost:8554/webcam

If you can see the notebook webcam, the stream is ready for Frigate.


14. Option B — Use a Recorded Vehicle Video

Section titled “14. Option B — Use a Recorded Vehicle Video”

This is highly recommended for number-plate testing because the exact same clip can be replayed repeatedly.

Example:

C:\Users\harry\Videos\anpr-test\night-car.mp4

Start MediaMTX.

Then publish the file:

Terminal window
ffmpeg -re -stream_loop -1 -i "C:\Users\harry\Videos\anpr-test\night-car.mp4" -c copy -f rtsp rtsp://localhost:8554/testcar

If -c copy causes codec problems, use:

Terminal window
ffmpeg -re -stream_loop -1 -i "C:\Users\harry\Videos\anpr-test\night-car.mp4" -c:v libx264 -an -f rtsp rtsp://localhost:8554/testcar

The resulting stream is:

rtsp://localhost:8554/testcar

Test it in VLC before adding it to Frigate.


If an existing CCTV or IP camera supports RTSP, this is even easier.

Example:

rtsp://username:password@192.168.1.50:554/stream

The exact URL depends on the camera manufacturer.

Test it first in VLC.

If it works in VLC, it is usually much easier to connect it to Frigate.


Frigate’s current UI includes an Add Camera wizard.

Use:

Settings
→ Global configuration
→ Camera management
→ Add Camera

For the notebook webcam RTSP stream, use the MediaMTX address reachable from the Frigate container.

Depending on Docker Desktop networking, localhost from inside the container refers to the container itself, not Windows.

A common Windows Docker host address is:

host.docker.internal

Therefore try:

rtsp://host.docker.internal:8554/webcam

For the recorded vehicle stream:

rtsp://host.docker.internal:8554/testcar

If using a real IP camera:

rtsp://user:password@CAMERA_IP/...

After adding the camera, confirm:

Live view works
No continuous FFmpeg errors
Video updates normally

Start simple.

Use Frigate’s default CPU detector for the POC.

A minimal detector configuration is:

detectors:
cpu1:
type: cpu
num_threads: 3

Then configure the webcam camera to track:

person

Using the UI:

Settings
→ Camera configuration
→ Objects
→ Objects to track
→ person

Now walk in front of the notebook camera.

Expected:

person bounding box
person event
timestamp
snapshot

If person detection works, the object-detection part of the POC is successful.


Frigate face recognition is disabled by default.

Go to:

Settings
→ Enrichments
→ Face recognition

Enable it.

For the notebook POC choose:

Model size: small

The small model is designed to run on CPU.

Equivalent YAML:

face_recognition:
enabled: true
model_size: small
detection_threshold: 0.7
min_area: 750

Frigate must first detect a person before it attempts face detection and recognition.

Therefore:

person detection
↓
face detection
↓
face recognition

Use:

Face Library
→ Add Face

Start with a few clear photos.

Recommended:

front-facing
good lighting
not blurry
face reasonably large

For example:

Harry
├── front
├── slight-left
└── slight-right

Avoid uploading many poor-quality images.

Quality and variation are more useful than a large number of almost identical images.

Then stand in front of the webcam again.

Expected:

person detected
↓
face detected
↓
Harry

If confidence is insufficient:

Unknown

Use the Face Library training workflow to improve the model with good-quality examples.


20. Step 10 — Enable Licence Plate Recognition

Section titled “20. Step 10 — Enable Licence Plate Recognition”

Go to:

Settings
→ Enrichments
→ License plate recognition

Enable LPR.

Recommended first settings:

Enabled: Yes
Device: CPU
Model size: small
Detection threshold: 0.7
Recognition threshold: 0.9
Minimum plate length: 4
Save debug plates: Yes

Equivalent YAML:

lpr:
enabled: true
device: CPU
model_size: small
detection_threshold: 0.7
recognition_threshold: 0.9
min_plate_length: 4
debug_save_plates: true

Frigate’s built-in LPR can use:

YOLOv9 plate detection
+
PaddleOCR

when the main object model does not natively detect plates.


21. Step 11 — Test Licence Plate Recognition

Section titled “21. Step 11 — Test Licence Plate Recognition”

The easiest repeatable test is a recorded vehicle video.

Use a clip containing:

vehicle clearly visible
plate visible
plate reasonably large
minimal motion blur

Publish it with MediaMTX:

night-car.mp4
|
FFmpeg
|
MediaMTX
|
RTSP
|
Frigate

For normal Frigate LPR operation, the vehicle should first be detected as:

car

or another supported vehicle class.

Then Frigate attempts to find and read the plate.

Check:

Explore
Review / History
Tracked object details
Recognized licence plate

Start conservatively.

lpr:
enabled: true
device: CPU
model_size: small
detection_threshold: 0.7
recognition_threshold: 0.9
min_plate_length: 4
debug_save_plates: true

Do not immediately lower all thresholds if detection fails.

First inspect the debug plate crops.

Ask:

Did Frigate find the plate?
Is the crop sharp?
Can I read the plate manually?
Is the plate large enough?

This separates:

capture problem
plate detection problem
OCR problem

Create a small benchmark dataset.

For example:

data/
video/
car-001.mp4
car-002.mp4
car-003.mp4
ground-truth.csv

Example:

video,actual_plate
car-001.mp4,ABC123
car-002.mp4,XYZ789
car-003.mp4,DEF456

Then record:

video,actual_plate,frigate_plate,correct,confidence
car-001.mp4,ABC123,ABC123,true,0.97
car-002.mp4,XYZ789,XYZ7B9,false,0.91
car-003.mp4,DEF456,DEF456,true,0.96

Do not judge the software from one plate.

Aim for at least:

20–50 test vehicles

for the first meaningful experiment.

Later use:

100–200 vehicles

for a stronger test.


Track separate metrics.

Readable plates / total vehicles

Example:

47 readable / 50 vehicles
= 94%

Plate crops detected / readable plates

Correct OCR / detected readable plates

Require the complete plate to match:

ABC123 == ABC123

A one-character error counts as incorrect.


Measure:

person events detected / actual person appearances

Measure:

correct identity matches
false unknowns
false identity matches

False identity matches are particularly important.


TestExpected Result
Walk in front of webcamPerson detected
Stand still facing cameraFace detected
Known enrolled faceCorrect name where image quality is sufficient
Unknown personShould not confidently become another known person
Clear static platePlate recognized
Day vehicle videoPlate recognized if sufficiently clear
Low-resolution plateLikely lower accuracy
Blurry plateLikely lower accuracy
Night phone videoTest only; not equivalent to ANPR camera
Replay same videoSimilar result each run

Good for:

person detection
face testing
basic Frigate testing

Poor for:

moving roadside plates
night vehicles
headlight glare
long distance

Suitable for:

POC
one camera
low/moderate detect FPS

Not ideal for:

many cameras
high-resolution continuous AI
production deployment

Accuracy is affected by:

  • face angle;
  • lighting;
  • blur;
  • distance;
  • face size;
  • glasses;
  • hats;
  • partial occlusion.

Treat recognition as probabilistic.


Accuracy is affected by:

  • plate pixel size;
  • blur;
  • viewing angle;
  • reflections;
  • headlights;
  • overexposure;
  • dirt;
  • plate design;
  • compression.

Check:

Terminal window
docker logs frigate

Validate YAML indentation carefully.


Check:

Terminal window
docker ps

Then:

https://localhost:8971

Do not use:

rtsp://localhost:8554/webcam

inside the Docker container unless MediaMTX is running inside that same container/network.

Try:

rtsp://host.docker.internal:8554/webcam

First verify with VLC:

rtsp://localhost:8554/webcam

If VLC cannot read it, fix FFmpeg / MediaMTX before troubleshooting Frigate.


Run:

Terminal window
ffmpeg -list_devices true -f dshow -i dummy

Use the exact video-device name.


Reduce:

detect FPS
resolution
number of active features

For example:

detect:
fps: 5

For this POC, 5 FPS is enough for basic person testing.


Check:

Is person detection working first?
Is the face large enough?
Is face recognition globally enabled?

Frigate does not attempt face recognition until a person has been detected.


Check:

Is LPR globally enabled?
Is a supported vehicle being detected?
Is the plate large enough?
Can you read the plate yourself?

Enable:

debug_save_plates: true

and inspect the saved crops.


Examples:

0 ↔ O
1 ↔ I
5 ↔ S
8 ↔ B

Do not immediately auto-correct the result.

Record:

raw OCR
confidence
actual plate

Later, build NZ-specific normalisation carefully.


The notebook POC is considered successful when:

  • Frigate starts reliably in Docker;
  • the browser UI is accessible;
  • a test RTSP stream is visible.
  • walking in front of the webcam generates a person detection;
  • the event appears in Frigate;
  • a useful snapshot is available.

Optional:

  • Frigate detects a face after detecting a person;
  • your enrolled face can be recognized under good conditions;
  • an unknown person is not incorrectly treated as a known identity.
  • Frigate detects a vehicle in a test clip;
  • it finds the number plate;
  • it produces an OCR result;
  • debug plate images can be reviewed;
  • at least several clear NZ plates are recognized correctly.

The purpose is not yet to achieve production accuracy.

The purpose is to prove:

video
|
Frigate
|
AI detection
|
useful structured result

Once this notebook POC works:

Buy or borrow one proper ANPR camera.

Test:

night
30–50 km/h
headlights
10–20 m
IR

Connect the real camera to Frigate:

ANPR camera
|
RTSP
|
Frigate

Compare:

Frigate LPR
vs
camera-native ANPR

Write a custom Python comparison:

YOLO
+
PaddleOCR

Run it against the exact same video dataset.


Only after recognition is reliable, build:

solar
battery
MPPT
4G/LTE
weatherproof box

for the roadside prototype.


frigate-poc/
│
├── docker-compose.yml
│
├── config/
│ └── config.yml
│
├── storage/
│
├── test-data/
│ ├── videos/
│ │ ├── daytime/
│ │ └── night/
│ │
│ ├── plates/
│ └── ground-truth.csv
│
├── notes/
│ └── test-results.md
│
└── scripts/
└── start-test-stream.ps1

Start Frigate:

Terminal window
docker compose up -d

Stop Frigate:

Terminal window
docker compose down

Restart:

Terminal window
docker compose restart

Logs:

Terminal window
docker logs -f frigate

List containers:

Terminal window
docker ps

List webcam devices:

Terminal window
ffmpeg -list_devices true -f dshow -i dummy

Replay MP4 over RTSP:

Terminal window
ffmpeg -re -stream_loop -1 -i test.mp4 -c:v libx264 -an -f rtsp rtsp://localhost:8554/testcar

For this POC:

  • use your own face for recognition testing where possible;
  • obtain consent before enrolling another person’s face;
  • do not create a database of strangers;
  • do not publish captured faces or number plates;
  • keep test data local;
  • delete test data when no longer required.

Person detection is different from identity recognition.

This POC should preferably stop at:

person detection
+
optional face recognition of consenting test subjects

before any real-world deployment decisions are made.

A roadside deployment involving biometric identification requires a separate privacy and legal review.


Main documentation:

https://docs.frigate.video/

Installation:

https://docs.frigate.video/frigate/installation/

Getting started:

https://docs.frigate.video/guides/getting_started/

Configuration:

https://docs.frigate.video/configuration/config/

Camera configuration:

https://docs.frigate.video/configuration/cameras/

Object detectors:

https://docs.frigate.video/configuration/object_detectors/

Licence Plate Recognition:

https://docs.frigate.video/configuration/license_plate_recognition/

Face Recognition:

https://docs.frigate.video/configuration/face_recognition/

go2rtc:

https://docs.frigate.video/configuration/go2rtc/


Main documentation:

https://mediamtx.org/docs/

Windows / generic webcam publishing:

https://mediamtx.org/docs/publish/generic-webcams

FFmpeg publishing:

https://mediamtx.org/docs/publish/ffmpeg


Do not try to build the final roadside system immediately.

Use this exact progression:

DAY 1
Windows notebook
|
Docker Desktop
|
Frigate starts

Then:

DAY 1–2
Notebook webcam
|
MediaMTX
|
RTSP
|
Frigate
|
person detection

Then:

NEXT
person
|
face detection
|
known-face test

Then:

NEXT
recorded car video
|
MediaMTX
|
Frigate
|
LPR

Then:

AFTER SOFTWARE POC
Dedicated ANPR camera
|
real daylight/night testing

And only after that:

FINAL REMOTE POC
Roadside location
|
ANPR camera
|
optional overview camera
|
LiFePO4 battery
|
solar + MPPT
|
4G/LTE + VPN
|
Frigate / central server

The notebook POC therefore has one simple purpose:

Prove the software workflow cheaply before spending money on the roadside hardware.