Build a Video Streaming Server with Node.js

Core Streaming Protocols

Modern video streaming relies on several standardized protocols, each optimized for specific use cases and device compatibility. Understanding these protocols helps you choose the right approach for your application requirements and audience needs.

RTMP (Real-Time Messaging Protocol)

RTMP remains widely used for ingesting live streams from encoders and broadcasting software. Originally developed by Adobe, RTMP maintains low-latency connections between sources and servers, making it the preferred protocol for live event streaming. While Flash Player discontinuation reduced RTMP's client-side relevance, it continues serving as a crucial internal protocol for stream ingestion. Many encoders, including OBS Studio, output RTMP streams by default, requiring RTMP support on the server side for compatibility.

HLS (HTTP Live Streaming)

HLS developed by Apple has become the dominant protocol for adaptive bitrate streaming to web and mobile browsers. HLS works by dividing video into small segments (typically 2-10 seconds) and providing a manifest file that lists available quality levels. Clients automatically select appropriate quality based on network conditions, delivering smooth playback even when bandwidth fluctuates. The protocol's widespread browser support and adaptive streaming capabilities make it the standard choice for most web-based video delivery.

WebRTC (Web Real-Time Communication)

WebRTC enables peer-to-peer, ultra-low latency streaming for interactive applications. According to VideoSDK's protocol overview, video conferencing, live gaming, and real-time interaction platforms benefit from WebRTC's millisecond-level latency, which traditional streaming protocols cannot achieve. The protocol handles NAT traversal, codec negotiation, and stream synchronization automatically, simplifying real-time communication development. WebRTC excels for applications where immediate response matters more than broadcast-quality video optimization.

To learn more about implementing real-time communication features, see our comprehensive guide to the WebRTC API for browser-based video and audio streaming implementation.

Building a Basic Streaming Server

The foundational approach to Node.js video streaming involves using the filesystem module's streaming capabilities and properly handling HTTP Range requests. This implementation requires minimal dependencies while providing the core functionality needed for video playback.

Project Setup

Begin by creating a project directory and initializing a Node.js project with npm init -y. The streaming server implementation relies on Node.js's built-in modules, including fs for file operations, path for file path manipulation, and http for network communication. The server parses incoming requests to identify the requested video file and determine whether a Range header is present.

Core Implementation

When a Range header exists, the server extracts the start and end byte positions requested by the client. It then creates a read stream for the specific file portion, sets appropriate HTTP headers indicating partial content status, and pipes the stream directly to the response. For requests without Range headers, the server can either redirect to a range-based request or stream the entire file from the beginning. This dual-mode handling ensures compatibility with various player implementations.

const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer((req, res) => {
 const filePath = path.join(__dirname, 'videos', req.url);
 const stat = fs.statSync(filePath);
 const fileSize = stat.size;
 const range = req.headers.range;

 if (range) {
 const parts = range.replace(/bytes=/, '').split('-');
 const start = parseInt(parts[0], 10);
 const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
 const chunksize = end - start + 1;
 
 const file = fs.createReadStream(filePath, { start, end });
 
 res.writeHead(206, {
 'Content-Range': `bytes ${start}-${end}/${fileSize}`,
 'Accept-Ranges': 'bytes',
 'Content-Length': chunksize,
 'Content-Type': 'video/mp4'
 });
 
 file.pipe(res);
 } else {
 res.writeHead(200, {
 'Content-Length': fileSize,
 'Content-Type': 'video/mp4'
 });
 fs.createReadStream(filePath).pipe(res);
 }
});

server.listen(3000);

The streaming implementation must correctly calculate file sizes, handle edge cases like requests beyond file bounds, and set proper Content-Type headers based on file extensions. Error handling prevents crashes when files are missing or unreadable, while streaming optimizations like buffer sizing adjustments ensure smooth data transmission.

Advanced Implementation with Node-Media-Server

For production deployments requiring protocol transcoding, live streaming support, and advanced features, the Node-Media-Server library provides a comprehensive solution. This npm package implements RTMP, HTTP-FLV, HLS, and WebRTC capabilities without requiring extensive low-level networking code.

Installation and Configuration

npm install node-media-server

const NodeMediaServer = require('node-media-server');

const config = {
 rtmp: {
 port: 1935,
 chunk_size: 60000,
 gop_cache: true,
 ping: 30,
 ping_timeout: 60
 },
 http: {
 port: 8000,
 mediaroot: './media',
 allow_origin: '*'
 },
 trans: {
 ffmpeg: '/usr/bin/ffmpeg',
 tasks: [
 {
 app: 'live',
 hls: true,
 hlsFlags: '[hls_time=2:hls_list_size=3:hls_flags=delete_segments]',
 dash: true,
 dashFlags: '[f=dash:window_size=3:extra_window_size=5]'
 }
 ]
 }
};

const nms = new NodeMediaServer(config);
nms.run();

Event Handling

The Node-Media-Server emits events throughout the streaming lifecycle, enabling custom logic for analytics, access control, and stream management. The prePublish event allows authentication checks before streams begin, while donePublish triggers cleanup operations when streams end.

nms.on('prePublish', (id, StreamPath, args) => {
 const streamKey = StreamPath.split('/')[2];
 console.log('Stream started:', streamKey);
});

nms.on('donePublish', (id, StreamPath, args) => {
 const streamKey = StreamPath.split('/')[2];
 console.log('Stream ended:', streamKey);
});

OBS Studio Integration

Configure OBS to stream to your Node-Media-Server using the URL format:

• Server: rtmp://localhost/live
• Stream Key: your unique stream identifier

Access the stream via:

• HTTP-FLV: http://localhost:8000/live/stream-key.flv
• HLS: http://localhost:8000/live/stream-key/index.m3u8

For organizations building cloud-based solutions, integrating a media server with cloud infrastructure enables scalable video streaming that grows with audience demand.

FFmpeg Integration and Transcoding

FFmpeg serves as the engine powering video transcoding within Node.js streaming servers, converting source videos into streaming-optimized formats and quality levels. The integration enables adaptive bitrate streaming, format conversion, and quality optimization essential for professional deployments.

Transcoding Configuration

Transcoding configurations specify input sources, output formats, and encoding parameters through FFmpeg command-line syntax. For HLS streaming, configuration defines segment duration (typically 2-10 seconds), playlist size, and cleanup behavior for old segments.

Adaptive Bitrate Streaming

Adaptive bitrate streaming requires multiple quality variants, each with different resolution and bitrate settings:

Clients automatically select appropriate quality based on available bandwidth, delivering smooth playback even when network conditions fluctuate.

Recording Live Streams

Node-Media-Server can automatically record live streams for video-on-demand playback:

{
 "record": {
 "enable": true,
 "path": "./media/recordings",
 "accessControl": "allow"
 }
}

Recorded files can be served via HTTP for on-demand viewing, extending the utility of live streaming infrastructure. Hardware acceleration via GPU encoding significantly improves transcoding performance, reducing CPU load during high-volume processing.

Security and Authentication

Securing video streaming servers prevents unauthorized access, protects content rights, and maintains service quality. Multiple layers of security address different threat vectors across the streaming infrastructure.

Token-Based Authentication

Token-based authentication validates stream access requests using time-limited tokens signed with secret keys. The server generates tokens for authorized publishers and viewers, verifying token validity before permitting stream access. Token expiration prevents replay attacks and limits exposure if credentials are compromised.

nms.on('prePublish', (id, StreamPath, args) => {
 const token = args.token;
 if (!verifyToken(token)) {
 const session = nms.getSession(id);
 session.reject();
 }
});

Stream Key Management

Stream keys should be:

• Randomly generated (use crypto.randomUUID())
• Unique per channel
• Rotatable without disrupting viewers
• Never exposed in public URLs

Network Security Measures

• Firewall rules limiting RTMP and HTTP ports
• HTTPS encryption for HTTP-based streaming
• IP allowlisting for encoder sources
• Rate limiting to prevent abuse

Best Practices Summary

1. Use authentication tokens for all stream access
2. Enable SSL/TLS for encrypted transmission
3. Implement stream key rotation policies
4. Monitor for unauthorized publishing attempts
5. Regular security audits and updates

For robust error handling patterns in Node.js applications, see our guide to JavaScript error handling covering try-catch patterns, error events, and graceful failure management.

Implementing proper security measures is essential for enterprise web applications that handle sensitive video content or require compliance with data protection regulations.

Scaling and Performance Optimization

High-traffic streaming deployments require horizontal scaling strategies that distribute load across multiple server instances while maintaining quality of service. Infrastructure design and configuration optimization ensure responsive playback under varying demand.

GOP Caching

GOP (Group of Pictures) caching accelerates stream startup by maintaining recent video frames for immediate delivery. New viewers receive recent keyframes without waiting for full segment generation, reducing time-to-first-frame.

{
 "rtmp": {
 "gop_cache": true,
 "ping": 30
 }
}

Clustering Multiple Instances

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isPrimary) {
 for (let i = 0; i < numCPUs; i++) {
 cluster.fork();
 }
} else {
 // Start NodeMediaServer instance
}

For a comprehensive overview of Node.js modules and module patterns, explore our guide to JavaScript modules covering exports, imports, and module resolution.

CDN Integration

CDN integration caches streaming content at edge locations, reducing origin server load and improving playback latency for geographically distributed viewers. Segment-based caching aligns with HLS and DASH architecture, enabling efficient cache population and invalidation.

Performance Monitoring

Key metrics to track:

• Concurrent viewer connections
• Stream startup latency
• Bitrate stability
• Server CPU and memory usage
• CDN cache hit ratio
• Error rates by stream type

For large-scale deployments, consider integrating with cloud infrastructure services that provide auto-scaling, global edge networks, and managed streaming capabilities.

Client-Side Playback Implementation

Delivering video to viewers requires client-side players capable of consuming the streaming protocol and rendering video content. Player selection and configuration significantly impact user experience and device compatibility.

HTTP-FLV Playback with flv.js

<script src="https://cdn.jsdelivr.net/npm/flv.js/dist/flv.min.js"></script>
<video id="videoElement" controls></video>
<script>
 if (flvjs.isSupported()) {
 const flvPlayer = flvjs.createPlayer({
 type: 'flv',
 url: 'http://localhost:8000/live/stream.flv'
 });
 flvPlayer.attachMediaElement(videoElement);
 flvPlayer.load();
 flvPlayer.play();
 }
</script>

HLS Playback with hls.js

<script src="https://cdn.jsdelivr.net/npm/hls.js/dist/hls.min.js"></script>
<video id="videoElement" controls></video>
<script>
 if (Hls.isSupported()) {
 const hls = new Hls();
 hls.loadSource('http://localhost:8000/live/stream/index.m3u8');
 hls.attachMedia(videoElement);
 hls.on(Hls.Events.MANIFEST_PARSED, () => {
 videoElement.play();
 });
 }
</script>

Native HLS in Safari

Safari provides native HLS support without requiring additional libraries:

const video = document.getElementById('videoElement');
video.src = 'http://localhost:8000/live/stream/index.m3u8';
video.addEventListener('canplay', () => {
 video.play();
});

Adaptive bitrate selection algorithms balance video quality against playback smoothness. Players monitor download speed and buffer levels, switching quality levels to maintain continuous playback. Manual quality controls allow users to override automatic selection for specific preferences or device limitations.

Sources

1. LogRocket: Build a video streaming server with Node.js - Comprehensive guide covering Node.js streams, Range headers, and chunked video delivery patterns
2. VideoSDK: Node.js Media Server Complete Guide 2025 - Complete coverage of RTMP, HLS, WebRTC protocols, Node-Media-Server setup, FFmpeg integration, and security best practices
3. 100ms: How to Create a Node.js Video Streaming Server - Step-by-step tutorial for real-time video streaming implementation