Spin Up Your Own Private RTMP Server in Minutes with This Docker Image

You've got OBS Studio set up, your stream looks great, but the platform you're streaming to is adding latency, compressing your video, or just doesn't fit your use case. Maybe you want to stream to a handful of friends without going through Twitch, or you're building a internal video distribution system at work. Setting up a streaming server from scratch sounds like a nightmare of compiled modules and cryptic config files. It doesn't have to be.

There's a Docker image that wraps up Nginx with the RTMP module so you can get a private streaming server running with a single command. It's called tiangolo/nginx-rtmp, and it does exactly what the name suggests: gives you a ready-to-go RTMP server for live video.

What It Does

This is a Docker image built from the latest sources of Nginx 1.15.0 and the nginx-rtmp-module 1.2.1. The module adds RTMP (Real-Time Messaging Protocol) support to Nginx, which is the protocol that tools like OBS Studio use to push live video streams out to the world.

The core use case here is straightforward: you run one Docker container, point OBS Studio at it, and then anyone with a media player like VLC can connect and watch the stream. Since it's built on Nginx, you're getting a battle-tested web server handling the heavy lifting rather than some niche streaming daemon.

The image was inspired by several other similar Docker projects, and the author built it specifically to solve the problem of streaming from OBS Studio to multiple different clients simultaneously. It's currently published with a latest tag, and if you want to pin your deployments to a specific build, there are also date-based tags available like latest-2020-08-16.

Why It's Cool

The killer feature here is how it collapses what used to be a fairly involved setup process into a single command. Before Docker images like this existed, getting an RTMP server running meant compiling Nginx from source with the right module flags, writing a custom config file, and hoping you didn't miss a dependency along the way.

What stands out about this project:

• It's genuinely one command to get started. The README shows a single docker run command that gets you a working server. No build steps, no configuration file editing, no guesswork.

• It handles the multi-client problem elegantly. The whole point is letting multiple people watch the same stream simultaneously. When OBS pushes a stream to the server, Nginx handles retransmitting it to however many clients connect. You don't need to think about fan-out or bandwidth management on the server side.

• It works with tools you probably already have. OBS Studio is the standard for streaming software, and VLC is the standard for playing just about anything. The README walks through testing with both, which means you can go from zero to streaming in a few minutes.

• It's built on current sources. Rather than using some stale packaged version of Nginx, this image builds from the latest available sources, so you're not starting with years-old software.

• The test workflow is thoughtful. There's a script included in the repo that publishes a test stream with a moving pattern and generated tone, so you can verify everything works without firing up OBS. That's the kind of detail that saves real debugging time.

How to Try It

Getting started is genuinely simple. First, make sure you have Docker installed, then run:

docker run -d -p 1935:1935 --name nginx-rtmp tiangolo/nginx-rtmp

That's it. You now have an RTMP server listening on port 1935.

To test it with OBS Studio and VLC:

1. Open OBS Studio and go to Settings, then the Stream section.
2. Set Stream Type to "Custom Streaming Server."
3. Enter rtmp://<ip_of_host>/live as the URL, replacing <ip_of_host> with your machine's IP address.
4. Set a stream key—something like test works fine.
5. Add a source (like screen capture), then hit "Start Streaming."

On the viewing side, open VLC and go to Media > Open Network Stream. Enter rtmp://<ip_of_host>/live/<key> (for example, rtmp://192.168.0.30/live/test) and click Play. VLC will start playing whatever OBS is transmitting.

If you want to test without OBS, you can build the image locally and use the included test script:

docker build -t nginx-rtmp-test .
docker run --rm --name nginx-rtmp-test -p 1935:1935 nginx-rtmp-test

Then in a second terminal, publish a test stream:

./scripts/publish-test-stream.sh

And in a third terminal, watch it:

ffplay rtmp://127.0.0.1:1935/live/test

The test stream runs continuously with a generated video pattern and tone, so you'll know immediately if everything is working.

Final Thoughts

This project is best for anyone who needs a private streaming setup without wanting to become an Nginx module compilation expert. Whether you're streaming a presentation to remote team members, testing video pipelines, or just want to broadcast to a few friends without a third-party platform, this image gets you there fast.

The honest limitation is that it's a fairly minimal setup—you get the RTMP server and not much else. There's no web UI for managing streams, no authentication layer, and no built-in transcoding. But for the core job of getting video from OBS to multiple viewers, it does exactly what it claims with minimal friction. Sometimes the right tool is the simple one that gets out of your way.

Follow @githubprojects for more developer tools and open source projects.