🎥 Frigate NVR Configuration Generator

Method 1: Camera Web Interface (Most Reliable)

1. Find your camera's IP address (check router DHCP table or use IP scanner like Advanced IP Scanner)
2. Open web browser and navigate to http://CAMERA_IP
3. Log in with camera credentials (common defaults: admin/admin, admin/12345, admin/password)
4. Navigate to Settings → Network → Stream or Video Settings
5. Look for RTSP settings or Stream URLs
6. Copy both "Main Stream" (high resolution) and "Sub Stream" (low resolution) URLs
7. Note the resolution, bitrate, and encoding settings for each stream

Method 2: Test with VLC Media Player

1. Download and install VLC from videolan.org
2. Open VLC → Media → Open Network Stream
3. Try common RTSP URL formats (see below)
4. If video plays successfully, that's your working RTSP URL!
5. Right-click video → Codec Information to see resolution and bitrate

Method 3: ONVIF Device Manager (Advanced)

1. Download ONVIF Device Manager
2. Scan your network for ONVIF-compatible cameras
3. Device manager will display all available streams with exact URLs
4. This works for most modern IP cameras

Common RTSP URL Formats by Camera Brand:

Troubleshooting RTSP Connection:

• Camera unreachable: Ensure camera and server are on same network or properly routed subnet
• Authentication failed: Double-check username and password (URL encoding needed for special characters)
• Port blocked: Default RTSP port is 554, check firewall rules on server and camera
• Stream not found: Try different stream paths, check camera documentation
• Connection timeout: Some cameras need ?tcp at end of URL to force TCP mode
• H.265 codec issues: Ensure camera is set to H.264 for maximum compatibility
• Multiple channels: For multi-channel cameras, change channel=1 to channel=2, channel=3, etc.

Best Practices for Camera Configuration:

• Main stream: 1920×1080 (1080p) @ 15fps, 4096-6144 kbps, H.264 encoding
• Sub stream: 1280×720 (720p) @ 5fps, 1024-2048 kbps, H.264 encoding
• Frame rate: 15fps for main, 5fps for sub (higher FPS = more storage/bandwidth)
• Bitrate mode: CBR (Constant Bitrate) strongly recommended over VBR
• I-frame interval: Set to match framerate (e.g., 15 for 15fps)
• Disable: WDR, HDR, 3D-NR on sub stream (keeps detection fast)

Models included by default in Frigate:

• SSDLite MobileNet v2 (OpenVINO/CPU) - 300×300 - Default, balanced speed/accuracy, no setup required
• SSD MobileNet v2 (EdgeTPU) - Optimized for Google Coral, excellent efficiency

Additional models (require manual download and configuration):

⚠️ Important Model Considerations:

• Model size vs. speed: Larger models (YOLOv9, YOLOv11) = better accuracy but slower detection
• Input resolution: Higher input resolution = better small object detection but slower
• Testing required: Always test new models with your cameras before production deployment
• Default is excellent: SSDLite MobileNet v2 works great for most use cases, don't fix what isn't broken
• Hardware dependency: Model performance varies significantly by detector type (OpenVINO vs Coral vs CPU)
• Coral limitation: Coral Edge TPU only supports pre-compiled EdgeTPU models, cannot use YOLO without complex conversion

Model Performance Comparison:

Understanding bitrate encoding modes is CRITICAL for Frigate stability.

How to configure encoding in camera:

1. Log into camera web interface
2. Navigate to Video Settings or Stream Configuration
3. For EACH stream (main and sub):
   • Set "Rate Control" or "Bitrate Mode" to CBR
   • Set bitrate to recommended values above
   • Set I-frame interval (GOP) to match framerate (e.g., 15 for 15fps stream)
   • Set encoding to H.264 (not H.265/HEVC unless specific requirement)
   • Disable smart encoding, WDR, 3D-NR on sub stream (keeps detection fast)
4. Save settings and test stream in VLC before deploying

Verifying your stream configuration:

# Test with FFmpeg
ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,bit_rate,r_frame_rate,width,height rtsp://admin:pass@192.168.1.64/stream1

# Check bitrate stability over time
ffmpeg -i rtsp://admin:pass@192.168.1.64/stream1 -t 60 -f null - 2>&1 | grep bitrate

Formula for storage calculation:

Per camera per day:
5 Mbps × 24 hours × 0.45 = 54 GB/day

All 4 cameras per day:
54 GB × 4 cameras = 216 GB/day

Weekly storage:
216 GB × 7 days = 1,512 GB = 1.5 TB/week

Monthly storage:
216 GB × 30 days = 6,480 GB = 6.5 TB/month

Yearly storage:
216 GB × 365 days = 78,840 GB = 79 TB/year

Storage Recommendations by Camera Count:

• 1-2 cameras: 1TB minimum, 2TB recommended (30 days retention)
• 3-4 cameras: 2TB minimum, 4TB recommended (14-30 days retention)
• 5-8 cameras: 4TB minimum, 8TB recommended (10-20 days retention)
• 8-12 cameras: 8TB minimum, 12-16TB recommended (7-14 days retention)
• 12+ cameras: 12TB+, consider NAS or RAID array

Storage Best Practices:

• Separate storage types:
  • SSD: Frigate database, clips, snapshots (fast access needed)
  • HDD: Continuous recordings (large capacity, sequential writes)
• Two-tier retention:
  • Continuous recordings: 3-7 days (fills storage quickly)
  • Event recordings: 30-90 days (smaller size, important footage)
• Motion-based recording: Saves 60-90% storage vs 24/7 for low-activity areas
• Monitor disk health: Use smartmontools to check drive status weekly
• Plan for growth: Buy 50% more storage than calculated (future cameras, longer retention)
• Backup strategy: Config + database weekly, important clips monthly

Storage Hardware Recommendations:

Monitoring storage usage:

# Check overall storage
df -h /mnt/frigate

# Check per-camera usage
du -sh /mnt/frigate/recordings/*

# Find oldest recordings
find /mnt/frigate/recordings -type f -printf '%T+ %p\n' | sort | head -20

# Check database size
du -sh /opt/frigate/config/frigate.db

On your Linux server (Proxmox/Ubuntu/Debian/Any Linux):

Step 1: Create directory structure

# Create Frigate directories
sudo mkdir -p /opt/frigate/config
sudo mkdir -p /mnt/frigate

# Set permissions (replace 'youruser' with your username)
sudo chown -R youruser:youruser /opt/frigate
sudo chown -R youruser:youruser /mnt/frigate

# Navigate to Frigate directory
cd /opt/frigate

Step 2: Save docker-compose.yml

# Open nano editor
nano docker-compose.yml

# Paste the generated docker-compose.yml from this tool
# (Copy from the green "Copy to Clipboard" button above)

# Save and exit:
# Press Ctrl+O (save)
# Press Enter (confirm filename)
# Press Ctrl+X (exit)

Step 3: Save config.yml

# Open nano editor for config
nano config/config.yml

# Paste the generated config.yml from this tool
# (Copy from the green "Copy to Clipboard" button above)

# Save and exit: Ctrl+O, Enter, Ctrl+X

Step 4: Verify configuration files

# Check docker-compose.yml syntax
cat docker-compose.yml

# Check config.yml syntax
cat config/config.yml

# Verify directory structure
ls -la /opt/frigate/
ls -la /opt/frigate/config/

Step 5: Start Frigate

# Start Frigate container
docker compose up -d

# Verify container is running
docker ps | grep frigate

# Should show: frigate container with status "Up"

Step 6: Get admin password from logs

# Wait 10-15 seconds for Frigate to fully start, then:
docker logs frigate 2>&1 | grep -i password

# Look for line like:
# "Frigate admin user password: Xh9kL2mP5qR8tY"

# COPY THIS PASSWORD IMMEDIATELY!

Step 7: Access Frigate Web UI

1. Open web browser on any device on your network
2. Navigate to: http://YOUR_SERVER_IP:8971
3. Example: http://192.168.1.100:8971
4. Login with:
   • Username: admin
   • Password: (from logs above)

Step 8: Change password immediately

1. After login, click Settings (gear icon) in top right
2. Navigate to Users tab
3. Click "Update Password" for admin user
4. Enter new strong password (use password manager!)
5. Click Save
6. Test login with new password

Step 9: Verify everything works

# Check logs for errors
docker logs frigate --tail 100 | grep -i error

# Verify go2rtc streams are working
docker exec frigate curl -s http://127.0.0.1:1984/api/streams

# Should show all your cameras with "producers" field populated

# Check GPU access (if using Intel VAAPI)
docker exec frigate ls -la /dev/dri

# Check GPU access (if using NVIDIA)
docker exec frigate nvidia-smi

# Check Coral TPU (if using)
docker exec frigate ls -la /dev/bus/usb  # for USB Coral
docker exec frigate ls -la /dev/apex_0    # for PCIe Coral

Step 10: Monitor Frigate

# Watch logs in real-time
docker logs frigate -f

# Check for any warnings or errors
# Ctrl+C to stop watching

# Check detection FPS (should be close to your configured FPS)
docker logs frigate 2>&1 | grep "detection_fps"

# Check storage usage
df -h /mnt/frigate

⚠️ Common First-Startup Issues:

• "No frames received": Check camera RTSP URLs, test in VLC first
• GPU not detected: Verify device passthrough, check permissions
• High CPU usage: Ensure hardware acceleration working, check detector config
• Can't access UI: Check firewall, verify port 8971 not blocked
• Coral not found: Install libedgetpu runtime, check USB permissions

• Lower detection FPS: 5fps is plenty for most scenarios. Reducing to 3fps saves GPU while maintaining good detection. Use 10fps only for very fast-moving objects.
• Use sub streams for detection: 720p is plenty for detection, don't use 1080p/4K. Higher resolution = slower detection with minimal accuracy gain.
• Enable motion detection: Only runs object detection when motion present. Saves 70-90% GPU/CPU cycles on static cameras.
• Optimize camera settings: Set cameras to CBR encoding, disable WDR/HDR on sub stream, lower bitrate on sub stream to minimum acceptable quality.
• Use SSD for clips/snapshots: Faster UI response, less wear on spinning drives. Keep recordings on HDD (sequential writes are fine).
• Reduce snapshot quality: Default 70% JPEG quality is good, can lower to 50-60% for storage savings with minimal visual impact.
• Disable unused features: If not using audio detection, disable it. If not using all object types, filter to only what you need.
• Limit recording retention: 7 days continuous + 30 days events is usually enough. Adjust based on your actual needs.
• Use zones effectively: Only detect in areas that matter. Reduces false positives and unnecessary processing.
• Motion masks: Exclude trees, flags, busy roads from motion detection to reduce detector load.

Security Best Practices (All Methods):

• ✅ Use strong, unique password for Frigate admin account
• ✅ Enable two-factor authentication when available
• ✅ Keep Frigate updated to latest stable version
• ✅ Regularly review access logs
• ✅ Use separate VLAN for cameras (isolate from main network)
• ✅ Disable UPnP on router (prevents unauthorized port forwards)
• ✅ Set camera passwords to strong values (not default admin/admin)
• ❌ Never use port forwarding directly to Frigate (port 8971)
• ❌ Never use default credentials on any component
• ❌ Never trust "security by obscurity" (changing port doesn't help)

Frigate integrates seamlessly with Home Assistant via MQTT for powerful automations.

automation:
  - alias: "Notify on Person at Front Door"
    trigger:
      - platform: mqtt
        topic: "frigate/front_door/person"
        payload: "ON"
    condition:
      - condition: state
        entity_id: alarm_control_panel.home
        state: "armed_away"
    action:
      - service: notify.mobile_app
        data:
          title: "Person Detected"
          message: "Someone is at the front door"
          data:
            image: "https://frigate.local:8971/api/front_door/person/snapshot.jpg"
            actions:
              - action: "VIEW_CLIP"
                title: "View Clip"
              - action: "DISMISS"
                title: "Dismiss"

automation:
  - alias: "Front Porch Light on Person Detection"
    trigger:
      - platform: mqtt
        topic: "frigate/front_door/person"
        payload: "ON"
    condition:
      - condition: sun
        after: sunset
        before: sunrise
    action:
      - service: light.turn_on
        target:
          entity_id: light.front_porch
        data:
          brightness: 255
      - delay: "00:05:00"
      - service: light.turn_off
        target:
          entity_id: light.front_porch

automation:
  - alias: "Disable Frigate When Home"
    trigger:
      - platform: state
        entity_id: person.john
        to: "home"
    action:
      - service: switch.turn_off
        target:
          entity_id: switch.frigate_front_door_detect
  
  - alias: "Enable Frigate When Away"
    trigger:
      - platform: state
        entity_id: person.john
        to: "not_home"
    action:
      - service: switch.turn_on
        target:
          entity_id: switch.frigate_front_door_detect

Available Entities in Home Assistant:

• Cameras: camera.frigate_CAMERA_NAME
• Sensors: sensor.frigate_CAMERA_NAME_person_count (and car, dog, etc.)
• Binary Sensors: binary_sensor.frigate_CAMERA_NAME_person (on/off state)
• Switches: switch.frigate_CAMERA_NAME_detect (enable/disable detection)
• Switches: switch.frigate_CAMERA_NAME_recordings (enable/disable recording)
• Switches: switch.frigate_CAMERA_NAME_snapshots (enable/disable snapshots)

Zones allow you to only trigger events when objects enter specific areas.

cameras:
  front_door:
    zones:
      porch:
        coordinates: 100,200,300,200,300,400,100,400
        objects:
          - person
      driveway:
        coordinates: 400,300,800,300,800,600,400,600
        objects:
          - person
          - car
    objects:
      filters:
        person:
          mask: 50,50,150,50,150,150,50,150  # Exclude neighbor's yard
          min_area: 2000  # Minimum 2000 pixels (filters out distant people)
          max_area: 100000  # Maximum size (filters out vehicles misclassified as person)
          min_score: 0.6  # 60% confidence minimum
          threshold: 0.7  # 70% for tracking
          min_ratio: 0.2  # Aspect ratio filter (prevents horizontal blobs)
          max_ratio: 5.0

Filtering Best Practices:

• min_area: Use to filter distant objects (person = 2000-5000 pixels, car = 8000-15000 pixels)
• max_area: Prevent misclassifications (person shouldn't be bigger than 100000 pixels)
• min_score: Detector confidence (0.5-0.7 good for person, 0.6-0.8 for vehicles)
• min_ratio/max_ratio: Aspect ratio to filter weird shapes (person ~0.3-2.0, car ~1.5-3.5)
• Zones: Only create events when object enters specific zone (ignore street traffic)
• Masks: Permanently exclude areas from detection (trees, neighbor's yard, sky)

• Stationary object detection: Detect abandoned packages/bags by tracking objects that don't move for X minutes. Use stationary object filter with threshold parameter.
• Pet vs Person differentiation: Use min_area to separate cats/dogs from people. People are typically 5000+ pixels, pets 1000-3000 pixels at typical camera distance.
• Shadow reduction: Enable improve_contrast in camera config. Lower detection sensitivity near walls where shadows frequently appear.
• Night mode optimization: Enable camera IR mode, use lower confidence thresholds for detection at night (0.5 instead of 0.7). Consider separate day/night zones if needed.
• Multi-camera tracking: Track person across multiple cameras using MQTT + Home Assistant automation. Create "person entering house" event by chaining camera detections.
• Custom labels: Train custom models using Frigate+ to detect specific objects (packages, specific vehicles, tools, specific animals).
• Geofencing integration: Auto-disable detection when family is home via Home Assistant presence detection. Saves processing and prevents false alerts.
• Smart retention: Keep recordings with events forever (or very long), delete no-event recordings after 3-7 days. Saves storage while keeping important footage.
• Alert fatigue fix: Use cooldown periods in Home Assistant automations (don't alert on same person for 5-10 minutes). Prevents notification spam.
• Privacy zones: Mask neighbor's windows/yards in detection config using motion mask coordinates. Respects privacy while maintaining your security.
• False positive reduction: Increase min_frames from 3 to 5 or 10 for objects that must be present longer before alerting (reduces birds, reflections).
• Audio detection: Frigate supports audio event detection (glass breaking, barking). Enable in config for additional alert triggers.
• PTZ camera support: Frigate supports PTZ (pan-tilt-zoom) cameras with ONVIF protocol. Can auto-track detected objects.
• License plate recognition: Use Frigate+ or third-party integration for LPR (License Plate Recognition). Requires dedicated model.
• Facial recognition: Integrate with Double-Take or Compreface for facial recognition via MQTT integration.

• Official Documentation: docs.frigate.video - Complete documentation with examples
• GitHub Repository: github.com/blakeblackshear/frigate - Source code, issue tracker, feature requests
• Reddit Community: r/frigate_nvr - Active community, setup help, show-off your configs
• Home Assistant Forum: Search "Frigate" for hundreds of integration examples and automation ideas
• YouTube Tutorials: Search "Frigate NVR tutorial" for video guides (Everything Smart Home, BeardedTinker, etc.)
• Frigate+ Service: frigate.video/plus - Cloud AI model training, supports development

🙏 Remember to support the project:

Frigate is free and open source thanks to Blake Blackshear and contributors. If it saves you money or time, please consider donating or subscribing to Frigate+ to ensure continued development!