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
Table of Contents
Section titled “Table of Contents”- Introduction
- What This Proof of Concept Is Testing
- What This POC Is Not Testing
- POC Architecture
- Recommended Test Order
- Hardware and Software Requirements
- Important Note About Windows and Frigate
- Step 1 — Install Docker Desktop
- Step 2 — Create the Frigate Project Folder
- Step 3 — Create Docker Compose
- Step 4 — Start Frigate
- Step 5 — Prepare a Camera Stream
- Option A — Use the Notebook Webcam
- Option B — Use a Recorded Vehicle Video
- Option C — Use an IP / RTSP Camera
- Step 6 — Add the Camera to Frigate
- Step 7 — Test Person Detection
- Step 8 — Enable Face Recognition
- Step 9 — Train a Known Face
- Step 10 — Enable Licence Plate Recognition
- Step 11 — Test Licence Plate Recognition
- Recommended Frigate LPR Settings
- How to Test New Zealand Number Plates
- How to Measure Accuracy
- Suggested POC Test Matrix
- Expected Limitations
- Troubleshooting
- POC Success Criteria
- What to Do After the POC
- Recommended Folder Structure
- Useful Commands
- Privacy Notes
- Reference Links
- Final Recommended Workflow
1. Introduction
Section titled “1. Introduction”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 serverHowever, 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.
2. What This Proof of Concept Is Testing
Section titled “2. What This Proof of Concept Is Testing”The POC tests three separate functions.
2.1 Person detection
Section titled “2.1 Person detection”The system should detect:
personwhen somebody walks in front of the test camera.
Expected output:
Person detectedTimestamp recordedEvent appears in FrigateSnapshot available2.2 Face recognition
Section titled “2.2 Face recognition”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:
HarryConfidence: 92%or:
UnknownFor the POC, use only your own face or the face of another person who has agreed to participate.
2.3 Number plate recognition
Section titled “2.3 Number plate recognition”The system should process a vehicle image or video and attempt to produce:
ABC123together 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.
3. What This POC Is Not Testing
Section titled “3. What This POC Is Not Testing”The notebook POC is not a reliable test of final roadside camera performance.
A notebook webcam does not reproduce:
30–50 km/h moving vehiclesnight-time conditionsheadlightsretroreflective plates10–30 metre capture distancerainroadside mounting angle850 nm IR illuminationTherefore:
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.
4. POC Architecture
Section titled “4. POC Architecture”The overall notebook POC is:
WINDOWS 11 NOTEBOOK | +----------+----------+ | | v v Docker Desktop MediaMTX | | v | Frigate <-------- RTSP --+ | +-------+--------+--------+ | | | v v v Person Face LPR Detection RecognitionPossible video sources:
Notebook webcamRecorded MP4IP / RTSP camera5. Recommended Test Order
Section titled “5. Recommended Test Order”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 plateDo not begin with all features enabled at the same time.
6. Hardware and Software Requirements
Section titled “6. Hardware and Software Requirements”Hardware
Section titled “Hardware”Suggested minimum:
Windows 11 notebook4 GB RAM minimum for LPR8 GB+ RAM preferableModern x86-64 CPUAVX + AVX2 supportWebcam or test videoInternet for initial model downloadsA 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.
Software
Section titled “Software”Install:
Docker DesktopWSL2FrigateFFmpegMediaMTXOptional:
VLCVisual Studio Code7. 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+Frigateor 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 |FrigateThis makes the webcam look like a normal IP camera to Frigate.
8. Step 1 — Install Docker Desktop
Section titled “8. Step 1 — Install Docker Desktop”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:
docker --versionThen:
docker compose versionExpected 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:
mkdir C:\Users\harry\MyWorks\frigate-poccd C:\Users\harry\MyWorks\frigate-pocmkdir configmkdir storageResult:
frigate-poc/│├── docker-compose.yml├── config/│ └── config.yml│└── storage/10. Step 3 — Create Docker Compose
Section titled “10. Step 3 — Create Docker Compose”Create:
docker-compose.ymlwith:
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.
11. Step 4 — Start Frigate
Section titled “11. Step 4 — Start Frigate”From PowerShell:
cd C:\Users\harry\MyWorks\frigate-pocdocker compose up -dCheck status:
docker psCheck Frigate log:
docker logs frigateOn the first run, Frigate creates an admin login.
Open:
https://localhost:8971Your 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.
12. Step 5 — Prepare a Camera Stream
Section titled “12. Step 5 — Prepare a Camera Stream”Frigate normally expects a network video stream.
For this POC, there are three easy choices:
A. Notebook webcamB. Recorded MP4C. Existing IP / RTSP cameraOption 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.
13. Option A — Use the Notebook Webcam
Section titled “13. Option A — Use the Notebook Webcam”13.1 Install FFmpeg
Section titled “13.1 Install FFmpeg”Install FFmpeg for Windows and ensure:
ffmpeg -versionworks.
13.2 Install MediaMTX
Section titled “13.2 Install MediaMTX”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.
13.3 Find the webcam name
Section titled “13.3 Find the webcam name”Run:
ffmpeg -list_devices true -f dshow -i dummyLook for something similar to:
Integrated Cameraor:
USB2.0 HD UVC WebCamCopy the exact device name.
13.4 Configure MediaMTX
Section titled “13.4 Configure MediaMTX”Open:
mediamtx.ymland 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: yesReplace:
Integrated Camerawith the actual device name.
13.5 Start MediaMTX
Section titled “13.5 Start MediaMTX”Run:
mediamtx.exeThe webcam stream should become:
rtsp://localhost:8554/webcam13.6 Test with VLC
Section titled “13.6 Test with VLC”Open VLC:
Media→ Open Network StreamEnter:
rtsp://localhost:8554/webcamIf 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.mp4Start MediaMTX.
Then publish the file:
ffmpeg -re -stream_loop -1 -i "C:\Users\harry\Videos\anpr-test\night-car.mp4" -c copy -f rtsp rtsp://localhost:8554/testcarIf -c copy causes codec problems, use:
ffmpeg -re -stream_loop -1 -i "C:\Users\harry\Videos\anpr-test\night-car.mp4" -c:v libx264 -an -f rtsp rtsp://localhost:8554/testcarThe resulting stream is:
rtsp://localhost:8554/testcarTest it in VLC before adding it to Frigate.
15. Option C — Use an IP / RTSP Camera
Section titled “15. Option C — Use an IP / RTSP Camera”If an existing CCTV or IP camera supports RTSP, this is even easier.
Example:
rtsp://username:[email protected]:554/streamThe 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.
16. Step 6 — Add the Camera to Frigate
Section titled “16. Step 6 — Add the Camera to Frigate”Frigate’s current UI includes an Add Camera wizard.
Use:
Settings→ Global configuration→ Camera management→ Add CameraFor 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.internalTherefore try:
rtsp://host.docker.internal:8554/webcamFor the recorded vehicle stream:
rtsp://host.docker.internal:8554/testcarIf using a real IP camera:
rtsp://user:password@CAMERA_IP/...After adding the camera, confirm:
Live view worksNo continuous FFmpeg errorsVideo updates normally17. Step 7 — Test Person Detection
Section titled “17. Step 7 — Test Person Detection”Start simple.
Use Frigate’s default CPU detector for the POC.
A minimal detector configuration is:
detectors: cpu1: type: cpu num_threads: 3Then configure the webcam camera to track:
personUsing the UI:
Settings→ Camera configuration→ Objects→ Objects to track→ personNow walk in front of the notebook camera.
Expected:
person bounding boxperson eventtimestampsnapshotIf person detection works, the object-detection part of the POC is successful.
18. Step 8 — Enable Face Recognition
Section titled “18. Step 8 — Enable Face Recognition”Frigate face recognition is disabled by default.
Go to:
Settings→ Enrichments→ Face recognitionEnable it.
For the notebook POC choose:
Model size: smallThe small model is designed to run on CPU.
Equivalent YAML:
face_recognition: enabled: true model_size: small detection_threshold: 0.7 min_area: 750Frigate must first detect a person before it attempts face detection and recognition.
Therefore:
person detection ↓face detection ↓face recognition19. Step 9 — Train a Known Face
Section titled “19. Step 9 — Train a Known Face”Use:
Face Library→ Add FaceStart with a few clear photos.
Recommended:
front-facinggood lightingnot blurryface reasonably largeFor example:
Harry ├── front ├── slight-left └── slight-rightAvoid 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 ↓HarryIf confidence is insufficient:
UnknownUse 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 recognitionEnable LPR.
Recommended first settings:
Enabled: YesDevice: CPUModel size: smallDetection threshold: 0.7Recognition threshold: 0.9Minimum plate length: 4Save debug plates: YesEquivalent YAML:
lpr: enabled: true device: CPU model_size: small detection_threshold: 0.7 recognition_threshold: 0.9 min_plate_length: 4 debug_save_plates: trueFrigate’s built-in LPR can use:
YOLOv9 plate detection+PaddleOCRwhen 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 visibleplate visibleplate reasonably largeminimal motion blurPublish it with MediaMTX:
night-car.mp4 |FFmpeg |MediaMTX |RTSP |FrigateFor normal Frigate LPR operation, the vehicle should first be detected as:
caror another supported vehicle class.
Then Frigate attempts to find and read the plate.
Check:
ExploreReview / HistoryTracked object detailsRecognized licence plate22. Recommended Frigate LPR Settings
Section titled “22. Recommended Frigate LPR Settings”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: trueDo 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 problemplate detection problemOCR problem23. How to Test New Zealand Number Plates
Section titled “23. How to Test New Zealand Number Plates”Create a small benchmark dataset.
For example:
data/ video/ car-001.mp4 car-002.mp4 car-003.mp4
ground-truth.csvExample:
video,actual_platecar-001.mp4,ABC123car-002.mp4,XYZ789car-003.mp4,DEF456Then record:
video,actual_plate,frigate_plate,correct,confidencecar-001.mp4,ABC123,ABC123,true,0.97car-002.mp4,XYZ789,XYZ7B9,false,0.91car-003.mp4,DEF456,DEF456,true,0.96Do not judge the software from one plate.
Aim for at least:
20–50 test vehiclesfor the first meaningful experiment.
Later use:
100–200 vehiclesfor a stronger test.
24. How to Measure Accuracy
Section titled “24. How to Measure Accuracy”Track separate metrics.
Plate capture rate
Section titled “Plate capture rate”Readable plates / total vehiclesExample:
47 readable / 50 vehicles= 94%Plate detection rate
Section titled “Plate detection rate”Plate crops detected / readable platesOCR accuracy
Section titled “OCR accuracy”Correct OCR / detected readable platesExact match accuracy
Section titled “Exact match accuracy”Require the complete plate to match:
ABC123 == ABC123A one-character error counts as incorrect.
Person detection
Section titled “Person detection”Measure:
person events detected / actual person appearancesFace recognition
Section titled “Face recognition”Measure:
correct identity matchesfalse unknownsfalse identity matchesFalse identity matches are particularly important.
25. Suggested POC Test Matrix
Section titled “25. Suggested POC Test Matrix”| Test | Expected Result |
|---|---|
| Walk in front of webcam | Person detected |
| Stand still facing camera | Face detected |
| Known enrolled face | Correct name where image quality is sufficient |
| Unknown person | Should not confidently become another known person |
| Clear static plate | Plate recognized |
| Day vehicle video | Plate recognized if sufficiently clear |
| Low-resolution plate | Likely lower accuracy |
| Blurry plate | Likely lower accuracy |
| Night phone video | Test only; not equivalent to ANPR camera |
| Replay same video | Similar result each run |
26. Expected Limitations
Section titled “26. Expected Limitations”Notebook webcam
Section titled “Notebook webcam”Good for:
person detectionface testingbasic Frigate testingPoor for:
moving roadside platesnight vehiclesheadlight glarelong distanceCPU-only object detection
Section titled “CPU-only object detection”Suitable for:
POCone cameralow/moderate detect FPSNot ideal for:
many camerashigh-resolution continuous AIproduction deploymentFace recognition
Section titled “Face recognition”Accuracy is affected by:
- face angle;
- lighting;
- blur;
- distance;
- face size;
- glasses;
- hats;
- partial occlusion.
Treat recognition as probabilistic.
Licence plate OCR
Section titled “Licence plate OCR”Accuracy is affected by:
- plate pixel size;
- blur;
- viewing angle;
- reflections;
- headlights;
- overexposure;
- dirt;
- plate design;
- compression.
27. Troubleshooting
Section titled “27. Troubleshooting”Frigate does not start
Section titled “Frigate does not start”Check:
docker logs frigateValidate YAML indentation carefully.
Cannot open Frigate UI
Section titled “Cannot open Frigate UI”Check:
docker psThen:
https://localhost:8971Frigate cannot connect to webcam RTSP
Section titled “Frigate cannot connect to webcam RTSP”Do not use:
rtsp://localhost:8554/webcaminside the Docker container unless MediaMTX is running inside that same container/network.
Try:
rtsp://host.docker.internal:8554/webcamWebcam stream does not work
Section titled “Webcam stream does not work”First verify with VLC:
rtsp://localhost:8554/webcamIf VLC cannot read it, fix FFmpeg / MediaMTX before troubleshooting Frigate.
Cannot find webcam name
Section titled “Cannot find webcam name”Run:
ffmpeg -list_devices true -f dshow -i dummyUse the exact video-device name.
High CPU usage
Section titled “High CPU usage”Reduce:
detect FPSresolutionnumber of active featuresFor example:
detect: fps: 5For this POC, 5 FPS is enough for basic person testing.
Face recognition does nothing
Section titled “Face recognition does nothing”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.
LPR does nothing
Section titled “LPR does nothing”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: trueand inspect the saved crops.
LPR reads one character incorrectly
Section titled “LPR reads one character incorrectly”Examples:
0 ↔ O1 ↔ I5 ↔ S8 ↔ BDo not immediately auto-correct the result.
Record:
raw OCRconfidenceactual plateLater, build NZ-specific normalisation carefully.
28. POC Success Criteria
Section titled “28. POC Success Criteria”The notebook POC is considered successful when:
Frigate
Section titled “Frigate”- Frigate starts reliably in Docker;
- the browser UI is accessible;
- a test RTSP stream is visible.
Person
Section titled “Person”- 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.
Licence plate
Section titled “Licence plate”- 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 result29. What to Do After the POC
Section titled “29. What to Do After the POC”Once this notebook POC works:
Stage 2
Section titled “Stage 2”Buy or borrow one proper ANPR camera.
Test:
night30–50 km/hheadlights10–20 mIRStage 3
Section titled “Stage 3”Connect the real camera to Frigate:
ANPR camera |RTSP |FrigateCompare:
Frigate LPRvscamera-native ANPRStage 4
Section titled “Stage 4”Write a custom Python comparison:
YOLO+PaddleOCRRun it against the exact same video dataset.
Stage 5
Section titled “Stage 5”Only after recognition is reliable, build:
solarbatteryMPPT4G/LTEweatherproof boxfor the roadside prototype.
30. Recommended Folder Structure
Section titled “30. Recommended Folder Structure”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.ps131. Useful Commands
Section titled “31. Useful Commands”Start Frigate:
docker compose up -dStop Frigate:
docker compose downRestart:
docker compose restartLogs:
docker logs -f frigateList containers:
docker psList webcam devices:
ffmpeg -list_devices true -f dshow -i dummyReplay MP4 over RTSP:
ffmpeg -re -stream_loop -1 -i test.mp4 -c:v libx264 -an -f rtsp rtsp://localhost:8554/testcar32. Privacy Notes
Section titled “32. Privacy Notes”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 subjectsbefore any real-world deployment decisions are made.
A roadside deployment involving biometric identification requires a separate privacy and legal review.
33. Reference Links
Section titled “33. Reference Links”Frigate
Section titled “Frigate”Main documentation:
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/
MediaMTX
Section titled “MediaMTX”Main documentation:
Windows / generic webcam publishing:
https://mediamtx.org/docs/publish/generic-webcams
FFmpeg publishing:
https://mediamtx.org/docs/publish/ffmpeg
34. Final Recommended Workflow
Section titled “34. Final Recommended Workflow”Do not try to build the final roadside system immediately.
Use this exact progression:
DAY 1Windows notebook |Docker Desktop |Frigate startsThen:
DAY 1–2Notebook webcam |MediaMTX |RTSP |Frigate |person detectionThen:
NEXTperson |face detection |known-face testThen:
NEXTrecorded car video |MediaMTX |Frigate |LPRThen:
AFTER SOFTWARE POCDedicated ANPR camera |real daylight/night testingAnd only after that:
FINAL REMOTE POCRoadside location |ANPR camera |optional overview camera |LiFePO4 battery |solar + MPPT |4G/LTE + VPN |Frigate / central serverThe notebook POC therefore has one simple purpose:
Prove the software workflow cheaply before spending money on the roadside hardware.