OBS can play either role in SRT Matrix — 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 SRT Matrix — 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.
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 SRT Matrix instance in both directions, with sustained
throughput, not just a completed handshake. Full install/usage details
are on its own wiki page —
the SRT-Matrix-specific settings are summarized here:
12000 + destination-index*10 + slot, but SRT
Matrix'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.14000 (SRT Matrix'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 wiki page for current status.
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.
This uses OBS's built-in Stream output — no plugins needed for SRT or RTMP.
5001).Custom...srt://<gateway-public-ip>:<ingest-port>?passphrase=<the passphrase> to the Server URL instead, or the
connection will be refused.live/site-2).Custom...rtmp://<gateway-public-ip>:<ingest-port>live/<site-id> — e.g. live/site-2. This must
match exactly, or the connection is rejected.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.
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.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.
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 SRT Matrix (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.
SRT Matrix's destinations always dial out to whatever they're feeding — so for OBS to receive anything, OBS has to be the one listening, and SRT Matrix calls in to it.
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.
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). |
mpegts explicitly rather than leaving it
blank/auto — skips container probing and speeds up lock-on when
the stream starts flowing.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 SRT Matrix'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.
| Symptom | Likely cause | Fix |
|---|---|---|
OBS log says Failed to open media: srt://... immediately | Missing mode=listener, or the port's already in use | Confirm mode=listener is in the URL; check nothing else (another scene, another app) is already listening on that port. |
| SRT Matrix's status dot is green, but OBS shows a black screen | Connected, but the FFmpeg demuxer stalled | Set Input Format to mpegts explicitly, and confirm timeout=5000000 is in the URL so FFmpeg resets its input pipeline instead of hanging. |
| Video stutters or drops frames, only in OBS | OS-level UDP receive buffer overflowing | Add rcvbuf=67108864 to the URL; on Windows, running OBS as Administrator also helps by giving it higher thread priority for network demuxing. |
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 SRT Matrix. 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).
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:
mode=listener in the Stream tab's Server field; OBS will fail
to apply the setting or fail to connect.The workaround is OBS's Custom FFmpeg Output, normally used for local recording, repurposed to stream to a network URL instead of a file:
Custom Output (FFmpeg).Output to URL.srt://0.0.0.0:14000?mode=listener&latency=200000
14000 is the default, shared across every SRT destination unless
program_out_port_override is set; see
Ports and Troubleshooting).mpegts.x264 or a hardware encoder like NVENC)
and bitrate as you would for any other OBS output.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 SRT Matrix'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.
| Role | Method | Key setting |
|---|---|---|
| OBS pushes a source in | OBS SRT Toolkit — SRT Output, Caller | Host/Port = the source's Ingest address/port |
| OBS receives a routed slot | OBS SRT Toolkit — SRT Source, Listener | Port = the slot port shown on the destination's card |
| OBS sends its Program/Live output back | OBS SRT Toolkit — SRT Output, Listener | Port 14000 (default, no changes needed) |
| OBS pushes a source in (SRT, no plugin) | Settings → Stream → Custom | Server = srt://<gateway-ip>:<port>, no stream key by default |
| OBS pushes a source in (RTMP, no plugin) | Settings → Stream → Custom | Stream Key = live/<site-id> exactly |
| OBS receives its own return feed (as a source, no plugin) | Sources → Media Source (caller) | Input = srt://<gateway-ip>:5000?streamid=return_site_<index>, no mode=listener |
| OBS receives a routed slot (as a destination, no plugin) | Sources → Media Source (listener) | Uncheck Local File; Input = srt://0.0.0.0:<port>?mode=listener&timeout=5000000&latency=200000&rcvbuf=67108864&pkt_size=1316; Input Format = mpegts |
| OBS sends its Program/Live output back (no plugin) | Settings → Output → Recording → Custom Output (FFmpeg) | URL = srt://0.0.0.0:<port>?mode=listener&latency=200000; start via Start Recording, not Start Streaming; doesn't auto-reconnect |
| Source/destination has a passphrase set | Add ?passphrase=<value> to the SRT URL | Check the card's SRT settings/Edit ports panel first |