# 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](https://docs.frigate.video/frigate/camera_setup)
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](/reference/cameras/).

## Steps

1. Open the Fregata web UI from the menu-bar tray
   (**Open Frigate Web UI**, or `⌘O`). It opens
   [https://localhost:8971](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](/getting-started/installation/#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.

:::tip[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!
:::

:::tip[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

The first time a model runs, Fregata times two warmup inferences and
classifies the result. Look at the **Detector** row in the menu-bar
tray (or the System tab in the web UI):

- **~1–4 ms per frame** — detection is on the Apple Neural Engine.
  This is the correct, intended path.
- **5–15 ms per frame** — detection is on the GPU (Metal). This
  happens if the bundled model uses ops the ANE doesn't support, or
  if you forced `inference_backend: gpu` in config.
- **50+ ms per frame** — detection has fallen back to CPU. Something
  went wrong; restart the app and check the log via the tray's
  **Settings → Open Frigate Logs** for an `ane_init` or
  `coreml_session` error.

For a deeper look, see [Performance](/guides/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](/guides/recordings-and-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:

```yaml
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](/guides/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](/guides/recordings-and-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](https://docs.frigate.video/configuration/reference)
documents the complete schema and its **stock defaults**. One caveat
when reading it: on a **new install only**, Fregata seeds a handful of
features that stock Frigate ships *off*, so the defaults in that
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"]`** |

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](/guides/detection-tuning/) — masks, zones,
  per-object thresholds, custom models.
- [Hook Fregata into Home Assistant](/guides/home-assistant/) via
  the official Frigate HACS integration.