OBS Setup Guide

OBS can play either role in OmniBridge — pushing a feed in as a source, or acting as a destination (receiving a routed feed into a scene, and/or sending OBS's own Program/Live output back out to the gateway).

Recommended: install OBS SRT Toolkit, a free, open-source OBS plugin built and tested specifically against OmniBridge — it covers every direction below with a proper Start/Stop dock and a real Source type, no URL-crafting or repurposed Recording tab involved. The manual, no-plugin methods further down (Direction 1, 2, 3) still work and remain fully documented, for anyone who can't install a plugin (e.g. a machine they don't control) or just prefers OBS's built-in features.

Menu wording can shift slightly between OBS versions — the settings and values below are what matters; if a label has moved, look for the nearest equivalent.

Recommended: OBS SRT Toolkit

OBS SRT Toolkit is a native OBS Studio plugin — Windows .msi or Linux .tar.gz from its GitLab Releases — that adds a real SRT Output (its own dock, Docks → "SRT Toolkit", independent of Start Streaming/Start Recording) and a real SRT Source (Sources → + → SRT Source). It's been verified end-to-end against a real OmniBridge instance in both directions, with sustained throughput, not just a completed handshake. Full install/usage details are on its own docs page — the OmniBridge-specific settings are summarized here:

• OBS as a source (pushing a feed in) — add an SRT Output in the dock, Mode Caller, Host/Port = the OmniBridge source's Ingest address/port shown on its card.
• OBS as a destination, receiving a routed slot — add an SRT Source, Mode Listener, Port = the slot port shown on the destination's card (12000 + destination-index*10 + slot, but OmniBridge's own UI shows the real number — use that). No URL-crafting, no rcvbuf/timeout/pkt_size tuning required — the toolkit hands off to OBS's own FFmpeg-backed decoder either way.
• OBS as a destination, sending Program/Live output back — add an SRT Output, Mode Listener, Port 14000 (OmniBridge's fixed default program-out port — the toolkit's own default needs no changes for this pairing). Unlike the Custom-FFmpeg-Output workaround below, this reconnects on its own if the connection drops.

One shared limitation to know about: the SRT Output currently reuses whichever encoder OBS's own Streaming or Recording output already has configured, rather than creating a dedicated one — Stream or Record needs to have been started at least once first to bring that encoder up (it doesn't need to keep running once the toolkit's Output is started). A version with its own dedicated encoder is a planned follow-up — see the toolkit's own docs page for current status.

Manual setup without the plugin

Everything below uses only OBS's own built-in features — no plugin install required. Each direction uses a different native OBS feature (Stream output, a Media Source, or a Custom FFmpeg Output), so they're covered separately.

Direction 1: OBS pushes a feed IN (OBS = a source)

This uses OBS's built-in Stream output — no plugins needed for SRT or RTMP.

Push via SRT (recommended default)

1. In OmniBridge, add a source with type "OBS / vMix / generic encoder (SRT push)". Note the Ingest port shown on its card (e.g. 5001).
2. In OBS: Settings → Stream
3. Service: Custom...
4. Server: srt://<gateway-public-ip>:<ingest-port>
5. Stream Key: leave blank — OmniBridge's source ingest doesn't check a stream ID by default. If the source's card has a passphrase set under SRT settings, add ?passphrase=<the passphrase> to the Server URL instead, or the connection will be refused.
6. Use Authentication: leave unchecked.
7. Click Apply, close Settings, then Start Streaming as normal.
8. Back in OmniBridge, the source's status dot should go yellow within a second or two (connected, not yet routed), and its traffic stat should start counting bytes — drag it onto a destination slot to go green. Check the Diagnostics tab for the same connection as a grouped row with real reconnect/error history if anything looks off.

Push via RTMP

1. Add a source with type "OBS / generic encoder (RTMP push)". Note the stream key/path shown right on its card (e.g. live/site-2).
2. In OBS: Settings → Stream
3. Service: Custom...
4. Server: rtmp://<gateway-public-ip>:<ingest-port>
5. Stream Key: live/<site-id> — e.g. live/site-2. This must match exactly, or the connection is rejected.
6. Start Streaming.

Receiving your own return feed (still as a source)

If a destination sends its program-out back to this source as a return/preview feed (see Home's "Routing, both directions"), OBS receives it as a Media Source — but as a caller, not a listener, since sources always dial out to the gateway, even to pull their own return feed. This is the opposite direction from Direction 2 below, which is why it's covered here instead.

1. Sources → + → Media Source, uncheck Local File.
2. Input: srt://<gateway-public-ip>:5000?streamid=return_site_<index> — port 5000 is fixed and shared across every source's return feed; <index> is this source's own index (shown on its card, or computed as return_site_1, return_site_2, etc. in the order sources were added). No mode=listener here — omitting it is correct, since OBS is the caller in this direction.
3. Input Format: mpegts, same reasoning as Direction 2 below.

If nothing shows up: double-check the streamid matches this exact source's index — a return feed only exists once something is actually routed to send it (see "Routing, both directions" on Home), and the gateway rejects a streamid that doesn't match a real source.

Direction 2: OBS receives a routed feed into a scene (OBS = a destination's slot)

This is how a routed source's video shows up inside an OBS scene — using a Media Source, not the Stream tab (Stream is output-only, see Direction 1).

This is receive-only. A Media Source can put video into an OBS scene; it cannot send OBS's own Program/Live mix back out anywhere. If what you actually want is for OBS's own program output to go back to OmniBridge (e.g. so a field source can see OBS's live mix as a return feed), that's a different OBS feature entirely — see Direction 3 below.

OmniBridge's destinations always dial out to whatever they're feeding — so for OBS to receive anything, OBS has to be the one listening, and OmniBridge calls in to it.

Setting up an SRT Media Source (receiving a routed slot)

OBS's Media Source uses FFmpeg's libsrt under the hood — since OBS is the one holding a port open and waiting (the gateway always dials out to destinations, never the reverse), the URL's query-string options control that listening socket's timeout and buffer behavior. The defaults FFmpeg picks aren't very forgiving of a relay dropping and reconnecting mid-show, which is the likely cause behind Media Source being less reliable than a raw SRT connection (see Future Plan) — the settings below are the fix.

1. In OmniBridge, add a destination with type "vMix / OBS (SRT, 3 slots + program-out)", with Host set to this OBS machine's own LAN IP address.
2. Note the slot port for whichever routed source you want OBS to receive. The gateway's own default SRT latency is 120ms unless overridden per source/destination.
3. In OBS, in the scene where you want to receive this feed: Sources → + → Media Source. Give it a name (e.g. "Slot 1 In"), click OK.
4. In the Media Source properties dialog:
5. Uncheck "Local File" — this is the key step; without this, OBS expects a file path instead of a network URL.
6. Input: use the full listener URL, not just the bare mode=listener form — e.g. for a slot port: srt://0.0.0.0:<port>?mode=listener&timeout=5000000&latency=200000&rcvbuf=67108864&pkt_size=1316 | Parameter | Value | Why | |---|---|---| | mode=listener | — | Mandatory — binds and waits for the gateway to dial in, instead of trying to dial out itself. | | 0.0.0.0 | — | Binds to all local interfaces so the gateway can reach it over LAN/VPN either way. | | timeout | 5000000 (5s, in µs) | Fixes the classic "Media Source freezes on disconnect" symptom — resets the socket after 5s of silence so it can re-listen cleanly when the relay reconnects. | | latency | 200000 (200ms, in µs) | Receive-side buffer latency; SRT negotiates the higher of the two ends' values, giving enough ARQ retransmission window for a lossy LAN/WAN hop. | | rcvbuf | 67108864 (64MB) | Expands the OS-level UDP receive buffer — the OS default is often ~256KB, too small to absorb bitrate burst spikes without dropping packets. | | pkt_size | 1316 | Standard MPEG-TS payload alignment (7×188-byte packets). |
7. Input Format: type mpegts explicitly rather than leaving it blank/auto — skips container probing and speeds up lock-on when the stream starts flowing.
8. Close file when inactive: check this. If you switch away from the scene holding this source and back, this releases and re-binds the listener socket cleanly instead of leaving it in a stuck state.
9. Restart playback when source becomes active: check this too — re-initializes the FFmpeg demuxer as soon as video resumes.
10. Click OK. The source will show black/nothing until OmniBridge actually has something routed to that slot and dials in — this is normal; it's not a broken source, it's just idle. Once it connects, that slot's traffic stat in OmniBridge should start counting bytes — if the status dot is green but the traffic stat stays at 0 B, OBS isn't actually receiving anything yet even though the socket is open. Check Diagnostics for that slot's Last Error if it never connects at all.

Common mistake: leaving "Local File" checked, or typing a plain srt://gateway-ip:port without ?mode=listener and without the leading 0.0.0.0 — both cause OBS to try to connect out instead of listen, which will never work here, since OmniBridge's destinations are never callers.

Passphrase-protected destinations: if the destination's card has a passphrase set (via Edit ports), append it to the listener URL — &passphrase=<the passphrase>&pbkeylen=16 (or 32 for AES-256), e.g.:

srt://0.0.0.0:<port>?mode=listener&passphrase=MySecretPassphrase123&pbkeylen=16

SRT requires passphrases to be 10-79 characters — shorter than that and libsrt refuses to bind the listener socket at all, which looks like a connection failure with no useful error in OBS's own log.

Troubleshooting a Media Source

Receiving a single-feed destination (RTMP/RIST) instead

If the destination is UDP-TS, RTMP, or RIST (a single-feed destination, not the 3-slot vMix shape), OBS's role is the same idea — it just needs to be configured as whatever that protocol's listening endpoint is expected to be, matching the destination's port shown in OmniBridge. For RTMP, that means running OBS's own stream ingest (not something OBS ships out of the box — this direction is more commonly a dedicated RTMP server or a hardware decoder, covered in Adding Sources and Destinations).

Direction 3: OBS sends its own Program/Live output back to OmniBridge

This is for when OBS's own program mix needs to be the thing SRT Matrix pulls as a destination's program-out — e.g. so a field source can see OBS's live output as a return feed. This is not the same as Direction 2 above (receiving into a scene) and it's not possible via the Stream tab either — the gateway always dials out to a destination's program-out port and pulls from it (confirmed in the gateway's own relay code), so OBS has to actively serve its output through a listening socket. Neither OBS feature can do that on its own:

• Settings → Stream can only act as an SRT caller — you cannot put mode=listener in the Stream tab's Server field; OBS will fail to apply the setting or fail to connect.
• A Media Source (Direction 2) is receive-only — it puts video into a scene, it can't serve OBS's own output back out.

The workaround is OBS's Custom FFmpeg Output, normally used for local recording, repurposed to stream to a network URL instead of a file:

1. Settings → Output → set Output Mode to Advanced.
2. Go to the Recording tab.
3. Type: Custom Output (FFmpeg).
4. FFmpeg Output Type: Output to URL.
5. File Path or URL: srt://0.0.0.0:14000?mode=listener&latency=200000 (or whatever port this destination's program-out actually uses — 14000 is the default, shared across every SRT destination unless program_out_port_override is set; see Ports and Troubleshooting).
6. Container Format: mpegts.
7. Set a Video Encoder (x264 or a hardware encoder like NVENC) and bitrate as you would for any other OBS output.
8. Click Apply, close Settings.
9. To actually start serving the feed: click Start Recording on OBS's main window — not Start Streaming, which is a different output entirely and won't use this configuration.

This is not auto-reconnecting. Unlike Direction 2's Media Source (which has "Restart playback when source becomes active"), a Custom FFmpeg recording output doesn't retry on its own if the socket drops — if OmniBridge's connection to this destination's program-out goes red mid-show, someone has to click Start Recording again in OBS to re-open the listener. OBS SRT Toolkit's SRT Output reconnects on its own and doesn't require repurposing the Recording tab — use it instead if you can install a plugin on this machine.

Quick reference