Frigate vs motionEye: Which NVR Should You Use?

Quick Verdict

Frigate is the better NVR for anyone serious about self-hosted surveillance. It has real-time AI object detection, native Home Assistant integration, efficient recording with event-based retention, and an active community. motionEye is a simpler tool — a lightweight web frontend for motion-triggered recording that works well for basic camera viewing on low-power hardware. If you just want to check on a few cameras with minimal setup and no AI features, motionEye gets the job done. For anything beyond that, Frigate wins decisively.

Overview

Frigate is an open-source NVR purpose-built around real-time AI object detection. It uses Google Coral TPUs, Intel OpenVINO, or ONNX for hardware-accelerated inference, integrates natively with Home Assistant via MQTT, and manages recordings intelligently by retaining only clips with detected objects. It is the most actively developed and widely used self-hosted NVR as of 2026.

motionEye is a web-based frontend for the motion daemon — a long-standing Linux motion detection engine. It provides a clean browser interface for viewing camera feeds, configuring motion detection zones, and managing recordings. It supports RTSP, MJPEG, and USB cameras. motionEye targets users who want a simple, low-resource camera dashboard without the complexity of a full NVR stack.

Feature Comparison

Feature	Frigate	motionEye
AI Object Detection	Built-in (Coral TPU, OpenVINO, ONNX, CPU)	None (pixel-based motion only)
Home Assistant Integration	Native (MQTT + dedicated integration)	Manual (webhook/API)
Object Types Detected	Person, car, dog, cat, 80+ COCO classes	Motion only (no object classification)
Live Streaming	RTSP restream, WebRTC, MSE	MJPEG streaming
Recording Strategy	Event-based (records around detections)	Continuous or motion-triggered
Hardware Acceleration	Coral TPU, Intel QSV/VAAPI, NVIDIA, AMD ROCm	None (CPU only)
Camera Protocol Support	RTSP, ONVIF, RTMP	RTSP, MJPEG, V4L2 (USB cameras)
Multi-User Support	Single admin (v0.16)	Admin + viewer accounts
Mobile App	Via Home Assistant companion app	Browser-based (responsive)
MQTT Support	Full (events, snapshots, automation triggers)	None
Notification Support	Via MQTT/Home Assistant automations	Email, webhook, custom scripts
API	REST API + MQTT topics	Limited REST API
Minimum RAM	2 GB+ (more with cameras)	512 MB
License	MIT	GPLv3
Active Development	Very active (frequent releases, large community)	Slow (community-maintained)
Web UI	Modern (built-in config editor, Birdseye view)	Clean but dated

Docker Compose Configurations

Frigate

Frigate requires a config file and benefits significantly from a hardware AI accelerator like a Google Coral USB TPU.

Create a docker-compose.yml:

services:
  frigate:
    image: ghcr.io/blakeblackshear/frigate:0.16.4
    container_name: frigate
    restart: unless-stopped
    privileged: true
    shm_size: 256mb # Increase for more cameras or higher resolutions
    ports:
      - "8971:8971"     # Authenticated Web UI
      - "8554:8554"     # RTSP restream
      - "8555:8555/tcp" # WebRTC over TCP
      - "8555:8555/udp" # WebRTC over UDP
    volumes:
      - ./config:/config           # Config file and database
      - /path/to/recordings:/media/frigate  # Recordings and snapshots
      - /etc/localtime:/etc/localtime:ro    # Timezone
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000  # 1 GB cache to reduce SSD wear
    devices:
      - /dev/bus/usb:/dev/bus/usb  # Google Coral USB TPU (remove if not using)
    environment:
      FRIGATE_RTSP_PASSWORD: "changeme"  # RTSP password for camera auth

Create a minimal config/config.yml:

mqtt:
  enabled: false  # Set to true and configure if using Home Assistant

detectors:
  coral:
    type: edgetpu
    device: usb  # Change to "pci" for PCIe Coral

cameras:
  front_door:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/stream1
          roles:
            - detect
            - record
    detect:
      width: 1280
      height: 720
      fps: 5
    record:
      enabled: true
      retain:
        days: 7
        mode: motion  # Keep all motion clips for 7 days
      events:
        retain:
          default: 30  # Keep detection events for 30 days
    snapshots:
      enabled: true
      retain:
        default: 30

Start the stack:

docker compose up -d

Access the web UI at http://your-server:8971.

motionEye

motionEye runs as a single container with minimal configuration.

Create a docker-compose.yml:

services:
  motioneye:
    image: ghcr.io/motioneye-project/motioneye:0.43.1
    container_name: motioneye
    restart: unless-stopped
    ports:
      - "8765:8765"  # Web UI
    volumes:
      - ./config:/etc/motioneye   # Configuration files
      - ./recordings:/var/lib/motioneye  # Recordings and snapshots
      - /etc/localtime:/etc/localtime:ro  # Timezone
    environment:
      - TZ=America/New_York  # Set your timezone

Start the stack:

docker compose up -d

Access the web UI at http://your-server:8765. Default credentials are admin with no password. Set a password immediately after first login.

Installation Complexity

motionEye wins on simplicity. You spin up a single container, open the web UI, add your camera URLs through the browser interface, and you are done. The entire setup takes five minutes. No config files to write, no MQTT broker to run, no hardware accelerator to source.

Frigate requires more upfront work. You need a config.yml with camera stream URLs, detection settings, and recording rules. For optimal performance, you need a Google Coral USB TPU (~$30) or compatible AI accelerator. If you use Home Assistant, you also need an MQTT broker (Mosquitto). Plan for 30-60 minutes on first setup, depending on camera count.

That said, Frigate’s complexity pays off quickly. The config editor built into the web UI catches errors before they cause problems, and the detection tuning workflow is well-documented. Once configured, Frigate is lower-maintenance than motionEye because its AI-driven recording means fewer false positives to wade through.

Performance and Resource Usage

Frigate is heavier on resources but uses them efficiently. AI inference offloaded to a Coral TPU adds negligible CPU load — the main cost is FFmpeg decoding camera streams. Expect 2-4 GB of RAM for a typical 4-camera setup. Frigate supports Intel Quick Sync, VAAPI, and NVIDIA hardware decoding to keep CPU usage manageable.

motionEye uses less baseline RAM (under 512 MB for a few cameras) but does all motion detection on the CPU. With multiple high-resolution cameras, CPU usage climbs fast because there is no hardware acceleration option. A Raspberry Pi can handle 2-3 low-resolution cameras; beyond that, you need more CPU.

Resource	Frigate (4 cameras)	motionEye (4 cameras)
RAM (idle)	~2 GB	~400 MB
CPU (idle)	5-15% (with HW decode)	10-30%
CPU (motion events)	15-25% (Coral handles AI)	40-80%
Minimum disk	50 GB recommended	20 GB recommended
Recommended hardware	x86 with Coral TPU	Raspberry Pi or x86

Recording and Storage

Frigate’s recording strategy is its strongest advantage over motionEye. It records continuously but only retains clips where objects were detected. You can set different retention policies for motion events versus AI-detected events. A typical setup keeps all detection events (person, car) for 30 days but discards empty motion clips after 7 days. This dramatically reduces storage consumption compared to continuous recording.

motionEye offers continuous recording or motion-triggered recording. Motion detection is pixel-based — any change in the frame triggers it. Shadows, lighting changes, insects, and wind-blown trees all cause false positives. You will either miss real events (if sensitivity is too low) or drown in false recordings (if too high). There is no way to filter for specific object types.

Community and Ecosystem

Frigate has a large, active community. The GitHub repository has over 20,000 stars, regular releases, and detailed documentation. The Home Assistant community has thousands of posts about Frigate. Discord and Reddit (r/homeassistant, r/selfhosted) are active with troubleshooting help.

motionEye’s development has slowed significantly. The original project by ccrisan was archived, and the community fork keeps it alive but releases are infrequent. Documentation is adequate for basic setups but thin on advanced topics. The underlying motion daemon is mature and stable, which means motionEye still works — it just is not evolving.

Use Cases

Choose Frigate If…

• You want AI-powered object detection (people, cars, animals — not just pixel changes)
• You use Home Assistant and want camera events to trigger automations
• You have 3+ cameras and need efficient storage management
• You plan to scale your surveillance setup over time
• You want RTSP restreaming to reduce camera connection load
• You care about active development and long-term project viability

Choose motionEye If…

• You have 1-2 cameras and just want to view them in a browser
• You are running on a Raspberry Pi or other low-power hardware
• You do not need object detection — basic motion alerts are enough
• You want the simplest possible setup with zero config files
• You need multi-user access with viewer accounts
• You use USB webcams (V4L2 support) rather than IP cameras

Final Verdict

Frigate is the clear winner for self-hosted video surveillance in 2026. AI object detection is not a luxury feature — it is the difference between a useful security system and a storage-wasting motion recorder. Frigate detects actual people and cars, Frigate records intelligently, and Frigate integrates seamlessly with Home Assistant for automations like turning on lights when someone approaches the door.

motionEye is not a bad tool. It fills a specific niche: simple camera viewing on minimal hardware. If you have a Raspberry Pi and a single USB camera monitoring your 3D printer, motionEye is the pragmatic choice. But the moment you need more than a basic camera dashboard — object detection, smart recording, automation triggers, scaling beyond a few cameras — Frigate is the only serious option.

For most self-hosters building a surveillance setup, start with Frigate. The initial setup takes longer, but you get a system that actually works as a security tool rather than just a camera viewer.

Related

• How to Self-Host Frigate
• Best Self-Hosted Video Surveillance
• Frigate vs Shinobi
• Frigate vs ZoneMinder
• ZoneMinder vs Shinobi
• Docker Compose Basics
• How to Self-Host Home Assistant