Receive an SRTLA stream with srtla_rec (Docker) in OBS Studio

SRTLA is BELABOX's link-bonding protocol: SRT2GO splits one SRT stream across several network connections at once (Wi-Fi + mobile data), so when one link stutters the others carry the stream. Services like Belabox Cloud receive SRTLA for you — but you can also self-host the receiver on your own PC or server with srtla_rec, BELABOX's open-source receiver, and feed the rebuilt stream straight into OBS. No subscription, no third party in the middle.

SRT2GO (phone) ══ bonded SRTLA links (UDP) ══▶ srtla_rec (Docker) ── plain SRT ──▶ OBS Media Source (listener) Wi-Fi + mobile data :5000/udp :4001/udp

srtla_rec listens on one UDP port, accepts all the phone's bonded links, reassembles them into a single ordinary SRT stream, and relays it to an SRT listener — which can simply be an OBS Media Source. OBS never knows bonding was involved.

Know what you're signing up for: BELABOX marks srtla_rec as unsupported and not suitable for production — their supported receiver is the paid Belabox Cloud (we have a guide for that too). Self-hosting works well for personal streams, but it's experimental software: expect to troubleshoot. Licensing-wise it's AGPL-3.0 — running the unmodified receiver on your own machine is exactly its intended use and is completely fine.

What you need

Docker Docker Desktop (Windows/macOS) or Docker Engine (Linux) on the machine that will receive the stream.
OBS 28+ Native SRT Media Source support. Free from obsproject.com.
SRT2GO With the SRTLA toggle enabled on the Custom SRT screen.
Reachability For a same-network test: nothing. For real bonding over the internet: a UDP port forward on your router (covered below).

Step 1 — Build the srtla_rec container

There's no official Docker image, but srtla is a tiny C program that builds in seconds. Create a folder (e.g. srtla-rec) containing one file named Dockerfile:

# Build BELABOX's srtla_rec from source
FROM debian:bookworm-slim AS build
RUN apt-get update && apt-get install -y --no-install-recommends \
      build-essential git ca-certificates
RUN git clone https://github.com/BELABOX/srtla.git /src
WORKDIR /src
RUN make

FROM debian:bookworm-slim
COPY --from=build /src/srtla_rec /usr/local/bin/srtla_rec
EXPOSE 5000/udp
# srtla_rec <SRTLA_LISTEN_PORT> <SRT_HOST> <SRT_PORT>
ENTRYPOINT ["srtla_rec"]
CMD ["5000", "host.docker.internal", "4001"]

Open a terminal in that folder and build the image:
```
docker build -t srtla-rec .
```

Run it, publishing the SRTLA port:

docker run -d --name srtla-rec --restart unless-stopped -p 5000:5000/udp srtla-rec

What the arguments mean: srtla_rec 5000 host.docker.internal 4001 listens for bonded SRTLA links on UDP 5000 and relays the rebuilt SRT stream to port 4001 on the machine running Docker — where OBS will be listening. host.docker.internal is how a container reaches its host on Docker Desktop. On Linux, add --add-host=host.docker.internal:host-gateway to the docker run command, or replace it with the PC's LAN IP.

Step 2 — Set OBS to listen

In the Sources panel, click + → Media Source and name it (e.g. Phone Bonded).
Uncheck "Local File."

In Input, enter a listener URL on the port srtla_rec relays to:

srt://0.0.0.0:4001?mode=listener&latency=2000000&lossmaxttl=40

Set Input Format to mpegts.
Click OK. OBS now waits for srtla_rec to deliver the stream.

lossmaxttl=40 matters for bonding. Packets from different links arrive out of order by design; this option gives SRT a reorder window (in packets) before it demands retransmissions. Without it the receiver floods the phone with unnecessary re-requests and bonding performs far worse than a single link. BELABOX recommends values between 10 and 50 — start at 40.

Firewall: allow OBS (UDP 4001) and Docker (UDP 5000) through the PC's firewall. SRT and SRTLA are both UDP — TCP rules won't help.

Step 3 — Point SRT2GO at srtla_rec

Open SRT2GO and tap Custom SRT.
Enter the host (your PC's address — see the two scenarios below) and port 5000.
Turn on the SRTLA (bonded) toggle.
Tap Connect, then Go Live. Your camera appears in OBS within a second or two.

Same network first, then the internet

A — First test on the same Wi-Fi

Use your PC's local IP (e.g. 192.168.1.50) as the host in SRT2GO. The phone will bond over a single link (its Wi-Fi), which is still a valid end-to-end test of the whole chain — phone → srtla_rec → OBS — with nothing exposed to the internet.

B — Real bonding over the internet

For bonding to be worth anything, the phone needs to reach your receiver over both Wi-Fi and mobile data — which means srtla_rec's port must be reachable from the internet:

On your router, port-forward UDP 5000 to the Docker PC — the procedure (and the CGNAT and dynamic-IP caveats that come with it) is identical to Method C of the OBS guide, just with port 5000 instead of 9000.
In SRT2GO, use your home's public IP (or a Dynamic DNS hostname) as the host, port 5000, SRTLA toggle on.
Only the SRTLA port needs forwarding. The phone's links are all outgoing callers, so mobile-carrier CGNAT on the phone side doesn't matter — only the receiving end must be reachable.

Behind CGNAT at home, or don't want to open ports? Run the same container on a small VPS instead, with an SRT relay (e.g. MediaMTX) next to it as the SRT_HOST, and have OBS pull from the relay as a caller — the same pattern as Method B of the OBS guide, with srtla_rec bolted on the front.

Latency

Bonded links ride over mobile data, so give SRT room to re-request lost packets: SRT2GO's default of 2 s is right, and the OBS URL above matches it (latency=2000000 — OBS counts in microseconds). Keep the two ends the same. Drop both only if you've measured a consistently clean link.

Security

An open UDP 5000 means anyone who finds it can attempt to register links and push video. For occasional streaming, the practical mitigations are: forward the port only while you stream, prefer a Dynamic DNS name you don't publish, and keep an eye on docker logs srtla-rec (it logs every connection group it accepts). For a permanently-open receiver, use the VPS + relay variant with a streamid-checking relay in front of OBS.

Before you start — quick checklist

Container running: docker ps shows srtla-rec with 5000/udp published.
OBS Media Source is in mode=listener on the port srtla_rec relays to (4001), before going live.
"Local File" unchecked, Input Format mpegts, and lossmaxttl=40 in the URL.
SRTLA toggle on in SRT2GO — without it the phone speaks plain SRT at port 5000 and srtla_rec will ignore it.
Matching latency on both ends (2 s phone ↔ 2000000 µs OBS).
Internet use: router forwards UDP 5000, PC firewall allows it, and you're not behind CGNAT.

Troubleshooting

SRT2GO says "srtla ready" but OBS stays black.
srtla_rec accepted the phone's links but can't deliver the stream to OBS. Check that the OBS Media Source is active and listening on 4001, and that the container can reach the host — on Linux, confirm you added --add-host=host.docker.internal:host-gateway or used the PC's LAN IP in the CMD.

SRT2GO never gets to "ready" / times out connecting.
The phone's links can't reach UDP 5000. Same network: check the PC firewall and that -p 5000:5000/udp (note the /udp!) is on the container. Over the internet: the port forward is missing, TCP instead of UDP, or you're behind CGNAT — see the OBS guide's Method C caveats.

It works on Wi-Fi but the bond never uses mobile data.
Both links must reach the same public address. If you used a LAN IP (192.168.x.x) as the host, the cellular link can't route to it — use your public IP / DDNS name and the port forward even when you're at home.

It connects, then drops repeatedly.
Raise the latency on both ends and try a lower SRT2GO quality profile. Check docker logs srtla-rec — link registrations dropping and re-registering point at an unstable path rather than an OBS problem.

Bonding works but quality is worse than plain SRT.
Almost always a missing or too-small lossmaxttl on the OBS listener URL. Cross-link reordering without a reorder window triggers a storm of retransmissions; set lossmaxttl=40 and re-test. (BELABOX's own receivers also use a patched SRT library tuned for this — an upstream receiver like OBS's works, just slightly less efficiently.)

Garbled image or audio-only.
Keep SRT2GO on the default H.264 profile for the first test — it's the most broadly compatible with OBS's decoder.

Still stuck? Email support@srt2go.app.