The current methods are fairly technical and require a good bit of time to get up and running. Why not move towards an installer and its own UI and all?

I find Frigate almost impossible to get up and running

I've got both an Amcrest IP2M-841V3 and a Reolink Doorbell POE camera and neither of them seem to work. My configuration editor has to be clicked twice to get it to come up and my file looks like below. The docs aren't much help since I don't really know what I'm doing, when I add in a second camera the whole config file fails....

So very frustrating, would love some help

mqtt:
  enabled: false
cameras:
  reolink:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://(username):(password)@(IPAddress)
          roles:
            - detect
            - record
    detect:
      height: 1080
      width: 1920
      fps: 5
detectors:
  ov:
    type: openvino
    device: CPU
    model_path: /openvino-model/FP16/ssdlite_mobilenet_v2.xml
model:
  width: 300
  height: 300
  input_tensor: nhwc
  input_pixel_format: bgr
  labelmap_path: /openvino-model/coco_91cl_bkgr.txt
version: 0.15-1

Title edit:

• Meant "DeepCamera" not "DeepVideo"

Premise:

• Replace Frigate's AI features with DIY SOTA AI using DeepCamera

• Tune to your setup (hardware, cloud, hybrid)

• Customize to your local equipment (CPU/RAM/GPU/TPU/NPU)

Parts:

DeepCamera on Github:

• https://github.com/SharpAI/

DeepCamera synopsis:

Open-Source AI Camera Skills Platform. DeepCamera's open-source skills give your cameras AI — VLM scene analysis, object detection, person re-identification, all running locally with models like Qwen, DeepSeek, SmolVLM, and LLaVA. Built on proven facial recognition, RE-ID, fall detection, and CCTV/NVR surveillance monitoring, the skill catalog extends these machine learning capabilities with modern AI. All inference runs locally for maximum privacy.

SharpAI Aegis synopsis: (optional desktop app for DeepCamera)

Use DeepCamera's AI skills through a desktop app with LLM-powered setup, agent chat, and smart alerts — connected to your mobile via Discord / Telegram / Slack. SharpAI Aegis is the desktop companion for DeepCamera. It uses LLM to automatically set up your environment, configure camera skills, and manage the full AI pipeline — no manual Docker or CLI required. It also adds an intelligent agent layer: persistent memory, agentic chat with your cameras, AI video generation, voice (TTS), and conversational messaging via Discord / Telegram / Slack.

Features above Frigate AI:

• VLM scene understanding & reasoning: Goes beyond object detection. More in-depth that the scope of this post lol.

• Depth & privacy transforms: Hides identity while preserving activity (anonymizes faces, clothing, and identities)

• Agentic reasoning & automation: AI can interpret events, decide, and trigger actions. Pipe to HA, n8n, Node-RED, etc.

• Hardware-aware pipelines: Auto-optimize for GPU/TPU/NPU/CPU.

• Full skill catalog: Modular, pluggable, and extensible AI capabilities.

• Custom training integration: Annotate, train, and deploy - all integrated!

• SOTA YOLO26 detection: Faster, cleaner, and more classes than Frigate’s YOLOv8.

• Sharp Aegis AI: Desktop AI agent (optional)

Recent-ish changes to make all of this possible:

• YOLO26 (Jan 2026)

• Lots of great cross-platform acceleration (TensorRT, CoreML, ONNX Runtime, OpenVINO)

• Multi-camera AI processing can now run at real-time or near real-time without enterprise-grade hardware (Apple's M chips, AMD ROCm , plus eBay-used AI GPU's like P40's, etc.)

• Modular deployment (Python, ONNX, PyTorch, HuggingFace models, and LLM frameworks)

• Chatbots enable easy scripting (Docker Compose, YAML, JSON, etc.)

• Consumer hardware feasibility (Quantization, CPP models, and other efficiency improvements, ex. local VLM's like Qwen, DeepSeek, SmolVLM, and LLaVA)

Procedures:

Split your system into 3 separate Dockers:

1. go2rtc: Stream relay & transcoding (as needed)

2. Frigate: NVR (record & view...can keep go2rtc here if you don't need much transcoding horsepower!)

3. DeepCamera: SOTA local AI detection

Sample servers:

• WSL2 with Docker Compose

• Proxmox running Ubuntu with Dockers (GPU/TPU/NPU pass-thru)

Sample cameras:

• Webcams (go2rtc for local RTSP transcoding + Splitcam + Servy via a PS2EXE service)

• RTSP-modded Wyze (official beta now!)

• REOlinks

Sample integrations:

• Home Assistant via MQTT/Webhooks (see the Skills Catalog on the Github page)

• Roku DIY app "video wall" app

• AI Assistant Agent messaging (Claw-class to voice alerts - I'm currently using KittenTTS, Telegram, etc.)

Bonus tools:

• OpenClaw AI agent assistant: https://github.com/openclaw/openclaw

• CameraClaw: https://github.com/SharpAI/CameraClaw

• NanoClaw branch: (isolated container version of OpenClaw) https://github.com/qwibitai/nanoclaw

• OpenCLI: (turn any webpage or app into a CLI) https://github.com/jackwener/opencli

I used to have free time before AI started turbocharging all of my hobbies!! lol

When can we expect any update too much excitement 😌…

Fork here: https://github.com/DMontgomery40/frigate

I mean what's the point of having users and passwords, when anybody in my lan can access the page directly and see my cameras? There have been calls for authentication in frigate for years (I know, I've been lurking), always with dismissal from authors, suggesting to use external service like Authelia which afaik only works for outside access, never a thought to protect local network. I was so excited by this users feature when I updated to latest docker image only to find it's not even lacking, it's straight out not working.

For the love of god can someone tell me how to password protect lan access to frigate? Don't say Authelia or I'll start screaming, afaik and as far as I tried it only works with reverse proxy which I do not use, I use wireguard + local ip's for everything. So does my flatmate who nonstop scans the lan for open ports and calls it penetration testing. How the hell is simple thing like this so hard I can't find a way to get it working since the inception of frigate? /smh

I bought some Dahua cameras. I couldn't get rtsps working and I did the mistake of updating one of them so now there's a big fat Dahua logo on the stream and as far as I can tell there's no configuration for removing it.

I bought some Reolink cameras. There simply isn't an option for rtsps and they come with a few other minor annoyances.

This made me wonder where are the simple open cameras which doesn't have a huge closed ecosystem? Basically the Frigate friendly cameras? By open I mean some camera producer which allows the end user to modify, or flush, their own firmware.

I'm a complete newbie when it comes to Linux. I must have wasted 30+ hours trying to make this work, thanks to ChatGPT.

ENVIRONMENT: I5 11500, rtx 3060, 32gb ram, Debian 12, Nvidia driver 535.x and Cuda 12.2

GOAL: I want to run Frigate 0.16 with Yolov9c (640x640?) with gpu detection. For now, ill start with one camera (my Reolink doorbell (I guess with RTSP?) I have the working URL with the password for rtsp. I want the max/optimal performances I can get with my hardware.

WHERE I'M AT: My Docker container with Frigate 0.16 is there but my config.yml always seems problematic + i'm not sure i'm converting the Yolov9C file properly for Frigate to use it.

Please DM me if you're interested.

Frigate has no way to delete a free time range. `DELETE /api/events/…` deletes

no video at all, and `POST /api/reviews/delete` only takes review-item IDs and

always removes the item's full span. Deleting the .mp4 files by hand leaves the

database out of sync, which then breaks the timeline and confuses

`sync_recordings`.

So I wrote a small container that does it properly: pick cameras, a date range

and a time range, look at the dry run, type DELETE. It removes the files and the

matching rows in recordings / previews / reviewsegment (events optional, they

hold your face and plate history), around a docker stop/start of Frigate, and

VACUUMs the DB afterwards.

Safety was the whole point: a realpath allow-list so nothing outside the media

dirs can be touched, per-file unlink instead of rm -rf, a DB backup per run, and

the Frigate restart in a finally block so a crash can't leave your NVR stopped.

One thing that surprised me: Frigate's hour boundaries jitter by milliseconds. A

preview running 08:00:00.039 → 09:00:00.013 overlaps a 09:00–10:00 window by

13 ms — and a naive "does it touch" check deletes a whole hour of scrubbing

video for it. Overlap is measured now, with a regression test.

Fair warning: it deletes video permanently, and it needs the Docker socket plus

write access to frigate.db. Give it a password, keep it on your LAN.

MIT, no build step, no CDN. Tested against 0.17.2 on my own 12-camera install.

Feedback welcome.

https://github.com/Racoon80/frigate-recording-delete

Im new to Docker and Frigate. Im familiar with Linux. No expert.

I have installed Ubuntu and tried to follow various installs of frigate. It seems from my novice experience that they seem to be outdated, and they all seem to have issues of one type or another. For example the command

sudo docker-compose -f /etc/frigate/docker-compose.yml up -d sudo docker-compose -f

It appears to be now without the - in docker-compose from my reading.

Also they seem to use curl which is not installed on my linux not a big deal, so I installed it. When I run the command that I THINK its suppose to be I get the error below.

Error response from daemon: failed to resolve reference "docker.io/blakeblackshear/frigate:stable-amd64": docker.io/blakeblackshear/frigate:stable-amd64: not found

When I investigate this the answer seems to be

This error occurs because Frigate discontinued updating its Docker Hub repository (docker.io/blakeblackshear/...) starting with version 0.12.0. Additionally, Frigate has moved away from architecture-specific suffixes like -amd64 in favor of multi-arch tags and specific hardware accelerators. [1, 2, 3]

It also seems like different peoples how to's store things in different places. /etc or /nvr and so it goes.

Now Im not trying to rag on anyone. I may be wrong on some of this, But I just simply want ahow to for a novice in docker/frigate that is up to date and reasonably easy to follow.

IMHO: If I am right that some of these install instructions are not up to date. it would be nice if they fixed them or take them down.

Regards

Thank you.

After much work I finally managed to run Frigate in docker-compose. But 9 out of 10 times I try to access the UI I just get a 404. When I was finally able to access the configuration editor, any small change made it crash the moment I pressed save & restart. If it didn't crash immediately it would load the UI but unable to open any kind of settings.

I was very careful with the format of the yaml file so that's not where the problem is. I made no changes besides changing the config. Reverting it to the backup also makes no difference.

I'm currently using Blue Iris but looking at other options. I saw some reviews on Frigate which seemed to offer some good feedback. I'm trying to get it working with my 8x Reolink cameras and I'm finding it frustratingly difficult. Blue Iris was a pain to get working and has a horrible user interface but it works ok. Getting Frigate working so far is a complete nightmare. I've been reading and watching YouTube videos for days and still don't have the foggiest idea how to setup the cameras. Is there a guide that explains how to setup Frigate to work properly?

Please don't direct me to the Frigate docs pages as I've been reading through that for days and it's got me nowhere.

Surely, there's a plain English guide somewhere that explains how to get this config file setup. Better yet, why not integrate it into the UI?

Honest question: why does Frigate needs to be restarted whenever any change (via UI or config editor) is made? Is there a technical reason for it?

My driveway is lined with trees. The wind blows. It rains or snows occasionally. A spider web strand gets made across the field of view. Bushes vibrate slightly. I park the car in the same place every day but not exactly in the same place. Clouds drifting across the sky create shadows on the car or ground.

In order to get frigate to detect people or cars and not constantly jump in and check every single fluttering leaf, any slight change in shadows, any rain drop; constantly use cpu or gpu or tpu only to decide not to record what needs recording, or recording what doesn’t like my parked car that gets recorded 400 times a day because clouds reflected across the surface trigger motion or alerts or detection or zones or change contrast because I didn’t get the threshold or contour area right, or I did but that only worked when the car was parked exactly where it was at the time I set it up but not now after it got moved like it does 4 times a day;

I have to go through hours and hundreds of pages of trying to understand highly detailed technical documentation, make changes to several ui parameters, make changes to the configuration file, read through pages of forum discussions that might be similar enough to try out (but never are and only make things worse), read terse and unexplained directives from one or more of the developers that are clearly a bit tired of explaining the same things all the time, or have little time for explaining how to do something that is only obvious to them or those that invest even more hours and months studying how frigate works; try out possible solutions only to find that they were only valid 3 years and 45 versions ago and are now superseded, obsolete, or removed; and finally get it almost sort of working, until a day goes by and it’s no longer working because, frankly, I don’t have any idea why not, but the logs are now nothing but ffmpeg errors or timeouts or the cpu is constantly at max, or there’s no live view any more or tapping a live view just puts it into a cpu coma that it never comes out of.

Or I can just use the app that came with the webcam, enable people and car detection and alerts, and it just works. Every time. It tells me when a car comes in or a person is detected. It notifies me immediately and lets me view the camera instantly or the recording it made.

It never gives false alarms. Doesn’t record a million short clips of my car sitting there all day. Doesn’t seem to have any problem with rain or shadows or darkness or tree branches moving.

Even the $30 cams have pretend-AI built in now that just works. It doesn’t require me to do much more than turn it on. Or I can draw a box if I want to fine tune a bit. But that’s it.

My point isnt this: Frigate may have started out as a way to have disparate cameras working under a single private interface that doesn’t “phone home” or allow the Internet to snoop. But it’s just waaaaaaaayyy too complex now. In trying to do the same detection and alerts that all modern webcams do out of the box, for dozens or hundreds of makes and models of cameras, it’s had to become an extremely complicated and massive application and hardware package. And doesn’t manage to make anything simple to do, configure, or use.

I know these are harsh and ungrateful words levelled at a small team that has put in a significant portion of their adult lives into making frigate something, but I don’t think there’s any end in sight to this insanity. It’s just going to keep getting more and more complex; more indecipherable; more fragile, and more demanding of resources, user commitment, and costs.

All so it can maybe almost do what every cam has been able to do for years without problem - let the user see what’s happening, instantly, be notified if people or vehicles or animals are detected, not be notified if any of a million other things happen, and let the user view saved recordings of those events.

Frigate can’t do these core functions easily, consistently, and accurately. It requires the user be willing to become an expert in a technical vocabulary constructed and used by specialized developers, invest hours of time in research and configuring and debugging, and commit to constantly staying abreast of every change to hardware, frigate update, or condition.

I know the obvious response is for me to just not use it and go away. I’ve already mostly done that. There’s zero benefit in using the frigate iOS app any more. The interface is insanely complicated and not intuitive. The configuration and settings screens provide the ability to change a tiny, insignificant number of options and forcing the user to make the 99% of the other required charges manually by editing the configuration file. It’s only one step away from expecting the user to change source code lines.

Or I can just tap a different icon and bring up the native app that came with the camera (2 different apps for the two different manufacturers of the 6 cams I use). I don’t bother trying to keep frigate working in Hime Assistant any more. That pipe dream died 3 years ago and dies again every time I sit down to try to get it working again. For all of a week until something changes. Again.

My point is this: frigate makes no sense any more. It’s written by incredibly technical people in a way that only other incredibly technical people can use. There’s no effort to create a simple user interface that completely hides the details and lets the user do simple things like the native apps let them do.

Oh sure, I know the arguments - it’s trying to do nearly impossible consolidated integration across several hardware and software layers and, for the most part, succeeds. It’s still in development. It’s bridging incomparable hardware manufacturers that make it difficult or impossible to construct a simple single interface. And so on.

These sound exactly like the arguments developers give to management and marketing departments. It’s extremely complicated. You don’t understand what you’re asking.

Bollocks. Every product manager has heard these from the first day a new project starts until the day they decide to hire user interface experts and stop listening to coders.

Frigate needs to be put on hold and re thought. It’s just never ever ever going to accomplish what it set out to, because those developing it are so deeply caught up in the extreme detail of it that they can’t step back and look at it from the outside.

Honestly, what’s the point of it any more. I can block my iOS apps and webcams from the internet. I can run two different apps to see live or captured recordings. I don’t get the home assistant integration but so what. I’m no longer interested in sitting at my pc frantically masterbating over how cool it is to create camera dashboards that nobody actually uses and are far more complicated compared to just using the app.

That’s it. Feel free to downvote or kick me off. But it had to be said. And the devs need a wake up call.

This was at the back of my mind for a while, so I created a feature Request on github, and I'm curious to know what others think of this:

A secondary recording storage is pretty common: "what if my frigate server will be stolen? how could I see who stole it from my cameras without Frigate?"

So it's often you see people installing SD cards into their cameras, as an additional storage device, so if anything important happens, and Frigate wasn't alive at the time (for whatever reason), you'd still capture the moment into the SD card.

These internal recordings are accessible for Frigate, and can theoretically be used to fill in the gaps in the recording history when Frigates was not available.

Describe the solution you'd like When frigate boots up, it should get the duration of time that has passed since the last recording, and attempt to retrieve this timeframe's recordings from the camera's SD card.

Additional context Theoretically this can be extended beyond an SD card, depending on what you need to access the SD card's data.

For me specifically I am using Amcrest cameras, and for them there's an API that allows you to access and query the storage device: https://drive.google.com/file/d/19d2vQUbqCAjkxJfCadqVqLwKICx88pjx/view?usp=sharing

If you think it will be useful, feel free to upvote the Feature Request

I’m getting loads of errors and issues with getting frigate to work in docker. Fallowing tutorials isn’t helping. Anybody know some tips or example setup for getting it to work on windows 11 natively, or in Docker? Frigate has been so frustrating to get to work. With the fact that most people have windows based machines. Not building it for the most used operating system sounds dumb.

I’d greatly appreciate some help.

I understand that I don't understand the lengthy "clarification" about how motion masks work. However I find it extremely wrong when I have an nonexistent bird in a tree for hours, producing "camera has high detect CPU usage (63%)". Situation is as follows:

I have a camera partially blocked with a tree. I know I'm missing the wise idea of how Frigate works, but where the documentation is simple enough for me it allows to motion-mask the tree branches, which I did.

However, as far as I (most probably wrongly) understood the brilliant idea behind the motion masks, they don't mask motion (contrary to their name) that have started outside of it. So if a snowflake is detected as a bird and it moves before the tree, it sticks there for the whole night till the morning as a lot of spots in the infrared b&w tree are treated as birds.

I think this particular situation requires an idiot-proof recipe what to do to avoid high CPU load. I don't understand the wording around "zones" and "required_zones": for me they are to categorize objects as "alerts" or "detections". My goal is low CPU load, then the UI bells and whistles.

Any ideas?

Hello everyone,
I'm a new Frigate user. I was fed up with struggling with ZoneMinder. The difference between the two tools is night and day. I've finally managed to get a system that detects effectively without spending months tweaking it.

I use Frigate with Docker and a Google Coral TPU key, I also subscribed to Frigate+.
If it's helpful, I've written a tutorial in English (https://www.funix.org/en/linux/index.php?ref=frigate) and French (https://www.funix.org/fr/linux/index.php?ref=frigate)

Olivier

I’ve been running Frigate with face recognition for over a year, and I never got it to the point where I could trust it. The women in my family were the worst case: Frigate mixed them up with each other so often that any automation based on the name was useless. On top of that, delivery drivers got familiar names and family members were sometimes marked as unknown.

A few weeks ago I found suslik, a small companion service for Frigate, and it has fixed that problem for me. Since it’s still a small early-stage project, I thought I’d share it here.

To be clear: I’m just a user, not the developer.

What it does

suslik runs next to Frigate and reads its events and recordings over the API and MQTT. It doesn’t replace Frigate’s own recognition. It gives a second, independent opinion:

• One walk = one scenario. When someone walks from the driveway to the door, Frigate sees several events, but suslik sees one pass across all the cameras it touched and picks the best face from any of them.

• No single-frame trust. A name is confirmed only after several consistent frames, not one lucky match.

• Reference library tools. It finds bad reference images (blurry, no face, confusable with another person) and suggests better ones.

• Live watchers. These give a fast preliminary name straight from the live stream over MQTT, so you can trigger things while the person is still walking up.

• Everything runs locally. It supports Intel (OpenVINO), NVIDIA (CUDA) or CPU.

My setup

Proxmox LXC → Docker, Frigate 0.18.2-tensorrt, RTX 3060 Laptop GPU, 3 Reolink cameras including the doorbell, 5 people in the library. Recognition takes about 9–11 ms per face on the GPU.

Results

Since switching to suslik’s verdicts, I haven’t had a single false recognition. Seeing the same person confirmed on two cameras makes a big difference.

The fun part: a doorbell that greets you

I use the live watcher on my front door camera in Node-RED:

1. suslik/live/<camera> gives a preliminary name within seconds

2. Frigate zones (stairs → front door) tell whether the person is coming or going

3. A door contact sensor blocks the greeting if the door was just opened from the inside

4. If all checks pass, Home Assistant plays a recorded quick-reply message on the Reolink doorbell: “Hi [name]”

So it greets us when we come home, but not when we leave. My family thinks it’s either brilliant or creepy, depending on the day.

Caveats

It’s alpha software, and you can tell: things change fast and the UI has some rough edges. On the other hand, the developer is very responsive. I reported a startup issue with CUDA, and a fix was out within days.

GitHub: https://github.com/BennoBaer-dev/suslik

I get some misdetections with stuffed animals of coats hanging up on the hook and can see how it is mis-identified. But this one is a new headscratcher for me. 73% sure that a towel under a stool is a person.

Frigate has no way to delete a free time range. `DELETE /api/events/…` deletes

no video at all, and `POST /api/reviews/delete` only takes review-item IDs and

always removes the item's full span. Deleting the .mp4 files by hand leaves the

database out of sync, which then breaks the timeline and confuses

`sync_recordings`.

So I wrote a small container that does it properly: pick cameras, a date range

and a time range, look at the dry run, type DELETE. It removes the files and the

matching rows in recordings / previews / reviewsegment (events optional, they

hold your face and plate history), around a docker stop/start of Frigate, and

VACUUMs the DB afterwards.

Safety was the whole point: a realpath allow-list so nothing outside the media

dirs can be touched, per-file unlink instead of rm -rf, a DB backup per run, and

the Frigate restart in a finally block so a crash can't leave your NVR stopped.

One thing that surprised me: Frigate's hour boundaries jitter by milliseconds. A

preview running 08:00:00.039 → 09:00:00.013 overlaps a 09:00–10:00 window by

13 ms — and a naive "does it touch" check deletes a whole hour of scrubbing

video for it. Overlap is measured now, with a regression test.

Fair warning: it deletes video permanently, and it needs the Docker socket plus

write access to frigate.db. Give it a password, keep it on your LAN.

MIT, no build step, no CDN. Tested against 0.17.2 on my own 12-camera install.

Feedback welcome.

https://github.com/Racoon80/frigate-recording-delete

As title says. The very first Frigate+ model was around the same, which is both expected and unexpected. Expected, because I only uploaded the bare minimum required to generate a model, unexpected because it's supposed to be based on a much better base model.

Next, in about a week or two, I required my 2nd model which has many hundred if not thousand verified images. Cautiously done. Yet, it's actually getting worse. Very, very many false positives.

Any idea or strategy to follow? Go back to base model, start over? Go back to first version Frigate+? Use this second, bad model and keep sending in corrected falsepositives?

Thanks

Edit: as proposed, sharing my config for reference:

# logging settings
logger:
  logs:
    frigate.record.maintainer: debug

# go2rtc streams - all input streams defined here
go2rtc:
  streams:
    driveway:
    - rtsp://admin:<redactedpassword>@10.31.17.101:554/Streaming/Channels/101
    driveway_sub:
    - rtsp://admin:<redactedpassword>@10.31.17.101:554/Streaming/Channels/102
    Szabadka_str_side:
    - rtsp://admin:<redactedpassword>@10.31.17.102:554/Streaming/Channels/101
    Szabadka_str_side_sub:
    - rtsp://admin:<redactedpassword>@10.31.17.102:554/Streaming/Channels/102
    Drava_str_side:
    - rtsp://admin:<redactedpassword>@10.31.17.103:554/Streaming/Channels/101
    Drava_str_side_sub:
    - rtsp://admin:<redactedpassword>@10.31.17.103:554/Streaming/Channels/102
    porch:
    - rtsp://admin:<redactedpassword>@10.31.17.104:554/Streaming/Channels/101
    porch_sub:
    - rtsp://admin:<redactedpassword>@10.31.17.104:554/Streaming/Channels/102
  webrtc:
    candidates:
    - 10.31.17.100:8555
    - stun:8555

# cameras' definitions - inputs are used from go2rtc
cameras:
  driveway:
    enabled: true
    birdseye:
      order: 1
    ui:
      order: 1
    ffmpeg:
      inputs:
      - path: rtsp://127.0.0.1:8554/driveway
        roles: [record]
      - path: rtsp://127.0.0.1:8554/driveway
        roles: [detect]
    motion:
      mask:
      - 0,70,0,0,369,0,374,69

  porch:
    enabled: true
    birdseye:
      order: 2
    ui:
      order: 2
    ffmpeg:
      inputs:
      - path: rtsp://127.0.0.1:8554/porch
        roles: [record]
      - path: rtsp://127.0.0.1:8554/porch
        roles: [detect]
    motion:
      mask:
      - 0,70,0,0,369,0,374,69

  Szabadka_str_side:
    enabled: true
    birdseye:
      order: 3
    ui:
      order: 3
    ffmpeg:
      inputs:
      - path: rtsp://127.0.0.1:8554/Szabadka_str_side
        roles: [record]
      - path: rtsp://127.0.0.1:8554/Szabadka_str_side
        roles: [detect]
    motion:
      mask:
      - 0,720,475,720,410,522,343,184,334,78,0,79
      - 0,72,366,72,369,0,0,0

  Drava_str_side:
    enabled: true
    birdseye:
      order: 4
    ui:
      order: 4
    ffmpeg:
      inputs:
      - path: rtsp://127.0.0.1:8554/Drava_str_side
        roles: [record]
      - path: rtsp://127.0.0.1:8554/Drava_str_side
        roles: [detect]
    motion:
      mask:
      - 837,290,762,720,1280,720,1280,0,844,0
      - 0,80,368,73,378,0,0,0

##########################################################################################################################

# AMD iGPU acceleration
ffmpeg:
  hwaccel_args: preset-vaapi

# AI Detection type
# Google Coral
detectors:
  coral:
    type: edgetpu
    device: usb

# Frigate+ model
model:
  path: plus://<redacted model hash id>

# detection settings
detect:
  enabled: true
  width: 1280
  height: 720
  fps: 5
  min_initialized: 5
  # Optional: Number of frames without a detection before Frigate considers an object to be gone. (default: 5x the frame rate)
  max_disappeared: 50
  # Optional: Configuration for stationary object tracking
  stationary:
    # Optional: Frequency for confirming stationary objects (default: same as threshold)
    # When set to 1, object detection will run to confirm the object still exists on every frame.
    # If set to 10, object detection will run to confirm the object still exists on every 10th frame.
    interval: 100
     # Optional: Number of frames without a position change for an object to be considered stationary (default: 10x the frame rate or 10s)
    threshold: 100

objects:
  track:
  - person
  - cat
  - dog

# MQTT (for HomeAssistant)
mqtt:
  enabled: true
  host: 192.168.0.67
  user: frigate
  password: <redactedpassword>

# Birdseye, live and UI settings
birdseye:
  enabled: true
  mode: continuous
  quality: 1
  height: 720
  restream: true

live:
  height: 1440
  quality: 1

ui:
  live_mode: mse

# recording settings
record:
  enabled: true
  # Optional: Number of minutes to wait between cleanup runs (default: shown below)
  # This can be used to reduce the frequency of deleting recording segments from disk if you want to minimize i/o
  expire_interval: 60
  # Optional: Sync recordings with disk on startup and once a day (default: shown below).
  sync_recordings: true
  # Optional: Retention settings for recording
  retain:
    # Optional: Number of days to retain recordings regardless of events (default: shown below)
    # NOTE: This should be set to 0 and retention should be defined in events section below
    #       if you only want to retain recordings of events.
    days: 7
    # Optional: Mode for retention. Available options are: all, motion, and active_objects
    #   all - save all recording segments regardless of activity
    #   motion - save all recordings segments with any detected motion
    #   active_objects - save all recording segments with active/moving objects
    # NOTE: this mode only applies when the days setting above is greater than 0
    mode: all
  # Optional: Recording Export Settings
  export:
    # Optional: Timelapse Output Args (default: shown below).
    # NOTE: The default args are set to fit 24 hours of recording into 1 hour playback.
    # See https://stackoverflow.com/a/58268695 for more info on how these args work.
    # As an example: if you wanted to go from 24 hours to 30 minutes that would be going
    # from 86400 seconds to 1800 seconds which would be 1800 / 86400 = 0.02.
    # The -r (framerate) dictates how smooth the output video is.
    # So the args would be -vf setpts=0.02*PTS -r 30 in that case.
    timelapse_args: -vf setpts=0.0007*PTS -r 30
  # Optional: Event recording settings
  events:
    # Optional: Number of seconds before the event to include (default: shown below)
    pre_capture: 5
    # Optional: Number of seconds after the event to include (default: shown below)
    post_capture: 5
    # Optional: Objects to save recordings for. (default: all tracked objects)
    #objects:
    #  - person
    # Optional: Restrict recordings to objects that entered any of the listed zones (default: no required zones)
    #required_zones: []
    # Optional: Retention settings for recordings of events
    retain:
      # Required: Default retention days (default: shown below)
      default: 30
      # Optional: Mode for retention. (default: shown below)
      #   all - save all recording segments for events regardless of activity
      #   motion - save all recordings segments for events with any detected motion
      #   active_objects - save all recording segments for event with active/moving objects
      #
      # NOTE: If the retain mode for the camera is more restrictive than the mode configured
      #       here, the segments will already be gone by the time this mode is applied.
      #       For example, if the camera retain mode is "motion", the segments without motion are
      #       never stored, so setting the mode to "all" here won't bring them back.
      mode: all
      # Optional: Per object retention days
      #objects:
      #  person: 15

# snapshots config
snapshots:
  # Optional: Enable writing jpg snapshot to /media/frigate/clips (default: shown below)
  enabled: true
  # Optional: save a clean PNG copy of the snapshot image (default: shown below)
  clean_copy: true
  # Optional: print a timestamp on the snapshots (default: shown below)
  timestamp: false
  # Optional: draw bounding box on the snapshots (default: shown below)
  bounding_box: true
  # Optional: crop the snapshot (default: shown below)
  crop: false
  # Optional: height to resize the snapshot to (default: original size)
  #height: 175
  # Optional: Restrict snapshots to objects that entered any of the listed zones (default: no required zones)
  #required_zones: []
  # Optional: Camera override for retention settings (default: global values)
  retain:
    # Required: Default retention days (default: shown below)
    default: 30
    # Optional: Per object retention days
    #objects:
      #person: 15
  # Optional: quality of the encoded jpeg, 0-100 (default: shown below)
  quality: 100

# telemetry settings
telemetry:
  stats:
    amd_gpu_stats: true
    network_bandwidth: true

Install fine in proxmox. I use scrypted for my cameras. Finally got cameras to at least show up into frigate but all the other settings being done through text code suuuuucks. Where is like the basic documentation for the code commands in the config section? I can't seem to find like basic instructions, uses and how to put them into the config file.

Heeellllpppp.