Add your first camera

Once the app is activated, the next step is to point it at one camera and verify the whole pipeline — capture, decode, detect, record — is working.

What you’ll need

• An IP camera that speaks RTSP with valid credentials and a network path between it and your Mac.
• The camera’s RTSP URL.

The Frigate project has a thorough camera setup primer covering codec choice, resolution, bitrate, FPS, and the per-brand URL shapes for Reolink, Amcrest, Dahua, Hikvision, UniFi, and others. Everything there applies to Fregata unchanged. For a quick brand-by-brand URL cheatsheet, see also Cameras.

Steps

1. Open the Fregata web UI from the menu-bar tray (Open Frigate Web UI, or ⌘O). It opens https://localhost:8971 in your default browser. The first visit shows a “Not Private” warning — that’s expected (Fregata uses a self-signed certificate for localhost); click through to continue. Then sign in with the admin username and the password from first-run setup — see Your dashboard sign-in if you need to find or reset it.
2. In the web UI, go to Settings → Camera Management.
3. Click + Add camera. The camera wizard opens.
4. Give the camera a short, lowercase name (front_porch, driveway, garage — whatever you want it called in URLs and recordings).
5. Paste the RTSP URL of your main stream.
6. (Optional) If your camera exposes a separate sub-stream URL, you can paste that too — but on Fregata you usually don’t need to. See the tip below.
7. Save. Fregata reloads its config and the camera tile appears on the live dashboard.

The camera should appear in the live tile grid within a few seconds. Detection runs automatically on every camera by default; you’ll see green bounding boxes around moving objects with the class label and confidence score.

Sub-streams: usually optional on Fregata

Unlike Frigate running via Docker, Fregata on Apple Silicon can easily handle object detection on most Macs at full resolution and full FPS — the ANE runs inference and VideoToolbox handles decode, so neither saturates the CPU. The “main stream for recording, sub-stream for detection” pattern Frigate-on-Linux relies on isn’t necessary here. Try the main stream alone first!

Reduce connections to camera

On the stream-configuration step, each stream has a Reduce connections to camera toggle (go2rtc restreaming) — on by default. Either way, Fregata wires up go2rtc for the in-browser live view, so you get sub-second MSE/WebRTC playback. With it on, Fregata also routes detection and recording through go2rtc, so it opens a single connection to the camera instead of one for detection/recording and another for the live view. Leave it on unless a camera misbehaves behind the restream.

Verifying detection is on the ANE

Fregata already knows — you don’t have to work it out yourself. Look at the Detector row in the menu-bar tray (or the System tab in the web UI): it reads something like “1.8 ms/frame (ANE)”. That (ANE) — or (GPU) / (CPU) — is a real measurement Fregata took at startup, not a range you need to interpret.

Here’s how: at startup, Fregata reads Apple Silicon’s own per-engine energy counters to see directly whether the ANE or the GPU actually drew power during a warmup inference. If that measurement isn’t available on your Mac or macOS version, Fregata falls back to a timing-based estimate instead — either way, the tray row is always populated with a tier, not raw milliseconds you’d have to interpret.

• ANE — the correct, intended path.
• GPU (Metal) — happens if the bundled model uses ops the ANE doesn’t support, or if you set inference_backend: gpu in config. Still fast enough for any reasonable number of cameras, just not the ANE.
• CPU — something’s wrong, most likely CoreML couldn’t compile the model at all. Restart the app, then check Settings → Open Frigate Logs for the CoreML: warmup inference… line — a CPU result always comes with a reason attached there.

That same log line has the full detail behind the tray’s tier — the exact energy readings, and whether they came from the direct measurement or the timing fallback — for example: CoreML: warmup inference 2 ms (ANE, via power) (ANE 687.00 mJ, GPU 0.85 mJ) ✓

For a deeper look, see Performance.

Where Fregata stores recordings

By default, recordings live under:

~/Fregata/media/recordings/

with sub-paths organized by camera and date. Event clips live under ~/Fregata/media/clips/ and exports under ~/Fregata/media/exports/.

You can change the Media location at any time from Settings → Folders → Change Media Location… in the tray menu. Fregata will move existing files for you on the next launch.

Retention is per-camera and configured in config.yml; defaults are 14 days for recordings and longer for event clips. See Recordings & retention to tune this for your disk budget.

Your config file, explained

Fregata stores its settings in ~/Fregata/config/config.yml — a plain YAML file you can edit by hand (the web UI’s Config editor, or any text editor; restart Fregata to apply). Out of the box it enables the headline features globally, and the camera wizard adds your cameras and their go2rtc streams. A basic, complete config looks like this:

detectors:
  coreml:
    type: coreml
    inference_backend: ane   # ane = Apple Neural Engine (default) · gpu = Metal

# Object detection on every camera. The bundled model uses COCO labels.
detect:
  enabled: true
objects:
  track:
    - person
    - car
    - dog
    - cat

# Tiered recording: 1 day continuous, 14 days motion, 30 days of events.
record:
  enabled: true
  continuous:
    days: 1
  motion:
    days: 14
  alerts:
    retain:
      days: 30
  detections:
    retain:
      days: 30

snapshots:
  enabled: true
  retain:
    default: 30

# NOTE: Cameras can be set up completely from the Frigate WebUI, but if you want to configure them manually:
# Live view + single-connection re-streaming. Point this at your real
# camera URL; ffmpeg below pulls from go2rtc rather than the camera.
go2rtc:
  streams:
    front_door:
      - rtsp://USERNAME:PASSWORD@CAMERA_IP:554/your-main-stream

cameras:
  front_door:
    live:
      streams:
        Main: front_door   # must match the go2rtc.streams key above
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/front_door
          input_args: preset-rtsp-restream
          roles:
            - detect
            - record

# ── Home Assistant / MQTT (optional, off by default) ─────────────────────────
# Uncomment and point at your broker to use the Frigate HACS integration.
mqtt:
  enabled: false
  # host: 192.168.1.10
  # user: mqtt_user
  # password: mqtt_pass

What’s turned on, and the parts worth knowing:

• Object detection (detect.enabled) runs on every camera, tracking person, car, dog, and cat. The bundled model uses the COCO label set; detecting packages, license plates, and the like needs a custom / Frigate+ model — see Detection tuning.
• Recording (record.enabled) is tiered: 1 day of continuous 24/7 footage, 14 days of motion-only segments, and 30 days of event clips (alerts and detections). Continuous is the disk-hungry tier (~25–40 GB per 1080p camera per day) — set continuous.days: 0 for event-only recording, or raise any tier if you have the disk. See Recordings & retention.
• Snapshots (snapshots.enabled) saves a JPEG per tracked object, kept 30 days.
• Live view uses go2rtc: each camera has one go2rtc.streams entry pointing at the real camera URL, and ffmpeg pulls from go2rtc (127.0.0.1:8554) so a single connection feeds detection, recording, and the browser. The live.streams key maps the camera’s friendly stream name(s) to their go2rtc stream name(s) — the web UI uses this to serve MSE/WebRTC live tiles. If it’s missing or the name doesn’t match a go2rtc stream, the live view silently falls back to low-quality jsmpeg.

Each of these is a global default; set the same key under a specific cameras.<name>: block to override it for one camera.

For every option not shown here, Frigate’s full configuration reference documents the complete schema and its stock defaults.

Defaults that differ from Frigate

On a new install only, Fregata seeds a handful of features that stock Frigate ships off, so the defaults in Frigate’s reference won’t match what a fresh Fregata install writes for you:

Setting	Stock Frigate	Fregata (new install)
detect.enabled	false	true
record.enabled	false	true
record.continuous.days	0	1
record.motion.days	0	14
record.alerts / record.detections retain	10 days	30 days
snapshots.enabled	false	true
snapshots.retain.default	10 days	30 days
objects.track	["person"]	["person", "car", "dog", "cat"]

The same changes as a diff against Frigate’s defaults for these keys:

detect:
  enabled: false
  enabled: true

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

record:
  enabled: false
  enabled: true
  continuous:
    days: 0
    days: 1
  motion:
    days: 0
    days: 14
  alerts:
    retain:
      days: 10
      days: 30
  detections:
    retain:
      days: 10
      days: 30

snapshots:
  enabled: false
  enabled: true
  retain:
    default: 10
    default: 30

The table and diff above are seeded into config.yml once, on a brand-new install — edit or delete those lines and Fregata leaves them alone from then on. A separate, smaller set of defaults works differently: they’re not written into your config file at all, they’re what Fregata falls back to whenever the key is left unset — so they apply to every install, new or upgraded, for as long as you leave the key out:

Setting	Stock Frigate	Fregata
semantic_search.model_size	small	large
face_recognition.model_size	small	large

Both exist to reach the GPU by default, rather than the CPU-only path stock Frigate’s own small default takes on a Mac — see AI Models for Frigate Enrichments for what each size actually runs and why.

These are written only when Fregata creates a config for the first time. An existing config.yml — or one imported from Frigate — is left exactly as-is: Fregata never flips these on a returning user, and every other default matches upstream Frigate.

Next steps

• Add more cameras the same way.
• Tune detection — masks, zones, per-object thresholds, custom models.
• Hook Fregata into Home Assistant via the official Frigate HACS integration.