Belabox and SRTLA Guide 2026

Published on | Updated

How BELABOX and SRTLA bond several mobile connections for IRL streaming, and how to run your own SRTLA relay on a Linux VPS with srtla_rec, srt-live-transmit, MediaMTX and OBS. Includes BELABOX's own warning about srtla_rec and when BELABOX cloud is the better pick.

Streaming setup

BELABOX is open-source encoder software for IRL streaming. It takes the video from your camera, encodes it on a small board and sends it over several internet connections at once, usually two or more mobile modems. The part that spreads the stream over those connections is SRTLA, a link aggregation layer on top of the SRT protocol. At the other end you need a relay: a server that receives all the pieces, puts them back in order and hands one SRT stream to OBS.

This guide is about that relay. You can rent one from BELABOX (BELABOX cloud) or run your own on a Linux VPS. Read the next section before you choose the second option.

Quick answer: Your own SRTLA relay needs a Linux VPS with a public IPv4 address and two open UDP ports. On it you run srtla_rec and srt-live-transmit from BELABOX's GitHub, plus MediaMTX so OBS can pull the stream with a password. The VPS does not re-encode anything, so a small plan is enough. At Space-Node that is VPS-S (3 vCores, 4GB RAM, €4.99 per month, in an EU data center); the Premium VPS-S (Ryzen 9 9950X) is €8.40 per month. BELABOX says itself that srtla_rec is not suitable for production, so for streams you earn money from, BELABOX cloud (from $10 per month according to belabox.net) is the safer choice. Checked on 28 September 2026.

Read this first: srtla_rec is not for production

The srtla README opens with a clear warning: the receiver, srtla_rec, "is unsupported, no longer under development and not suitable for production deployment." It points to BELABOX cloud instead. According to belabox.net, BELABOX cloud runs private relay software with extra reliability work for bonded SRTLA streams, on servers in the USA, EU, UK, Japan, Singapore, Australia, Brazil and South Africa. The README also calls srtla experimental.

Your own relay is still fine for learning, testing and hobby streams, and you keep the whole server in your own hands. Just know what you are running. The steps below follow the README as closely as possible.

There is no official Docker image for srtla either. The belabox namespace on Docker Hub has no repositories, and third-party images can fall behind. The current version, srtla2, does not work with older srtla versions, so an outdated image may not talk to your BELABOX at all. That is why we build srtla from source here.

How the chain works

BELABOX encoder
  modem on network A  \
  modem on network B   >  SRTLA over UDP, port 5000
  modem on network C  /
                           |
                           v
VPS relay
  srtla_rec              joins the connections back together
     |                   SRT to 127.0.0.1:5002
  srt-live-transmit      SRT with the options the README requires, listens on 127.0.0.1:5001
     |
  MediaMTX               pulls the stream as path "live", offers it on SRT port 8890 with a password
                           |
                           v
OBS (at home or on another machine)
                           |
                           v  RTMP
Twitch / Kick / YouTube

Twitch, Kick and YouTube don't speak SRTLA, so something has to join the connections again. That is srtla_rec. OBS then pulls the stream, puts your scenes and overlays on top and streams to the platform as usual. BELABOX describes its own cloud relays the same way on belabox.net: they relay the bonded stream to OBS.

Why not push straight from the VPS to Twitch with FFmpeg? On RK3588 boards BELABOX encodes in H.265. OBS reads that without trouble and encodes again for the platform. Copying the H.265 stream straight to an RTMP ingest only works when the platform accepts H.265 over RTMP, and that differs per platform. With OBS in between you don't have to care, and tools like NOALBS, which switches to a "be right back" scene when the bitrate drops, keep working.

The encoder side in short

The official board comparison is on belabox.net/rk3588. For new setups BELABOX recommends the Radxa Rock 5B+, with a list price of $99 for the 8GB version on that page. BELABOX also says the 4GB version of each board has enough memory. The Orange Pi 5 Plus is supported, "but Rock 5B+ is preferred": BELABOX warns that mobile modems placed next to that board or its HDMI cable make HDMI capture fail. The Jetson Nano version is still maintained, but RK3588 boards are preferred for new setups. Raspberry Pi is not on the list of supported boards.

A few things that older guides get wrong:

  • You download the image for your board from belabox.net/rk3588. Each board has a "microSD / eMMC image" and an "eMMC installer", both as zip files. There is no GitHub releases page with BELABOX images.
  • There is no default login such as admin/admin. The first time you open belaUI, the web interface, it asks you to set a password. The BELABOX wiki says to do that first setup over Ethernet at http://belabox.local.
  • Any USB modem that Linux supports and that shows up as a virtual Ethernet interface should work, according to the wiki. It lists the Huawei E3372 and E5576 as known to work, and rules out the older style of modem that uses PPP over a USB serial port.
  • Put your SIM cards on different networks. The Netherlands has three: KPN, VodafoneZiggo and Odido. T-Mobile Netherlands was renamed Odido in September 2023, so a T-Mobile SIM and an Odido SIM are on the same network.

Our guide Build your own IRL stream bag covers the full build: board, storage, power, flashing and belaUI. There is also a Dutch version.

What the VPS needs

The relay doesn't encode. It receives packets, puts them in order and passes them on, so the network matters more than CPU or RAM:

RequirementWhy
Public IPv4 addressBELABOX connects to it over every modem
UDP 5000 and 8890 open5000 for SRTLA from BELABOX, 8890 for OBS
Enough monthly traffic6000 kbps is about 2.7 GB per hour. The relay receives it and sends it on to OBS, so count it twice
A location near you and your OBS machineThe SRT latency window also has to cover the round trip, so a nearby server leaves more time for resending lost packets

At Space-Node, VPS-S fits this: 3 vCores, 4GB RAM, 60GB NVMe, 10 TB traffic and a 1 Gbps uplink, in an EU data center, for €4.99 per month. It is our smallest Standard plan. Premium VPS plans start at €4.20 per month. The commands below assume Ubuntu 24.04, with us or with any other provider.

Step 1: prepare the server

ssh root@YOUR_VPS_IP

apt update && apt upgrade -y
apt install -y build-essential git tcl pkg-config cmake libssl-dev docker.io ufw

Firewall:

# Keep SSH open, or you lock yourself out
ufw allow 22/tcp

# SRTLA from your BELABOX
ufw allow 5000/udp

# SRT to OBS (MediaMTX)
ufw allow 8890/udp

ufw enable

If your OBS machine always has the same fixed IP address, open 8890 for that address only: ufw allow from YOUR_HOME_IP to any port 8890 proto udp. Ports 5001 and 5002 stay closed. The relay only uses them inside the server.

Step 2: build BELABOX's SRT and srtla

The README says the receiver should use BELABOX's patched SRT library. The upstream library works too, but performance may suffer, because upstream SRT asks for too many retransmissions when packets arrive out of order.

# BELABOX's SRT fork (provides srt-live-transmit)
cd /opt
git clone https://github.com/BELABOX/srt.git
cd srt
./configure
make

# srtla (provides srtla_rec and srtla_send)
cd /opt
git clone https://github.com/BELABOX/srtla.git
cd srtla
make

Afterwards srt-live-transmit is in /opt/srt and srtla_rec is in /opt/srtla. srtla builds with plain make. There is no cmake step and no configuration file.

srtla_rec takes exactly three arguments: the port it receives SRTLA on, and the address and port of the SRT listener it forwards to (srtla_rec [-v] SRTLA_LISTEN_PORT SRT_HOST SRT_PORT). Start it with fewer and it prints that usage line and exits.

Step 3: srt-live-transmit and srtla_rec as services

This is the receiver example from the README:

srt-live-transmit -st:yes "srt://127.0.0.1:5002?mode=listener&lossmaxttl=40&latency=2000" "srt://0.0.0.0:5001?mode=listener" &
srtla_rec 5000 127.0.0.1 5002

srtla_rec takes the connections from your BELABOX on UDP port 5000 and sends the joined stream to srt-live-transmit on port 5002. The README calls lossmaxttl a required option: it lets packets arrive out of order without SRT asking for a resend straight away. It suggests values between 10 and 50 as a starting point. latency (in milliseconds) sets how much time there is for resending and reordering.

We keep that example with one change: srt-live-transmit listens on 127.0.0.1:5001 instead of 0.0.0.0:5001, so only MediaMTX on the same server can pull the stream. The README points out that this basic setup has no authentication or encryption and that srt-live-transmit handles one connection at a time. MediaMTX adds the password.

Create /etc/systemd/system/srt-bridge.service:

[Unit]
Description=srt-live-transmit between srtla_rec and MediaMTX
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/opt/srt/srt-live-transmit -st:yes "srt://127.0.0.1:5002?mode=listener&lossmaxttl=40&latency=2000" "srt://127.0.0.1:5001?mode=listener"
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

And /etc/systemd/system/srtla-rec.service:

[Unit]
Description=srtla_rec for BELABOX
After=network-online.target srt-bridge.service
Wants=network-online.target

[Service]
ExecStart=/opt/srtla/srtla_rec 5000 127.0.0.1 5002
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

Start both:

systemctl daemon-reload
systemctl enable --now srt-bridge srtla-rec
systemctl status srt-bridge srtla-rec

Step 4: MediaMTX in Docker

MediaMTX pulls the stream from srt-live-transmit and offers it to OBS. The official Docker image is bluenviron/mediamtx (install docs). The tag 1 follows the newest 1.x release.

mkdir -p /opt/relay/config
nano /opt/relay/config/mediamtx.yml

Paste this:

# Only the SRT server of MediaMTX is enabled
rtsp: no
rtmp: no
hls: no
webrtc: no
moq: no
srt: yes
srtAddress: :8890

# API for status checks (and NOALBS later)
api: yes
apiAddress: :9997

authInternalUsers:
  # API only, without a password, and only from the VPS itself
  - user: any
    pass:
    ips: ["127.0.0.1", "::1"]
    permissions:
      - action: api
  # OBS reads the stream with a username and password
  - user: obs
    pass: CHOOSE_A_LONG_PASSWORD
    ips: []
    permissions:
      - action: read
        path: live

paths:
  live:
    # Pull the stream from srt-live-transmit on the same server
    source: srt://127.0.0.1:5001

Older examples you may find elsewhere use settings that current MediaMTX has renamed or rejects. protocols and encryption are deprecated RTSP settings, replaced by rtspTransports and rtspEncryption, and srt was never a valid value there. runOnReady is deprecated in favour of runOnAvailable. And an image called ravenium/mediamtx, which some guides use, does not exist on Docker Hub.

Check your file first, then start MediaMTX:

# Validate the configuration
docker run --rm -v /opt/relay/config:/config -w /config bluenviron/mediamtx:1 --validate-conf=./mediamtx.yml

# Start
docker run -d --name mediamtx --restart unless-stopped \
  --network=host \
  -v /opt/relay/config:/config -w /config \
  bluenviron/mediamtx:1 ./mediamtx.yml

With --network=host, MediaMTX uses the server's ports directly and your ufw rules apply as usual. Port 9997 is not opened in ufw, so the API is only reachable from the VPS itself.

Step 5: point BELABOX at the relay

In belaUI, set "Relay server" to "Manual configuration" and fill in:

belaUI fieldValue
SRTLA receiver addressYour VPS IP address
SRTLA receiver port5000
SRT streamidLeave empty, this relay doesn't use it
SRT latency2000 ms

belaUI recommends a latency of 1500 to 2500 ms and warns that a lower value increases glitching and lowers the bitrate you can sustain. 2000 ms matches the srtla README example.

For the maximum bitrate, the BELABOX bitrate guide gives 2500 to 4000 kbps for 1080p30 indoor or urban scenes (good quality on a 13 inch screen, "good enough" for most viewers) and 4000 to 6000 kbps for good quality on a 27 inch screen. It was written for the Jetson Nano's H.265 encoder, so treat it as a starting point.

Step 6: pull the stream into OBS

In OBS, add a Media Source, untick "Local File" and enter this as input:

srt://YOUR_VPS_IP:8890?streamid=read:live:obs:CHOOSE_A_LONG_PASSWORD

That is MediaMTX's SRT read syntax, with the username and password in the streamid. If OBS doesn't show the picture, set the input format to mpegts, as the OBS wiki page on SRT suggests. Put this source in your main scene and stream from OBS to Twitch, Kick or YouTube as you normally would.

OBS can live in a datacenter as well. Our streaming VPS comes with OBS pre-installed and opens in the browser, so your scenes keep running when your home PC or home upload does not.

Testing

Start the stream in belaUI, then check the VPS:

systemctl status srtla-rec srt-bridge
journalctl -u srtla-rec -f
docker logs -f mediamtx

# Path status from the MediaMTX API
curl -s http://127.0.0.1:9997/v3/paths/get/live

If available is true and inboundBytes keeps rising, the stream is coming in. While nothing is streaming, MediaMTX logs that the SRT source doesn't respond and keeps retrying. That is normal.

If BELABOX can't reach the relay, check that UDP 5000 is open (ufw status), that srtla-rec is running, and that belaUI has the right address and port. If the stream stutters, lower the maximum bitrate in belaUI first, or raise the latency within the 1500 to 2500 ms that belaUI recommends.

FAQ

What is SRTLA?

SRT link aggregation. The srtla README describes it as a way to carry SRT traffic over several network links for more capacity and redundancy, balancing the traffic dynamically based on network conditions. The intended use is bonding mobile modems for live streaming.

Do I need my own VPS for SRTLA?

You need an SRTLA receiver somewhere, but it doesn't have to be your own server. BELABOX cloud offers relays from $10 per month. A VPS is the option where you run srtla_rec yourself, which BELABOX does not support for production.

What VPS should I use for BELABOX?

Any Linux VPS with a public IPv4 address, UDP ports you can open, and enough traffic for your bitrate counted twice. Pick one close to where you stream and where OBS runs. At Space-Node, VPS-S (€4.99 per month) is enough for a relay, and the Premium VPS-S is €8.40 per month.

Can I send the stream from the VPS straight to Twitch?

Not reliably with a plain copy. BELABOX on RK3588 sends H.265, and whether an RTMP ingest accepts H.265 differs per platform. Letting OBS pull the stream and encode it for the platform avoids that problem.

Sources

Checked on 28 September 2026:

Related: RTMP vs SRT vs SRTLA compared, Build your own IRL stream bag, IRL stream tas zelf bouwen (Dutch), Space-Node VPS plans