Scrypted vs Frigate: Camera Stacks Compared

Every “Frigate or Scrypted?” thread goes the same way. Half the replies say Frigate because the object detection is excellent. The other half say Scrypted because it puts cameras in HomeKit and the phone app is instant. Both halves are right, and they are answering different questions, which is why the thread never resolves.

I have run both, concurrently, on the same cameras, for long enough to have opinions. Here is what actually separates them.

They are solving different problems

Frigate is a detection engine with a recorder attached. Its centre of gravity is the inference loop: pull an RTSP sub-stream, run motion detection cheaply, run a quantised object detector on the moving regions, track objects across frames, and fire an event when a tracked object of interest enters a zone. Recording exists to give those events a video clip. The UI is a review timeline for the events. Everything Frigate does well flows from that focus. The setup, including the accelerator that makes it practical, is covered in Frigate NVR with a Coral TPU.

Scrypted is a protocol translation layer with detection bolted on. Its centre of gravity is taking a camera that speaks one dialect and presenting it to a client that speaks another. RTSP in, HomeKit Secure Video out. ONVIF in, Google Home out. A vendor’s proprietary cloud API in, a plain RTSP stream out for anything else to consume. It has object detection plugins, and they are decent, though they were built to satisfy HomeKit’s requirements rather than to be the point of the product.

That distinction predicts almost every difference you will encounter.

Configuration: YAML file vs clicking things

Frigate is one YAML file. Every camera, every zone, every mask, every retention rule lives in it. You edit it in a text editor, restart the container, and the entire system state is that file. Put it in git and your NVR configuration is versioned, diffable and restorable in the time it takes to git checkout.

Scrypted is a web UI with a plugin system. You install plugins, click through camera discovery, tick boxes for which integrations each camera is exposed to, and the state lives in a database inside the container. There is a settings export, and it works, though it is a blob rather than something you can read in a diff.

If you are the kind of person who keeps their homelab in a repository — and much of this site is arguing you should — Frigate’s approach is a meaningful advantage. Scrypted’s approach is genuinely faster for the first hour and genuinely worse on the day you need to rebuild the host.

Here is the Frigate side of that, as a shape:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

cameras:
  driveway:
    ffmpeg:
      inputs:
        - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@192.168.1.40:554/stream2
          roles: [detect]
        - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@192.168.1.40:554/stream1
          roles: [record]
    zones:
      gate:
        coordinates: 0,480,0,240,300,220,340,480
        objects: [person]

And the equivalent Scrypted state, which you reach by clicking, and which looks like this if you go digging for it through the plugin console:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$ docker exec -it scrypted npx scrypted service-info
Scrypted Server 0.123.0
Plugins:
  @scrypted/homekit           HomeKit Secure Video bridge
  @scrypted/onvif             ONVIF camera provider
  @scrypted/objectdetector    Video analysis pipeline
  @scrypted/openvino          OpenVINO object detection
  @scrypted/rebroadcast       Stream management / prebuffer
  @scrypted/nvr               Recording (subscription)
Devices: 4 cameras, 4 motion sensors, 4 object detectors

Note the last plugin in that list. We will come back to it.

Where Scrypted wins outright

HomeKit Secure Video. This is the reason most Scrypted installs exist, and nothing else does it. Scrypted takes a generic £40 RTSP camera and presents it to Apple’s ecosystem as a native HomeKit camera, with the whole HKSV pipeline: local analysis, encrypted upload to iCloud, ten days of retention, notifications with rich previews, and face recognition from your Photos library. Frigate has no answer to this and no intention of having one.

The live view latency. Scrypted’s rebroadcast plugin maintains a prebuffer — a rolling few seconds of every camera’s stream held in memory, already parsed. When you open the app, the stream starts from that buffer instantly rather than waiting for the camera to send a new keyframe. Frigate’s live view, by comparison, waits on the camera. On a camera with a 4-second keyframe interval, that is the difference between “instant” and “a black rectangle for four seconds”, and it is very noticeable when you are standing at the door holding a phone.

Weird cameras. Scrypted has plugins for vendor clouds, doorbells with proprietary two-way audio, and cameras that only speak their own app’s protocol. If your camera cannot produce a plain RTSP stream, Frigate simply cannot see it. Scrypted often can.

Two-way audio. It works, on more cameras than you would expect. Frigate has RTSP restreaming and go2rtc underneath it, and two-way audio remains an adventure.

Where Frigate wins outright

Detection quality and tunability. Frigate’s zones, masks, object filters, score thresholds and required-zones logic give you real control over what constitutes an event. You can say “a person, scored above 0.75, whose bounding box bottom edge is inside the gate zone, for at least three consecutive frames”. Scrypted’s detection is a plugin that tells you a person was seen. For a driveway that faces a public pavement, that distinction is the whole ballgame — one setup alerts on the postman, the other alerts on every pedestrian in the street.

Resource honesty. Frigate tells you, per camera, exactly what your CPU is doing and why. The stats API exposes inference speed, ffmpeg CPU per process, skipped frames and detection FPS. When something is slow, you can find out what. Scrypted’s resource usage is more opaque, and the Node.js process with several plugins loaded is comfortably hungrier at idle than Frigate is.

Storage control. Frigate’s retain.mode: motion and the split between continuous retention and event retention is precise and it works. Scrypted’s free tier does not record at all in any serious sense — recording is the paid NVR plugin.

The licence. Frigate is MIT and the whole thing is there. Scrypted’s core is open source; the NVR plugin, which is the bit that records and does the searchable timeline, is a paid subscription. The price is modest and the developer has earned it. Know about it before you build a house on it.

Detectors and hardware

Both will use an accelerator, and they disagree about which.

Frigate’s first-class detector is the Coral Edge TPU, with OpenVINO on Intel iGPUs, TensorRT on Nvidia, and Hailo as the newer option. Its models are small quantised ones — MobileDet by default — chosen to fit the TPU’s on-chip memory, and the whole pipeline is built around running the detector only on regions where cheap motion detection already found something.

Scrypted’s detection plugins lean on OpenVINO or CoreML, and on Apple hardware the CoreML path is genuinely excellent — a Mac mini running Scrypted does face and object recognition at a quality Frigate’s default model does not reach. On a generic Linux box, Scrypted’s OpenVINO plugin works and costs more CPU than Frigate does for equivalent work, because the frame-skipping and motion-gating is less aggressive.

A rough summary of the split:

The combination nobody mentions

They are not exclusive. The arrangement I ended up with runs both, and it is better than either alone.

Frigate owns the cameras and does the detection and recording. Frigate’s built-in go2rtc then restreams each camera on rtsp://frigate-host:8554/<camera>. Scrypted consumes those restreams and does the HomeKit bridging. The cameras themselves only ever talk to one client, which matters more than it sounds — cheap cameras often support two or three concurrent RTSP sessions before the encoder falls over, and a camera serving Frigate, Scrypted, Home Assistant and your phone directly is a camera that will stop serving anyone.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

go2rtc:
  streams:
    driveway:
      - rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@192.168.1.40:554/stream1
    driveway_sub:
      - rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@192.168.1.40:554/stream2

cameras:
  driveway:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/driveway_sub
          input_args: preset-rtsp-restream
          roles: [detect]
        - path: rtsp://127.0.0.1:8554/driveway
          input_args: preset-rtsp-restream
          roles: [record]

Everything downstream now points at rtsp://192.168.1.20:8554/driveway. The camera has one client. Scrypted stops fighting Frigate for the encoder, and the mystery stream dropouts stop.

Troubleshooting the pair

Streams drop out when you add a second consumer. This is the camera’s session limit, and it is by far the most common cause of “Frigate was fine until I installed Scrypted”. Restream through go2rtc as above and the problem disappears.

HomeKit shows the camera but the stream never starts. HKSV is strict about codecs. It wants H.264 with a keyframe interval of about 2 seconds (i-frame interval in the camera’s web UI, usually expressed as a multiple of the frame rate) and AAC audio, or no audio at all. H.265 will pair happily and then refuse to play. Scrypted can transcode to fix this, at real CPU cost — fixing it in the camera’s own settings is free.

Scrypted’s prebuffer eats RAM. Each prebuffered stream holds several seconds of video in memory. Four 4K cameras will take a gigabyte or two. This is a deliberate trade for the instant live view, and it is worth knowing about before you deploy it on a 4 GB machine.

Detection events fire twice. If both stacks are detecting on the same camera and both are wired into Home Assistant, you will get two notifications for one postman. Pick one detector. Mine is Frigate; Scrypted’s object detection plugin gets disabled on every camera and it only bridges.

Frigate’s recordings exist but the timeline is blank. Frigate keeps recording segments on disk and their index in a SQLite database. If the database and the media directory disagree — usually because someone deleted files by hand to free space — the UI shows gaps over footage that is right there. Delete through the UI or the API, and let Frigate maintain its own index. The same discipline applies to any SQLite-backed service in the rack, for the reasons set out in SQLite is a production database.

The cameras are talking to the internet. Check. Then stop them. Both stacks pull from the camera, so the camera needs no outbound route whatsoever, and cheap camera firmware is among the least trustworthy code you will ever run — the segregated setup in VLAN segmentation at home exists largely because of these devices.

Verdict

If you live in the Apple ecosystem and want cameras that behave like Apple cameras, run Scrypted. Nothing else gets you HomeKit Secure Video, and the difference between “notifications that work on the family’s phones without training anyone” and “a self-hosted dashboard nobody else opens” is the difference between a system that gets used and a hobby.

If you want to decide precisely what counts as an event, keep everything in a version-controlled file, and know exactly what your CPU is doing, run Frigate. The detection pipeline is more sophisticated, the configuration survives a host rebuild, and the whole thing is MIT-licensed with no tier above you.

If you have the RAM, run both, with Frigate owning the cameras and restreaming to Scrypted. That is where I landed after six months of switching back and forth, and the only real cost is that you now maintain two things instead of one. Given that each was going to annoy me in a different way regardless, I decided I would rather have both sets of strengths than pick which weakness to live with.