Frigate Configurator

Frigate NVR Configuration Expert

Comprehensive Frigate NVR configuration assistance with optimized YAML generation, detector setup, and troubleshooting.

BEFORE YOU START

This skill prevents 12+ common errors and saves ~60% tokens on Frigate configuration.

Known Issues This Skill Prevents

1. Bus errors from insufficient shared memory allocation 2. Green/distorted video from incorrect resolution configuration 3. Database locked errors when using network storage for SQLite 4. Missing audio in recordings due to default audio stripping 5. MQTT connection failures from using localhost in Docker 6. Coral TPU not detected due to missing device passthrough 7. High CPU usage from missing hardware acceleration 8. False positives from missing motion masks on timestamps 9. No alerts triggered due to misconfigured required_zones 10. Recording corruption from h265 streams without transcoding 11. go2rtc WebRTC failures from missing STUN configuration 12. Object detection misses from wrong detect stream resolution

Quick Start

Step 1: Create Minimal Configuration

mqtt:
  enabled: false

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://user:pass@192.168.1.100:554/stream1
          roles:
            - detect
    detect:
      width: 1280
      height: 720
      fps: 5

Why this matters: Start with the absolute minimum to verify camera connectivity before adding complexity. Frigate requires explicit detect stream role assignment.

Step 2: Add Hardware-Accelerated Detector

detectors:
  coral:
    type: edgetpu
    device: usb

# OR for Intel with OpenVINO:
detectors:
  ov:
    type: openvino
    device: GPU

Why this matters: CPU detection is not recommended for production. Even a single USB Coral TPU dramatically reduces CPU usage and improves detection latency.

Step 3: Enable Recording with Retention

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

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://user:pass@192.168.1.100:554/stream1
          roles:
            - detect
        - path: rtsp://user:pass@192.168.1.100:554/stream2
          roles:
            - record

Why this matters: Use separate streams for detect (low-res) and record (high-res) to optimize performance. Retention modes prevent storage from filling up.

Critical Rules

Always Do

• Use width and height that match your camera's ACTUAL resolution (verify with VLC)
• Set detect fps between 5-10 (higher wastes resources, lower misses events)
• Use separate streams for detect (sub-stream) and record (main stream)
• Allocate adequate shm-size in Docker (64MB minimum per camera)
• Create motion masks for timestamp overlays and areas with constant motion
• Use environment variables for credentials: {FRIGATE_RTSP_PASSWORD}
• Test RTSP URLs in VLC first before adding to Frigate config

Never Do

• Never use localhost or 127.0.0.1 for MQTT inside Docker containers
• Never set detect resolution higher than 1280x720 (wastes detector capacity)
• Never enable recording without specifying retention policy
• Never mount /media/frigate on network storage without relocating database
• Never mix multiple detector types for object detection (e.g., Coral + OpenVINO)
• Never use UDP RTSP transport without explicit configuration (TCP is default)

Common Mistakes

Wrong:

cameras:
  cam1:
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.100/stream
          roles:
            - detect
            - record
    detect:
      width: 1920
      height: 1080
      fps: 30

Correct:

cameras:
  cam1:
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.100/substream
          roles:
            - detect
        - path: rtsp://192.168.1.100/mainstream
          roles:
            - record
    detect:
      width: 1280
      height: 720
      fps: 5

Why: Using 1080p@30fps for detection wastes resources. Detection works best at 720p or lower at 5fps. Always use the camera's sub-stream for detection and main stream for recording.

Known Issues Prevention

Configuration Reference

config.yml Structure

# MQTT Configuration (optional but recommended)
mqtt:
  enabled: true
  host: 192.168.1.50
  port: 1883
  user: "{FRIGATE_MQTT_USER}"
  password: "{FRIGATE_MQTT_PASSWORD}"

# Detector Configuration
detectors:
  coral:
    type: edgetpu
    device: usb  # or pci for M.2/PCIe

# Global Object Settings
objects:
  track:
    - person
    - car
    - dog
    - cat
  filters:
    person:
      min_area: 5000
      max_area: 100000
      threshold: 0.7

# Recording Settings
record:
  enabled: true
  retain:
    days: 1
    mode: motion
  alerts:
    retain:
      days: 14
  detections:
    retain:
      days: 7

# Snapshot Settings
snapshots:
  enabled: true
  retain:
    default: 7

# Camera Configuration
cameras:
  front_door:
    enabled: true
    ffmpeg:
      inputs:
        - path: "rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.1.100:554/stream1"
          input_args: preset-rtsp-restream
          roles:
            - detect
        - path: "rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.1.100:554/stream0"
          input_args: preset-rtsp-restream
          roles:
            - record
      output_args:
        record: preset-record-generic-audio-aac
    detect:
      width: 1280
      height: 720
      fps: 5
    motion:
      mask:
        - 0,0,200,0,200,100,0,100  # Timestamp area
    zones:
      front_yard:
        coordinates: 100,500,400,500,400,720,100,720
        objects:
          - person
          - car
    review:
      alerts:
        required_zones:
          - front_yard

Key settings:

• detect.fps: 5 is optimal for most cameras (reduces detector load)
• detect.width/height: Must match actual camera sub-stream resolution
• record.retain.mode: Use motion or active_objects to save storage
• motion.mask: Define polygons as comma-separated coordinates
• zones.coordinates: Bottom-center of bounding box determines zone presence

Hardware Acceleration Presets

Intel (6th Gen+)

# For Intel gen8+ (prefer QSV)
ffmpeg:
  hwaccel_args: preset-intel-qsv-h264  # or preset-intel-qsv-h265

# For Intel gen1-gen7 (use VAAPI)
ffmpeg:
  hwaccel_args: preset-vaapi

NVIDIA GPU

ffmpeg:
  hwaccel_args: preset-nvidia

Requires NVIDIA Container Toolkit:

# docker-compose.yml
services:
  frigate:
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

AMD GPU

ffmpeg:
  hwaccel_args: preset-vaapi

# docker-compose.yml
environment:
  - LIBVA_DRIVER_NAME=radeonsi

Raspberry Pi

# Raspberry Pi 4/5
ffmpeg:
  hwaccel_args: preset-rpi-64-h264  # or preset-rpi-64-h265

Requires: gpu_mem=128 in /boot/config.txt and device mapping in Docker.

Object Detector Types

USB Coral TPU

detectors:
  coral:
    type: edgetpu
    device: usb  # Single USB Coral
    # device: usb:0  # First of multiple USB Corals

Docker device mapping:

devices:
  - /dev/bus/usb:/dev/bus/usb

M.2/PCIe Coral TPU

detectors:
  coral:
    type: edgetpu
    device: pci
    # device: pci:0  # First of multiple PCIe Corals

OpenVINO (Intel)

detectors:
  ov:
    type: openvino
    device: GPU  # or CPU

model:
  path: /openvino-model/ssdlite_mobilenet_v2.xml
  width: 300
  height: 300

ONNX (Multi-GPU)

detectors:
  onnx:
    type: onnx
    # Automatically uses: ROCm (AMD), OpenVINO (Intel), TensorRT (NVIDIA)

Advanced Features

Zone-Based Speed Estimation

zones:
  driveway:
    coordinates: 100,500,400,500,400,720,100,720
    distances:
      - "100,500|400,500|20ft"  # 20 feet between points
    speed:
      threshold: 15  # Minimum mph to register

Audio Detection

audio:
  enabled: true
  listen:
    - bark
    - fire_alarm
    - scream
    - speech

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://camera/stream
          roles:
            - audio

GenAI Event Descriptions

genai:
  enabled: true
  provider: ollama
  base_url: http://192.168.1.100:11434
  model: llava

Face Recognition (Frigate+)

face_recognition:
  enabled: true
  threshold: 0.6

cameras:
  front_door:
    detect:
      width: 1280  # Higher res improves face detection

License Plate Recognition

lpr:
  enabled: true

cameras:
  driveway:
    lpr:
      enabled: true

go2rtc Integration

go2rtc:
  streams:
    front_door:
      - rtsp://user:pass@192.168.1.100:554/stream1
      - "ffmpeg:front_door#video=copy#audio=opus"
  webrtc:
    candidates:
      - 192.168.1.50:8555
      - stun:8555

Docker Compose Template

services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    restart: unless-stopped
    shm_size: "256mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb  # USB Coral
      - /dev/dri/renderD128:/dev/dri/renderD128  # Intel GPU
    volumes:
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"  # Web UI
      - "8554:8554"  # RTSP feeds
      - "8555:8555/tcp"  # WebRTC
      - "8555:8555/udp"  # WebRTC
    environment:
      FRIGATE_RTSP_USER: admin
      FRIGATE_RTSP_PASSWORD: ${RTSP_PASSWORD}
      FRIGATE_MQTT_USER: frigate
      FRIGATE_MQTT_PASSWORD: ${MQTT_PASSWORD}

Bundled Resources

Templates

Located in templates/:

• `docker-compose.yml` - Production-ready compose file
• `config-minimal.yml` - Minimal starter config
• `config-full.yml` - Full-featured config template

References

Located in references/:

• `detector-comparison.md` - Detector performance comparison
• `ffmpeg-presets.md` - All available FFmpeg presets
• `mqtt-topics.md` - MQTT topic reference

Scripts

Located in scripts/:

• validate-config.sh - Validate config syntax before applying

Dependencies

Required

Optional

Official Documentation

• Frigate Documentation
• Configuration Reference
• Getting Started Guide
• Troubleshooting FAQs

Troubleshooting

Camera Shows Offline

Symptoms: Camera fps shows 0, web UI shows offline status

Solution:

# Test RTSP URL directly
ffprobe -rtsp_transport tcp "rtsp://user:pass@ip:554/stream"

# Check Docker logs
docker logs frigate 2>&1 | grep -i "camera_name"

High CPU Usage

Symptoms: CPU consistently above 80%, system becomes unresponsive

Solution: 1. Enable hardware acceleration (see presets above) 2. Reduce detect fps from 10 to 5 3. Lower detect resolution to 720p or below 4. Add Coral TPU for object detection

No Objects Detected

Symptoms: Motion detected but no object events created

Solution: 1. Verify detector is configured and running: check /api/stats 2. Check object filters aren't too restrictive (min_area, threshold) 3. Ensure detect stream resolution is correct 4. Verify objects list includes desired types

Recording Not Working

Symptoms: Events show but no recordings available

Solution:

# Ensure record role is assigned
cameras:
  cam1:
    ffmpeg:
      inputs:
        - path: rtsp://camera/stream
          roles:
            - record  # Must be explicitly set
    record:
      enabled: true  # Must be true

Setup Checklist

Before deploying Frigate, verify:

• [ ] Docker and docker-compose installed
• [ ] RTSP URLs tested in VLC (note actual resolution)
• [ ] Camera credentials ready for environment variables
• [ ] Storage volume has adequate space (100GB+ recommended)
• [ ] Shared memory size configured (64MB per camera minimum)
• [ ] Hardware acceleration device mapped (if applicable)
• [ ] Coral TPU device mapped (if using)
• [ ] MQTT broker accessible (if integrating with Home Assistant)
• [ ] Port 8971 available for web UI
• [ ] Firewall allows required ports (8554, 8555 for streaming)

Frigate NVR Configuration Expert

Configure Frigate NVR with optimized YAML, object detection, recording, zones, and hardware acceleration.

What This Skill Does

This skill provides expert-level assistance for configuring and troubleshooting Frigate NVR, an AI-powered network video recorder with real-time object detection.

Core Capabilities

• Generate optimized Frigate YAML configurations for any camera setup
• Configure object detectors (Coral TPU, OpenVINO, ONNX, CPU)
• Set up hardware-accelerated video decoding (Intel QSV/VAAPI, NVIDIA, AMD, Raspberry Pi)
• Configure recording with intelligent retention policies
• Create zones for location-aware detection and speed estimation
• Troubleshoot common issues (bus errors, green video, high CPU)
• Integrate with Home Assistant via MQTT
• Configure go2rtc for WebRTC live streaming
• Set up advanced features: face recognition, LPR, audio detection, GenAI descriptions

Auto-Trigger Keywords

Primary Keywords

Exact terms that strongly trigger this skill:

• frigate
• frigate config
• frigate yaml
• frigate nvr
• frigate camera
• frigate detector
• frigate recording
• frigate zones
• coral tpu
• edgetpu

Secondary Keywords

Related terms that may trigger in combination:

• object detection nvr
• ai camera recording
• rtsp object detection
• home assistant camera
• nvr configuration
• video surveillance ai
• birdseye view
• motion mask
• detection zone
• go2rtc

Error-Based Keywords

Common error messages that should trigger this skill:

• "Fatal Python error: Bus error"
• "database is locked"
• "shm_size"
• "green video frigate"
• "coral not detected"
• "mqtt connection failed"
• "camera offline frigate"
• "no objects detected"
• "recording not working frigate"
• "high cpu usage frigate"

Known Issues Prevention

When to Use

Use This Skill For

• Initial Frigate NVR setup and configuration
• Adding new cameras to existing Frigate installation
• Configuring Coral TPU or OpenVINO detectors
• Setting up recording with retention policies
• Creating detection zones and motion masks
• Troubleshooting camera connectivity issues
• Optimizing performance and reducing CPU usage
• Integrating Frigate with Home Assistant
• Configuring hardware acceleration (Intel/NVIDIA/AMD/RPi)
• Setting up go2rtc for live streaming

Don't Use This Skill For

• General RTSP camera troubleshooting (not Frigate-specific)
• Home Assistant automations (use ha-dashboard skill)
• Generic Docker troubleshooting
• Network configuration unrelated to Frigate
• Non-Frigate NVR software (ZoneMinder, Blue Iris, etc.)

Quick Usage

# Minimal Frigate config with Coral TPU
mqtt:
  enabled: false

detectors:
  coral:
    type: edgetpu
    device: usb

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://user:pass@192.168.1.100:554/stream1
          roles:
            - detect
    detect:
      width: 1280
      height: 720
      fps: 5

Token Efficiency

File Structure

frigate-configurator/
├── SKILL.md        # Detailed instructions and patterns
├── README.md       # This file - discovery and quick reference
├── templates/      # Docker-compose and config templates
│   ├── docker-compose.yml
│   ├── config-minimal.yml
│   └── config-full.yml
├── references/     # Supporting documentation
│   ├── detector-comparison.md
│   ├── ffmpeg-presets.md
│   └── mqtt-topics.md
└── scripts/        # Validation utilities
    └── validate-config.sh

Dependencies

Official Documentation

• Frigate Documentation
• Configuration Reference
• Object Detectors
• Hardware Acceleration
• Troubleshooting FAQs

Related Skills

• ha-dashboard - Home Assistant Lovelace dashboard configuration
• esphome-config-helper - ESPHome device configuration

---

License: MIT

Frigate Object Detector Comparison

Detector Types Overview

Detailed Comparison

USB Coral TPU

Pros:

• Best performance per watt
• Simple USB connection
• Works on any system with USB
• Handles 10+ cameras easily

Cons:

• Can be hard to find in stock
• USB bandwidth can be limiting with many cameras
• Generates some heat

Configuration:

detectors:
  coral:
    type: edgetpu
    device: usb

PCIe/M.2 Coral TPU

Pros:

• Same performance as USB
• No USB bandwidth limitations
• Lower latency
• Dual-edge TPU available for double throughput

Cons:

• Requires PCIe slot or M.2 slot
• Harder to install
• Limited to desktop/server systems

Configuration:

detectors:
  coral:
    type: edgetpu
    device: pci

OpenVINO (Intel)

Pros:

• Uses existing Intel GPU (free)
• Good performance on modern Intel CPUs
• Supports multiple model architectures

Cons:

• Requires Intel 6th Gen (Skylake) or newer
• GPU mode requires compatible integrated graphics
• CPU mode is inefficient

Configuration:

detectors:
  ov:
    type: openvino
    device: GPU  # or CPU for testing

ONNX Runtime

Pros:

• Automatically uses available GPU acceleration
• Works with AMD ROCm, Intel OpenVINO, NVIDIA TensorRT
• Flexible model support (YOLO variants)

Cons:

• Requires compatible GPU drivers
• Performance varies by hardware

Configuration:

detectors:
  onnx:
    type: onnx
    device: auto  # Automatically selects best available

TensorRT (NVIDIA Jetson)

Pros:

• Optimized for Jetson hardware
• Low power consumption
• Good for edge deployments

Cons:

• Only works on Jetson devices
• Requires model preprocessing on target hardware
• Limited to NVIDIA ecosystem

Configuration:

detectors:
  tensorrt:
    type: tensorrt
    device: 0

Hailo-8L (Raspberry Pi 5 AI Kit)

Pros:

• Designed for Raspberry Pi 5
• Low power consumption
• Good performance for edge

Cons:

• Limited to specific hardware
• Newer, less tested

Configuration:

detectors:
  hailo:
    type: hailo8l

CPU Detector

Pros:

• Works on any hardware
• No additional hardware needed

Cons:

• Very high CPU usage
• Not suitable for production
• Slow inference times

Configuration:

detectors:
  cpu:
    type: cpu
    num_threads: 3

Capacity Guidelines

Important Notes

1. Cannot mix detector types for object detection - You can't use Coral for some cameras and OpenVINO for others. Pick one detector type for all object detection.

2. Other tasks can use different hardware - Semantic search, face recognition, and other features can use different hardware than the main object detector.

3. USB bandwidth matters - If using multiple USB Coral TPUs, ensure they're on different USB controllers.

4. Temperature affects performance - Coral TPUs throttle at high temperatures. Consider cooling for sustained workloads.

Recommendations

Frigate FFmpeg Presets Reference

Hardware Acceleration Presets

Intel Platforms

Example:

ffmpeg:
  hwaccel_args: preset-intel-qsv-h264

NVIDIA Platforms

Example:

ffmpeg:
  hwaccel_args: preset-nvidia

Docker Requirements:

services:
  frigate:
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

AMD Platforms

Example:

ffmpeg:
  hwaccel_args: preset-vaapi

Environment Variable:

environment:
  - LIBVA_DRIVER_NAME=radeonsi

Raspberry Pi

Requirements:

• gpu_mem=128 in /boot/config.txt
• Device mapping: /dev/video10, /dev/video11, /dev/video12

Input Presets

RTSP Transport

Example:

cameras:
  cam1:
    ffmpeg:
      inputs:
        - path: rtsp://camera/stream
          input_args: preset-rtsp-restream

HTTP/MJPEG

Output Presets

Recording Output

Example:

cameras:
  cam1:
    ffmpeg:
      output_args:
        record: preset-record-generic-audio-aac

Common Configurations

Intel System with Audio Recording

ffmpeg:
  hwaccel_args: preset-intel-qsv-h264

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://camera/substream
          input_args: preset-rtsp-restream
          roles:
            - detect
        - path: rtsp://camera/mainstream
          input_args: preset-rtsp-restream
          roles:
            - record
      output_args:
        record: preset-record-generic-audio-aac

NVIDIA with go2rtc Restream

ffmpeg:
  hwaccel_args: preset-nvidia

go2rtc:
  streams:
    front_door:
      - rtsp://camera/mainstream
      - "ffmpeg:front_door#video=copy#audio=opus"

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/front_door
          input_args: preset-rtsp-restream
          roles:
            - detect
            - record

Raspberry Pi with H.265 Camera

ffmpeg:
  hwaccel_args: preset-rpi-64-h265

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://camera/h265stream
          input_args: preset-rtsp-restream
          roles:
            - detect
            - record

UDP Transport for Unreliable Networks

cameras:
  outdoor_cam:
    ffmpeg:
      inputs:
        - path: rtsp://camera/stream
          input_args: preset-rtsp-udp
          roles:
            - detect

Troubleshooting

RTSP URL Works in VLC but Not Frigate

Frigate defaults to TCP transport, while VLC auto-switches between UDP and TCP.

Solution:

input_args: preset-rtsp-udp

No Audio in Recordings

Default presets strip audio to prevent corruption.

Solution:

output_args:
  record: preset-record-generic-audio-aac

High CPU Despite Hardware Acceleration

1. Verify hardware acceleration is active in Frigate logs 2. Check Docker device mappings are correct 3. Ensure using correct preset for your hardware

Green/Corrupted Video

Usually indicates wrong codec or resolution mismatch.

Solutions: 1. Verify camera actually outputs H.264 or H.265 2. Match detect.width and detect.height exactly to camera output 3. Try software decoding temporarily to rule out hwaccel issues

Custom FFmpeg Arguments

For advanced use cases, you can specify raw FFmpeg arguments:

cameras:
  cam1:
    ffmpeg:
      inputs:
        - path: rtsp://camera/stream
          input_args:
            - -avoid_negative_ts
            - make_zero
            - -fflags
            - +genpts+discardcorrupt
            - -rtsp_transport
            - tcp
            - -use_wallclock_as_timestamps
            - "1"

See FFmpeg documentation for all available options.

Frigate MQTT Topics Reference

Topic Prefix

All topics are prefixed with the configured topic_prefix (default: frigate).

Example: frigate/available or frigate/front_door/person

Availability Topics

Camera Topics

Camera State

Camera Control

Object Detection

Example: frigate/front_door/person = 1

Motion Detection

Audio Detection

Audio Types: bark, fire_alarm, scream, speech, yell, etc.

Event Topics

New Events

Event Payload Structure:

{
  "before": {
    "id": "1234567890.123456-abc123",
    "camera": "front_door",
    "frame_time": 1234567890.123456,
    "snapshot_time": 1234567890.123456,
    "label": "person",
    "sub_label": null,
    "top_score": 0.89,
    "false_positive": false,
    "start_time": 1234567890.123456,
    "end_time": null,
    "score": 0.89,
    "box": [100, 200, 300, 400],
    "area": 40000,
    "ratio": 1.5,
    "region": [0, 0, 640, 480],
    "stationary": false,
    "motionless_count": 0,
    "position_changes": 5,
    "current_zones": ["front_yard"],
    "entered_zones": ["front_yard"],
    "thumbnail": null,
    "has_clip": true,
    "has_snapshot": true
  },
  "after": {
    // Same structure with updated values
  },
  "type": "new"  // "new", "update", or "end"
}

Event Types

Review Topics

Statistics Topics

Stats Payload Example:

{
  "cpu_usages": {"python_frigate": 15.2},
  "detectors": {
    "coral": {
      "detection_start": 0.0,
      "inference_speed": 8.5,
      "pid": 1234
    }
  },
  "cameras": {
    "front_door": {
      "camera_fps": 5.0,
      "detection_fps": 5.0,
      "capture_pid": 1235,
      "ffmpeg_pid": 1236,
      "process_fps": 5.0
    }
  },
  "service": {
    "uptime": 86400,
    "version": "0.14.0",
    "storage": {
      "/media/frigate/recordings": {
        "free": 500000000000,
        "total": 1000000000000
      }
    }
  }
}

Home Assistant Integration

Auto-Discovery

Frigate publishes Home Assistant MQTT discovery messages automatically when configured:

mqtt:
  enabled: true
  host: 192.168.1.50

Created Entities

Example Automations

Notification on Person Detection

automation:
  - alias: "Frigate Person Alert"
    trigger:
      - platform: mqtt
        topic: frigate/front_door/person
    condition:
      - condition: template
        value_template: "{{ trigger.payload | int > 0 }}"
    action:
      - service: notify.mobile_app
        data:
          title: "Person Detected"
          message: "Person detected at front door"
          data:
            image: "http://frigate:8971/api/front_door/latest.jpg"

Track Events

automation:
  - alias: "Frigate Event Logger"
    trigger:
      - platform: mqtt
        topic: frigate/events
    action:
      - service: logbook.log
        data:
          name: "Frigate"
          message: >
            {{ trigger.payload_json.after.label }} detected on
            {{ trigger.payload_json.after.camera }}

Control Recording

# Enable recording
service: mqtt.publish
data:
  topic: frigate/front_door/recordings/set
  payload: "ON"

# Disable detection
service: mqtt.publish
data:
  topic: frigate/front_door/detect/set
  payload: "OFF"

Debugging MQTT

Subscribe to All Frigate Topics

mosquitto_sub -h 192.168.1.50 -u user -P password -t "frigate/#" -v

Subscribe to Specific Camera Events

mosquitto_sub -h 192.168.1.50 -u user -P password -t "frigate/front_door/person" -v

Test Publishing

mosquitto_pub -h 192.168.1.50 -u user -P password -t "frigate/front_door/detect/set" -m "OFF"