Most people who go looking for RTMP server hosting already know what they want: a box that accepts an encoder push, fans it out to a few destinations, and hands viewers an HLS playlist — without a shared platform sitting between them and their bitrate. The catch is that standing that up from a bare Linux image means an evening of compiling modules, editing nginx.conf, and guessing at buffer sizes. This is a note from our rack on how to shortcut that: a streaming VPS with unmetered traffic, no per-VM bandwidth ceiling and full root, onto which you install the ingest-and-package stack from upstream distro packages, single binaries or containers in minutes instead of compiling.
What "RTMP server hosting" actually means
RTMP is still the workhorse ingest protocol — it's what OBS, vMix, and hardware encoders speak by default over port 1935. An RTMP server's job is narrow: terminate that push, then do something useful with it. In practice "something useful" is one of three things, often all at once. Relay the stream on to other RTMP endpoints (multistreaming). Repackage it into HLS or LL-HLS so browsers and phones can play it without a plugin. Or transcode it into a bitrate ladder so viewers on bad connections still get a picture. Hosting the server yourself, instead of renting a slot on a SaaS streaming platform, means you own the ingest URL, the stream keys, the retention, and the egress bill.
The reason self-hosting has a reputation for pain isn't the software — Nginx-RTMP, MediaMTX and friends are solid — it's the assembly. You need the module built against the right Nginx version, an HLS output directory with sane fragment settings, a firewall that lets 1935 and 443 through, and enough bandwidth headroom that a restream to five destinations doesn't saturate the link. Get one of those wrong and the stream stutters under load, which is exactly when you can't afford it to.
The stack, without the compile step
Our streaming VPS gives you full root on a plain Linux image, and none of the stack needs compiling any more: Nginx-RTMP ships as a distro package (libnginx-mod-rtmp on Debian and Ubuntu), MediaMTX is a single binary, and Restreamer, MistServer and Owncast run from their own builds or containers. Between them they cover the protocol matrix you'd otherwise stitch together by hand — RTMP, RTMPS, SRT, HLS and LL-HLS. So a plain nginx rtmp server setup on a VPS becomes an install, a short config and "point your encoder at the ingest URL," not "spend Saturday reading module docs."
Concretely, that means:
- Ingest — push RTMP/RTMPS from OBS or an encoder, or SRT if you're on a lossy uplink and want the error correction.
- Restream — fan a single push out to multiple destinations from one host, so your uplink carries one stream and the box does the duplication. That's the multistream VPS pattern without paying a per-destination SaaS fee.
- Package HLS — Nginx-RTMP or MediaMTX writes the HLS/LL-HLS segments, and you serve them straight off the same machine or front them with a cache.
Because you have root access, none of this is a locked appliance. Swap the HLS fragment length, add an auth hook on on_publish, drop in a transcode profile, or write the config from scratch — it's your kernel and your nginx.conf.
Why bandwidth is the whole game
Streaming is the one workload where the network matters more than the CPU. A restream to five destinations at 6 Mbps each is 30 Mbps of egress off a single 6 Mbps ingest — and HLS viewers add to that linearly. On a metered or oversold link, that's where the buffering starts. Every streaming VPS tier runs unmetered, with no per-VM bandwidth ceiling, so the restream fan-out and the HLS viewer pull both draw from the node uplink with no transfer quota to watch. Direction matters too: ingest is upload-heavy from the encoder's side and download-heavy from the viewer's, and you want headroom both ways.
Traffic leaves through our own AS60982, which takes IP transit from a single upstream carrier, and you can deploy in seven locations — Bucharest, Sofia, Warsaw, Amsterdam, Frankfurt, Vienna and Ashburn — so the ingest sits close to your encoder. And every box includes 100 Gbps of DDoS protection, which for a public ingest endpoint is not optional insurance; an exposed RTMP port is a target.
Picking a tier
Sizing an RTMP host is mostly about whether you transcode. Pure relay and HLS packaging is light on CPU and leans on the network — the entry tier handles it. The moment you add a transcode ladder (one input, multiple output bitrates), CPU becomes the constraint and you'll want more vCPUs.
| Workload | What it needs | Where to start |
|---|---|---|
| Single ingest → HLS, no transcode | Bandwidth, a little RAM | Entry streaming tier, EUR 9.99/mo |
| Restream / multistream to several endpoints | Bandwidth headroom | Entry to mid streaming tier |
| Transcode ladder (multi-bitrate output) | vCPUs + RAM | Higher streaming tiers (up to 32 GB / 12 vCPU / 120 GB) |
The streaming line runs from EUR 9.99/mo up to EUR 139.99/mo, all on SSD, unmetered, with no per-VM bandwidth ceiling. If your project is more general compute with occasional streaming, a plain hourly VPS can run the same stack (with its port shaped 100–300 Mbps) — but the streaming tiers exist because an unshaped port is what streaming actually needs.
How Noded Can Help
We built the streaming VPS because standard VPS shapes cap throughput per VM, and a busy restream or HLS origin shouldn't be capped. It's an unmetered box with no per-VM bandwidth ceiling and full root, deployed in about a minute. Install Nginx-RTMP, MediaMTX, MistServer or Restreamer, push your first stream, and tune from there — the config is yours to own. The streaming VPS page lists every tier from EUR 9.99/mo up. And if your workload is mostly general compute with the odd broadcast, our hourly VPS line runs the same stack and bills by the hour, so a spin-up to test a broadcast only costs for the hours it exists — delete it when you're done, since a stopped VPS still bills and a started hour counts as a full hour.
FAQ
Do I need to install Nginx-RTMP myself?
Yes, but it's quick. The streaming VPS gives you full root on a plain Linux image: on Debian or Ubuntu, Nginx-RTMP is one package (libnginx-mod-rtmp), and MediaMTX, MistServer and Restreamer install from their own binaries or containers. No compiling modules — install, add a short config, point your encoder at the ingest URL and check the HLS playlist. Because you have root, you can customise or replace any of it.
Can one server restream to multiple destinations?
Yes. Restreaming (multistreaming) is the core relay pattern — a single encoder push is fanned out to several RTMP endpoints from one host, so your uplink only carries one stream. Streaming plans are unmetered with no per-VM bandwidth ceiling, so the extra egress from the fan-out is neither throttled per VM nor counted against a transfer quota.
Which streaming protocols are supported?
RTMP, RTMPS, SRT, HLS and LL-HLS are all supported by the open-source servers you install — MediaMTX alone covers all five. RTMP/RTMPS for standard encoder ingest, SRT when your uplink is lossy and you want error correction, and HLS/LL-HLS for browser and mobile playback.
How much does RTMP server hosting cost?
The streaming VPS line starts at EUR 9.99/mo for the entry tier and runs up to EUR 139.99/mo for the largest, all on SSD, unmetered, with no per-VM bandwidth ceiling. If you'd rather pay by the hour, the same stack runs on our hourly VPS line, which is billed by the hour.
What size VPS do I need for RTMP?
Pure ingest and HLS packaging with no transcode is bandwidth-bound and runs comfortably on the entry tier. If you add a transcode ladder — one input, several output bitrates — CPU becomes the limit, so step up to a higher tier with more vCPUs and RAM.