Frigate NVR Documentation: Install, Configure, And Integrate

Running cameras overnight in an empty building is standard practice for any serious paranormal investigation. But raw footage alone doesn’t cut it, you need a system that can detect movement, tag objects, and record only what matters. That’s where Frigate NVR documentation becomes essential reading. Frigate is an open-source network video recorder built around real-time AI object detection, and it’s become a go-to tool for investigators who want smarter surveillance during their sessions.

At Haunt Gears, we spend a lot of time testing and recommending night vision cameras and monitoring setups for ghost hunting. Frigate NVR pairs exceptionally well with the kind of multi-camera rigs our community uses on location. Its ability to distinguish between a person, an animal, and other motion sources means fewer hours scrubbing through false alerts and more time focused on genuine anomalies worth reviewing.

This guide walks you through everything you need to get Frigate up and running, from hardware requirements and installation steps to configuration files and Home Assistant integration. Whether you’re building a permanent monitoring station or a portable investigation kit, you’ll find the technical details laid out clearly so you can set up your system with confidence. We’ve organized each section to match the order you’d actually follow during setup, so you can work through it start to finish or jump to the part you need.

Prerequisites and how Frigate NVR works

Before you install anything, it helps to understand what Frigate is doing under the hood and what your machine needs to support it. Frigate runs as a Docker container that pulls RTSP or RTMP streams from your IP cameras, decodes them in real time, runs AI object detection on each frame, and writes only the clips and snapshots that match your configured object types to disk. If your hardware can’t keep up with that pipeline, you’ll see frame drops, missed detections, or a system that locks up mid-investigation.

What Frigate NVR actually does

Frigate is not a passive recorder. It’s an active detection system that processes every camera feed through a configurable pipeline. The software decodes each video stream, passes frames to a detection model, compares results against your defined object classes (person, car, animal, and more), and then decides in real time whether to start recording or capture a snapshot. Reading through the official frigate nvr documentation in the project repository gives you the full architecture breakdown, including how each component connects.

Frigate separates stream decoding from detection, which means it can handle cameras at full resolution while running detection on a lower-resolution sub-stream to save CPU cycles.

The go2rtc component sits at the front of this pipeline and handles all incoming camera streams before Frigate processes them. Detection gets handed off to either your CPU, a Google Coral accelerator, or a compatible GPU, depending on what you configure. This design lets the system scale from a modest home server all the way up to a dedicated rack-mounted rig running a dozen cameras simultaneously.

System prerequisites

Your host machine needs to meet a few baseline requirements before Frigate runs reliably. The table below covers the minimum and recommended specs for a typical multi-camera investigation setup.

Component	Minimum	Recommended
CPU	4-core x86_64 or ARM64	6-core or better
RAM	4 GB	8 GB or more
Storage	50 GB SSD	500 GB+ SSD or NVMe
OS	Linux (Ubuntu 22.04+)	Ubuntu 22.04 LTS
Docker	20.x	24.x or latest
Network	100 Mbps LAN	Gigabit LAN

You also need Docker and Docker Compose installed on your host before you begin. On Ubuntu, you can install both with the command sudo apt install docker.io docker-compose-plugin. Your cameras must support RTSP streaming, which is standard on most IP cameras available today, including the night vision units we review at Haunt Gears.

Hardware accelerators for detection

Running detection on CPU alone works for one or two cameras, but it hits its limits quickly. A Google Coral USB Accelerator or Coral M.2 module offloads neural network inference entirely from your CPU, letting Frigate process ten or more camera streams without significant performance impact. If you already have an NVIDIA GPU in your server, Frigate also supports CUDA-based detection through the tensorrt detector type.

AMD GPU support exists through ROCm, but driver compatibility varies by card generation. For paranormal investigation rigs where reliability matters more than chasing the latest features, stick with Coral or NVIDIA for the smoothest and best-documented experience. Both hardware paths have strong community support and are covered thoroughly in the official project repository, so troubleshooting is straightforward if something doesn’t work on the first attempt.

Step 1. Pick hardware and storage

Your hardware choices set a hard ceiling on how many cameras Frigate can handle and how long your recorded footage stays available before the drive fills up. Underpowering your host machine is the most common reason new users hit problems immediately, and the frigate nvr documentation is direct about this: detection speed and stream count both depend on what’s running underneath the software. Sorting hardware before you write a single line of configuration saves you from rebuilding your setup partway through an investigation.

Choose your host machine

The host you pick determines how many camera streams Frigate can decode and analyze at the same time. A dedicated mini PC or small server keeps your investigation rig separate from your everyday machine and avoids the performance conflicts that come from running Frigate alongside other workloads. For a four-camera setup without a hardware accelerator, an Intel N100-based mini PC with 8 GB of RAM handles the load reliably. If you plan to run more than four cameras, add a Google Coral USB Accelerator so neural network inference moves off the CPU entirely and frame processing stays fast.

A Coral USB Accelerator costs around $60 and lets Frigate process ten or more camera streams simultaneously without putting meaningful load on your host CPU.

Use this table to match your camera count to the right hardware tier:

Camera Count	Recommended Host	Accelerator Needed
1-2	Any modern quad-core PC or mini PC	No
3-6	Intel N100 or equivalent, 8 GB RAM	Optional but recommended
7-12	Intel i5/i7 or Ryzen 5, 16 GB RAM	Yes (Coral or NVIDIA GPU)
12+	Dedicated server, 32 GB RAM	Yes, multiple Coral devices

Plan your storage

Storage capacity directly controls how many days of recorded footage you can keep before Frigate starts overwriting old clips. Frigate writes clips, snapshots, and database entries continuously during active detection, so a slow mechanical hard drive creates write bottlenecks that cause missed recordings. Use a dedicated SSD or NVMe drive as your primary recording target. For two weeks of retention across four cameras running at 1080p, budget at least 500 GB of dedicated storage.

Mount your recording drive as a Docker volume so Frigate writes directly to your chosen path. A typical volume mapping in your Compose file looks like /mnt/investigation-drive/frigate:/media/frigate. Keep your OS and Frigate application data on a separate drive from your recordings so a full storage disk doesn’t crash the container or corrupt your configuration files mid-session.

Step 2. Install Frigate with Docker Compose

Docker Compose is the standard installation method recommended throughout the frigate nvr documentation, and it keeps your entire setup portable and easy to update. Before you write any configuration, create a dedicated project directory on your host machine where Frigate will store its config file, database, and media output.

Create your directory structure

Your directory layout determines how cleanly Frigate separates its configuration from your recorded footage. Run the following commands to build the structure before you create any files:

mkdir -p ~/frigate/config
mkdir -p /mnt/investigation-drive/frigate

The config directory holds your config.yml file, and the media directory is where Frigate writes all recorded clips and snapshots. Keeping them on separate paths, and ideally separate drives, protects your configuration if your recording disk fills up completely during a long overnight session.

Write the Docker Compose file

Create a file named docker-compose.yml inside your ~/frigate directory and paste in the template below. This gives you a working starting point that you can adjust based on your hardware:

services:
  frigate:
    container_name: frigate
    privileged: true
    restart: unless-stopped
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "128mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb  # Remove if not using Coral USB
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ~/frigate/config:/config
      - /mnt/investigation-drive/frigate:/media/frigate
    ports:
      - "5000:5000"
      - "8554:8554"
      - "8555:8555/tcp"
      - "8555:8555/udp"
    environment:
      FRIGATE_RTSP_PASSWORD: "your_password_here"

The shm_size value controls shared memory allocation for frame processing. If you add more cameras later, increase this to 256mb or higher to prevent frame decoding errors. Remove the devices line entirely if you are not using a Coral USB Accelerator.

Start the container

Once your Compose file is in place, navigate to your ~/frigate directory and bring the container up with a single command:

cd ~/frigate && docker compose up -d

Check that Frigate starts without errors by running docker logs frigate immediately after launch. Any misconfiguration in your Compose file shows up in the first 30 seconds of output.

The web interface becomes available at http://your-host-ip:5000 within about 60 seconds. You won’t see any camera feeds yet since you haven’t added cameras to your config file, but a clean startup screen confirms your container is running correctly.

Step 3. Add cameras and restream with go2rtc

Adding cameras to Frigate happens inside your config.yml file, and go2rtc acts as the stream manager that sits between your cameras and Frigate’s detection pipeline. Every camera feed enters go2rtc first, which restreams it to Frigate using a more efficient internal path than pulling the RTSP feed directly. This approach reduces CPU load because Frigate decodes the stream once through go2rtc rather than opening multiple connections to your cameras for detection, recording, and live view at the same time.

Configure go2rtc in your config.yml

Go2rtc has its own configuration block inside your Frigate config.yml, and you define each camera’s source stream there by name. The name you assign in go2rtc becomes the reference you use throughout the rest of your Frigate configuration, so keep camera names short and consistent with no spaces or special characters. Open your ~/frigate/config/config.yml file and add the block below, replacing each placeholder URL with your camera’s actual RTSP address:

go2rtc:
  streams:
    front_entrance:
      - rtsp://admin:your_password@192.168.1.101:554/stream1
    back_hallway:
      - rtsp://admin:your_password@192.168.1.102:554/stream1
    basement:
      - rtsp://admin:your_password@192.168.1.103:554/stream1

Most IP cameras publish their RTSP stream path in their admin panel or printed manual, typically formatted as /stream1 for the main high-resolution feed and /stream2 for a lighter sub-stream.

The sub-stream option is worth using on multi-camera investigation rigs. You can point go2rtc at both the main stream and a sub-stream from the same camera, letting Frigate use the full-resolution feed for recording while running detection on the lighter sub-stream to keep CPU usage manageable across all channels.

Point Frigate cameras at go2rtc streams

Once go2rtc has your streams defined, you reference them inside the cameras block of your config file. The frigate nvr documentation recommends using the go2rtc internal RTSP path rather than a direct camera URL for both your record and detect inputs, which keeps all stream handling centralized and prevents duplicate connections to your cameras:

cameras:
  front_entrance:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/front_entrance
          roles:
            - record
        - path: rtsp://127.0.0.1:8554/front_entrance
          roles:
            - detect
    detect:
      width: 1280
      height: 720
      fps: 5

Save your config file and restart the container with docker compose restart frigate. Your camera feeds should appear in the web interface at http://your-host-ip:5000 within about 30 seconds of the container completing its restart cycle.

Step 4. Configure detection, recording, and snapshots

With your cameras feeding into Frigate, the next step is telling the system what to detect, when to record, and how to save snapshots. These three settings work together inside your config.yml and control the core behavior of every camera you’ve defined. Getting this right means Frigate stores the footage you actually want and skips the hours of empty hallway video that wastes drive space during long investigation sessions.

Set up your detector

Your detector block tells Frigate which hardware to use for AI inference and which object classes to watch for. Add this block near the top of your config.yml, before your cameras section:

detectors:
  coral:
    type: edgetpu
    device: usb

objects:
  track:
    - person
    - cat
    - dog
  filters:
    person:
      min_score: 0.5
      threshold: 0.7

If you are running detection on CPU only, replace the detector block with type: cpu. The min_score value filters out low-confidence detections before they trigger recording, and the threshold value sets the point at which Frigate confirms an object and logs it to the database. Raising both values reduces false positives, which is particularly useful in locations with unstable lighting or strong infrared reflection.

Setting min_score too high causes Frigate to miss real detections, so start at 0.5 and adjust upward only after reviewing your first night of footage.

Configure recording behavior

The recording block controls when Frigate writes video clips to your storage drive and how long it keeps them. Add this global block to apply default recording settings across all cameras, then override individual cameras as needed:

record:
  enabled: true
  retain:
    days: 7
    mode: motion
  events:
    retain:
      default: 14
      mode: active_objects

Setting mode: motion on the base retain block saves only segments where motion occurred, while mode: active_objects on your events retain block keeps clips that contain a confirmed object detection for a longer window. This pairing keeps your storage use predictable without deleting potentially important footage too quickly.

Enable snapshots

Snapshots give you a still image for every confirmed detection event, which makes reviewing an investigation far faster than scrubbing through video. Add this block to your config and reference the frigate nvr documentation for additional crop and quality options:

snapshots:
  enabled: true
  bounding_box: true
  retain:
    default: 14

Enabling bounding_box draws the detection region directly on each saved image, so you can immediately see what Frigate identified and where it appeared in the frame.

Step 5. Tune accuracy with zones, masks, and filters

Raw detection across an entire camera frame generates a lot of noise. A camera pointed down a hallway will trigger on curtains moving near a window, shadows shifting on a wall, or insects flying past the lens. Zones, motion masks, and object filters let you tell Frigate exactly where to pay attention and what to ignore, which dramatically cuts the number of false detection events you need to review after a full night of recording. This is where most of the precision tuning work happens, and the frigate nvr documentation covers each tool in detail with visual examples you can reference alongside this guide.

Define zones for targeted detection

Zones are custom polygonal regions you draw over your camera frame that let Frigate apply different detection rules to specific areas. You define each zone with a list of x,y coordinate pairs that map to normalized positions on the frame, where 0,0 is the top-left corner and 1,1 is the bottom-right. Add your zones directly inside the camera block in your config.yml:

cameras:
  front_entrance:
    zones:
      doorway:
        coordinates: 0.2,0.4,0.8,0.4,0.8,1.0,0.2,1.0
      window_area:
        coordinates: 0.6,0.0,1.0,0.0,1.0,0.5,0.6,0.5

Use the Frigate web interface at http://your-host-ip:5000 to display your camera feed and estimate coordinates visually before writing them into your config file.

Naming your zones clearly matters because you reference them later when configuring per-zone object filters and alerts. A zone named doorway is easier to work with than zone1 when you’re reviewing events or adjusting thresholds weeks later.

Apply motion masks to cut out noise

Motion masks block specific regions of your camera frame from triggering motion-based recording, which is different from blocking object detection. You use masks to suppress persistent motion sources like tree branches, ceiling fans, or reflective surfaces that constantly register movement without containing anything worth recording.

cameras:
  front_entrance:
    motion:
      mask:
        - 0.0,0.0,0.3,0.0,0.3,0.3,0.0,0.3

Each mask entry is a polygon using the same normalized coordinate format as zones. You can stack multiple mask entries under the same camera to cover several problem areas at once.

Filter objects per zone

Per-zone object filters let you apply stricter confidence thresholds inside specific regions without affecting detection sensitivity across the whole frame. Add a filters block inside any zone definition to override the global object settings:

zones:
  window_area:
    coordinates: 0.6,0.0,1.0,0.0,1.0,0.5,0.6,0.5
    objects:
      - person
    filters:
      person:
        min_score: 0.65
        threshold: 0.8

Raising the threshold inside high-noise zones keeps your event log clean without sacrificing detection accuracy in the areas of your location that matter most.

Step 6. Integrate with Home Assistant and MQTT

Frigate connects to Home Assistant through a dedicated integration that exposes every camera, detection event, and object count as entities you can build automations around. If you run Home Assistant on the same network as your investigation rig, this integration turns your NVR into a fully interactive monitoring layer that responds to detections in real time. Before the integration works, you need MQTT running as the messaging layer between the two systems, since Frigate and Home Assistant communicate through that broker rather than through a direct API connection.

Set Up an MQTT Broker

Mosquitto is the standard MQTT broker used alongside Frigate and Home Assistant, and you can run it as a Home Assistant add-on or as a separate Docker container. Install it through the Home Assistant Add-on Store if you’re running Home Assistant OS, then create a dedicated user for Frigate inside the Mosquitto configuration so you can track which messages originate from your NVR. Once your broker is running, add the MQTT block to your Frigate config.yml with the broker address, port, and credentials you just created:

mqtt:
  host: 192.168.1.50
  port: 1883
  user: frigate_mqtt
  password: your_mqtt_password
  topic_prefix: frigate
  client_id: frigate_nvr

Frigate publishes detection events, object counts, and camera states to MQTT topics automatically once you add this block and restart the container with docker compose restart frigate.

The topic_prefix value determines the root path for all Frigate messages on your broker. Keeping it set to frigate matches the defaults expected by the Home Assistant integration, so leave it as shown unless you’re running multiple Frigate instances on the same MQTT broker.

Add the Frigate Integration to Home Assistant

With MQTT connected, install the Frigate Home Assistant integration through HACS or by following the steps in the official frigate nvr documentation for manual installation. Navigate to Settings > Integrations > Add Integration in your Home Assistant dashboard, search for Frigate, and enter your Frigate host URL when prompted. The integration discovers all your cameras and entities automatically without additional configuration.

Each camera appears as a media source inside Home Assistant, and detection events trigger binary sensors you can wire into automations. A practical starting configuration is an automation that sends a push notification whenever Frigate detects a person inside a named zone during your scheduled investigation window, referencing the zone names you defined in the previous step.

Step 7. Secure, monitor, and troubleshoot

A Frigate instance running on your local network without any access controls is an open door for anyone else on that network. Locking down your setup before you take it into the field protects both your footage and your configuration, and the steps to do it are straightforward enough that skipping them is never worth the risk.

Restrict access and set authentication

Frigate does not ship with built-in authentication on its web interface by default, so you need to add a layer in front of it. The practical approach for most investigation setups is to put Frigate behind a reverse proxy running on the same host. Add the following Nginx service to your Docker Compose file to handle basic auth on port 8080 while Frigate continues to run internally on port 5000:

  nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ~/frigate/nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - frigate

Your Nginx config file should proxy requests to http://frigate:5000 and include an auth_basic directive pointing to a .htpasswd file you generate with htpasswd -c ~/frigate/.htpasswd your_username. This keeps the Frigate UI off any port that’s directly accessible without a password.

Never expose port 5000 directly to the internet without authentication, even temporarily during testing.

Monitor system health

Frigate exposes real-time performance statistics through its web interface under the System tab, including detector inference speed, camera frame rates, and process CPU usage. Check this panel after every configuration change to confirm your detection pipeline is keeping up with your camera count. If inference speed drops below 20ms per frame, your accelerator or CPU is working at capacity and you may need to reduce detection resolution or add hardware.

You can also query Frigate’s stats endpoint directly with curl http://your-host-ip:5000/api/stats to get a JSON response you can log or pipe into a monitoring script during long overnight sessions.

Fix common problems

Most startup issues in Frigate trace back to three root causes. Check these areas in order before digging deeper into the frigate nvr documentation for more obscure errors:

Symptom	Likely Cause	Fix
No camera feed in UI	Wrong RTSP URL	Verify URL with VLC first
High CPU usage	No accelerator configured	Add Coral or switch detector type
Container exits on start	Low shm_size	Increase to 256mb or higher
MQTT not connecting	Wrong broker IP or port	Run docker logs frigate to confirm error

Restarting the container with docker compose restart frigate resolves most config-related issues after you make corrections to your config.yml.

Next steps

You now have a complete Frigate NVR installation running with cameras, AI detection, recording, and Home Assistant integration all configured and working together. Each section of this guide maps directly to the official frigate nvr documentation sections where you can dig deeper into options not covered here, including advanced detector configurations and multi-instance setups for larger rigs.

Your most immediate next step is reviewing your first full night of footage and adjusting your zone coordinates and detection thresholds based on what you actually capture. Real-world conditions always surface edge cases that testing doesn’t, so expect to refine your config file two or three times before your setup feels dialed in.

Once your monitoring system runs reliably, the right cameras and sensors make a significant difference in what Frigate actually has to work with. Browse our paranormal investigation equipment to find night vision cameras and detection devices that pair well with the setup you just built.