MediaMTX / rtsp-simple-server is a ready-to-use and zero-dependency server and proxy that allows users to publish, read and proxy live video and audio streams.

Live streams can be published to the server with:

And can be read from the server with:

Features:

rtsp-simple-server is being rebranded as MediaMTX. The reason is pretty obvious: this project started as a RTSP server but has evolved into a much more versatile media server (i like to call it a "media broker", a message broker for media streams), that is not tied to the RTSP protocol anymore. Nothing will change regarding license, features and backward compatibility.

Furthermore, my main open source projects are being transferred to the bluenviron organization, in order to allow the community to maintain and evolve the code regardless of my personal availability.

In the next months, the repository name and the Docker image name will be changed accordingly.

Download and extract a precompiled binary from the release page.

Start the server:

Download and launch the image:

The --network=host flag is mandatory since Docker can change the source port of UDP packets for routing reasons, and this doesn't allow the server to find out the author of the packets. This issue can be avoided by disabling the UDP transport protocol:

Please keep in mind that the Docker image doesn't include FFmpeg. if you need to use FFmpeg for an external command or anything else, you need to build a Docker image that contains both rtsp-simple-server and FFmpeg, by following instructions here.

In a x86 Linux system, download the OpenWRT SDK corresponding to the wanted OpenWRT version and target from the OpenWRT website and extract it.

Open a terminal in the SDK folder and setup the SDK:

Download the server Makefile and set the server version inside the file:

Compile the server:

Transfer the .ipk file from bin/packages/*/base to the OpenWRT system and install it with:

Publish a stream. For instance, you can publish a video/audio file with FFmpeg:

or GStreamer:

To publish from other hardware / software, take a look at the Publish to the server section.

Open the stream. For instance, you can open the stream with VLC:

or GStreamer:

or FFmpeg:

All the configuration parameters are listed and commented in the configuration file.

There are 3 ways to change the configuration:

By editing the mediamtx.yml file, that is

included into the release bundle

available in the root folder of the Docker image (/mediamtx.yml); it can be overridden in this way:

The configuration can be changed dynamically when the server is running (hot reloading) by writing to the configuration file. Changes are detected and applied without disconnecting existing clients, whenever it's possible.

By overriding configuration parameters with environment variables, in the format MTX_PARAMNAME, where PARAMNAME is the uppercase name of a parameter. For instance, the rtspAddress parameter can be overridden in the following way:

Parameters that have array as value can be overriden by setting a comma-separated list. For example:

Parameters in maps can be overridden by using underscores, in the following way:

This method is particularly useful when using Docker; any configuration parameter can be changed by passing environment variables with the -e flag:

By using the HTTP API.

Edit mediamtx.yml and replace everything inside section paths with the following content:

Only publishers that provide both username and password will be able to proceed:

It's possible to setup authentication for readers too:

If storing plain credentials in the configuration file is a security problem, username and passwords can be stored as sha256-hashed strings; a string must be hashed with sha256 and encoded with base64:

Then stored with the sha256: prefix:

WARNING: enable encryption or use a VPN to ensure that no one is intercepting the credentials.

Authentication can be delegated to an external HTTP server:

Each time a user needs to be authenticated, the specified URL will be requested with the POST method and this payload:

If the URL returns a status code that begins with 20 (i.e. 200), authentication is successful, otherwise it fails.

Please be aware that it's perfectly normal for the authentication server to receive requests with empty users and passwords, i.e.:

This happens because a RTSP client doesn't provide credentials until it is asked to. In order to receive the credentials, the authentication server must reply with status code 401 - the client will then send credentials.

The configuration file can be entirely encrypted for security purposes.

An online encryption tool is available here.

The encryption procedure is the following:

NaCL's crypto_secretbox function is applied to the content of the configuration. NaCL is a cryptographic library available for C/C++, Go, C# and many other languages;

The string is prefixed with the nonce;

The string is encoded with base64.

After performing the encryption, put the base64-encoded result into the configuration file, and launch the server with the MTX_CONFKEY variable:

MediaMTX is also a proxy, that is usually deployed in one of these scenarios:

Edit mediamtx.yml and replace everything inside section paths with the following content:

After starting the server, users can connect to rtsp://localhost:8554/proxied, instead of connecting to the original url. The server supports any number of source streams, it's enough to add additional entries to the paths section:

It's possible to save bandwidth by enabling the on-demand mode: the stream will be pulled only when at least a client is connected:

To change the format, codec or compression of a stream, use FFmpeg or GStreamer together with MediaMTX. For instance, to re-encode an existing stream, that is available in the /original path, and publish the resulting stream in the /compressed path, edit mediamtx.yml and replace everything inside section paths with the following content:

To save available streams to disk, you can use the runOnReady parameter and FFmpeg:

In the configuratio above, streams are saved into TS files, that can be read even if the system crashes, while MP4 files can't.

Edit mediamtx.yml and replace everything inside section paths with the following content:

The command inserted into runOnDemand will start only when a client requests the path ondemand, therefore the file will start streaming only when requested.

Systemd is the service manager used by Ubuntu, Debian and many other Linux distributions, and allows to launch MediaMTX on boot.

Download a release bundle from the release page, unzip it, and move the executable and configuration in the system:

Create the service:

Open a terminal, navigate to the folder and run:

The server is now installed as a system service and will start at boot time.

The server can be queried and controlled with an HTTP API, that must be enabled by setting the api parameter in the configuration:

The API listens on apiAddress, that by default is 127.0.0.1:9997; for instance, to obtain a list of active paths, run:

Full documentation of the API is available on the dedicated site.

A metrics exporter, compatible with Prometheus, can be enabled with the parameter metrics: yes; then the server can be queried for metrics with Prometheus or with a simple HTTP request:

Obtaining:

A performance monitor, compatible with pprof, can be enabled with the parameter pprof: yes; then the server can be queried for metrics with pprof-compatible tools, like:

Install Go ≥ 1.20, download the repository, open a terminal in it and run:

The command will produce the mediamtx binary.

The server can be compiled with native support for the Raspberry Pi Camera. Compilation must happen on a Raspberry Pi Device, with the following dependencies:

Download the repository, open a terminal in it and run:

The command will produce the mediamtx binary.

Compilation for all supported platform can be launched by using:

The command will produce tarballs in folder binaries/.

To publish the video stream of a generic webcam to the server, edit mediamtx.yml and replace everything inside section paths with the following content:

If the platform is Windows:

Where USB2.0 HD UVC WebCam is the name of your webcam, that can be obtained with:

After starting the server, the webcam can be reached on rtsp://localhost:8554/cam.

MediaMTX natively support the Raspberry Pi Camera, enabling high-quality and low-latency video streaming from the camera to any user. There are a couple of requisites:

The server must run on a Raspberry Pi, with Raspberry Pi OS bullseye or newer as operative system. Both 32 bit and 64 bit operative systems are supported.

Make sure that the legacy camera stack is disabled. Type sudo raspi-config, then go to Interfacing options, enable/disable legacy camera support, choose no. Reboot the system.

If you want to run the standard (non-containerized) version of the server:

Make sure that the following packages are installed:

download the server executable. If you're using 64-bit version of the operative system, make sure to pick the arm64 variant.

edit mediamtx.yml and replace everything inside section paths with the following content:

If you want to run the server with Docker, you need to use the latest-rpi image (that already contains libcamera) and set some additional flags:

After starting the server, the camera can be reached on rtsp://raspberry-pi:8554/cam or http://raspberry-pi:8888/cam.

Camera settings can be changed by using the rpiCamera* parameters:

All available parameters are listed in the sample configuration file.

OBS Studio can publish to the server by using the RTMP protocol. In Settings -> Stream (or in the Auto-configuration Wizard), use the following parameters:

If credentials are in use, use the following parameters:

If you want to generate a stream that can be read with WebRTC, open Settings -> Output -> Recording and use the following parameters:

The use the button Start Recording (instead of Start Streaming) to start streaming.

To publish a video stream from OpenCV to the server, OpenCV must be compiled with GStreamer support, by following this procedure:

You can check that OpenCV has been installed correctly by running:

And verifying that the output contains GStreamer: YES.

Videos can be published with VideoWriter: