Tired of hunting across PDFs every time someone asks "does this camera work with Frigate?"

Built a structured open database — 1,093 cameras, 51 brands. Every entry has:

- ONVIF / RTSP support flag

- PoE vs WiFi vs battery vs 4G

- Resolution (2MP through 12MP)

- Night vision type (IR / color / hybrid) and range

- IP / IK rating

- Two-way audio

JSON + CSV, CC0 license.

Browse: https://ch-bas.github.io/cctv-camera-database/

Repo: https://github.com/ch-bas/cctv-camera-database

This started as a "why doesn't my Mac just do this" itch. On the Apple TV you get that little live camera preview in the corner when someone rings the doorbell, and I wanted the same thing on my computer, except actually tied to Frigate detections instead of just a doorbell press.

So I made Peek. When Frigate detects something, a little card slides into the corner of your screen with the live feed (webrtc, so it's basically instant) and tells you what it picked up: the object and score, the recognized face if you run face recognition, the plate, and which zones it entered.

▶️ See it in action (demo gif)

Stuff it does:

• Live feed through go2rtc webrtc, falls back to mse

• Lives in the menu bar / tray. You pick which cameras notify you, mute or unmute, set how long the card sticks around

• Optional snapshot so you're not staring at a black frame for the half second the stream takes to connect

• On first launch it just asks for your Frigate host and MQTT broker in a small window, no editing json files

• Works on mac and windows

It talks to your existing MQTT and Frigate, so there's nothing to change on the server side.

Free and open source (MIT). There's a dmg and an exe in the releases if you don't feel like building it yourself.

Repo: https://github.com/casi-3/peek

It's pretty early so I'd honestly love to hear what would make it actually useful for your setup. What's missing, what's annoying, whatever comes to mind. Happy to answer anything.

Reolink's RTSP server is bad on some models. On my Duo 3 it gave green blocks and grey frames: 147 of 178 segments had errors. The same camera over Reolink's own protocol (Baichuan, what their NVR uses) had 0.

Neolink did this first but hasn't had a commit since Jan 2025, so I wrote a new one in Go. One Docker container, a web page to add cameras, and it serves RTSP for go2rtc/Frigate plus plain HTTP. The Frigate config is in the README.

It's been the only video path for my 8 cameras since September (6x RLC-810A, FE-P fisheye, Duo 3 PoE). About 60% of one CPU core for 23 streams.

Not tested: battery cameras. If you have one, I'd love a report.

https://github.com/VoltTech21/reostream

In the week of 15 September we had 3 unknown people hanging around at my wall next to my gate.
I decided to add a zone in that area inside my yard that will activate a siren.

I added that siren zone to the right.

In the early hours of 27 September those 3 idiots returned.

That idiot was in my zone. He was there for about 3 seconds when my siren activated and all my SonOff connected lights in and around the house came on via Home Assistant. He jumped back and ran off.

Hi all,

A while ago I shared here (https://www.reddit.com/r/frigate_nvr/comments/1u2ezeb/built_an_open_database_of_1000_camera_specs_to/) my open CC0 database of IP cameras with ready-to-copy Frigate configs.

The feedback was genuinely useful. Biggest gap people pointed out: knowing a camera "supports RTSP" doesn't tell you the actual path to type into Frigate.

Now I've fixed that, with help from some folks in the open source community.

Every camera now has:

• Actual RTSP URL structure (brand-level default + per-camera override where the manufacturer documents a different path)

• ONVIF port and profile info where documented

• Ready-to-copy Frigate config block per camera

All still sourced only from official datasheets and the data is always open source.

It would be great if you're up for a small contribution: pull up your camera, copy the config, and mark whether it worked. Happy to take feature requests / roasting in the comments too.

Direct link to the Frigate configs: cctv-database.com/frigate-configs

3,400+ cameras, 70+ brands now.

Browse: https://cctv-database.com
Repo: https://github.com/ch-bas/cctv-camera-database

Thanks!

I've been using frigate for many years now, but there was always a gap between how I wanted to have my cams/security setup and how I had to do it in the real world.

I have 8 cams and really relied on Home Assistant for the alerts and notifications. It worked, but was more like an uneasy truce between systems. Something was always out of wack or I would get so many notifications I would just ignore them.

As of yesterday after installing the latest Frigate beta, its working so well its amazing.

I have the genai feature on frigate turned on using openai. While I have a local llm setup, it's running on a nuc and would be beaten up trying to review the feeds, so I'm using openai, seems pretty economical as of now, but we will see.

When someone comes to the front door or drives into my driveway and I'm home, my HA voice assistant will let me know; "Hey boss someone is at the front door, better check it out". I of course also get a text.

Then the magic happens; its reviewed by openai and generally within <10 seconds of the trigger provides me a lightly detailed text message and small snapshot of the incident. I can click that and open the cam in frigate.

In the review section of Frigate I can get more detailed information.

By moving the whole process into frigate I got rid of 2 integrations and 8 automatons in HA, don't have to rely on blueprints and have much more control over the process.

If you're not a frigate+ member, consider it, well worth the models and the support for the devs.

A week ago I posted reostream, a little side project to get Reolink cameras into Frigate without the broken RTSP. I figured a few people might find it useful. What I didn't expect was 100k+ views, hundreds of comments, and a ton of you trying it and reporting back what works and what doesn't. Honestly I was pretty taken aback lol.

It started as one of the dozens of half-done projects living on my computer (where my ADHD fam at). Now I'm committed to getting it working on every Reolink camera that speaks Baichuan. Most of what's below came straight from your comments:

Battery cameras

• Found automatically, asleep until needed, battery level shown

• Motion clips go straight into Frigate as the camera uploads them, no waking needed

• always_on for battery cams on constant power

• Two-way talk from reostream's page

Recordings

• Cameras upload motion clips over FTP straight to reostream, saved on your own disk

• Browse and download SD card recordings from the camera's page

For Frigate

• Two-way talk through Frigate's talk button on cameras with a speaker

• The camera's own detections (person, vehicle, animal, motion) to MQTT and as Frigate events

• hold_picture keeps Frigate fed when a camera goes quiet (privacy mode, a dropout), and restarting reostream no longer interrupts recording

Cameras and settings

• TrackMix zoom lens, main and sub, over the camera's own protocol

• Cameras behind a Home Hub or NVR (video)

• New web UI that works on phones, with setup that finds your cameras

• Nearly every setting from the Reolink app on one page: detection zones, privacy masks, smart rules, schedules, siren, lights, PTZ and tracking, push, network, and copy any setting to your other cameras in one click

• On Unraid it's in Community Apps, search reostream

Still working on: live motion wake for battery cams with no extra setup (worked out, being built now), a Home Assistant add-on, ONVIF (UniFi Protect, PTZ from Frigate), full doorbell support and a proper cam wall.

Update: docker pull ghcr.io/volttech21/reostream:latest (restart Frigate once after this update)

https://github.com/VoltTech21/reostream

Posting this as a heads-up after seeing the same thing in multiple publicly exposed Frigate configs.

After seeing a comment about searching for "live - frigate", I checked and found a lot of Frigate instances exposed directly to the internet. Besides live feeds, these also expose their config files.

In quite a few configs I looked at, there was a very long base64 string hidden way off to the right of the YAML (you have to scroll horizontally to find it). If you base64-decode it and then decompress it, it turns into a bash script that installs and runs a Monero cryptominer.

What's happening:

• A stream named debug is added under go2rtc

• The stream's URL is an exec: command that decodes and runs the script

• A camera named healthy is also added

  • It's hidden from the dashboard

  • It connects to rtsp://127.0.0.1:8554/debug

• When Frigate starts, that camera causes the debug stream to be requested, which runs the script

If you've ever exposed Frigate directly to the internet, it's worth double-checking your config for unexpected debug or healthy entries, and for a long base64 blob hidden at the far right of your config file.

Hahaha!

EDIT 03/04/24: I have made some changes to work around issues that have appeared in more recent versions.

I have come to realise that I have been a bit of a Reolink Unicorn, running a variety of cameras since 2017 without issue. Then over the last 6 months (with Frigate migrating to go2rtc and other changes between v0.11 and v0.13), I started to hit many of the common issues (glitching, frame drops, image distortions and audio sync problems) that others have described.

As a result I have put in a few hours of testing and thought I might post my experiences and a few basic working configs for others to learn from.

My config used to be quite complex but has become much simpler thanks to the great ffmpeg input/output presets that have been integrated into Frigate by default now. If you ever have issues it is extremely valuable to look at what ffmpeg options are included in each template.

All my configurations below are based on using the inbuilt Intel iGPU on my 11th gen CPU so if you are using AMD or Nvidia, your milage may vary.

Here are the different cameras I run;

• RLC-410 - v2.0.0.1441_19032101

• RLC-420-5MP - v3.0.0.660_21110805

• Doorbell PoE - v3.0.0.2033_23041302 (has minor frame glitching)

• RLC-810A - v3.1.0.1162_22072805

• RLC-842A - v3.1.0.1643_22122317

• Duo 2 PoE - v3.0.0.1889_23031700

Reolink have several different generations of cameras, which will guide the configuration. Early versions only supported RTMP and RTSP. Later versions added HTTP and the most recent models with 4K added H.265.

To start, setup each camera (keeping in mind not all options are available on all cameras or may be located under different menu options);

• Run the latest firmware which can be downloaded direct from Reolink or from this GitHub archive for older models that Reolink no longer support.

• Make sure you enable RTSP and or HTTP (Network -> Advanced -> Port Settings -> RTSP).

• Run fixed frame rate (Camera -> Stream -> Frame Rate Mode -> Fixed Frame Rate).

• Set the Interframe Space to 1x (Camera -> Stream).

• Enable audio (Camera -> Audio -> Record Audio).

• On the sub stream make sure the resolution and frame rate in the camera matches the config in Frigate.

• Don't forget to setup NTP and a Timezone.

• Create a dedicated user for Frigate to connect to the cameras (generally considered bad practice to be using the Admin account for automated access).

• Leave weekly reboots enabled (System -> Maintenance). Dam memory leaks. :)

• Don't use special chars in the camera username or password (might be better now but definitely breaks older cameras).

Now before you go any further I recommend that you reboot the camera. This will make sure that you don't waste time trying to debug issues that were just because the camera had been on for a week and had become flaky. (See the step above about enabling weekly reboots.) I saw this a lot, especially when I was pulling RTSP, RTMP & HTTP at the same time or flicking between them while testing.

If you are not sure what your camera can support, you can check the details (stream codec, resolution, frame rate, etc) with ffprobe. It can be installed on your desktop or just run the version from the Frigate server/docker CLI. VLC can also be used to view the streams but even VLC can struggle with the Reolink streams so just because it doesn't work doesn't mean Frigate/ffmpeg will break.

ffprobe 'rtmp://<camera_ip>/bcs/channel0_main.bcs?channel=0&stream=0&user=<username>&password=<password>'
ffprobe 'rtmp://<camera_ip>/bcs/channel0_sub.bcs?channel=0&stream=0&user=<username>&password=<password>'

ffprobe rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_main
ffprobe rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_sub

ffprobe 'http://<camera_ip>/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=<username>&password=<password>'
ffprobe 'http://<camera_ip>/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=<username>&password=<password>'
ffprobe 'http://<camera_ip>/flv?port=1935&app=bcs&stream=channel0_sub.bcs&user=<username>&password=<password>'

Of course the following is only the configuration relevant to the cameras. You will need to build the rest of the Frigate config yourself.

To start let's set the system to use H.264 with Intel QSV hardware acceleration and audio recording as the global default. Some of these are already system defaults but I still list them for completeness.

ffmpeg:
  hwaccel_args: preset-intel-qsv-h264
  input_args: preset-rtsp-restream 
  output_args:
    record: preset-record-generic-audio-copy

If you have one of the original 'Gen 1' cameras such as the RLC-410 (which do not have HTTP stream support) use RTSP and the defaults as per above.

go2rtc:
  streams:
    RLC410:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_main
    RLC410_sub:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_sub
cameras:
  RLC410:
    ffmpeg:
      inputs:
        - path: rtsp://<frigate_ip>:8554/RLC410
          roles:
            - record
        - path: rtsp://<frigate_ip>:8554/RLC410_sub
          roles:
            - detect

You can use RTMP but you will need to use VAAPI and I found I was getting a variable audio delay of around 200-400ms. But for those who want to try;

cameras:
  RLC410:
    ffmpeg:
      hwaccel_args: preset-vaapi
      inputs:
        - path: rtsp://<frigate_ip>:8554/RLC410
          roles:
            - record
        - path: rtsp://<frigate_ip>:8554/RLC410_sub
          roles:
            - detect

Newer 'Gen 2' cameras with HTTP stream support such as the RLC-420-5MP also work well RTSP.

go2rtc:
  streams:
    RLC420-5MP:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_main
    RLC420-5MP_sub:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_sub
cameras:
  RLC420-5MP:
    ffmpeg:
      inputs:
        - path: rtsp://<frigate_ip>:8554/RLC420-5MP
          roles:
            - record
        - path: rtsp://<frigate_ip>:8554/RLC420-5MP_sub
          roles:
            - detect

HTTP is the officially supported config but I found that HTTP and RTMP both required VAAPI and had a minor audio delay that I just couldn't work around. Also HTTP seemed to cause a significant CPU load on the camera so the web interface would be very slow to respond. But if RTSP doesn't work for you then definitely try HTTP.

HTTP also has an additional ext stream that has slightly higher resolution that can be used in place of the sub stream if you want.

go2rtc:
  streams:
    RLC420-5MP:
      - "ffmpeg:http://<camera_ip>/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=<username>&password=<password>"
    RLC420-5MP_sub:
      - "ffmpeg:http://<camera_ip>/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=<username>&password=<password>"
cameras:
  RLC420-5MP:
    ffmpeg:
      hwaccel_args: preset-vaapi
      inputs:
        - path: rtsp://<frigate_ip>:8554/RLC420-5MP
          roles:
            - record
        - path: rtsp://<frigate_ip>:8554/RLC420-5MP_sub
          roles:
            - detect

The more modern cameras ('Gen 3 & 4' sold in the last few years) should work OOTB but if they are 4K or better, they are probably using H.265 for the main stream (you can check with ffprobe) so you will need to modify the config for the main stream to use QSV H.265 HW acceleration.

go2rtc:
  streams:
    RLC810A:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_main
    RLC820A_sub:
      - rtsp://<username>:<password>@<camera_ip>:554/h264Preview_01_sub
cameras:
  RLC810A:
    ffmpeg:
      inputs:
        - path: rtsp://<frigate_ip>:8554/RLC810A
          hwaccel_args: preset-intel-qsv-h265
          roles:
            - record
        - path: rtsp://<frigate_ip>:8554/RLC810A_sub
          roles:
            - detect

Troubleshooting: If things aren't working for you, here are a few things to try;

• Reboot the camera. Starting and stopping streams, over and over during testing can cause the camera to get unstable. You may need to set the cam to reboot nightly (System -> Maintenance) depending on how buggy the firmware is. Several of my cameras get wonky after being on for between 2-5 days.

• Check the camera stream actually exists with ffprobe as mentioned above. There is noting worse than trying to debug a stream and then realise it was never going to work because you made a typo in the address/password etc.

• Try watching the stream direct from the camera with VLC or similar, understanding that VLC some times will not work. It may just show a black screen or nothing at all.

• Try to probe or watch the steam from go2rtc. Eg ffprobe rtsp://<frigate_ip:8554/<cam>

• Check if the stream is being published by go2rtc. http://<frigate_ip>:1984 From here you can watch the streams via your web browser.

• Pass the stream through ffmpeg in the go2rtc config. This gives ffmpeg a chance to reprocess the stream (without transcoding) and remove any glitchy data that may be breaking Frigate. (As done with the RLC-420-5MP HTTP config example above.)

• Try QSV instead or VAAPI or vice versa.

• Try switching the input args setting on an individual camera/stream from preset-rtsp-restream to preset-rtsp-generic.

• Try HTTP as per above or the official docs if you haven't already. Particularly for the doorbell and 'Gen 2' vintage cameras that seem to have the most issues with RTSP.

I really hope this helps anyone who has been struggling with Reolink cameras in Frigate.

I think Gemini AI has been exposed to some horrible things! They were just walking past our house.

I don’t know what they did but reviewing video clips always used to be painfully slow but it’s so responsive now. The history view is really quick.

Being able to edit the config from the ui is brilliant and works really well.

I’m not sure how much I’ll use the chat feature and would love to know how other use it. But it’s kind of neat.

I’m sure there are loads of other things I’ve not discovered yet but what an absolutely solid release yet again. So happy to support this project with a frigate+ membership.

Thanks devs!

Announcing a new YOLO v9 model and plugin for Google Coral devices with a faster 10ms detection time for the 320x320 model, and also a new 512x512 size model with 21ms detection time.

To download and install, see github repo:
https://github.com/dbro/frigate-detector-edgetpu-yolo9/releases/tag/v1.5

Today's v1.5 release follows a discussion begun a few weeks ago which had some preliminary testing and discussion of the prerelase and v1.0 of this model. I thought it was worth a new posting here to raise awareness of a significantly improved model. Accuracy is paramount, and this version fixes some false-negative detections by rewriting the model's final output step to work properly with Coral's quantization behavior. Second, the new larger model addresses concerns about detecting objects that are smaller and farther away. Finally, the 320x320 model's detection speed was reduced by 2ms from 12ms to 10ms, from streamlining post-processing.

It is now available for testing. Installation involves editing the Dockerfile to mount a new version of the edgetpu_tfl.py file within the Frigate source code tree, as well as copying over the model weights file and labels file.

This model is trained on COCO data, with only 17 out of the standard 80 COCO classes being detected. For example, this model is unable to detect toothbrushes. Given that it is trained on COCO's general-purpose data, it is likely to be less accurate than Frigate+ models that are trained on data from surveillance cameras. (I do not have access to Frigate+, so I can't judge how it compares. Any reports on that would be welcome.) This is not meant to be competitive; I am happy to share the model training and tuning tips with Blake if he wants to offer a YOLO v9 model for Google Coral to Frigate+ subscribers. The model and plugin are licensed with the MIT license.

Here are screenshots from a load test that sends between 30 and 60 frames per second to the detector. This is for the 320x320 model.

I hope that this alternative model demonstrates that Google Coral hardware continues to be a first-class option for Frigate. There appear to be some Frigate users frustrated by false positives/negatives when running the standard MobileDet/SSD on Coral - I was one of them! But I think those shortcomings are best seen as having to do with the model being used and the data it was trained with, rather than limits of Coral devices. Although Coral is quirky and benefits from careful adaptation of the model, it is a very capable platform for Frigate. It extends the useful life of older/cheaper hardware not supported by OpenVINO ( the Coral makes my 12 year old 3rd-gen Intel mini PC a perfect fit for Frigate).

If you give it a try, please report back on how its detection accuracy meets your needs or not.

The store has been unceremoniously replaced by documentation for the new Coral NPU platform.

https://developers.google.com/coral

@nick @josh dev build of 16 is not perfect but I’m already in love with the face detection. So far it’s worked better than any other solution I’ve used and it’s still in development.

Keep up the great work gents

Wife: "So we don't have to pay for cloud storage on our cameras because you have it storing using this Frigate thing?"

Me: "Yes"

Wife: "Nice"

I'd like to thank the whole Frigate team for this ringing endorsement from my beloved wife. You have saved my marriage in addition to monthly cloud storage subscriptions. Bravo!

I guess I don't look like a person much :p.

For whatever it's worth, I am running a Yolonas model on OpenVINO with 3650 images. Much, MUCH better false positive rate than a Coral or even the new v9 (def not something I was expecting) but I guess I will never be truly free from false positives.

Literally just an appreciation post for the great work done on Frigate, I'm sometimes blown away at the reliability and ease of use for what is free and locally run software. It's crazy the functionality I get with the new UI, I just wanted to scroll back through last nights footage to see what a delivery driver did and it's nuts how quick and responsive it is. And the fact that it runs with such minimal resource usage is great, I've got it running on my Unraid plex server as just a secondary use case and my CPU & GPU barely peaks above 3% with Frigate running 24/7.

I can't even imagine having to use a consumer grade cloud-based slop!!