Frigate NVR Changed My Security Game (Here’s Why)

I was paying $15/month for Wyze Plus, another $12 for cloud storage, and getting notifications about every leaf that blew past my cameras. Then I found Frigate, and honestly? I don’t know why I waited so long.

Frigate is a self-hosted NVR (network video recorder) that runs AI object detection right on your hardware — no cloud, no subscriptions, no “person detected at 3 AM because a raccoon existed.” It knows the difference between a person, a car, a package, and your cat. And it only records when something actually matters.

Let me walk you through why this belongs in your homelab and how to get it running in about 20 minutes.

What Makes Frigate Actually Different

Most “smart” cameras are just dumb cameras with cloud processing. Frigate flips that on its head — everything runs locally on your hardware, typically a small server or even a Raspberry Pi with a Google Coral TPU accelerator.

Here’s the magic: instead of recording everything and then analyzing it, Frigate analyzes the stream in real-time as it arrives. It detects objects (people, cars, dogs, packages, faces) and only records snapshots or video clips when those objects appear. Your storage doesn’t bloat. Your privacy stays intact. Your wallet stays happy.

I’ve been running it for 6 months on an old i5 NUC with a Coral USB accelerator ($60), and it handles 4 IP cameras without breaking a sweat. The CPU-only mode works too if you don’t have a Coral — just slower.

The real win? Deep Home Assistant integration. When Frigate detects a person at your front door, it can trigger automations — send you a notification with a 10-second clip, unlock the door, turn on lights, whatever. No cloud API delays. Pure local automation.

The Install (It’s Stupidly Easy)

Frigate lives in Docker. If you’re running Proxmox or any Docker host, this is genuinely straightforward.

Here’s a minimal Docker Compose to get started:

version: '3.8'
services:
  frigate:
    image: ghcr.io/blakeblackshear/frigate:stable
    container_name: frigate
    privileged: true
    restart: unless-stopped
    shm_size: '256mb'
    ports:
      - "5000:5000"
      - "8554:8554"
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./config:/config
      - ./storage:/media/frigate
      - /dev/bus/usb:/dev/bus/usb
    environment:
      - FRIGATE_RTSP_PASSWORD=your_password
    devices:
      - /dev/dri:/dev/dri

Copy that, run docker-compose up -d, and navigate to http://your-ip:5000. You’ll see the web UI immediately.

The hard part isn’t the install — it’s the config. You need to add your cameras, set detection zones, and tune what Frigate cares about. But the docs are genuinely solid, and there’s an active community if you get stuck.

If you have a Coral TPU, add this to your compose file to make it scream:

devices:
  - /dev/coral:/dev/coral

With a Coral, you’re looking at 5-10ms detection latency. Without it, expect 100-200ms and higher CPU usage. Still usable, but the Coral is absolutely worth the $60 if you’re serious about this.

The Config That Actually Works

Frigate’s config lives in config/config.yml. Don’t let the complexity scare you — you only need a few sections to get going.

Here’s a real-world example with a Reolink camera:

frigateplus:
  stats: true
  detectors:
    coral:
      type: edgetpu
      device: usb

logger:
  default: info

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://user:[email protected]:554/h264Preview_01_main
          roles:
            - detect
            - rtmp
    detect:
      width: 1280
      height: 720
      fps: 5
    objects:
      track:
        - person
        - car
        - dog
        - package
    motion:
      mask: 0,0,1280,300
    snapshots:
      enabled: true
      timestamp: true
    record:
      enabled: true
      events:
        retain:
          default: 10
          objects:
            person: 30

What’s happening here: Frigate connects to your camera’s RTSP stream, analyzes frames at 5 FPS (adjustable), detects people/cars/dogs/packages, and records events for 10 days by default (30 for people). The motion mask prevents false triggers from trees or reflections.

Pro tip: Start with detection-only. Get comfortable with what’s being detected, then enable recording once you trust it. Saves storage while you tune.

Home Assistant Integration (Where It Gets Fun)

Once Frigate is running, connect it to Home Assistant. Go to Settings → Devices & Services → Create Integration, search for “Frigate,” and point it at your Frigate instance.

Now you get entities for every detection. A “person_detected” binary sensor. A “front_door_snapshot” camera. Event triggers for automations.

Here’s an automation I actually use:

automation:
  - alias: Person at front door
    trigger:
      platform: state
      entity_id: binary_sensor.front_door_person
      to: 'on'
    action:
      - service: notify.mobile_app_iphone
        data:
          title: Someone's here
          message: Person detected
          data:
            image: /api/frigate/front_door/thumbnail.jpg
            clickAction: /lovelace/security
      - service: light.turn_on
        target:
          entity_id: light.front_porch
        data:
          brightness: 255

When Frigate detects a person, you get a rich notification with a snapshot AND your porch lights turn on. No cloud. No delays. Pure local automation.

You can also use Frigate webhooks to trigger n8n or Node-RED for even crazier workflows. The integration is deep, and it’s beautiful.

Storage Reality Check

Here’s the thing about event-based recording: you’ll use way less storage than traditional NVRs, but not zero.

With 4 cameras recording events only, I’m using about 50-60GB per month. Continuous recording would be 500GB+ per month. So yeah, event recording saves a ton.

Set retention policies in config.yml (like my example above) and monitor /media/frigate periodically. If you’re tight on space, use an external NAS via NFS or SMB — Frigate doesn’t care where the storage lives.

Budget estimate: For a 2-week rolling buffer on 4 cameras, 2TB is comfortable. One-time cost, no monthly fees.

The Real Cost Comparison

Let’s do math. Wyze Plus + cloud storage was costing me $27/month = $324/year. I spent $150 on a Coral TPU, $40 on the NUC (had it lying around), and $80 on a 2TB external drive. Total: $270, one time. Paid for itself in under a year, and now I own my security data.

If you already have a homelab server, you’re spending basically nothing. Just the USB Coral if you want it.

Frigate is open source, actively maintained, and the community is solid. It’s not a hobby project that’ll die — it’s legitimately enterprise-grade software that happens to be free.

Stop throwing money at cloud subscriptions. Set up Frigate, tune it for a week, then forget about it. Your future self will thank you.

Explore Frigate NVR in our AI Homelab Toolkit.