Build Your Own IRL Stream Bag: Complete SRTLA & Belabox Guide 2026

Quick answer: A self-built IRL stream bag is an encoder board running BELABOX, two or more mobile modems on different networks, a power bank, and a relay server that puts the connections back together. For new setups BELABOX recommends the Radxa Rock 5B+ (list price on belabox.net: $99 for the 8GB version). You can run the relay yourself on a VPS, for example our VPS-S at €5.50 per month (temporarily out of stock, expected back around the end of October 2026). Be aware that BELABOX itself calls its receiver, srtla_rec, unsuitable for production, and sells BELABOX cloud relays from $10 per month. Prices and recommendations in this guide were checked on 28 September 2026.

---

Why build your own stream bag

The problem with a single connection

Streaming from your phone to Twitch or Kick works as long as your connection holds up. Drive into a tunnel, walk between tall buildings or end up somewhere with weak coverage, and your stream stutters or drops. RTMP, the usual protocol for sending a stream to a platform, runs over a single TCP connection. When that one connection struggles, so does your stream.

Bonding fixes that. Your encoder spreads the stream over several mobile connections at once, and a server along the way (the relay) puts everything back in the right order. BELABOX does this with SRTLA, a layer on top of the SRT protocol. According to the srtla README, srtla balances the traffic dynamically, depending on what each connection can handle at that moment.

Off the shelf or DIY

There are commercial systems that sell all of this as one package. LiveU, for example, sells the Solo PRO as an encoder, with Solo PRO Connect as a separate package of modems, unlimited data plans and a subscription to LRT, the technology LiveU uses to bond several networks into one connection (liveu.tv). There are also services that run the relay or a cloud OBS for you. Their prices change often, so check them on their own sites.

Building it yourself with BELABOX means you buy the hardware separately, install free open-source software, and sort out your own SIM cards and relay. It costs less per month and you know exactly how everything works. When something breaks on the road, though, you are your own helpdesk.

What you need

---

Part 1: Choosing the hardware

1.1 The encoder: an RK3588 board

The encoder is the heart of your bag. It takes the picture from your camera, compresses it and sends it over all your connections at once. BELABOX runs on several boards with the Rockchip RK3588 chip and on the older NVIDIA Jetson Nano. The official comparison is on belabox.net/rk3588. This is what it said on 28 September 2026:

The list prices are in US dollars, without shipping and import costs. BELABOX adds that the 4GB version of each board has enough memory, and that more RAM gives no advantage.

Why the Rock 5B+

BELABOX calls the Rock 5B+ the best compromise for most people. The main reason is that its HDMI input seems the least affected by radio interference from 4G and 5G modems. It also has a full-size HDMI port, an M.2 slot for a built-in 4G or 5G modem (42 mm; full-length 52 mm modems don't fit) and a USB-C input with USB PD. BELABOX lists three downsides as well. The HDMI input sits on the side of the board, which can make cable routing more awkward. The microSD slot sits right under that HDMI port, so the card can get knocked out by accident. And many M.2 modems only detect the SIM card after a workaround; belabox.net links to a photo and a Radxa forum topic for that.

Orange Pi 5 Plus

Earlier versions of this guide called the Orange Pi 5 Plus the default choice. That is no longer right. BELABOX supports it, but prefers the Rock 5B+. For the Orange Pi, BELABOX warns that mobile modems make HDMI capture fail when they sit next to the board or the HDMI cable. It also has no USB PD input. If you already own one, you can keep using it, as long as you keep the modems away from the board and the HDMI cable.

Jetson Nano and Raspberry Pi

According to belabox.net, the Jetson version of BELABOX is still maintained, but BELABOX recommends RK3588 for new setups. The Jetson Nano needs a USB capture card for HDMI, and NVIDIA doesn't support anything newer than Ubuntu 18.04 on that board. Newer features, such as 5G modems over M.2 or mini PCIe, are therefore only available on RK3588. The Raspberry Pi is not on the list of supported boards.

Interference between modems and HDMI

This applies to every RK3588 board: if the HDMI cable or the board sits right next to a 4G or 5G modem, HDMI capture can fail until the modem is moved away. BELABOX calls it a hardware design issue that is very unlikely to be fixable in software. On the Rock 5B+ it appears to be solved, or at least much improved. Keep it in mind when you pack your bag.

Accessories

• Storage: a microSD card rated UHS Class 3 or V30 or higher (advice from the BELABOX wiki), or eMMC. BELABOX recommends eMMC because it is more reliable and performs more consistently. On the Rock 5B+ the eMMC is an option soldered onto the board; on the Orange Pi 5 Plus it is a separate module that isn't included. The wiki also mentions that eMMC issues have been reported on the Rock boards and points to the BELABOX Discord for details, so ask there before you order.
• Cooling: a heatsink with a fan. The board runs for hours inside a closed bag.
• Power: see 1.4.

1.2 The modems: different networks

The point of several modems is that they don't all lose signal in the same place. If one modem drops out in a tunnel, a modem on another network takes over. SRTLA spreads the stream over every connection that works at that moment and gives the fastest one the most traffic.

That only works if your SIM cards really are on different networks. Many mobile brands don't run their own network but use one of the big operators, so two SIM cards from two different brands can end up on the same masts. Check which network each provider uses before you buy.

The Netherlands, where our VPS runs, is a good example. It has three mobile networks: KPN, VodafoneZiggo and Odido (ACM, in Dutch). Odido is the name T-Mobile Netherlands has used since 5 September 2023, and Tele2's mobile business became Odido as well (Odido, in Dutch). An Odido SIM and an old T-Mobile SIM are therefore on the same network. The same goes for Ben and Simpel, which Odido keeps as its own brands. Every other Dutch provider uses one of those three networks.

Which modems

According to the BELABOX wiki, any USB modem works if Linux supports it and it shows up as a virtual Ethernet interface. The older kind that works through PPP over a USB serial port does not. The wiki lists the Huawei E3372 and E5576 as known to work. If you use more than one modem, make sure you can change the IP range on each of them so they don't overlap. On the Rock 5B+ you can also fit an M.2 modem.

Better to skip:

• Modems that only work over PPP.
• Modems without 4G. 3G is being switched off. According to the Dutch regulator ACM (December 2024), KPN and VodafoneZiggo had already stopped offering 3G and Odido would follow in August 2026 at the earliest. ACM adds that other countries have started switching off their old networks too.
• Modems you can't confirm work under Linux.

1.3 SIM cards and data

We don't list bundle prices on purpose. They change often, and an earlier version of this guide listed Dutch bundle prices that we could not confirm on the providers' own sites. Check those sites for current prices.

Work out how much data you need from your bitrate. A 4000 kbps stream is 4 megabits per second, which is about 1.8 GB per hour. That data is spread over your SIM cards, but not evenly: the fastest connection gets the most. Add a little for packets that have to be sent again. Four hours at 4000 kbps comes to a little over 7 GB, spread over your modems.

Test the coverage on your usual route before you sign a contract. Walk or drive it once with SIM cards from different networks in your phone.

1.4 Power and housing

How much current your board can deliver to USB devices decides how many modems you can plug straight into it. BELABOX gives these figures per board:

If your modems need more than the board can deliver, use a powered USB hub. A USB PD input lets the board negotiate a higher voltage and current with a PD power bank. According to BELABOX that generally makes the system more stable and gives the USB modems a steadier power supply.

How long a power bank lasts depends on your board, modems and camera. Measure it yourself with a USB power meter during a test stream at home, then work back from there. The BELABOX wiki has a list of power banks that users have run BELABOX on, such as the Baseus Blade 100W (tested with an Orange Pi 5 Plus) and the UGREEN Nexode 140W 25000mAh. The wiki itself says the list isn't curated, so an entry is no guarantee that a product suits your setup.

For the housing, an ordinary backpack with foam compartments, a camera backpack or a foam-lined case will do. Leave room for air around the board and keep the modems away from the board and the HDMI cable.

---

Part 2: Installing BELABOX

2.1 What BELABOX does

BELABOX is open-source software that turns a board into an encoder for IRL streams. According to belabox.net you get H.265 encoding, bonding of several modems or network connections, a dynamic bitrate that keeps you connected when the signal is weak, and control from your phone or computer.

In practice it goes like this:

1. BELABOX takes video over HDMI, from a USB camera or from an RTMP feed.
2. The board encodes it to H.265 with its hardware encoder.
3. The stream goes out over all your connections at once through SRTLA.
4. Everything comes back together at your relay.

So BELABOX doesn't send straight to Twitch. It sends to a relay (your own VPS or BELABOX cloud), and OBS picks the stream up from there.

2.2 Downloading and flashing the image

Step 1: download the image for your board

Go to belabox.net/rk3588. For each board there is a "microSD / eMMC image" and an "eMMC installer", both as zip files. Take the image for your own board; BELABOX stresses that you need the correct file for your board. For the Rock 5B+ the file is currently called belabox_rock_5b_plus-latest.img.zip. There is no GitHub releases page with images, whatever older guides say.

Step 2: flash it to a microSD card

On Windows and Mac, use balenaEtcher, the tool belabox.net itself links to:

1. Open Etcher.
2. Under "Flash from file", pick the downloaded file.
3. Under "Select target", pick your microSD card.
4. Click "Flash".

On Linux you can also use dd:

# Unzip the download; it contains an .img file
unzip belabox_rock_5b_plus-latest.img.zip

# Find your SD card
lsblk

# Flash (replace /dev/sdX with your SD card, or you will overwrite the wrong disk)
sudo dd if=THE_IMG_FILE.img of=/dev/sdX bs=4M status=progress conv=fsync

Installing to eMMC instead

To put BELABOX on eMMC, flash the installer to a microSD card instead of the image. Fit the eMMC module (if your board uses a removable one), put the microSD card in the board and power it on. The board boots from the microSD card, installs BELABOX to the eMMC and shuts down. Take the microSD card out; on the next start BELABOX runs from the eMMC.

2.3 First boot and password

1. Put the microSD card in the board (or use the eMMC).
2. Connect the board to your router with a network cable. The BELABOX wiki recommends Ethernet for the first setup.
3. Power on the board.
4. On a computer on the same network, open http://belabox.local, or the board's IP address (your router will show it).

The first time, belaUI, the BELABOX web interface, shows the "Initial BELABOX setup" screen, where you choose a password for belaUI. There is no default login such as admin/admin: whoever opens the web interface first sets the password, so do it straight away. The old BELABOX tutorial describes it the same way: on first access, belaUI asks you to set a password. That tutorial is otherwise out of date, and for installation it refers to belabox.net itself.

You don't need SSH for this guide. If you want it anyway, turn it on under "Advanced / developer" with the "Start SSH server" button. The SSH login details are shown there too.

On the road you control belaUI from your phone. The wiki mentions two ways to do that: a modem with Wi-Fi that your phone connects to, or a BELABOX cloud remote (from $5 per month according to belabox.net). One more tip from the wiki: settings are only saved when you start a stream.

2.4 Setting up belaUI

Connections

Plug in your modems. belaUI shows a row for each network interface with its IP address and throughput in Kbps, plus a checkbox to turn that connection on or off. There are no priorities to set. SRTLA divides the traffic itself, based on what each connection can carry.

Encoder settings

Pick a pipeline that matches your source. On RK3588 they have names like h265_hdmi_1080p30 for an HDMI camera at 1080p30; the full list is in the belacoder repository. Then choose your audio source and audio codec, and set the maximum bitrate with the slider.

For a starting bitrate, use the BELABOX bitrate guide. For 1080p30 in an indoor or urban scene it gives 2500 to 4000 kbps for good quality on a 13 inch screen (which the guide calls good enough for most viewers), and 4000 to 6000 kbps for good quality on a 27 inch screen. The guide was written for the Jetson Nano's H.265 encoder, so treat it as a starting point. The same guide advises against streaming at 50 or 60 fps unless you really need it, because that can take up to 50% more bitrate for the same picture quality.

Relay server settings

Under "Relay server", choose "Manual configuration" and fill in:

belaUI itself recommends a latency of 1500 to 2500 ms and warns that setting it too low increases glitching and lowers the bitrate you can sustain. The 2000 ms matches the example in the srtla README. We set up the VPS in the next part, so only start your stream once that is ready.

---

Part 3: Your own SRTLA relay on a VPS

3.1 Why a relay

Twitch, Kick and YouTube don't understand SRTLA. Something has to sit in between and merge the separate connections back into one SRT stream. OBS then picks up that stream, adds your scenes and overlays, and streams to your platform. belabox.net describes its own relays the same way: they relay the bonded BELABOX stream to OBS.

Stream bag (BELABOX)
  Modem, network A \
  Modem, network B  >  SRTLA over UDP, port 5000
  Modem, network C /
                       |
                       v
VPS (relay)
  srtla_rec            merges the connections
     |                 SRT to 127.0.0.1:5002
  srt-live-transmit    SRT with the BELABOX settings, listens on 127.0.0.1:5001
     |
  MediaMTX             pulls the stream in as path "live", SRT port 8890 with a password
                       |
                       v
OBS (at home or on another machine)
                       |
                       v  RTMP
Twitch / Kick / YouTube

On RK3588, BELABOX encodes in H.265. OBS reads that without trouble and encodes your stream again for the platform. That is why OBS sits in this chain, and why NOALBS works with it (part 5).

3.2 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. The README also calls srtla experimental. BELABOX points to BELABOX cloud instead. Those relays run BELABOX's own private server software, which according to belabox.net has extra reliability optimizations for bonded SRTLA streams, with servers in the USA, the EU, the UK, Japan, Singapore, Australia, Brazil and South Africa. It costs from $10 per month and comes as a perk for GitHub sponsors.

A relay on your own VPS is fine for learning, testing and hobby streams. If your income depends on a stream, go for BELABOX cloud or another relay service that looks after this every day. The steps below follow the README as closely as possible.

There is also no official Docker image for srtla. Docker Hub has nothing under the name belabox. The old BELABOX tutorial mentions a third-party Docker image, but adds that BELABOX can't guarantee such packages stay up to date. That image was last updated on Docker Hub in June 2021, and the README says the current srtla version doesn't work with earlier versions. That is why we build srtla from source here.

3.3 Which VPS

The relay doesn't encode anything. It receives packets, puts them in order and passes them on, and that doesn't take a heavy server. What matters more:

• a public IP address and open UDP ports;
• a location close to you and to your OBS machine;
• enough traffic. A 6000 kbps stream is about 2.7 GB per hour, and the relay both receives it and sends it on to OBS, so count it twice.

At Space-Node, VPS-S fits: 2 vCores, 4GB RAM, 40GB NVMe and 10 TB traffic, in the Netherlands, for €5.50 per month. It is our smallest plan, and enough to start with when all it does is relay. Because it runs in the Netherlands, it makes the most sense if you stream in or near Europe. Please note that our VPS plans are temporarily out of stock and expected back around the end of October 2026. The steps below assume Ubuntu 24.04, with us or with any other provider.

3.4 Preparing 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 will 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 always runs from the same fixed IP address, you can open port 8890 for that address only: ufw allow from YOUR_HOME_IP to any port 8890 proto udp. Ports 5001 and 5002 don't need to be open, because the relay only uses them internally.

3.5 Building srtla and BELABOX's version of SRT

According to the README, the receiver should use BELABOX's patched SRT library. srtla also works with the upstream SRT library, but performance may suffer, because upstream SRT causes too many retransmissions when packets arrive out of order.

# SRT from BELABOX (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

After that, srt-live-transmit is in /opt/srt and srtla_rec is in /opt/srtla.

srtla_rec expects 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 arguments and it only prints that line and exits.

3.6 srtla_rec and srt-live-transmit as services

The example in the README looks like this:

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 receives the connections from your BELABOX on UDP port 5000 and sends the merged stream to srt-live-transmit on port 5002. According to the README, lossmaxttl is required: it lets packets arrive out of order without SRT immediately asking for them to be sent again. Values between 10 and 50 are a reasonable starting point. latency sets how much time there is to resend packets and put them back in order.

We use that example with one change: on the output side, srt-live-transmit listens on 127.0.0.1 instead of 0.0.0.0. That way only MediaMTX on the same server can pull the stream, and MediaMTX controls access with a password. The README itself says this basic setup has no authentication or encryption, and that srt-live-transmit can only handle one connection at a time.

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 them:

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

3.7 MediaMTX in Docker

MediaMTX (installation docs) pulls the stream from srt-live-transmit and makes it available to OBS. The official Docker image is bluenviron/mediamtx. The 1 tag follows the latest 1.x release; 1-ffmpeg is the same with FFmpeg included, which this setup doesn't need.

Create a folder and a config file:

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

Paste this in:

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

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

authInternalUsers:
  # No password: API only, 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, including an earlier version of this guide, use settings that current MediaMTX rejects. protocols: [srt] fails, because protocols is an old RTSP setting in which srt is not a valid value. A path called all with a fixed source is refused unless you also set sourceOnDemand: yes. The earlier version of this guide also put runOnInit on that all path, which MediaMTX refuses on such a path. Other examples use runOnReady, which still loads but is deprecated in favour of runOnAvailable. We checked the configuration above with --validate-conf in MediaMTX v1.21.1.

Check your own file the same way, then start MediaMTX:

# Check 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 ports on the server directly, and your ufw rules apply as normal.

3.8 Connecting OBS

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

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

That is MediaMTX's SRT read request, with the username and password in the streamid. Put this source in your main scene and stream from OBS to Twitch, Kick or YouTube the way you normally do.

OBS does not have to run on your home PC. Our streaming VPS comes with OBS pre-installed and opens in the browser, so your scenes and your BRB screen stay online even when your computer at home is off.

---

Part 4: Testing and troubleshooting

4.1 First test at home

1. Start the stream in belaUI.
2. On the VPS, check that everything is running:

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

1. Ask MediaMTX for the status of the path:

curl -s http://127.0.0.1:9997/v3/paths/get/live

If available is true and inboundBytes keeps going up, the stream is coming in.

1. Check that the picture shows up in your OBS media source.

As long as no stream is coming in, MediaMTX logs that the SRT source isn't responding and keeps retrying. That is normal.

4.2 Field test

Then test outside, on a route you know:

1. Walking between tall buildings, where coverage changes all the time.
2. A tunnel or parking garage, where you briefly have no coverage at all.
3. A drive, where your modems keep switching masts.
4. A rural area with a weak signal.

belaUI shows the throughput in Kbps for each connection. With two or more connections, the total appears in bold at the top of the list. That tells you straight away which modem is pulling its weight and which isn't. In the encoder settings you can enable the dynamic bitrate overlay to see the bitrate on screen. It's handy during a test, but turn it off for a real stream.

4.3 Common problems

BELABOX can't connect to the relay

Check that UDP port 5000 is open and that srtla-rec is running:

ufw status
systemctl status srtla-rec

In belaUI, check the address and the port (5000), and that you chose "Manual configuration".

The stream stutters or buffers

Lower the maximum bitrate in belaUI. If you're at the low end of belaUI's advice (1500 to 2500 ms), raise the SRT latency within that range. Also check whether one of your connections keeps collapsing; you can switch it off for now with its checkbox.

One modem does nothing

Check in belaUI whether the interface shows up and has an IP address. If two modems use the same IP range, change the range on one of them in that modem's admin page. The BELABOX wiki names this as a requirement for running several modems. Also check that the SIM PIN is disabled and that the APN is right.

HDMI drops out as soon as the modems are on

That is the interference BELABOX describes for all RK3588 boards. Move the modems further away from the board and the HDMI cable. If you still have to choose a board: according to BELABOX the problem is smallest on the Rock 5B+.

The board gets too hot

Check the temperature (the value is in thousandths of a degree Celsius):

cat /sys/class/thermal/thermal_zone0/temp

Fit a heatsink with a fan and leave room for air in your bag. If that isn't enough, pick a pipeline with a lower resolution or frame rate.

---

Part 5: Extras

5.1 NOALBS: switching to a BRB scene automatically

NOALBS switches scenes in OBS automatically when your bitrate gets too low or your source disconnects completely. Your viewers see a "be right back" screen instead of a frozen picture. NOALBS is a standalone program for Windows, Mac and Linux that you run next to OBS. Download it from the releases on GitHub and turn on the WebSocket server in OBS.

NOALBS supports MediaMTX and reads the bitrate through the MediaMTX API. On the VPS, add a user with API permissions to authInternalUsers in mediamtx.yml:

  - user: noalbs
    pass: ANOTHER_LONG_PASSWORD
    ips: []
    permissions:
      - action: api

Open port 9997 only for the IP address NOALBS runs on. The API uses plain HTTP, so the password crosses the internet unencrypted:

ufw allow from YOUR_HOME_IP to any port 9997 proto tcp

In the NOALBS config, fill in the stream server like this (based on the example in the NOALBS README):

"streamServer": {
  "type": "Mediamtx",
  "statsUrl": "http://YOUR_VPS_IP:9997/v3/paths/get/live",
  "auth": {
    "username": "noalbs",
    "password": "ANOTHER_LONG_PASSWORD"
  }
}

The rest of the config, such as your scene names and the low bitrate threshold, is explained in the README.

5.2 Streaming to several platforms

The easiest way is to let OBS stream to several platforms, since OBS encodes the stream again anyway. MediaMTX can also forward a stream by itself with forward, but then the H.265 stream from BELABOX goes out unchanged. Check first whether the platform accepts H.265 over RTMP, or no picture will arrive. That is also why this guide no longer pushes the stream straight to Twitch with ffmpeg -c copy, as an earlier version did.

5.3 Recording on the VPS

MediaMTX can record the path itself. Extend the live path in mediamtx.yml like this:

paths:
  live:
    source: srt://127.0.0.1:5001
    record: yes
    recordPath: ./recordings/%path/%Y-%m-%d_%H-%M-%S-%f
    recordDeleteAfter: 7d

With the Docker setup from part 3, recordings end up in /opt/relay/config/recordings/live/ on your VPS. Watch recordDeleteAfter: by default MediaMTX deletes recordings after one day, here it's seven days. Keep an eye on your disk as well. At 4000 kbps an hour is about 1.8 GB, and VPS-S has 40GB NVMe for everything together. Download recordings with:

scp -r root@YOUR_VPS_IP:/opt/relay/config/recordings/live ./

---

Part 6: Costs

6.1 What is fixed and what varies

The board list prices exclude shipping and import costs. belabox.net also lists what its maker paid including shipping and import fees to the UK: $127 for the Rock 5B+ (8GB), and also $127 for the Orange Pi 5 Plus (4GB).

You can work out your first year like this: hardware plus twelve times your monthly cost for SIM cards and relay. With your own VPS-S the relay costs €66 a year (12 × €5.50). With BELABOX cloud it is at least $120 a year. From the second year on you only pay for SIM cards and the relay.

6.2 Your own relay or BELABOX cloud

Your own VPS is the cheapest option and keeps everything in your own hands: your config, your recordings and your logs. On the other hand, BELABOX says srtla_rec is unsupported and not meant for production, and you do the maintenance yourself. BELABOX cloud costs more, but runs BELABOX's own server software with its extra reliability work and has servers on several continents. Streams your income depends on are better off there.

6.3 When building it yourself is worth it

Building your own suits you if you stream IRL regularly, enjoy working with hardware and Linux, and want to decide for yourself how everything works. Pick a ready-made system or a managed relay instead if your stream is your income, if you have no time to troubleshoot on the road, or if you want a single supplier to call when something breaks.

---

Summary

With an RK3588 board, BELABOX, two or three modems on different networks and a relay, you have a complete IRL streaming bag. You buy the hardware once. Each month you pay for your SIM cards plus the relay: €5.50 for your own VPS-S, or from $10 for BELABOX cloud. How stable your stream is depends mostly on the coverage along your route, your modems and your bitrate. So test at home first, then on a short route.

Next steps:

1. Pick your board on belabox.net/rk3588. If in doubt, get the Rock 5B+.
2. Get SIM cards on at least two different networks.
3. Choose your relay: your own VPS (VPS-S is our smallest plan, 4GB RAM, €5.50 per month, temporarily out of stock until around the end of October 2026) or BELABOX cloud.
4. Follow this guide and test at home first.
5. Do a short test run on your usual route before you go live.

Need help?

• The BELABOX Discord: https://discord.gg/hS8TcpsCKu (the invite belabox.net itself gives)
• The BELABOX wiki: https://github.com/BELABOX/tutorial/wiki
• Space-Node support for questions about your VPS

---

Our VPS plans run in the Netherlands and start at €5.50 per month for VPS-S (2 vCores, 4GB RAM, 40GB NVMe, 10 TB traffic), with root access and DDoS protection. They are temporarily out of stock and expected back around the end of October 2026.

Sources (checked on 28 September 2026):

• BELABOX for RK3588, board comparison, downloads and FAQ: https://belabox.net/rk3588/
• BELABOX, features and BELABOX cloud: https://belabox.net/
• srtla README (warning, building, example): https://github.com/BELABOX/srtla/blob/main/README.md
• BELABOX wiki (modems, storage, first setup, SSH): https://github.com/BELABOX/tutorial/wiki
• BELABOX bitrate guide: https://github.com/BELABOX/tutorial/blob/main/bitrate_guide.md
• MediaMTX installation: https://github.com/bluenviron/mediamtx/blob/main/docs/1-kickoff/2-install.md
• ACM on switching off 2G and 3G (in Dutch): https://www.acm.nl/nl/publicaties/gevolgen-van-de-afschakeling-van-2g-en-3g
• Odido on the T-Mobile name change (in Dutch): https://www.odido.nl/t-mobile-nederland-wordt-odido

Related guides:

• KPN vs Ziggo vs Odido: Best 4G/5G for IRL Streaming 2026
• OBS + VPS: Remote Streaming Setup for Content Creators
• IRL Stream Tas Zelf Bouwen (this guide in Dutch)