Reolink + Frigate: A Practical NVR Build

You Don’t Need Ubiquiti. You Need a Reolink Camera and Frigate.

If you’ve been shopping for security camera setups, you’ve seen the Ubiquiti UniFi Protect pitch, beautiful web UI, professional gear, five-figure price tags, and the creeping feeling that you’re hiring a forklift to move a couch. Meanwhile, Reolink cameras do RTSP straight out of the box, Frigate runs on a potato, and you keep all your footage on local storage. Total cost: sub-$1,500 for a solid four-camera NVR that fits in a 1U rack and runs on a single power supply.

This isn’t about choosing the cheapest path. It’s about picking the right tool. I’ve run this setup for two years, through firmware updates, power losses, and the inevitable 2 AM “did someone just open the patio door?” moments. Here’s what works, what doesn’t, and exactly how to build it.

The Hardware List

Cameras

You want Reolink PoE cameras. Here’s why: RTSP support, 5MP+ resolution, sub-streams for motion detection, Reolink’s NVR is optional (but we’re replacing it with Frigate anyway), and they’re priced between $100 to 250 each.

My setup:

• 2× Reolink RLC-810A (5MP turret, 2.8mm fixed lens, PoE): $140 each
• 2× Reolink RLC-811A (5MP turret, varifocal 2.8 to 12mm, PoE): $200 each

The 811A is worth the extra $60 if you need zoom (perimeter scanning). For fixed entrances, the 810A is fine. Both support dual-stream RTSP, which is critical for Frigate’s detection/recording split.

Why not Hikvision? Similar price, similar specs, but Reolink cameras are consistently easier to integrate with Frigate, fewer wonky firmware quirks, better RTSP stability, and their sub-stream implementation is cleaner.

PoE Switch

You need at least 4 PoE ports. I’m using a MikroTik CSS106-1G-4P-1S (5× 1G PoE, 1× SFP, $90). Overkill? Yes. But it handles four cameras at full power-draw without throttling, and it’s fanless. Grab what fits your rack size, just verify watts-per-port before buying. Reolink cameras pull 3 to 5W each.

Don’t cheap out here. A $40 unmanaged PoE switch that undershoots power will throttle cameras mid-feed, and debugging “why is camera 3 dropping frames?” at 11 PM is not fun.

Storage

This is where the math gets real. Let me break it down:

5MP @ 2 Mbps (primary stream) + 2MP @ 512 kbps (sub-stream) per camera:

• 4 cameras × 2 Mbps = 8 Mbps aggregate = 1 MB/s = 86.4 GB/day

30-day retention:

• 86.4 GB/day × 30 = ~2.6 TB

My recommendation: Use ZFS with a striped mirror (2× 4TB drives) for fast writes and redundancy. That’s 4TB usable, good for 40 days at 2 Mbps aggregate. If you want 60+ days, move to 2× 8TB ($280 total). Raw HDDs in /mnt/frigate/recordings/ work fine too, but no redundancy, a single drive failure means everything from that time window is gone.

Storage layout:

/mnt/frigate/                    ← mount point (ZFS pool or direct HDD)
  recordings/
    clips/                       ← detected events (auto-trimmed)
    camera_1/
      2026-10/13/
        12-30-45.mp4             ← Frigate's default segment structure
        12-31-15.mp4
        ...

Server

Any modern x86 box runs Frigate. I’m using an Intel NUC11 Core i5 (bare bone, $250) with 16GB RAM. Overkill for four cameras, but headroom for inference (object detection) and future expansion.

Minimum: 2-core, 4GB RAM, 2× GigE NICs (one for PoE, one for LAN).

Getting RTSP URLs Right

This is where most people stumble. Reolink cameras expose two RTSP streams:

• Main stream: Full resolution (5MP), high bitrate
• Sub-stream: Lower resolution (2MP), low bitrate

You use the main stream for recording and the sub-stream for detection to save CPU and storage.

Getting the Credentials

1. Log into the camera’s web UI (IP address in your browser)
2. Admin panel → Network → RTSP
3. Enable RTSP, note the port (default 554)
4. Username: admin, Password: whatever you set during setup

RTSP URL Format

Reolink follows this pattern:

rtsp://admin:password@camera-ip:554/h264Preview_01_main
rtsp://admin:password@camera-ip:554/h264Preview_01_sub

Critical: Many Reolink models stream the main channel as H.265, in that case swap h264Preview_01_main for h265Preview_01_main. The sub-stream is usually H.264 either way. Check your camera’s manual or try both. (Newer 8MP+ models can be flaky over RTSP, Frigate’s docs recommend the HTTP-FLV stream there instead.)

Frigate Config Snippet

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/h264Preview_01_main
          roles:
            - record
        - path: rtsp://admin:[email protected]:554/h264Preview_01_sub
          roles:
            - detect
    detect:
      width: 640
      height: 480
      fps: 5
    objects:
      track:
        - person
        - car
        - dog

The sub-stream trick: Frigate runs object detection (YOLO or similar) on the sub-stream at 5 FPS, then records the main stream at 30 FPS continuously. Detection is cheap, recording is complete. You get the best of both worlds.

Complete Frigate Config Example

Here’s a production-ready config.yml for four cameras:

logger:
  default: info
  logs:
    frigate.record: debug

database:
  path: /config/frigate.db

mqtt:
  enabled: false

objects:
  track:
    - person
    - car
    - dog
    - cat

detectors:
  cpu:
    type: cpu
    num_threads: 2

ffmpeg:
  global_args:
    - -hide_banner
    - -loglevel
    - warning

snapshots:
  enabled: true
  clean_copy: true
  timestamp: false
  retain:
    default: 10
    objects:
      person: 30
      car: 20

record:
  enabled: true
  retain:
    days: 30
    mode: motion
  alerts:
    retain:
      days: 14
      mode: motion
  detections:
    retain:
      days: 7
      mode: motion

cameras:
  front_door:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/h264Preview_01_main
          roles:
            - record
        - path: rtsp://admin:[email protected]:554/h264Preview_01_sub
          roles:
            - detect
    detect:
      enabled: true
      width: 640
      height: 480
      fps: 5
    review:
      alerts:
        labels:
          - person
          - car
    motion:
      mask: ""

  driveway:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/h264Preview_01_main
          roles:
            - record
        - path: rtsp://admin:[email protected]:554/h264Preview_01_sub
          roles:
            - detect
    detect:
      enabled: true
      width: 640
      height: 480
      fps: 5
    review:
      alerts:
        labels:
          - person
          - car
    motion:
      mask: ""

  backyard:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/h264Preview_01_main
          roles:
            - record
        - path: rtsp://admin:[email protected]:554/h264Preview_01_sub
          roles:
            - detect
    detect:
      enabled: true
      width: 640
      height: 480
      fps: 5
    review:
      alerts:
        labels:
          - person
          - dog
          - cat

  side_gate:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://admin:[email protected]:554/h264Preview_01_main
          roles:
            - record
        - path: rtsp://admin:[email protected]:554/h264Preview_01_sub
          roles:
            - detect
    detect:
      enabled: true
      width: 640
      height: 480
      fps: 5
    review:
      alerts:
        labels:
          - person
          - car

ui:
  enabled: true
  order:
    - front_door
    - driveway
    - backyard
    - side_gate

birdseye:
  enabled: true
  restream: true
  mode: objects

Key settings:

• detect.fps: 5: Run detection on sub-stream at 5 FPS (cheap, fast)
• record.retain.days: 30: Keep 30 days of continuous video
• snapshots.retain.objects.person: 30: Keep person snapshots for 30 days
• review.alerts.labels: Promote person/car events to alerts (the high-priority review queue); everything else stays a lower-priority detection
• birdseye.mode: objects: Composite bird’s-eye view showing detected objects only

Storage Math Cheat Sheet

Quick reference for 5MP @ 2 Mbps:

Reducing storage:

1. Lower bitrate in camera settings (1.5 Mbps instead of 2 Mbps)
2. Reduce main-stream FPS (20 FPS instead of 30 FPS)
3. Use record.retain.mode: motion (only record when motion detected)
4. Aggressive object retention (7 days for person, 3 days for car)

My setup (4 cameras, 2× 4TB ZFS mirror):

• 40 days continuous video
• Unlimited event snapshots (auto-trim at 10 days)
• Costs about $280 in drives, lasts 5+ years

Sub-Stream Gotchas

Problem 1: “My sub-stream is dropping frames.”

• Check camera’s bandwidth limit setting (admin panel)
• Reolink defaults to limiting sub-stream to 1 Mbps, increase it to 2 to 3 Mbps
• Restart Frigate after changing camera settings

Problem 2: “Detection is laggy but recording is smooth.”

• Your detect model (yolonas, yolox, etc.) is too heavy for your CPU
• Switch to cpu detector in Frigate config
• Reduce detect FPS to 3 to 4
• Disable night detection (set enabled: false after sunset)

Problem 3: “One camera keeps disconnecting.”

• Reolink firmware bug (happens on older builds)
• Update camera firmware via admin panel
• Add reconnect logic to Frigate config:

 ffmpeg:
   retry_interval: 30  # reconnect every 30s if connection fails

Deployment: Docker or Bare Metal?

Docker (recommended):

docker run -d \
  --name frigate \
  --restart unless-stopped \
  -v /mnt/frigate/config:/config \
  -v /mnt/frigate/recordings:/media/frigate/recordings \
  -e FRIGATE_RTSP_PASSWORD=your_password \
  -p 5000:5000 \
  ghcr.io/blakeblackshear/frigate:stable

Bare metal: Use the official Frigate docs, it’s Python + FFmpeg + a bit of Go. Works fine on Ubuntu/Debian, but Docker is easier to upgrade.

The Decision

Build this if:

• You want local storage (no cloud subscription)
• You’re willing to run a small server 24/7
• You need RTSP access (for integrations, streaming to Home Assistant, etc.)
• You prefer open source over vendor lock-in

Skip this if:

• You want a plug-and-play solution (buy Ubiquiti UniFi Protect, live with the cost)
• Your internet connection is unreliable (Frigate needs stable network, not just WAN)
• You’re uncomfortable with YAML configs and Docker

Wrapping Up

Two years in, I’ve replaced three Reolink cameras (two failed power adapters, one lens got dirty), upgraded storage twice, and never lost footage. The system runs in a corner of my rack, costs about $80/month to run (power + eventual drive replacement), and gives me better visibility than anything off-the-shelf.

The real win isn’t the price. It’s knowing exactly where your data lives, running detection on your terms, and having zero subscription fees. Your 2 AM self will appreciate it.

Now go build something.

Common Questions

Can Frigate pull streams from a Reolink NVR instead of the cameras?

Yes, and it is usually the wrong choice. The NVR re-encodes and adds latency, and it exposes one RTSP path per channel like rtsp://user:pass@nvr-ip:554/h264Preview_ch01_main. Going straight to each camera gives Frigate the clean sub-stream it wants. Use the NVR path only when the cameras sit on a network Frigate cannot reach.

Does the Reolink video doorbell work with Frigate?

Yes. The wired and PoE doorbells expose standard RTSP and work like any other Reolink camera, including the package-detection field of view. The battery doorbells do not, because they sleep to save power and drop the stream. Check for a PoE or wired model before buying if Frigate is the goal.

Should I use RTSP or the http-flv source for Reolink in Frigate?

RTSP for recording, http-flv only as a fallback. Several Reolink firmware versions ship a broken RTSP timestamp that makes Frigate log continual frame drops, and the http-flv endpoint sidesteps it. Try RTSP first, and switch that camera to http://cam-ip/flv?port=1935&app=bcs&stream=channel0_main.bcs only if it misbehaves.

How many Reolink cameras can one Frigate box handle?

About 6 to 8 at 1080p detection on a Coral TPU, limited by decode rather than inference. Detection runs on the sub-stream at roughly 5fps, so CPU decode cost stays low. Without a Coral or an iGPU doing hardware decode, expect 2 to 3 cameras before a modern quad-core saturates.

Related Reading

• Frigate Beyond Coral: GPU and OpenVINO