{"id":1007,"date":"2026-05-06T11:41:29","date_gmt":"2026-05-06T04:41:29","guid":{"rendered":"https:\/\/liveapi.com\/blog\/nginx-rtmp\/"},"modified":"2026-05-06T11:41:59","modified_gmt":"2026-05-06T04:41:59","slug":"nginx-rtmp","status":"publish","type":"post","link":"https:\/\/liveapi.com\/blog\/nginx-rtmp\/","title":{"rendered":"Nginx RTMP: How to Set Up a Live Streaming Server (Complete Guide)"},"content":{"rendered":"Reading Time: <\/span> 10<\/span> minutes<\/span><\/span>

If you’ve ever wanted to run your own live streaming server without paying for a cloud platform, the nginx rtmp module is probably the first project you read about. It turns the same web server that powers a third of the internet into a working RTMP ingest endpoint, an HLS packager, and a multi-platform relay \u2014 for the cost of a small VPS.<\/p>\n

This guide walks through what the nginx rtmp module actually does, how the data flow works, every directive you need for a basic setup, an example that produces both RTMP playback and an HLS playlist, the trade-offs you’ll hit at scale, and when it makes more sense to send your stream to a managed API instead.<\/p>\n

What Is Nginx RTMP?<\/h2>\n

Nginx rtmp (also written as nginx-rtmp-module) is an open-source nginx module that adds support for the RTMP protocol<\/a>, HLS, and MPEG-DASH to the nginx web server. Once compiled in or loaded as a dynamic module, nginx accepts RTMP publishes on TCP port 1935, plays the streams back to RTMP viewers, and can package the same input as HLS or DASH segments served over HTTP.<\/p>\n

The original project \u2014 arut\/nginx-rtmp-module<\/a> \u2014 was created by Roman Arutyunyan and is licensed BSD-2-Clause. It has 14,000+ stars on GitHub, runs on Linux, FreeBSD, macOS, and Windows, and is the most widely deployed open-source RTMP server<\/a> in the developer community. Active development on the original repo slowed years ago, but several community forks (notably nginx-rtmp-module by sergey-dryabzhinsky) keep it patched against modern nginx releases.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Attribute<\/th>\nValue<\/th>\n<\/tr>\n<\/thead>\n
Project<\/td>\nnginx-rtmp-module<\/td>\n<\/tr>\n
License<\/td>\nBSD-2-Clause<\/td>\n<\/tr>\n
Default ingest port<\/td>\n1935 (TCP)<\/td>\n<\/tr>\n
Ingest protocol<\/td>\nRTMP, RTMPS (with stunnel)<\/td>\n<\/tr>\n
Output protocols<\/td>\nRTMP, HLS, MPEG-DASH, FLV<\/td>\n<\/tr>\n
Codecs<\/td>\nH.264 video, AAC audio (passthrough; transcoding via FFmpeg exec<\/code>)<\/td>\n<\/tr>\n
Recording<\/td>\nFLV files via record<\/code> directive<\/td>\n<\/tr>\n
Authentication<\/td>\nHTTP callback (on_publish<\/code>, on_play<\/code>)<\/td>\n<\/tr>\n
Platforms<\/td>\nLinux, FreeBSD, macOS, Windows (limited)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

How Does Nginx RTMP Work?<\/h2>\n

Nginx rtmp adds an rtmp { }<\/code> block at the top level of nginx.conf<\/code>, parallel to the standard http { }<\/code> block. When nginx starts with the module loaded, it opens a TCP listener on port 1935 and waits for RTMP clients.<\/p>\n

Here’s the data flow for a typical OBS-to-browser stream:<\/p>\n

    \n
  1. Publisher connects.<\/strong> OBS, FFmpeg, or another RTMP encoder<\/a> opens a TCP connection to rtmp:\/\/your-server\/live\/streamkey<\/code>. Nginx accepts it and matches the URL against an application<\/code> block.<\/li>\n
  2. Stream is received.<\/strong> Nginx parses the RTMP handshake, then begins accepting H.264 video and AAC audio chunks. The chunk_size 4096;<\/code> directive controls how big each RTMP message can be.<\/li>\n
  3. Stream is fanned out.<\/strong> With live on;<\/code>, nginx broadcasts the incoming feed to every RTMP viewer that has subscribed to the same path. This is the classic publisher-to-many-subscribers pattern.<\/li>\n
  4. Optional packaging.<\/strong> If hls on;<\/code> is set, nginx writes .ts<\/code> segments and an .m3u8<\/code> playlist to disk every few seconds. An HTTP server block then serves those files to browsers and mobile players. This is the same packaging step you read about in RTMP to HLS conversion<\/a>.<\/li>\n
  5. Optional recording or relay.<\/strong> With record all;<\/code>, nginx writes a .flv<\/code> file for each session. With push rtmp:\/\/otherserver\/live\/key;<\/code>, it forwards the stream to another endpoint \u2014 useful for multi-destination broadcasts.<\/li>\n<\/ol>\n

    The module never re-encodes by default. It moves bytes from publisher to subscriber and writes segments. If you need transcoding (different bitrates for adaptive bitrate streaming<\/a>, or codec changes), you wire up an exec<\/code> directive that calls ffmpeg<\/code> per stream.<\/p>\n

    Key Features of the Nginx RTMP Module<\/h2>\n

    The feature set is small but covers the core workflows for self-hosted live streaming.<\/p>\n

    RTMP Ingest and Playback<\/h3>\n

    The module accepts RTMP publishes and serves RTMP playback on the same port. This is the use case 90% of people install it for: an open ingest URL that OBS, vMix, FFmpeg, or any live streaming encoder<\/a> can push to.<\/p>\n

    HLS and DASH Packaging<\/h3>\n

    Setting hls on;<\/code> and dash on;<\/code> turns the same RTMP input into an HTTP-delivered stream that browsers and mobile devices can play. This is what makes nginx rtmp practical for web playback \u2014 without it, you’d be limited to Flash players, which no modern browser supports.<\/p>\n

    Multi-Worker Streaming<\/h3>\n

    The rtmp_auto_push on;<\/code> directive lets nginx run multiple worker processes and automatically relay streams between them, so you can use all your CPU cores instead of being capped at one.<\/p>\n

    Stream Relay (Push and Pull)<\/h3>\n

    push<\/code> sends an incoming stream to one or more downstream RTMP servers. pull<\/code> does the reverse \u2014 nginx fetches a remote stream when a viewer connects. This is how you build a small CDN tier or restream to YouTube and Twitch from a single ingest point.<\/p>\n

    Recording<\/h3>\n

    The record<\/code> directive saves incoming streams to FLV files. You can capture every session, only on demand via control API, or by file size. This is the typical building block for live RTMP stream<\/a> archive workflows.<\/p>\n

    HTTP Callbacks<\/h3>\n

    on_publish<\/code>, on_play<\/code>, on_record_done<\/code>, and similar hooks fire HTTP requests to your application when streams start, stop, or finish recording. You use them for authentication, billing, and to trigger downstream processing.<\/p>\n

    Statistics<\/h3>\n

    The module exposes an XML stats endpoint that you can serve through any HTTP location and style with the included XSL stylesheet. It shows active publishers, subscribers, bandwidth, and per-stream metadata.<\/p>\n

    Nginx RTMP vs. Other Streaming Servers<\/h2>\n

    Nginx rtmp is one of several open-source RTMP server projects. Here’s how it compares to the most common alternatives:<\/p>\n\n\n\n\n\n\n\n\n\n
    Server<\/th>\nProtocols<\/th>\nLicense<\/th>\nBest For<\/th>\nTrade-Off<\/th>\n<\/tr>\n<\/thead>\n
    nginx rtmp<\/strong><\/td>\nRTMP, HLS, DASH<\/td>\nBSD-2<\/td>\nSimple self-hosted ingest + HLS<\/td>\nNo WebRTC, slow upstream maintenance<\/td>\n<\/tr>\n
    SRS (Simple Realtime Server)<\/strong><\/td>\nRTMP, WebRTC, HLS, HTTP-FLV, SRT, DASH, GB28181<\/td>\nMIT<\/td>\nHigher concurrency, modern protocols<\/td>\nSteeper learning curve<\/td>\n<\/tr>\n
    Ant Media Server<\/strong><\/td>\nWebRTC, RTMP, SRT, HLS, CMAF<\/td>\nApache 2 (Community) \/ Commercial<\/td>\nSub-second WebRTC + transcoding<\/td>\nHeavier, JVM-based<\/td>\n<\/tr>\n
    MistServer<\/strong><\/td>\nRTMP, WebRTC, HLS, DASH, MP4<\/td>\nCustom<\/td>\nMany output formats<\/td>\nLess community<\/td>\n<\/tr>\n
    Wowza Streaming Engine<\/strong><\/td>\nRTMP, WebRTC, SRT, HLS, DASH<\/td>\nCommercial<\/td>\nEnterprise features, support<\/td>\nPaid license<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    If you only need RTMP ingest and HLS output and you’re comfortable in nginx config, the nginx rtmp module is the smallest, most predictable option. If you need WebRTC for sub-second latency, SRS or Ant Media is the better starting point. Compare more options in our list of the best video streaming servers<\/a>.<\/p>\n

    How to Install the Nginx RTMP Module<\/h2>\n

    There are two paths: install a pre-packaged version, or build nginx from source with the module compiled in. The first is faster; the second gives you the latest module version and lets you patch it.<\/p>\n

    Option 1: Install via Apt (Ubuntu\/Debian)<\/h3>\n

    The libnginx-mod-rtmp<\/code> package ships in the Ubuntu repos and works for most use cases.<\/p>\n

    sudo apt update\nsudo apt install libnginx-mod-rtmp<\/code><\/pre>\n
    This installs nginx (if it’s not already present) and the RTMP dynamic module. The module is auto-loaded via \/etc\/nginx\/modules-enabled\/50-mod-rtmp.conf<\/code>.<\/p>\n
    Option 2: Build From Source<\/h3>\n
    Use this when you need the latest module commit, want HLS encryption, or are running a non-Debian distribution.<\/p>\n
    sudo apt install -y build-essential libpcre3-dev libssl-dev zlib1g-dev git\ncd \/tmp\nwget https:\/\/nginx.org\/download\/nginx-1.26.2.tar.gz\ntar -xzf nginx-1.26.2.tar.gz\ngit clone https:\/\/github.com\/arut\/nginx-rtmp-module.git\ncd nginx-1.26.2\n.\/configure --with-http_ssl_module --add-module=\/tmp\/nginx-rtmp-module\nmake\nsudo make install<\/code><\/pre>\n
    Nginx will install to \/usr\/local\/nginx<\/code>. Symlink the binary into your path, then create a systemd unit so it starts on boot.<\/p>\n
    Open the Firewall<\/h3>\n
    RTMP listens on TCP 1935. If you’re running UFW:<\/p>\n
    sudo ufw allow 1935\/tcp\nsudo ufw allow 80\/tcp\nsudo ufw allow 8080\/tcp<\/code><\/pre>\n
    Port 80 or 8080 is for HTTP delivery of HLS segments. Port 1935 is for the RTMP ingest itself.<\/p>\n
    Basic Nginx RTMP Configuration<\/h2>\n
    The minimum working config for a private RTMP server is about 15 lines. Add this to \/etc\/nginx\/nginx.conf<\/code> (or \/usr\/local\/nginx\/conf\/nginx.conf<\/code> if you built from source):<\/p>\n
    load_module modules\/ngx_rtmp_module.so;\n\nevents {\n    worker_connections 1024;\n}\n\nrtmp {\n    server {\n        listen 1935;\n        chunk_size 4096;\n\n        application live {\n            live on;\n            record off;\n            allow publish 127.0.0.1;\n            allow publish 192.168.1.0\/24;\n            deny publish all;\n            allow play all;\n        }\n    }\n}\n\nhttp {\n    server {\n        listen 80;\n        location \/stat {\n            rtmp_stat all;\n            rtmp_stat_stylesheet stat.xsl;\n        }\n    }\n}<\/code><\/pre>\n
    After saving, run sudo nginx -t<\/code> to validate syntax, then sudo systemctl reload nginx<\/code>. You can now publish to rtmp:\/\/\/live\/<\/code> from OBS or FFmpeg, and play back from VLC at the same URL.<\/p>\n
    A few directives worth understanding:<\/p>\n