Frigate + Coral TPU: AI Cameras Without the Subscription

Your Raccoon Has Rights — But You Should Still Know When He’s at the Trash

Ring wants $10/month to tell you there’s motion on your porch. Nest wants $8/month. Neither of them will tell you what the motion is — just that something moved near your expensive camera. Meanwhile, you’re paying a monthly fee for a cloud service to send a push notification that says “Activity detected” with a blurry thumbnail.

Here’s the alternative: Frigate NVR running on your local server, a $60 Google Coral TPU, and a camera you already own. You get real-time object detection — person, car, dog, raccoon — running entirely on your hardware, with no subscription, no cloud, and no footage leaving your network. Home Assistant integration is a few lines of YAML.

Let’s talk about why Coral still makes sense in 2026, then get the whole stack running.

Why Coral (and Why Now?)

The Google Coral Edge TPU is a dedicated inference accelerator purpose-built for running TensorFlow Lite models. It draws about 2W, costs $60 for the USB version, and can run MobileNet-based detection at roughly 100+ FPS. That last number is the punchline — you’re not doing 100 FPS security camera inference on a CPU without melting something.

Here’s the honest comparison:

CPU detection (no Coral): Works fine on a beefy machine. An i5 or Ryzen 5 can run detection on 2-3 cameras at reasonable framerates, but it’s doing this on CPU cores that could be doing other things. Detection latency is higher, and CPU load spikes whenever motion fires off detection.

Nvidia GPU: If you already have a CUDA-capable card in your home server, use it — Frigate supports it and it’s fast. But if you’re buying hardware purely for camera detection, a $600 GPU is a lot to spend next to a $60 Coral.

Coral TPU: Dedicated inference silicon. The USB version (Coral USB Accelerator) plugs into any USB 3.0 port. The M.2 A+E version sits inside your machine if you have an open slot. You get ~100 inferences/second on MobileNet-SSD and the host CPU barely notices.

Coral got discontinued by Google in 2023, but the hardware is still widely available (Amazon, eBay, various resellers), the drivers still work, and Frigate still supports it. It’s not going anywhere soon. The runtime library situation has been stable for a couple of years now — libedgetpu on Debian/Ubuntu is painless.

The USB version is the easy button. Plug it in, done. The M.2 version requires the right slot (A+E key, not the storage M.2) and is faster in sustained workloads because it doesn’t hit USB bandwidth limits. For most home setups with 4-8 cameras, the USB version is fine.

The Stack

You need four things:

1. Frigate NVR — the actual camera manager, object detection engine, recording system
2. MQTT broker (Mosquitto) — Frigate publishes detection events here; Home Assistant subscribes
3. Cameras — anything RTSP works: old Dahua/Hikvision units, Reolink, Amcrest, even repurposed Wyze cams with custom firmware
4. Coral TPU — plugged into whatever box is running the Docker stack

Here’s the Compose file. This assumes your Coral USB is at /dev/bus/usb. If you’re using the M.2/PCIe version, swap the device path for /dev/apex_0.

version: "3.9"

services:
  mosquitto:
    image: eclipse-mosquitto:2
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883"
      - "9001:9001"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log

  frigate:
    image: ghcr.io/blakeblackshear/frigate:stable
    container_name: frigate
    privileged: true
    restart: unless-stopped
    shm_size: "256mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb   # Coral USB Accelerator
      # - /dev/apex_0:/dev/apex_0   # Coral M.2/PCIe — uncomment if using this instead
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./frigate/config:/config
      - /mnt/nvme/frigate:/media/frigate   # point this at fast storage
    ports:
      - "5000:5000"    # Web UI
      - "8554:8554"    # RTSP feeds (re-stream)
      - "8555:8555/tcp"
      - "8555:8555/udp"
    environment:
      FRIGATE_RTSP_PASSWORD: "changeme"
    depends_on:
      - mosquitto

Mosquitto needs a minimal config file at ./mosquitto/config/mosquitto.conf:

listener 1883
allow_anonymous true
persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

Don’t leave allow_anonymous true in production — set up credentials once you’ve confirmed everything works.

Frigate Config: One Camera to Start

Frigate’s config file lives at ./frigate/config/config.yml. This is where all the real work happens. Start simple with one camera, get detection working, then add the rest.

mqtt:
  host: mosquitto
  port: 1883
  # user: mqttuser
  # password: mqttpassword

detectors:
  coral:
    type: edgetpu
    device: usb   # use 'pci' for M.2/PCIe Coral

model:
  path: /edgetpu_model.tflite   # built-in MobileNet-SSD model
  width: 320
  height: 320

cameras:
  front_door:
    ffmpeg:
      inputs:
        - path: rtsp://admin:{FRIGATE_RTSP_PASSWORD}@192.168.1.50:554/stream1
          roles:
            - detect
            - record
    detect:
      enabled: true
      width: 1280
      height: 720
      fps: 5       # 5fps is plenty for detection; saves Coral capacity for more cameras
    objects:
      track:
        - person
        - car
        - dog
      filters:
        person:
          min_area: 5000       # ignore tiny detections (far-away pixels, shadows)
          max_area: 100000
          min_score: 0.5
          threshold: 0.7
    record:
      enabled: true
      retain:
        days: 7
        mode: motion     # only retain clips with motion
      events:
        retain:
          default: 14    # keep event clips for 14 days
          mode: active_objects
    snapshots:
      enabled: true
      timestamp: true
      retain:
        default: 14
    motion:
      mask:
        # Draw a polygon to exclude zones where you get false detections
        # Coordinates are x,y pairs as fractions of frame width/height (0.0 to 1.0)
        # Example: mask out the top-right corner where a tree sways in the wind
        - 0.75,0.0,1.0,0.0,1.0,0.25,0.75,0.25

A few things worth explaining here:

fps: 5 for detect — Frigate decodes a separate lower-resolution stream for detection. You don’t need 30fps detection; 5fps catches everything a human is doing and saves your Coral’s inference budget. The recording stream stays at full resolution and framerate.

min_area and threshold — These two filters eliminate most false positives. min_score is the raw model confidence, threshold is the final score after Frigate’s own averaging. Bumping threshold to 0.7-0.75 eliminates a huge chunk of “person detected” alerts that are actually shadows or a flapping flag.

Motion masks — The polygon coordinates exclude regions from motion detection. Use this for trees, street traffic, HVAC units — anything that moves but you don’t care about. Frigate’s web UI has a built-in mask editor; draw it there and copy the coordinates into config.

Zones: Smarter Than Motion Areas

Beyond masking out junk, you can define named zones within a camera’s view and only alert when an object enters a specific zone:

cameras:
  front_door:
    # ... (rest of camera config above) ...
    zones:
      driveway:
        coordinates: 0.0,0.5,0.5,0.5,0.5,1.0,0.0,1.0
        objects:
          - car
          - person
      porch:
        coordinates: 0.3,0.3,0.7,0.3,0.7,0.7,0.3,0.7
        objects:
          - person

Now instead of alerting on every person who walks past on the sidewalk, you only alert when someone enters the driveway or steps onto the porch. This is the feature that makes Frigate actually useful day-to-day instead of being a notification firehose.

MQTT Events: What Frigate Publishes

When Frigate detects something, it publishes to MQTT. Here’s the topic structure:

frigate/events           — all events (new, update, end)
frigate/<camera>/person  — person detection on a specific camera
frigate/<camera>/car     — car detection
frigate/stats            — detector stats, inference times
frigate/available        — online/offline status

A detection event payload on frigate/events looks roughly like:

{
  "type": "new",
  "before": { ... },
  "after": {
    "id": "1715623412.123456-abc",
    "camera": "front_door",
    "label": "person",
    "score": 0.82,
    "zones": ["porch"],
    "thumbnail": "...",
    "has_snapshot": true,
    "has_clip": true
  }
}

Home Assistant’s Frigate integration subscribes to all of this automatically once you point it at your MQTT broker.

Home Assistant Integration

If you’re running Home Assistant, add the Frigate integration via HACS (or the official integration in HA 2024.x+). Point it at your Frigate instance:

Settings → Integrations → Add Integration → Frigate
URL: http://<your-server-ip>:5000

You get:

• Binary sensors for each camera (person detected, car detected, etc.)
• Camera entities with live streams
• Sensor entities with detection counts
• Automatic MQTT event subscriptions

From there you can build automations: “if person detected in porch zone after sunset, turn on front light and send a notification.” The notification includes a snapshot thumbnail pulled directly from Frigate — no cloud involved.

Recording Strategy: Don’t Fill Your Drive in a Week

Frigate’s recording config has two modes worth understanding:

24/7 recording with motion retention — Record everything, but only retain segments that had motion. Everything else gets pruned after a configurable number of days. Good if you want forensic coverage but don’t want to store 30 days of empty driveway footage.

Event-only recording — Only record when an object is detected. Much smaller storage footprint. The downside is you miss the 10 seconds before detection triggered. Frigate has a pre_capture setting (in seconds) that buffers the stream and includes pre-detection footage in clips.

For storage: NVMe is your friend. Frigate does continuous writes and reads. A spinning disk will work but you’ll hear it. A 1TB NVMe drive handles 4-6 cameras at reasonable quality for 14 days of events easily. Point your frigate/media volume mount at wherever your NVMe is mounted.

The mode: active_objects retention setting is particularly useful — it only retains clips where an object actually appeared, not just motion. Motion from wind or a car reflection won’t accumulate clips.

Coral Makes Sense When…

• You’re running 2+ cameras with object detection
• Your server CPU is already doing other work (Plex transcoding, VMs, etc.)
• You want sub-100ms detection latency
• Your host has no Nvidia GPU
• You want dedicated, power-efficient inference hardware that doesn’t affect the rest of your workload
• Budget is under $100 for the detection upgrade

Skip the Coral when…

• You have an idle Nvidia GPU — use it, Coral doesn’t beat CUDA at sustained throughput
• You only have 1 camera and a modern CPU — a single-camera setup on an i5 is fine without Coral
• Your server is ARM-based and you’re not sure about USB compatibility — test first
• You’re running < 4 cameras on a dedicated NUC or mini-PC with no other workload — the CPU will handle it

The sweet spot is a general-purpose home server (NAS, Proxmox box, whatever) that’s already doing several things, where you don’t want camera detection competing for CPU cycles. Drop in a Coral USB, add the devices: line to your Compose, configure the edgetpu detector, and the CPU load from Frigate drops to near zero.

Your raccoon is still going to get into the trash. But now you’ll get a push notification with a snapshot showing exactly which raccoon it was, the clip will be saved locally for 14 days, and you won’t have paid Ring $120 this year to find out.

The whole stack — Frigate, Mosquitto, Coral detection — runs on hardware you probably already have, costs about $60 for the TPU, and integrates cleanly with Home Assistant. The subscription model for basic camera intelligence has always been a tax on people who haven’t found Frigate yet.

Now you have.