Frigate NVR: The Ultimate Open-Source AI-Powered Camera System for Home Assistant in 2026

The home surveillance landscape has dramatically shifted in 2026. While cloud-based camera systems continue to dominate retail shelves, privacy-conscious users and home automation enthusiasts have rallied around a different solution: Frigate NVR. This open-source Network Video Recorder combines local processing, AI-powered object detection, and seamless Home Assistant integration to deliver a surveillance system that respects your privacy while rivaling commercial alternatives.

What is Frigate NVR?

Frigate NVR is a complete, locally-hosted NVR system designed from the ground up for Home Assistant integration. Developed by Blake Blackshear and now maintained by Frigate, Inc., it leverages OpenCV and TensorFlow to perform real-time object detection on IP camera streams—without sending a single frame to the cloud.

Key Features at a Glance

• Real-time AI Object Detection: Identifies people, vehicles, animals, and dozens of other objects using TensorFlow Lite models
• Home Assistant Native Integration: Custom component for automation, notifications, and dashboard cards
• Efficient Motion Detection: Uses low-overhead motion analysis to trigger object detection only when needed
• Hardware Acceleration: First-class support for Google Coral TPU, Intel OpenVINO, NVIDIA GPUs, and more
• Smart Recording: Event-based and 24/7 recording with retention policies based on detected objects
• Low-Latency Live View: WebRTC and MSE support for sub-second live streaming
• Multi-Camera Scrubbing: Review footage across multiple cameras simultaneously
• MQTT Integration: Easy integration with Node-RED, n8n, and other automation platforms

Why Frigate NVR Stands Out in 2026

1. Privacy-First Architecture

In an era where data breaches and privacy violations make headlines weekly, Frigate NVR's local-only processing is its killer feature. Every video frame, every AI inference, every storage decision happens on your hardware. No cloud subscriptions required, no third-party analytics processors, no mysterious data retention policies.

2. Designed for Efficiency

Frigate's architecture prioritizes performance through smart design choices:

• Motion-Triggered Detection: Instead of running AI models on every frame from every camera, Frigate uses lightweight motion detection to identify areas of interest
• Multiprocessing Pipeline: Separates motion detection, object detection, recording, and API serving into isolated processes
• Selective Frame Analysis: Only analyzes frames when and where motion occurs, dramatically reducing compute requirements
• Accelerator Optimization: Offloads neural network inference to dedicated AI accelerators, keeping CPU usage minimal

This means a modest home server with a Google Coral USB accelerator can handle 10-15 camera streams simultaneously—performance that would require expensive cloud processing subscriptions in traditional systems.

3. Tight Home Assistant Integration

Frigate's official Home Assistant integration transforms it from a simple NVR into a home automation powerhouse:

• Binary Sensors: Trigger automations when specific objects are detected in specific zones
• Event Notifications: Send rich mobile notifications with snapshot images and video clips
• Conditional Automation: "Turn on lights when a person is detected in the backyard after sunset"
• Dashboard Cards: Embed live camera feeds and event timelines directly in Home Assistant dashboards
• Integration with Voice Assistants: "Show me the front door camera" via Google Home or Alexa

Hardware Requirements and AI Accelerators

While Frigate can run on CPU alone, the experience transforms with proper hardware acceleration.

Recommended AI Accelerators (2026)

Minimum System Specs

For a typical 4-6 camera home setup with a Coral USB:

• CPU: Intel i5 (8th gen+) or AMD Ryzen 5 3000+
• RAM: 8GB minimum, 16GB recommended
• Storage: 256GB SSD for OS + 2-4TB HDD for recordings
• Network: Gigabit Ethernet for camera streams
• OS: Ubuntu 22.04/24.04, Debian 11/12, or Home Assistant OS

Setting Up Frigate NVR: A Quick Start

Installation Options

1. Docker Compose (Most Common)

version: "3.9"
services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    restart: unless-stopped
    privileged: true
    shm_size: "256mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb  # For Coral USB
      - /dev/apex_0:/dev/apex_0    # For Coral PCIe/M.2
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "5000:5000"
      - "8554:8554"  # RTSP feeds
      - "8555:8555"  # WebRTC
    environment:
      FRIGATE_RTSP_PASSWORD: "your_password"

2. Home Assistant Add-on

If you're running Home Assistant OS, the Frigate add-on is the simplest route. Install from the Home Assistant add-on store, configure via YAML, and the integration auto-discovers your Frigate instance.

3. Kubernetes/Proxmox/Bare Metal

Advanced users can deploy via Kubernetes manifests or run directly on metal. The official documentation covers deployment options comprehensively.

Basic Configuration

Frigate uses a YAML configuration file. Here's a minimal example for two cameras:

mqtt:
  enabled: True
  host: mqtt.local
  user: frigate
  password: your_mqtt_password

detectors:
  coral:
    type: edgetpu
    device: usb

cameras:
  front_door:
    enabled: True
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.10:554/stream1
          roles:
            - detect
            - record
    detect:
      width: 1280
      height: 720
      fps: 5
    objects:
      track:
        - person
        - car
        - dog
    zones:
      entry:
        coordinates: 640,720,640,400,200,400,200,720
        objects:
          - person

  backyard:
    enabled: True
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.11:554/stream1
          roles:
            - detect
            - record
    detect:
      width: 1920
      height: 1080
      fps: 5
    objects:
      track:
        - person
        - cat
        - dog

record:
  enabled: True
  retain:
    days: 7
    mode: motion
  events:
    retain:
      default: 30
      mode: active_objects

snapshots:
  enabled: True
  retain:
    default: 30

Key Configuration Concepts:

• Detectors: Define your AI accelerator (Coral, OpenVINO, CPU)
• Cameras: Each camera stream with RTSP path, resolution, and frame rate
• Objects: Which objects to detect (person, car, dog, cat, bicycle, etc.)
• Zones: Define specific areas within camera views for targeted detection
• Retention: How long to keep recordings and snapshots

Built-In Mask and Zone Editor

One of Frigate's standout features is its visual zone and mask editor (as of version 0.13+). No more guessing coordinates:

1. Navigate to the Frigate web UI (http://your-frigate-ip:5000)
2. Go to Settings → Camera Name → Zones/Masks
3. Draw polygons directly on the live camera feed
4. Save, and Frigate updates the YAML automatically

This makes it trivial to:

• Mask static areas (timestamps, sky, tree branches that cause false motion)
• Define zones ("driveway", "front porch", "mailbox") for location-based automations
• Set motion sensitivity per region

Advanced Features for Power Users

1. 24/7 Recording with Smart Retention

Frigate supports continuous recording with intelligent retention policies:

record:
  enabled: True
  retain:
    days: 3  # Keep all footage for 3 days
    mode: all
  events:
    pre_capture: 5  # Seconds before event
    post_capture: 5
    retain:
      default: 30  # Keep event clips for 30 days
      objects:
        person: 60  # Keep person detections for 60 days
        car: 45

This allows you to:

• Keep all footage short-term for review
• Retain event-triggered clips (person detected) much longer
• Customize retention per object type

2. Stationary Object Detection

Frigate can detect objects that remain in place—perfect for catching packages left on porches or identifying abandoned items:

cameras:
  front_door:
    objects:
      filters:
        person:
          min_area: 5000
          max_area: 100000
          threshold: 0.7
          stationary:
            max_frames:
              default: 3000  # 10 minutes at 5fps

3. RTSP Re-streaming

Reduce camera connections by using Frigate as an RTSP relay:

go2rtc:
  streams:
    front_door:
      - rtsp://192.168.1.10:554/stream1
    front_door_hq:
      - rtsp://192.168.1.10:554/stream2

Multiple clients can pull streams from Frigate without overloading camera resources.

4. Audio Event Detection (Experimental)

As of 0.14+, Frigate supports audio event detection for sounds like glass breaking, dog barking, or smoke alarms:

audio:
  enabled: True
  num_threads: 2

cameras:
  backyard:
    audio:
      enabled: True
      listen:
        - bark
        - scream

5. Custom TensorFlow Models

Advanced users can train and deploy custom object detection models:

• Fine-tune models to detect specific objects (specific dog breeds, custom uniforms)
• Optimize models for your hardware accelerator
• Use YOLO, EfficientDet, or SSD architectures

Home Assistant Automation Examples

Example 1: Person Detection Notification

automation:
  - alias: "Front Door Person Detected"
    trigger:
      platform: mqtt
      topic: frigate/events
    condition:
      - condition: template
        value_template: "{{ trigger.payload_json['after']['camera'] == 'front_door' }}"
      - condition: template
        value_template: "{{ trigger.payload_json['after']['label'] == 'person' }}"
      - condition: template
        value_template: "{{ trigger.payload_json['type'] == 'new' }}"
    action:
      - service: notify.mobile_app
        data:
          message: "Person detected at front door"
          data:
            image: "https://your-frigate-url/api/events/{{trigger.payload_json['after']['id']}}/thumbnail.jpg"
            video: "https://your-frigate-url/api/events/{{trigger.payload_json['after']['id']}}/clip.mp4"

Example 2: Package Delivery Detection

automation:
  - alias: "Package Delivered"
    trigger:
      - platform: state
        entity_id: binary_sensor.front_door_person_occupancy
        to: "on"
        for:
          seconds: 30
      - platform: state
        entity_id: binary_sensor.front_door_person_occupancy
        to: "off"
    condition:
      - condition: time
        after: "08:00:00"
        before: "20:00:00"
    action:
      - service: camera.snapshot
        target:
          entity_id: camera.front_door
        data:
          filename: "/config/www/snapshots/delivery_{{now().strftime('%Y%m%d_%H%M%S')}}.jpg"
      - service: notify.family
        data:
          message: "Possible package delivery detected"

Example 3: Zone-Based Lighting

automation:
  - alias: "Backyard Motion Lights"
    trigger:
      platform: mqtt
      topic: frigate/events
    condition:
      - condition: template
        value_template: "{{ trigger.payload_json['after']['camera'] == 'backyard' }}"
      - condition: template
        value_template: "{{ trigger.payload_json['after']['entered_zones']|length > 0 }}"
      - condition: sun
        after: sunset
        after_offset: "-00:30:00"
    action:
      - service: light.turn_on
        target:
          entity_id: light.backyard_flood
        data:
          brightness: 255
      - delay: "00:05:00"
      - service: light.turn_off
        target:
          entity_id: light.backyard_flood

Performance Optimization Tips

1. Resolution and Frame Rate

Lower detect resolution for better performance:

detect:
  width: 1280
  height: 720
  fps: 5  # 5fps is usually sufficient for detection

Most scenarios don't need 1080p or 4K for object detection. Save bandwidth and compute by using:

• 720p for detection (fast, accurate for most use cases)
• 1080p/4K for recording (high quality footage when you need it)

2. Motion Mask Optimization

Mask areas that cause false motion (trees swaying, shadows, busy streets outside your property):

cameras:
  front_door:
    motion:
      mask:
        - 0,0,0,200,400,200,400,0  # Sky
        - 1200,0,1280,0,1280,100,1200,100  # Timestamp area

3. Object Filter Tuning

Reduce false positives with confidence thresholds and size filters:

objects:
  filters:
    person:
      min_area: 5000  # Minimum pixel area
      max_area: 100000
      threshold: 0.75  # Confidence threshold (default: 0.7)
      min_score: 0.6  # Minimum score to consider

4. Use tmpfs for Cache

Mount /tmp/cache as tmpfs (RAM disk) to reduce SSD wear and improve performance:

volumes:
  - type: tmpfs
    target: /tmp/cache
    tmpfs:
      size: 1000000000  # 1GB

Comparing Frigate NVR to Commercial Solutions

Cost Analysis (5-camera setup, 3 years):

• Frigate NVR: $800 (hardware) + $0 (ongoing) = $800
• Nest Cam: $750 (cameras) + $1,080 (subscription) = $1,830
• Ring: $500 (cameras) + $720 (subscription) = $1,220
• Reolink Cloud: $400 (cameras) + $540 (subscription) = $940
• Unifi Protect: $1,200 (cameras + NVR) + $0 (ongoing) = $1,200

Common Use Cases

Home Security

Monitor entry points, detect package deliveries, record 24/7, and receive instant notifications for person/vehicle detection.

Pet Monitoring

Track pets in specific zones, receive alerts when they enter restricted areas, and review playback of pet activities.

Business Surveillance

Small retail or office monitoring with object counting, time-based recording schedules, and multi-site MQTT integration.

Farm/Ranch Monitoring

Large property coverage, livestock monitoring, wildlife detection, and perimeter security with zone-based alerts.

Vacation Home Monitoring

Remote property surveillance with low bandwidth re-streaming, motion-triggered recording, and extended retention for security events.

Troubleshooting Common Issues

Issue: High CPU Usage

Solution:

• Lower detect fps (try 3-5 fps instead of 10)
• Reduce detect resolution (720p is usually sufficient)
• Add motion masks for busy areas
• Ensure hardware acceleration is working (docker logs frigate should show "coral" or "edgetpu" initialization)

Issue: Coral Not Detected

Solution:

# Check USB device
lsusb | grep Coral

# Verify device permissions
ls -l /dev/apex_0  # or /dev/bus/usb

# Add user to plugdev group
sudo usermod -aG plugdev $USER

# Restart Docker container
docker restart frigate

Issue: RTSP Stream Failures

Solution:

• Use sub-stream for detect, main stream for record
• Set hwaccel_args: preset-vaapi for Intel hardware acceleration
• Adjust max_timeout in camera config
• Verify camera credentials and network connectivity

Issue: False Motion Detections

Solution:

• Add motion masks for trees, shadows, and reflections
• Increase threshold in motion config (default: 25)
• Adjust contour_area to filter small movements
• Use improve_contrast for low-light cameras

The Future of Frigate NVR

As of May 2026, Frigate continues to evolve rapidly:

• Version 0.17: Enhanced audio detection, improved timeline UI, better multi-camera scrubbing
• Roadmap: Multi-object tracking improvements, license plate recognition (LPR), facial recognition options
• Community Growth: Over 32,000 GitHub stars, 745 contributors, and a thriving Discord community

The project has transitioned to Frigate, Inc. as a sponsored open-source project, ensuring long-term development while maintaining its MIT license and community-first ethos.

Getting Started Resources

• Official Documentation: https://docs.frigate.video
• GitHub Repository: https://github.com/blakeblackshear/frigate
• Home Assistant Integration: https://www.home-assistant.io/integrations/frigate/
• Community Forum: https://github.com/blakeblackshear/frigate/discussions
• Discord: https://discord.gg/frigate

Conclusion

Frigate NVR represents the gold standard for privacy-conscious, locally-processed surveillance in 2026. Its combination of powerful AI detection, efficient architecture, and seamless Home Assistant integration makes it the obvious choice for anyone building a modern smart home security system.

Whether you're protecting a single-family home, monitoring a small business, or managing a multi-building property, Frigate delivers enterprise-grade capabilities without the enterprise price tag or privacy compromises of cloud-based alternatives.

The initial setup requires more technical knowledge than plugging in a Nest Cam, but the payoff—complete ownership of your security footage, no recurring fees, and unlimited automation possibilities—makes it worthwhile for thousands of users worldwide.

Start with the official documentation, join the community, and discover why Frigate has become the de facto NVR solution for Home Assistant users everywhere.