How to configure Nginx RTMP for live streaming from OBS

Update the APT package index:

sudo apt update

This command syncs the lists of available packages. Required before installing anything new on a server that has been idle.

Install the compiler and the development libraries:

sudo apt install -y build-essential libpcre3-dev libssl-dev zlib1g-dev git wget

build-essential brings gcc and make. libpcre3-dev is required for the Nginx regex module, libssl-dev for HTTPS and zlib1g-dev for gzip. Around ~250 MB installed in total.

Create a working directory and download the stable Nginx release:

mkdir -p ~/build && cd ~/build
wget https://nginx.org/download/nginx-1.26.2.tar.gz
tar -xzvf nginx-1.26.2.tar.gz

The 1.26.x version is the current stable line. Avoid mainline (1.27.x) in production unless you need a specific feature.

Clone the RTMP module:

cd ~/build
git clone https://github.com/sergey-dryabzhinsky/nginx-rtmp-module.git

This fork maintains compatibility with modern Nginx and ships bugfixes that the archived original never received.

Configure the build pointing to the RTMP module:

cd ~/build/nginx-1.26.2
./configure \
  --prefix=/etc/nginx \
  --sbin-path=/usr/sbin/nginx \
  --conf-path=/etc/nginx/nginx.conf \
  --pid-path=/var/run/nginx.pid \
  --with-http_ssl_module \
  --with-http_v2_module \
  --add-module=../nginx-rtmp-module

If any --with-* complains about a missing library, install the corresponding -dev package via apt and re-run configure.

Compile and install:

make -j$(nproc)
sudo make install

-j$(nproc) parallelizes the compilation across the available cores. On a single vCPU it takes ~7 minutes; on 4 vCPUs, ~2 minutes.

Create the systemd service to manage Nginx:

sudo tee /etc/systemd/system/nginx.service > /dev/null <<'EOF'
[Unit]
Description=Nginx HTTP and RTMP server
After=network.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/usr/sbin/nginx -s reload
ExecStop=/usr/sbin/nginx -s quit
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable nginx

ExecStartPre validates the configuration before bringing it up — avoids a broken service after an edit.

Create the directory where HLS fragments will be written:

sudo mkdir -p /var/www/hls
sudo chown -R nobody:nogroup /var/www/hls

Nginx, without a custom user configured, runs as nobody. Adjust if you set user www-data in nginx.conf.

Replace /etc/nginx/nginx.conf with a configuration that combines HTTP + RTMP:

worker_processes auto;
events {
    worker_connections 1024;
}

rtmp {
    server {
        listen 1935;
        chunk_size 4096;

        application live {
            live on;
            record off;

            hls on;
            hls_path /var/www/hls;
            hls_fragment 3s;
            hls_playlist_length 60s;

            allow publish 127.0.0.1;
            allow publish 198.51.100.0/24;
            deny publish all;
        }
    }
}

http {
    include mime.types;
    default_type application/octet-stream;
    sendfile on;
    keepalive_timeout 65;

    server {
        listen 80;
        server_name _;

        location /hls {
            types {
                application/vnd.apple.mpegurl m3u8;
                video/mp2t ts;
            }
            root /var/www;
            add_header Cache-Control no-cache;
            add_header Access-Control-Allow-Origin *;
        }

        location /stat {
            rtmp_stat all;
            rtmp_stat_stylesheet stat.xsl;
        }

        location /stat.xsl {
            root /var/www;
        }
    }
}

Replace 198.51.100.0/24 with your actual source IP/network. The allow publish block is the first line of defense — without it, anyone with your RTMP URL can publish.

Validate the syntax and start the service:

sudo nginx -t
sudo systemctl start nginx

nginx -t should respond with configuration file ... test is successful. Any error here points to the exact line — fix it before continuing.

Enable UFW and open the required ports:

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 1935/tcp
sudo ufw enable

Confirm with sudo ufw status numbered that the 4 rules show up before you disconnect from SSH.

Open OBS → Settings → Stream and fill in:

The “key” is the name that shows up in the HLS fragments and in the Nginx-RTMP logs. It can be any ASCII string without spaces.

Click “Start Streaming” in OBS. OBS connects to rtmp://YOUR-IP/live and starts publishing the stream with the name my-stream-001.

List the files in /var/www/hls:

ls -la /var/www/hls/

Expected output, ~3 seconds after starting to publish:

my-stream-001-0.ts
my-stream-001-1.ts
my-stream-001.m3u8

The .ts files are MPEG-TS fragments of ~3 seconds each. The .m3u8 is the manifest that points to the current fragments.

Test it in the browser via https://hls-js.netlify.app/demo/ or any player that accepts HLS. Paste http://YOUR-IP/hls/my-stream-001.m3u8 and hit play.

For a quick test without a web player, use ffplay:

ffplay http://YOUR-IP/hls/my-stream-001.m3u8

Expected end-to-end latency from OBS to the player is 9-15 seconds with the default configuration above (hls_fragment 3s × buffer of 3 fragments on the player).