The SignalWire Video SDK lets developers build custom real-time video applications by combining REST endpoints for room and token management with client-side JavaScript video integration using WebRTC and a Multipoint Control Unit (MCU) architecture. This article explains how the Video SDK works, how it uses server-side REST interfaces and client-side code to create and manage video rooms, and why the MCU approach delivers consistent, low-latency video experiences regardless of participant count.
SignalWire's roots have always been in video communications, as our founder Anthony Minessale founded the FreeSWITCH project, one of the most popular open source media servers in the world.
The SignalWire Video SDK is a set of tools that allows developers to create and manage real-time video applications without relying on rigid, prebuilt conferencing software. Instead of forcing applications into a fixed UI or workflow, the SDK provides programmatic control over video rooms, participants, and media delivery.
How the SignalWire Video SDK works
Server-side video room and token management
Video rooms and participant access are managed through REST endpoints. Developers create rooms, generate tokens, and define permissions on the server side before clients ever connect.
This model keeps sensitive credentials off the client and gives developers full control over:
Who can join a room
How long access is valid
What actions participants are allowed to perform
Once a token is issued, the client can use it to establish a secure video session.
What developers can build with the Video SDK
The Video SDK is designed for flexibility rather than a single use case. Developers commonly use it to build:
Custom video conferencing applications
Embedded video features inside existing products
Real-time collaboration tools
Internal tools requiring controlled video access
Because room creation, access control, and UI are all programmable, the SDK can support both simple and complex workflows.
Why SignalWire uses an MCU-based video architecture
SignalWire Video uses a Multipoint Control Unit (MCU) to manage media streams. In an MCU architecture, each participant sends a single stream to the server, which mixes the media and sends back a consolidated stream.
This approach provides several advantages:
Consistent performance regardless of participant count
Reduced bandwidth and CPU usage on client devices
Centralized control over media quality and layout
Unlike peer-to-peer models, where each client must send and receive multiple streams, the MCU model simplifies scaling and produces predictable performance under load.
How to build with the Video SDK
SignalWire's video product consists of two different APIs that interact to help you build applications.
The server-side API is a collection of REST endpoints used to create and manage room, and add access tokens to them.
On the client side, the Javascript SDK allows you to build a custom video experience in a simple, standard-based way.
This demo is a very simple application that will generate a random user name and room, unless you pass them in via GET using respectively the user and room parameters.
Configuration
Start by copying the env.example file to a file named .env, and fill in the necessary information.
The application needs a SignalWire API token. You can sign up here, then put the Project ID and Token in the .env file as SIGNALWIRE_PROJECT_KEY and SIGNALWIRE_PROJECT_KEY, together with you full SignalWire Space URL as SIGNALWIRE_SPACE.
Running the application
If you are running the application with Ruby on your computer, run bundle install followed by bundle exec ruby app.rb after configuring the .env file.
To use the bundled Docker configuration, set up your .env, build the container using docker build . -t swvideo then run the application with docker run -it --rm -p 4567:4567 --name swvideo --env-file .env swvideo.
After starting the process with either of the two methods, head to http://localhost:4567.
If you would like to test it with friends and colleagues, we recommend ngrok. After starting the tunnel pointed at your port 4567, you can use the URL you receive from ngrok to access the application and to share the link with other participants.
Application code
On the server side, we have methods to create a room and retrieve a token to access it. Each of your users needs a separate token.
You can find the complete application here, but what follows is an abstract of how we create a token in Ruby, then how we access the room in the browser.
On the client side, we simply set up the client to put the video in a root element, and connect.
If you would like to test this example out, you can create a SignalWire account and space here.
If you are looking for more information about using SignalWire, refer to our Getting Started guide. Join our community Discord for more support.
Frequently asked questions
What is the SignalWire Video SDK?
The SignalWire Video SDK pairs REST video APIs for room and token management with a client-side JavaScript SDK that equips developers to build custom WebRTC-based video applications.
What is the role of the MCU in SignalWire Video?
SignalWire Video uses a Multipoint Control Unit (MCU) to receive media from each participant, mix it into a unified stream, and send back a single consolidated video feed, improving performance and reducing per-client bandwidth.
How do developers get started with the Video SDK?
Developers set up a SignalWire Space, populate environment variables for the API token and Space URL, then use the server REST API to create rooms and tokens and the client JavaScript SDK to connect and render video.
What kinds of applications can be built with the Video SDK?
With the Video SDK, you can build real-time video conferencing rooms, embed custom video experiences in web apps, and handle participant sessions with low latency for scalable use cases.
