PRODUCTS
80% of viewers abandon a stream after just one buffering event.
Now picture this: a fan’s watching your live concert stream. The music’s building, the crowd’s electric, and right as the guitar solo kicks in, the player freezes.
That’s not just a glitch. That’s a lost viewer.
In 2024, flawless live streaming isn’t a nice-to-have, it’s table stakes. Viewers expect real-time quality, no delays, and zero buffering. Behind the scenes, that means adaptive bitrate streaming, global delivery, instant encoding, and real-time analytics.
But building all that from scratch? It’s like coding a rocket launch system during takeoff.
That’s why we built the FastPix Node.js SDK. It gives developers everything they need to ship production-grade live streaming, without duct-taping custom workflows together. This guide will show you how to go from setup to global stream delivery using Node.js and FastPix.
Live streaming seems straightforward, until you’re knee-deep in edge cases.
You start by setting up an RTMP server. Then comes transcoding, chunking, adaptive bitrate packaging, CDN integration, real-time logging, and player compatibility. Each layer adds complexity. And every “simple” feature like switching streams mid-broadcast or recovering from a dropped connection takes days of dev time to stabilize.
That’s where SDKs shine.
SDKs aren’t shortcuts. They’re the result of hundreds of solved problems, bundled into code you can trust. They give you:
Instead of stitching together scripts, tools, and edge-case patches, SDKs let you focus on building features that matter like multi-host streams, chat overlays, or viewer analytics.
They don’t just save time. They prevent entire categories of bugs you’d otherwise discover only after going live.
If you’re building anything that involves video streaming in real time, an SDK isn’t just helpful it’s foundational.
Node.js isn’t just another backend framework it’s built for real-time work. And when it comes to live streaming, real-time is everything.
With non-blocking I/O and an event-driven architecture, Node can handle thousands of concurrent connections without breaking a sweat. Whether you’re managing WebSockets for chat, pushing live video chunks, or tracking user interactions in real time, Node keeps it fast and responsive.
It also plays nicely with modern frontends React, Vue, Electron, you name it. That makes it easier to build full-stack video applications where the backend and UI speak the same language. Add in the massive NPM ecosystem covering everything from media processing to monitoring and you've got a flexible, production-ready foundation.
But let’s be honest: the bottlenecks aren’t in your JavaScript.
They’re in everything else transcoding, CDN integration, playback compatibility, and recovery logic when streams fail.
Node.js gives you the speed and flexibility to build real-time applications—but streaming at scale needs more than just fast code. You need a system that handles the heavy lifting: encoding, ABR packaging, retries, live-to-VOD, and global delivery.
That’s where the FastPix Node.js SDK comes in. It wraps all that complexity into a single, developer-friendly toolkit so you can go from idea to production without wrestling with the video plumbing.
The FastPix Node.js SDK takes care of the heavy lifting so you can focus on building features, not infrastructure. It gives you:
Here’s how to build a live streaming app step by step, using Node.js and FastPix.
Before integrating FastPix, let’s create a simple video server to grasp core streaming concepts.
1. Initialize your project
npm init -y
npm install express
2. Create a simple express server
// app.js
const express = require('express');
const fs = require('fs');
const app = express();
// Serve HTML with video player
app.get('/', (req, res) => {
res.sendFile(__dirname + '/index.html');
});
// Stream video chunks
app.get('/video', (req, res) => {
const range = req.headers.range;
const videoPath = './demo.mp4';
const videoSize = fs.statSync(videoPath).size;
// Chunk settings (1MB chunks)
const chunkSize = 1e6;
const start = Number(range?.replace(/\D/g, '') || 0;
const end = Math.min(start + chunkSize, videoSize - 1);
// HTTP 206 headers for partial content
res.writeHead(206, {
'Content-Range': `bytes ${start}-${end}/${videoSize}`,
'Accept-Ranges': 'bytes',
'Content-Length': end - start + 1,
'Content-Type': 'video/mp4'
});
// Stream video chunk
const videoStream = fs.createReadStream(videoPath, { start, end });
videoStream.pipe(res);
});
app.listen(3000, () => console.log('Server running on port 3000'));
3. Create the HTML player
<!-- index.html -->
<!DOCTYPE html>
<html>
<body>
<video controls width="720">
<source src="/video" type="video/mp4">
</video>
</body>
</html>
This streams a static video file. Now let’s make it live with FastPix.
1. Install FastPix SDK
npm install @fastpix/fastpix-node
2. Initialize FastPix in your server
// Add to app.js
import Client from "@fastpix/fastpix-node";
const fastpix = new Client({
accessTokenId: "your-access-token-id",
secretKey: "your-secret-key"
});
3. Generate a live stream
const liveStreamRequest = {
playbackSettings: {
accessPolicy: "public", // Defines the access level of the live stream (public or private)
},
inputMediaSettings: {
maxResolution: "1080p", // Set the maximum resolution of the live stream
reconnectWindow: 1800, // Set the duration for reconnecting the stream in seconds
mediaPolicy: "private", // Define media policy (private or public)
metadata: {
liveStream: "fp_livestream", // Custom metadata for the live stream
},
enableDvrMode: true, // Enable DVR mode to allow viewers to rewind the live stream
},
};
// Initiating the live stream
const generateLiveStream = await fastpix.initiateLiveStream(liveStreamRequest);
console.log("Live Stream initiated successfully:", generateLiveStream);
4. Update the video player for HLS
<!-- Update index.html for HLS playback -->
<video id="player" controls></video>
<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
<script>
const video = document.getElementById('player');
const hls = new Hls();
// Fetch stream URL from your server
fetch('/live-stream-url')
.then(res => res.json())
.then(data => {
hls.loadSource(data.url);
hls.attachMedia(video);
});
</script>
5. Serve the live stream URL
// Add endpoint to get HLS manifest
app.get('/live-stream-url', async (req, res) => {
const playbackId = await fastpix.generateLiveStreamPlaybackId(
{ streamId: 'YOUR_STREAM_ID' },
{ accessPolicy: 'public' }
);
res.json({ url: `https://cdn.fastpix.io/${playbackId}/manifest.m3u8` });
});
1. Use OBS or FFmpeg to ingest video
Grab your stream’s RTMP ingest URL from FastPix Dashboard and configure your encoder:
RTMP URL: rtmps://live.fastpix.io:443/live
Stream Key: YOUR_STREAM_KEY
2. Simulcast to social platforms
// Stream to YouTube and Facebook simultaneously
app.post('/simulcast', async (req, res) => {
const simulcastConfig = {
destinations: [
{
url: 'rtmp://a.rtmp.youtube.com/live2',
streamKey: 'YOUTUBE_STREAM_KEY'
},
{
url: 'rtmps://live-api-s.facebook.com:443/rtmp',
streamKey: 'FACEBOOK_STREAM_KEY'
}
]
};
await fastpix.initiateLiveStreamSimulcast(
{ streamId: 'YOUR_STREAM_ID' },
simulcastConfig
);
res.json({ status: 'Simulcasting started!' });
});
1. Track viewer analytics in real-time
fastpix.on('playbackEvent', (event) => {
console.log('Viewer activity:', event.type); // e.g., 'play', 'pause', 'buffer'
});
For a complete reference of methods, events, and configurations, explore the FastPix Node.js SDK Documentation.
No infrastructure headaches: Forget spinning up FFmpeg workers, GPU instances, or managing CDN contracts. It’s all handled behind the scenes.
Scales with you, not against you: Pay-as-you-go pricing that grows with your audience. No massive upfront costs, no long-term lock-ins.
Made for developers: TypeScript support, webhooks, and a built-in playground make it easy to test, iterate, and ship.
Production-ready security: Token-based playback, AES-128 encryption, and geo-blocking keep your streams protected out of the box.
When you combine the FastPix Node.js SDK with the FastPix Player SDK, you get a full-stack setup that just works on the backend and in the browser. No complex wiring. No steep learning curves.
Live streaming in 2024 doesn’t require a PhD in video protocols or a seven-figure infrastructure budget. With Node.js and FastPix, you can:
Ready to build? Sign up and get $25 in free credits. No DevOps dramjust stream, scale, and ship. Few references to check out:
.png)
.png)
