Frigate: The Local AI NVR That Sees Everything Your Cameras Record and Sends None of It to the Cloud

"Your camera already films everything. The question is whose computer decides what any of it means — and with Frigate, the answer is the one in your closet."

Most home security cameras have a dirty secret: they record faithfully and understand nothing. You come home to 14 hours of porch footage to scrub through manually, or you pay a monthly cloud fee so a vendor's servers can tell you "a person was detected." Frigate (GitHub: blakeblackshear/frigate) takes the third path. It is a self-hosted NVR with real-time AI object detection, purpose-built to run locally and to integrate natively with Home Assistant. As of August 2026 it carries roughly 31,000 stars, is licensed MIT, and supports hardware accelerators from Google Coral to Intel OpenVINO to NVIDIA GPUs. For a blog about AI you can run on your own machine, it is one of the purest examples: genuine, useful, real-time computer vision — with the video never leaving your network. This is the honest breakdown: how the two-stage detection pipeline works, what hardware you actually need, what it really costs, and the responsibilities (legal and ethical) that come with pointing AI at your own cameras.

1. What Frigate Is (and Isn't)

Frigate is a network video recorder with a brain. You point it at RTSP streams from ordinary IP cameras — no smart-camera subscription required — and it turns them into a system that knows the difference between a person, a car, a package, and a swaying tree branch. Events get recorded when something matters, not 24/7 by default, which is what makes it usable. What it isn't is just motion detection. Traditional NVRs trigger on pixel change, which is why they spam you with alerts every time a shadow moves or headlights sweep the driveway. Frigate's entire value is that it runs object detection so it can tell you what changed, not merely that something did. It also isn't a camera brand — bring your own hardware, as long as it speaks RTSP. The feature set that matters day to day: event-based recording with per-object retention, 24/7 recording if you want it, a visual mask and zone editor (draw the region where the sidewalk is public and stop getting alerts for every passerby), RTSP re-streaming so multiple clients don't each open a connection to your camera, WebRTC/MSE low-latency live view, and MQTT for wiring detections into anything else.

2. The Two-Stage Pipeline: Motion First, AI Second

The reason Frigate runs on modest hardware instead of demanding a datacenter GPU is an architectural choice worth understanding. Running object detection on every frame of every stream is brutally expensive. So Frigate doesn't. 1. Cheap motion detection runs continuously. A very low-overhead pass watches for regions where pixels changed. This costs almost nothing. 2. Only where motion is detected does object detection run. Those candidate regions get handed to the inference backend — TensorFlow, ONNX, OpenVINO, Coral TPU, or Hailo — running in separate processes to maximize throughput. 3. Detections feed tracking and zone rules, which generate events, trigger recordings, and publish MQTT messages. The project's own framing is "only looking for objects when and where it is necessary," and it leans heavily on multiprocessing with "an emphasis on realtime over processing every frame." In practice that means a $60 Coral TPU can keep up with several cameras at once, because the expensive model only ever sees a few cropped frames per second rather than full 4K video. Detection classes cover the useful set — person, car, truck, bicycle, dog, cat, package, and more — and recent 0.16-era builds added face recognition and license plate recognition as optional capabilities. Those extras are genuinely powerful and genuinely raise the privacy stakes, which we'll cover in the limitations.

3. Why Local Detection Matters

The privacy case for Frigate is unusually concrete, so let's be specific about what stays home. Video never leaves your network. Not for storage, not for inference, not for "improving the service." Footage is written to a local disk you control. Contrast that with a cloud camera, where every clip is uploaded to someone else's storage and analyzed by someone else's models. Inference happens on your hardware. The object detection model runs on your Coral, your GPU, or your CPU. There is no API call to a vendor's vision service, which means no per-detection fee and no third party learning what happens outside your front door. No vendor can lose your footage. The cloud-camera breach headlines — strangers watching other people's living rooms — are structurally impossible here, because there is no central store to breach. You own the retention policy. Keep events for 7 days, 30 days, or forever; store 24/7 or only when a person is detected. That decision is yours rather than a subscription tier. There is one honest caveat: Frigate is frequently paired with Home Assistant and remote access, so you become responsible for securing that access. Local-first does not mean automatically secure — it means the responsibility moved to you, which is the whole deal with self-hosting.

4. Hardware: What You Actually Need

This is where projects live or die, so concretely: It runs on CPU — but you won't like it. Object detection on a general-purpose CPU works for one low-resolution stream and struggles beyond that. Everyone serious about Frigate adds an accelerator. The accelerator tiers:

• Google Coral TPU (USB or M.2) — the community default. Around $60–$80, sips a couple of watts, handles several cameras comfortably. Best performance-per-watt by a wide margin.
• Intel OpenVINO — free if you already have a modern Intel CPU with an iGPU (an N100 or N5105 mini-PC or NAS handles multiple streams well). Excellent value for hardware you already own.
• NVIDIA GPU — for larger deployments; far more power draw, much more headroom.
• Hailo — newer entrant with strong efficiency.

Storage matters more than people expect. Continuous event recording on several 2K cameras is a lot of writes. Use a surveillance-rated HDD or SSD, not the spare desktop drive, and size it against your retention goals. Memory and shm. The Docker deployment wants a generous shm_size (256MB is the common starting point) and a tmpfs cache for clips. Skimp here and you get mysterious stalls.

5. Home Assistant Integration: The Killer Feature

Frigate was designed for Home Assistant from day one, and it shows. Detections publish over MQTT, which means an automation can react the instant a person is seen in a zone: ``yaml automation: - alias: "Alert on person at front door after dark" trigger: - platform: mqtt topic: frigate/events payload: person condition: - condition: sun after: sunset action: - service: light.turn_on target: entity_id: light.porch - service: notify.mobile_app data: message: "Someone is at the front door" ` That is the payoff: your camera stops being a passive recorder and becomes an input to a locally-running automation system. Person detected after dark → porch light on, phone notified, recording extended. All of it inside your own network, with no cloud round trip. If you already run Home Assistant (see the Related links), Frigate is the single highest-value addition you can make to it.

6. The Cost, Honestly

Software: $0. MIT licensed. Worth noting for businesses: the code is MIT, but the "Frigate" name and logo are trademarks of Frigate, Inc. and are not covered by the license — relevant if you plan to ship a rebranded product. Cameras: whatever you already have, if they speak RTSP. This is the big saving — no proprietary smart-camera ecosystem, no per-camera cloud plan. Accelerator: $60–$80 for a Coral, or $0 if you'll use an existing Intel iGPU via OpenVINO. Host: a mini-PC or NAS you likely own. If buying, $150–$400 for something like an N100 box. Add $20–$60/year in electricity depending on hardware. Storage: budget for real capacity. A few cameras at 2K with 30-day retention can mean 1–4TB. Your time: the honest cost. Camera RTSP URLs, YAML config, tuning detection zones and thresholds, and tuning out false positives (tree branches are the eternal enemy). Expect a weekend to get it good, then occasional tweaking. Against a cloud camera subscription of roughly $5–$20/month per camera, Frigate pays for its accelerator within the first year on almost any camera count — and that's before counting the privacy upside, which for many readers is the actual reason.

7. Honest Limitations (Including the Ones About Responsibility)

A real assessment names the hard parts, and this project has more than most:

• The hardware requirement is real. "Just Docker it on your Pi" is a path to disappointment. Budget for an accelerator or accept limited capability.
• Configuration is YAML, and tuning is a craft. Zones, masks, thresholds, and per-camera detect settings are powerful and fiddly. Expect iteration before false positives settle down.
• Resource-hungry under load. Several high-resolution streams with 24/7 recording plus detection will push a small box hard. Frigate is efficient but not magic.
• The 0.16+ face recognition and license plate recognition features raise the stakes considerably. Identifying individuals and tracking plates is a qualitatively different capability from "a person is in the driveway." Use them deliberately, secure the instance, and understand that you are building a system that can profile people.
• Legal and ethical responsibility is yours. Recording rules vary by jurisdiction and context: audio recording is treated differently from video in many places, cameras aimed at public sidewalks or a neighbour's property can create real legal exposure, and signage or consent requirements may apply. The tool does not make these decisions for you. Point cameras at your own property, disable audio unless you know it's lawful, put the instance behind authentication and TLS, and treat the footage like the sensitive data it is.
• Mobile access isn't first-class on its own. You view and manage through the web UI or through Home Assistant; there's no flagship standalone app in the way a commercial camera brand offers.
• You are now the operator. Backups of config, disk health, updates, and uptime are your job — a security system that silently stopped recording is worse than none.

The middle two bullets are the ones marketing pages skip. Owning powerful local AI means owning the judgment about how to use it.

8. Getting Started

A minimal Docker Compose deployment: `yaml services: frigate: image: ghcr.io/blakeblackshear/frigate:stable container_name: frigate restart: unless-stopped privileged: true shm_size: "256mb" ports: - "5000:5000" # Web UI - "8554:8554" # RTSP re-stream - "8555:8555" # WebRTC volumes: - ./config:/config - /media/frigate:/media/frigate - type: tmpfs target: /tmp/cache tmpfs: size: 1000000000 environment: - FRIGATE_RTSP_PASSWORD=your-camera-password ` Then write config/config.yml with your camera RTSP URLs and a detector, start it, and use the built-in editor to draw zones and masks. Start with one camera and a single object type (person) — get that reliable before scaling up.

9. Frigate vs the Alternatives

| | Frigate | ZoneMinder | Cloud cameras (Ring/Nest) | |---|---|---|---| | License | MIT | GPL-2.0 | proprietary | | AI object detection | ✅ local | ❌ motion only | ✅ cloud | | Home Assistant | native | third-party | limited | | Video location | your disk | your disk | vendor cloud | | Monthly cost | $0 | $0 | $5–20 per camera | | Hardware accel | Coral/OpenVINO/NVIDIA/Hailo | limited | N/A | | Setup effort | moderate | high | trivial | The short version: Frigate wins decisively for any Home Assistant household that wants real detection without a subscription. ZoneMinder is the veteran with more traditional DVR depth and a dated feel. Cloud cameras win on convenience and lose on privacy, cost, and longevity — and when the vendor sunsets a model, your hardware becomes a brick.

10. Who Should Run It

Run it if: you already have RTSP cameras (or want to reuse ordinary ones), you run Home Assistant, you refuse to pay per-camera cloud fees, or you want the detection to happen on hardware you own. Also if you've ever scrolled through hours of footage wishing something would just tell you which 30 seconds mattered. Skip it if: you need five-minute setup with zero tuning (buy a cloud camera), you won't invest in an accelerator and expect multi-camera AI anyway, or you're not prepared to take on the legal and security responsibility that comes with running your own surveillance system. That last one is not a disclaimer — it's the actual requirement. For this blog's readers, Frigate is the most compelling demonstration of the core thesis available: real computer vision, running in real time, on a $60 USB stick in your hallway, deciding nothing about you in anyone else's datacenter.

11. A Real Deployment Walkthrough

Here's the sequence that works, and the order matters more than people expect: Step 1 — one camera, nothing else. Get a single RTSP stream working. Confirm the URL plays in VLC first (rtsp://user:[email protected]/live/ch00_0); if it doesn't play there, Frigate can't fix it. Give the camera a static IP or a DHCP reservation — a camera whose IP drifts will silently break your setup after the next router reboot. Step 2 — minimal config, one object type. Start with person only: `yaml cameras: front_door: ffmpeg: inputs: - path: rtsp://user:[email protected]/live/ch00_0 roles: [detect, record] detect: width: 1280 height: 720 detectors: coral: type: edgetpu device: usb objects: track: [person] ` Step 3 — verify inference is running. Check the system page for detector speed. If inference time is measured in hundreds of milliseconds per frame, your accelerator isn't being used. Step 4 — draw masks and zones. This is where false positives die. Mask out the swaying tree, the road beyond your property, and the neighbour's window. Create a zone for the walkway so "person in zone" is a meaningful event. Step 5 — tune, then add cameras. Only after one camera is quiet and reliable should you add the second. Adding four at once is how people end up with an unusable system and no idea which camera is the problem.

12. Troubleshooting & Tuning

The problems that actually come up:

• Detection is slow or frames are dropped. Accelerator not attached to the container (check device passthrough), or shm_size too small. Raise it.
• Constant false alerts. Almost always vegetation, shadows, or headlights. Mask the region, drop the threshold, or require a minimum object size.
• Missed events. Detection resolution too low, or the object moves through the frame too fast. Raise detect resolution and/or frame rate.
• High CPU with no accelerator. Expected. Either add a Coral/iGPU or reduce stream resolution and accept fewer cameras.
• Camera stream drops at night. IR mode changes bitrate and sometimes resolution; give the camera a substream for detection and a mainstream for recording.
• Disk fills instantly. Continuous recording plus long retention. Set per-object retention and use record` roles deliberately.

The tuning mindset: Frigate is a system you converge on, not one you configure perfectly on the first attempt. Start narrow, measure, then widen.

13. Storage and Retention Planning

The operational detail that catches everyone: video is big, and Frigate writes a lot of it. A single 2K camera at a reasonable bitrate can generate tens of gigabytes per week under continuous recording; four cameras at 30-day retention can quietly consume terabytes. Plan three tiers. Events (short clips around detections) are small and high-value — keep those longest, 30–90 days is common and cheap. Continuous recording is the storage hog — many users keep it short (a few days) or disable it entirely and rely on event clips plus 24/7 low-res streams. Snapshots are tiny and useful for quick review. Use a surveillance-rated drive (HDD or SSD designed for constant writes), not a desktop spare. Frigate's write pattern is relentless, and consumer drives rated for bursty desktop workloads wear out faster under continuous video. Finally, set retention per object type. There's no reason a "package delivered" clip needs the same 90-day retention as a "person at the door after midnight" clip. Granular retention is one of those features that looks minor in the docs and turns out to be the difference between a system you can afford to run and one you have to prune every weekend.

Related

• Home Assistant: The Open-Source Smart-Home Hub That Keeps Your Data on Your Own Hardware — Frigate's native companion; detections become automations, locally.
• Uptime Kuma: The Self-Hosted Status Page and Monitor That Kills Your SaaS Subscription — monitor Frigate's web UI so you know your recorder is actually recording.
• Headscale: The Open-Source Tailscale Control Server That Puts Your Mesh VPN Back in Your Hands — reach your camera feeds from anywhere without exposing ports.