Run Frigate Locally: Open-Source NVR With AI Object Detection

Your security cameras should not phone home to a stranger. Frigate is an MIT-licensed open-source NVR that runs real-time object detection, license plate recognition, face recognition, and CLIP-based semantic search entirely on your own hardware. No subscription, no cloud account, no monthly bill, and no third party watching your driveway. This guide gets you from zero to a working Frigate stack with one camera, AI detection, and a buying guide for the cameras that will not betray you.

What Frigate Actually Is

Frigate is a network video recorder that pairs a Python video pipeline with on-device AI inference. It pulls RTSP streams from your cameras, runs object detection on every relevant frame, records only when something interesting happens, and exposes the results through a clean web UI and a Home Assistant integration. The current stable release is v0.17.1 (March 2025), and it ships with features that used to require three separate paid services:

• Object detection on every frame using YOLOv9, MobileNet SSD, or your own custom model
• License plate recognition built in since v0.16, no plugin required
• Face recognition with a local training-data folder, also built in since v0.16
• CLIP-based semantic search added in v0.17, so you can search your recordings with text prompts like "person carrying a package"
• GenAI review summaries that describe what happened in plain English
• Audio detection, classification models, and PTZ autotracking

All of it runs locally. None of it requires an internet connection after install. The full source is on GitHub under the MIT license.

What You Will Need

Frigate is software, but it has real hardware appetites. Here is the honest minimum:

• A host machine running Linux (Debian or Ubuntu preferred), with a CPU that supports AVX and AVX2. Almost any Intel or AMD chip from the last decade qualifies. A used mini PC like an Intel NUC, an HP EliteDesk, or a Beelink runs Frigate beautifully for under 200 dollars.
• RAM: 4 GB is the floor with a hardware accelerator and one or two cameras. 16 GB is recommended if you plan to run 8 or more cameras with face recognition, LPR, and semantic search enabled at the same time.
• Storage: An SSD for the OS and a separate spinning disk or SSD for recordings. Storage I/O matters more than you think. Frigate over a slow NAS on a 1 Gbps link can take more than a minute to load a 20 second clip. Local disk loads in under a second.
• An AI accelerator. CPU-only detection works for testing, but Frigate themselves say "CPU detection should only be used for testing purposes." See the hardware acceleration section below for the options.
• One or more RTSP-capable cameras. This is the part most beginners get wrong. The next section explains why.

Picking the Right Camera (and Avoiding the Cloud Trap)

Your camera choice will make or break this project. Frigate needs a direct RTSP or ONVIF stream, and a frighteningly large slice of the consumer market does not give you one.

Cameras to avoid for Frigate. Ring, Nest, Eufy, Arlo, Wyze (stock firmware), and Blink all push frames to manufacturer clouds and gate basic features behind monthly subscriptions. Several of these vendors have shipped documented breaches: in 2022 Eufy was caught sending unencrypted thumbnails to its cloud despite advertising end-to-end privacy, and Ring has had multiple incidents of unauthorized employee access to customer footage. The pattern is consistent. If a camera requires an account just to view your own driveway, it is not your camera.

The subscription jail is the second tax. Once your hardware is locked to a cloud, basic features like clip history beyond a few hours, motion zones, and person detection disappear behind a recurring fee. You pay for the camera, then you pay forever to keep it useful.

Brands with first-class RTSP support. These work with Frigate out of the box, no firmware mods required:

Custom firmware: the cheap path. If you already own a Wyze v3, a Xiaomi Dafang, or any of the cheap HiSilicon, SigmaStar, or Goke chip cameras flooding eBay, you can flash open firmware and turn them into Frigate-friendly RTSP sources.

• OpenIPC is a fully open firmware project for IP cameras based on common SoCs. It replaces the vendor stack entirely with a Linux build that exposes RTSP and gives you root.
• WyzeHacks and the official Wyze RTSP firmware turn a $25 Wyze v3 into a usable Frigate source.
• Dahua and Hikvision firmware patching projects unlock additional features and remove the cloud calls.

Practical wiring rules. Use PoE, not WiFi, for every camera you can. Wire is more reliable, more secure, and one less attack surface. Configure two streams on every camera: a low-resolution sub-stream (640x480 or 720p, 5 fps) for Frigate to run detection on, and the main stream (2K or 4K, 15 to 20 fps) for recording. Put every camera on a dedicated VLAN with no internet route. A one-line firewall rule on your router blocks all egress from that VLAN, and Frigate still works perfectly because it talks to the cameras over the LAN.

Where the market is going. Subscription fatigue is real, post-Eufy and post-Wyze trust is gone, and projects like OpenIPC plus the Frigate ecosystem are showing that the alternative actually works. We expect a "Frigate-compatible, RTSP-only, no-account-required" badge to start appearing on consumer camera packaging by 2027, the same way "Works with Home Assistant" did over the last three years. The first vendor to ship a no-cloud line at consumer prices wins a meaningful slice of the market. Until that happens, the cameras above are how you opt out today.

Install Frigate With Docker Compose

Docker Compose is the canonical install path. Frigate ships an official image at ghcr.io/blakeblackshear/frigate:stable that includes everything you need.

1. Prerequisites

Install Docker and Docker Compose on your host. On Debian or Ubuntu:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

2. Create the project layout

mkdir -p ~/frigate/config ~/frigate/storage
cd ~/frigate

3. Write a minimal config.yml

Save this as ~/frigate/config/config.yml. Replace USER, PASS, and the IP with your camera details. The two inputs use the same camera but different sub-streams: a low-res one for detection and a high-res one for recording.

mqtt:
  enabled: false

cameras:
  driveway:
    ffmpeg:
      inputs:
        - path: rtsp://USER:PASS@192.168.10.20:554/cam/realmonitor?channel=1&subtype=1
          roles:
            - detect
        - path: rtsp://USER:PASS@192.168.10.20:554/cam/realmonitor?channel=1&subtype=0
          roles:
            - record
    detect:
      width: 1280
      height: 720
      fps: 5
    record:
      enabled: true
      retain:
        days: 7

detectors:
  cpu1:
    type: cpu
    num_threads: 3

4. Write docker-compose.yml

services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    restart: unless-stopped
    shm_size: "512mb"
    devices:
      - /dev/dri/renderD128:/dev/dri/renderD128
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "5000:5000"
      - "8554:8554"
      - "8555:8555/tcp"
      - "8555:8555/udp"

Avoid plain-text credentials in your config. The RTSP URL above embeds USER:PASS directly for clarity, but in production you should keep secrets in environment variables on the Docker host and reference them with curly-brace substitution like {FRIGATE_RTSP_USER} and {FRIGATE_RTSP_PASSWORD}. Frigate expands any {ENV_VAR} at startup.

Note the shm_size: "512mb" line. The default of 128 MB only covers two cameras at 720p. If you skip this and try to add a third camera, Frigate dies with a confusing "Bus error." Bump it now and forget it.

5. Start the stack

docker compose up -d
docker compose logs -f frigate

6. Open the web UI

Browse to http://your-host-ip:5000. You should see your camera live, with bounding boxes drawn around any people, cars, or other objects the default model detects.

Turn On AI Features

Better object detection. The default cpu detector ships a small MobileNet SSD model that works for testing only. Swap it for a real accelerator (next section) and you can run YOLOv9 or the Frigate+ base model for far better accuracy.

License plate recognition. LPR is built in as of v0.16. Add this to your config:

lpr:
  enabled: true
  min_area: 1500
  threshold: 0.7

cameras:
  driveway:
    lpr:
      enabled: true

Detected plates appear as a recognized_license_plate sub-label on tracked car and motorcycle objects. You can wire that into Home Assistant to fire automations when a known plate arrives.

Face recognition. Drop training images into config/faces/<name>/, one folder per person, then enable:

face_recognition:
  enabled: true
  model_size: large

cameras:
  front_door:
    face_recognition:
      enabled: true

Frigate matches detected faces against the training set and exposes the result through the API and Home Assistant.

Semantic search. v0.17 added CLIP-based search. Enable it and you can type "person on a bicycle at night" and get matching clips from your archive.

semantic_search:
  enabled: true
  model: jinaai/jina-clip-v1

Hardware Acceleration: Pick Your Detector

This is the single highest-impact decision you will make. The right detector turns CPU-pegging frames into 5 ms inference.

For most readers, the right answer is "the iGPU you already have." Any Intel chip from the 8th generation onward exposes a usable iGPU through OpenVINO, and v0.15 cut OpenVINO inference from 80 ms down to about 20 ms. To use it, add this detectors block:

detectors:
  ov:
    type: openvino
    device: GPU

model:
  width: 320
  height: 320
  input_tensor: nhwc
  input_pixel_format: bgr
  path: /openvino-model/ssdlite_mobilenet_v2.xml

Coral was the recommended accelerator for years. As of v0.16, the official position changed: "Coral is no longer recommended for new Frigate installations except for deployments with low power requirements or hardware incapable of utilizing alternative accelerators." If you already own one, keep using it. If you are buying fresh hardware, an iGPU or a Hailo-8L is the better call.

Tips and Gotchas

Bump shm_size to at least 256 MB if you have more than two cameras. The default of 128 MB silently corrupts the frame queue and Frigate crashes with "Bus error" instead of a useful message.

YAML is unforgiving. A missing colon, a stray tab, or wrong indentation breaks the entire startup. When Frigate refuses to start, the logs almost always point at the line. Use a YAML linter in your editor.

Slow storage shows up as slow clip playback. If your recordings live on a NAS over a 1 Gbps link, expect minute-long load times for 20 second clips. Local SSD or local HDD is fine. Network storage is not.

MQTT is required for Home Assistant. The HA integration needs an MQTT broker (Mosquitto is one Docker container away). Without it, you get no entities in HA.

Configure cameras at the resolution you want Frigate to see. If your camera streams at 30 fps and you set fps: 5 in Frigate, the decoder still has to decode all 30 frames and throw 25 away. Configure the sub-stream at 5 fps on the camera itself.

Model updates can change false-positive rates. When you upgrade the Frigate+ base model, your detection profile shifts. Test on a quiet day before relying on it for alerts.

Frigate vs Frigate+: When to Pay $50

Frigate is and will remain free. Frigate+ is the optional paid tier from the same maintainer at $50 per year, and the value proposition is narrow but real: you upload labeled clips from your own cameras, Frigate+ trains a custom YOLOv9 model on your specific hardware and lighting, and you get back a model file that you own and can use forever.

The free tier includes 12 custom training runs per year. Each extra training is $5. The 2026 base model uses YOLOv9s at 640x640 resolution and is noticeably better at the edge cases that hurt generic models: night-time package detection, partial occlusion, weird angles. If you have specific false positives or misses you cannot fix with config tuning, $50 buys you a model trained on the exact frames where Frigate gets confused. If your default model already works, skip it.

What You Can Build With This

Frigate is a building block. Here are four projects you can wire up in a weekend:

Driveway license plate gate. Combine LPR with Home Assistant and a smart switch to auto-open the gate for your own car and log every other plate that pulls up. Extra credit: pipe unknown plates into a webhook for review.

Porch package detection. Train Frigate+ on your specific porch, add a "package" object class, and fire a notification only when something gets dropped, not every time the mail carrier walks past.

Garage face-rec auto-unlock. Face recognition on the entry camera triggers a relay through Home Assistant. Family members get hands-free entry. Strangers do not.

Wildlife backyard cam. The classification models in v0.17 do animal and bird species recognition out of the box. Point a camera at a feeder, build a private ebird-style log of every visitor, and never share a single frame with anyone.

Sources and Further Reading

• Frigate official documentation
• Frigate on GitHub (MIT license)
• Frigate release notes
• Frigate+ pricing and features
• OpenIPC open camera firmware project
• Frigate Home Assistant integration

You now have a private, local NVR running real AI on your own hardware, fed by cameras that nobody else gets to watch. Pick one camera, follow the install, and have it running before dinner. Once one camera works, scaling to four is a copy-paste job. The cloud cameras can sit in a drawer.