You can run the Omada 8MP Bullet and Turret in Frigate and Home Assistant without the Omada Guard app, and both cameras speak plain RTSP and ONVIF. The defaults still trip Frigate in three places. The main stream ships as H.265+, which sends a keyframe only every 12 seconds. The Intel VAAPI decode path crashed the detect process about every 30 seconds on our iGPU. And while the Fusion Pro records the main stream, it takes only two more clients and answers the next one with “429 Stream Up To Limit”.
This guide covers the stream URLs and ONVIF port, the camera settings worth changing, a tested Frigate config with OpenVINO detection on an Intel iGPU, and the Home Assistant ONVIF integration. Omada sent both cameras and the Fusion Pro 2.5G PoE gateway they record to for review without payment. We ran all of this in November 2026 on a Rocky Linux 10 box with Frigate 0.18.2 and camera firmware 1.0.7, and it held steady once the three fixes below were in.
What you need before you start
The cameras do not need a cloud account or the Guard app for any of this. What they need is a device account, which the Fusion Pro (or an Omada NVR) sets when it adopts them, because RTSP and ONVIF both log in with it. If you adopted the cameras in the Fusion Pro web wizard, the account is the one you typed on the Set Device Account page. Our Fusion Pro review covers that wizard and the app failure that pushed us to it.
Ours ran on a Rocky Linux 10 box with a Core i7-6700T, which is about as old as an Intel chip gets for this. You need:
- Omada 8MP Bullet or Turret, adopted on a Fusion Pro
- A Docker host on the camera LAN
- An Intel iGPU, 6th gen or newer, or spare CPU
- Port 554 open to each camera, plus 2020 or 80
- Home Assistant, only for the optional last step
If you are buying, the Bullet is on the Omada store and Amazon, and the Turret is on the Omada store (out of stock on Amazon when we checked). Our full Frigate install guide covers MQTT, TLS and zones, which we skip here to stay on what is specific to these cameras.
Step 1: Find the RTSP and ONVIF details
Both cameras serve RTSP on port 554 and answer ONVIF on two ports, 2020 and 80. We read the stream paths from the cameras themselves over ONVIF (GetStreamUri), so these are the paths the firmware hands out, not guesses from a template for another brand:
| Item | Value on firmware 1.0.7 | Notes |
|---|---|---|
| Main stream | rtsp://user:pass@CAMERA:554/stream1 | 3840×2160, 25 fps, G.711 A-law audio at 16 kHz |
| Sub stream | rtsp://user:pass@CAMERA:554/stream2 | 848×480, 25 fps, same audio |
| JPEG profile | rtsp://user:pass@CAMERA:554/stream6 | 640×360, third ONVIF profile |
| ONVIF service | http://CAMERA:2020/onvif/service or port 80 | WS-Security digest login, no PTZ |
| Snapshot URL | none | GetSnapshotUri returns “NVT does not support the function” |
Set the camera address and your device account once, so the probe commands below run as written for you. Change the IP to the camera you are testing; ours are on the default Fusion Pro LAN, 192.168.188.0/24:
export CAM_IP="192.168.188.111"
export CAM_USER="admin"
export CAM_PASS="YourDeviceAccountPassword"
You do not need ffmpeg on the host to check a stream, because the Frigate image already carries ffprobe. This pulls the same image we run in Step 4 and asks the main stream what it is sending:
docker run --rm --entrypoint /usr/lib/ffmpeg/8.0/bin/ffprobe ghcr.io/blakeblackshear/frigate:0.18.2 -v error -rtsp_transport tcp -show_entries stream=codec_type,codec_name,profile,width,height,r_frame_rate,sample_rate -of compact "rtsp://${CAM_USER}:${CAM_PASS}@${CAM_IP}:554/stream1"
Our Turret answered with HEVC video and A-law audio, which is the factory default on both models:
stream|codec_name=hevc|profile=Main|codec_type=video|width=3840|height=2160|r_frame_rate=25/1
stream|codec_name=pcm_alaw|profile=unknown|codec_type=audio|sample_rate=16000|r_frame_rate=0/0
Keep that codec line in mind, because ONVIF does not tell you the truth about it. The cameras label both ONVIF video profiles as H264 even while they stream HEVC, so any tool that picks a decoder from the ONVIF profile instead of the stream itself picks the wrong one. If you get a 401 here, your device account is wrong. If you get a timeout, port 554 is blocked between your host and the camera.
Step 2: Switch the main stream off H.265+
H.265+ is the Omada smart codec mode, and it saves bitrate by stretching the gap between keyframes. Frigate cuts recordings and starts live views at keyframes, so a 12-second gap means clips that start up to 12 seconds early and a live view that sits black until the next one arrives. Plain H.265 or H.264 brings the gap down to 2 seconds. This probe prints only the keyframes in the first 30 seconds of the main stream:
docker run --rm --entrypoint /usr/lib/ffmpeg/8.0/bin/ffprobe ghcr.io/blakeblackshear/frigate:0.18.2 -v error -rtsp_transport tcp -select_streams v:0 -show_entries packet=pts_time,flags -of csv=p=0 -read_intervals %+30 "rtsp://${CAM_USER}:${CAM_PASS}@${CAM_IP}:554/stream1" | grep K
On the default H.265+ setting, the Turret produced three keyframes in 30 seconds, 12 seconds apart:
N/A,K__
12.000000,K__
24.160000,K__
Where do you change it? On the Fusion Pro, not on the camera. Open the gateway web UI, then Devices, click the camera, press Settings and go to Camera > Stream:

- 1Stream
- 2Main Stream
- 3Video Encoding
- 4Apply
- Open Stream under Camera.
- Leave Main Stream selected.
- Change Video Encoding from H265+ to H265 (or H264, see below).
- Press Apply. The camera restarts its streams with the new codec.
If Frigate is already running, restart it after a codec change with docker compose restart frigate. We flipped the Turret between H.265+ and H.265 with Frigate up, and each time its recorder wrote nothing valid for two minutes. Then the watchdog logged “No new valid recording segments were created for omada_turret in the last 120s” and restarted ffmpeg on its own.
The sub stream only offers H264 and H265, so there is no smart mode to switch off there, and it already sends a keyframe every 2 seconds. The same probe after the change shows the main stream doing the same:
N/A,K__
2.000000,K__
4.000000,K__
6.000000,K__
8.040000,K__
10.040000,K__
12.040000,K__
14.040000,K__
16.080000,K__
18.080000,K__
20.080000,K__
22.120000,K__
24.120000,K__
26.120000,K__
28.120000,K__
Should you pick H.265 or H.264? It is a storage versus compatibility call. We put the Turret on H.265 and the Bullet on H.264 to run both through Frigate, and both worked with the presets in Step 4. H.264 costs more disk: at night the Bullet wrote 294 MB of main stream in 10 minutes against 144 MB from the Turret, though the two cameras were pointed at different scenes, so read that as a rough ratio. What H.264 buys is browser compatibility: the Frigate live view docs recommend H.264 because not every browser plays HEVC. Leave SRTP under Advance Settings off; the help text on that page warns that with it on, you may be unable to play the video in third-party clients.
Whichever codec you pick, set it on Sub stream too, so both streams of a camera match. Frigate only decodes the sub stream (for detection) and copies the main stream to disk untouched, and the H.264 QuickSync preset in Step 4 forces the H.264 decoder, so the preset has to match the sub stream’s codec. We switched both of the Bullet’s streams to H.264 and left both of the Turret’s on H.265. Run the Step 1 probe against stream2 to confirm what your sub stream is sending. The stream page has no keyframe interval setting, so 2 seconds is as short as these cameras go.
Step 3: Create the Frigate project and credentials
Frigate replaces {FRIGATE_RTSP_USER} and {FRIGATE_RTSP_PASSWORD} in its config with environment variables of the same name, so the camera password stays in a .env file instead of the YAML. Create the project directory with its two data folders:
mkdir -p ~/frigate/config ~/frigate/storage
cd ~/frigate
Write the device account into .env from the variables set in Step 1, and keep the file readable by your user only:
printf 'FRIGATE_RTSP_USER=%s\nFRIGATE_RTSP_PASSWORD=%s\n' "${CAM_USER}" "${CAM_PASS}" > .env
chmod 600 .env
Keep $, #, spaces and quotes out of the device password, because Compose reads $ as a variable and # as the start of a comment in .env files. If the password holds URL characters such as / or ?, run the Step 1 probe with it before you rely on it, because it also sits inside every RTSP URL. One device account covers both cameras when the Fusion Pro adopted them together, which is how ours were set up. If yours differ, add a second pair of variables and use them in the URLs of the second camera.
Step 4: Write the Frigate config
The config below is the exact file our lab ran. These are the choices in it, and the first and fourth came from things that broke, which the last section of this guide walks through:
- go2rtc holds the one connection to each camera stream
- Detection on the 848×480 sub stream at 5 fps
- Recording copies the 4K main stream untouched
- QuickSync decode presets instead of VAAPI
- Recorded audio converted to AAC, the Frigate default
Open the config file:
vim ~/frigate/config/config.yml
Paste the following, and change the two camera IPs to yours. If both of your cameras use H.265 sub streams, change the global preset to preset-intel-qsv-h265 and drop the Turret’s own hwaccel_args line. If both are H.264, just drop the Turret’s line:
mqtt:
enabled: false
detectors:
ov:
type: openvino
device: GPU
model:
width: 300
height: 300
input_tensor: nhwc
input_pixel_format: bgr
path: /openvino-model/ssdlite_mobilenet_v2.xml
labelmap_path: /openvino-model/coco_91cl_bkgr.txt
ffmpeg:
hwaccel_args: preset-intel-qsv-h264
go2rtc:
streams:
omada_bullet:
- rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.188.101:554/stream1
omada_bullet_sub:
- rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.188.101:554/stream2
omada_turret:
- rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.188.111:554/stream1
omada_turret_sub:
- rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@192.168.188.111:554/stream2
record:
enabled: true
continuous:
days: 1
alerts:
retain:
days: 14
detections:
retain:
days: 14
objects:
track:
- person
- car
- dog
- cat
cameras:
omada_bullet:
ffmpeg:
output_args:
record: preset-record-generic-audio-aac
inputs:
- path: rtsp://127.0.0.1:8554/omada_bullet
input_args: preset-rtsp-restream
roles:
- record
- path: rtsp://127.0.0.1:8554/omada_bullet_sub
input_args: preset-rtsp-restream
roles:
- detect
detect:
width: 848
height: 480
fps: 5
live:
streams:
Main: omada_bullet
Sub: omada_bullet_sub
omada_turret:
ffmpeg:
hwaccel_args: preset-intel-qsv-h265
output_args:
record: preset-record-generic-audio-aac
inputs:
- path: rtsp://127.0.0.1:8554/omada_turret
input_args: preset-rtsp-restream
roles:
- record
- path: rtsp://127.0.0.1:8554/omada_turret_sub
input_args: preset-rtsp-restream
roles:
- detect
detect:
width: 848
height: 480
fps: 5
live:
streams:
Main: omada_turret
Sub: omada_turret_sub
The detector is the OpenVINO SSDLite model that ships inside the image, so there is nothing to download or convert, and on a 6th-gen iGPU it ran each frame in 10 ms. Frigate’s hardware table lists QuickSync as unsupported on 6th and 7th gen chips and points them at VAAPI, yet QuickSync was the preset that held on our 6th-gen i7 while VAAPI crashed, so try it first and fall back to preset-vaapi only if ffmpeg will not start. On a box without an Intel iGPU, remove the devices entry from the compose file, delete both hwaccel_args lines so Frigate auto-detects what it can, and change the detector’s device to CPU, which the Frigate docs prefer over their plain CPU detector. Our detector comparison covers what to add once two cameras turn into eight. Frigate appends a version: line to this file on its first start; leave it there.
Step 5: Start Frigate with Docker Compose
The compose file passes the iGPU render node into the container and gives Frigate a 1 GB tmpfs for recording segments before they land on disk. The image tag is pinned on purpose, because Frigate minor releases migrate the config and the database, and you want to read the Frigate release notes before that happens. Open the compose file:
vim ~/frigate/compose.yaml
Add the service definition:
services:
frigate:
image: ghcr.io/blakeblackshear/frigate:0.18.2 # https://github.com/blakeblackshear/frigate/releases
restart: unless-stopped
shm_size: "256mb"
devices:
- /dev/dri/renderD128:/dev/dri/renderD128
volumes:
- /etc/localtime:/etc/localtime:ro
- ./config:/config
- ./storage:/media/frigate
- type: tmpfs
target: /tmp/cache
tmpfs:
size: 1000000000
ports:
- "8971:8971"
- "8554:8554"
- "8555:8555/tcp"
- "8555:8555/udp"
env_file: .env
Port 8971 is the web UI with login, 8554 is the RTSP restream Home Assistant and other players can use, and 8555 carries WebRTC live view. Start the stack:
docker compose up -d
The first start creates an admin user and prints its password once in the log, so grab it before it scrolls away with docker compose logs frigate | grep -A2 "User: admin". Then confirm the detector loaded on the GPU and both cameras started:
docker compose logs --no-log-prefix frigate | grep -E "OpenVINO model|processor started"
A healthy start names the OpenVINO model on device GPU and a camera processor per camera:
2026-11-12 01:37:47.893434330 [2026-11-12 01:37:47] frigate.detectors.plugins.openvino INFO : Loading OpenVINO model /openvino-model/ssdlite_mobilenet_v2.xml on device GPU
2026-11-12 01:37:47.959180525 [2026-11-12 01:37:47] frigate.audio_manager INFO : Audio processor started (pid: 738)
2026-11-12 01:37:47.972332988 [2026-11-12 01:37:47] frigate.camera.maintainer INFO : Camera processor started for omada_bullet: 756
2026-11-12 01:37:48.049335762 [2026-11-12 01:37:48] frigate.camera.maintainer INFO : Camera processor started for omada_turret: 916
Open https://10.0.1.50:8971 (the address of your Docker host), accept the self-signed certificate and log in. Both cameras should show on the Live page within a few seconds:

Our cameras were still on the bench at this point, the Bullet facing a desk and the Turret the ceiling, which is why the live tiles show furniture instead of a driveway.
Step 6: Check decode, detection and disk use
Settings > System metrics in Frigate is where a bad hardware preset shows up first, so check it before trusting the setup. The detector card should show a steady inference time and the GPU decoder card should show the iGPU doing the decode work instead of the CPU:

The Cameras tab breaks the load down per camera. A steady 5 fps per camera with nothing skipped means detection keeps up; a camera fps that keeps dropping to zero means its ffmpeg process is crashing and restarting, which is what VAAPI did to us:

These are the numbers our two cameras settled at over 10 minutes of the final config (the screenshots above were taken a few minutes later, after a restart and while we briefly toggled the Turret’s main stream codec), with the Fusion Pro still recording both cameras at the same time:
| Measure | Omada 8MP Bullet (H.264) | Omada 8MP Turret (H.265) |
|---|---|---|
| Detect fps | 5.1 | 5.0 |
| ffmpeg CPU (one core = 100%) | 1.5% | 1.6% |
| iGPU decoder per stream | 0.62% | 0.54% |
| OpenVINO inference (shared) | 10 ms per frame | |
| Main stream written, 10 min at night | 294 MB | 144 MB |
| ffmpeg crashes in 10 min | 0 | 0 |
The CPU column is the point of the iGPU presets. Two 4K cameras cost you about 3% of one core for decode, which leaves an old 35 W mini PC plenty of room, and the iGPU barely notices them. The disk column is night footage of quiet scenes, so plan on more in daylight with movement; continuous recording at those rates fills roughly 1.8 GB an hour for the Bullet and 0.9 GB for the Turret. H.265 recordings also need a browser that plays HEVC: the Frigate docs list Chrome 108 or newer, Edge and Safari, and Safari also needs apple_compatibility: true under the camera’s ffmpeg section. If you are building a box around this, our Frigate NVR appliance build sizes the drive and the detector together.
Step 7: Add the cameras to Home Assistant over ONVIF
The built-in ONVIF integration in Home Assistant adds each camera with its controls. We added the Bullet on port 2020 and the Turret on the default port 80, and both came up with the same entities. In Home Assistant, go to Settings > Devices & services, add the ONVIF integration, untick Search automatically and press Submit to get the manual form:

- 1Host
- 2Port
- 3Username
- 4Password
- 5Submit
- Enter the camera IP in Host.
- Set Port to 2020, or keep the default 80.
- Put the device account in Username.
- Put its password in Password.
- Press Submit.
You get each camera as a device with six entities: a camera for the main stream, a camera for the sub stream, an IR lamp switch, an autofocus switch and buttons for reboot and setting the clock. The sub stream camera is disabled by default. Enable it (open the entity, then its settings, then the Enabled toggle) and use it for dashboards, because the main stream is the one that runs out of client slots:

Before you build automations on these entities, know what the cameras give Home Assistant and what they do not:
- No ONVIF snapshot URL, so stills come from ffmpeg
- Motion as ONVIF events, read over PullPoint
- Event topics for cell motion, line crossing, tamper and smart events
We pulled those event topics from the cameras ourselves, and the ONVIF event parser that Home Assistant ships has handlers for the motion, line crossing and tamper topics. Our Home Assistant test box reached the cameras through a TCP-only relay, so we could confirm the integration, the entities and the event topics but not the live view or the motion sensors end to end. If you already run Frigate, its restream at rtsp://10.0.1.50:8554/omada_bullet_sub is the lighter source for Home Assistant cameras, since it costs the camera no extra connection; our Home Assistant in Docker guide covers the install side.
What broke on the way
Every error below came from this lab, in the order we hit it. The first one cost the most time because it looks like a driver problem and is not one.
“Failed to sync surface” and “hwdownload: Failed to download frame: -5”
With preset-vaapi, the recommended preset for older Intel chips in the Frigate hardware acceleration docs, the detect processes of both cameras died about every 30 seconds with this in the log:
ffmpeg.omada_bullet.detect ERROR : [AVHWFramesContext @ 0x7fdde4080140] Failed to sync surface 0: 1 (operation failed).
ffmpeg.omada_bullet.detect ERROR : [hwdownload @ 0x7fddf4001f00] Failed to download frame: -5.
ffmpeg.omada_bullet.detect ERROR : [vf#0:0 @ 0x5631606f7e00] Error while filtering: Input/output error
watchdog.omada_bullet ERROR : Ffmpeg process crashed unexpectedly for omada_bullet.
We logged 16 crashes in the first 6 minutes. It is not the codec: the Bullet crashed the same way after we switched it to H.264. It is not the Frigate release either, because a bare ffmpeg VAAPI decode of the same sub stream died at about 150 frames in both the current image and an older one with a different Intel media driver. The same host decodes other cameras over VAAPI without trouble, so the fault sits between these streams and VAAPI on a 6th-gen iGPU. The QuickSync presets on the same GPU ran with zero crashes, which is why the config uses preset-intel-qsv-h264 and preset-intel-qsv-h265. If you are on newer Intel graphics and VAAPI holds for you, either preset family is fine.
“method PLAY failed: 429 (Stream Up To Limit)”
Home Assistant’s go2rtc log showed the Bullet’s main stream closing the moment it connected while Frigate was running, so we tested the limit directly. With the Fusion Pro recording the Bullet and Frigate stopped, we opened six RTSP clients on each stream: the main stream accepted two and refused the third, while the sub stream took all six:
[in#0 @ 0x561e0e143fc0] method PLAY failed: 429 (Stream Up To Limit)
[in#0 @ 0x561e0e143cc0] Error opening input: Server returned 429 Too Many Requests
So with the Fusion Pro and Frigate attached, you have one main stream slot left for everything else on your network. That is the reason the config routes Frigate through go2rtc and why Home Assistant should use the sub stream or the Frigate restream.
“Could not find ref with POC 48”
These lines appear at the start of every HEVC connection, followed by “Error constructing the frame RPS”. They mean ffmpeg joined the stream between keyframes and threw away the frames it could not decode yet. They are harmless on their own and stop once the first keyframe arrives, which takes up to 12 seconds on H.265+ and 2 seconds after the change in Step 2.
If you are choosing cameras for Frigate rather than wiring up ones you own, these two are workable once the three changes are made, and our Frigate camera buyer’s guide covers brands that need fewer of them. The NVR comparison is the place to start if you are still deciding whether the recorder built into the Fusion Pro is enough.