WebRTC Testing · TURN Server · SFU Server · Signaling Server

Test WebRTC Applications

A unified visual interface for deep testing, media stream inspection, and load verification of WebRTC, TURN, SFU, and signaling servers directly from your browser without writing client code.

$ curl -fsSL https://raw.githubusercontent.com/slyber-app/slyber-inspector/main/install.sh | sudo bash
Documentation Slyber Inspector on GitHub
Slyber Inspector :8095 Spawn: 50 pairs Media pool (IndexedDB) 4 streams 220-520 Hz Signaling & probe ws /ws (sdp + ice) post /api/check Redis & secret auth md5 & sha1 keys [Revoke redis key] Peer 1 · RTCPeerConnection tx: video A · rx: video B 30 fps relay 99.99.99.99:49213 2557 kbps · 117 mb · 22 ms Peer 2 · RTCPeerConnection tx: video B · rx: video A 30 fps relay 99.99.99.99:49212 1560 kbps · 68 mb · 24 ms Direct p2p blocked
Launch Interface in 30 Seconds
Single static Go binary with a built-in web interface and signaling server, installed into systemd or launched in Docker with one command.
Secret & Redis Mode Testing
Automatic generation of temporary HMAC-SHA1 tokens and direct writing of RFC 5389 MD5 keys to Redis with an instant access revocation button.
Live WebRTC Pair Spawner
Spawn up to 50 simultaneous peer pairs in force relay mode streaming real video files or synthetic Canvas feeds.
Telemetry & ICE Restart
Monitor allocated relay ports, bitrate, and RTT every second, and verify seamless session handover with the Ice restart button.
Engineer's Toolkit

Everything for visual verification and load testing of WebRTC in one application

From STUN checks and writing hashes to Redis to spawning dozens of live video calls - all diagnostic tools are packed into a single Go binary.

01 / 03
Multi Pair Load Spawner

Paired WebRTC Session Spawner & Stress Testing

Simultaneous launch of 1 to 50 pairs of two-way WebRTC connections with forced TURN routing.

Automatic selection of distinct videos for Peer 1 and Peer 2
Dual Auth & Redis Control

HMAC Auth Inspection & Redis Key Management

Full support for secret (HMAC-SHA1) and redis (RFC 5389 MD5) modes with on-the-fly key deletion.

Auto-provisioning of turn/realm//user//key records
Persistent Media Pool

Persistent Media Pool & Synthetic Streams

Custom video file uploads stored in browser memory (IndexedDB) and a built-in demo stream synthesizer.

Individual audio control via Web Audio API
ICE Restart & Probing

On-the-Fly ICE Restart Testing & STUN Diagnostics

Instant node availability check (Verify server connection) and seamless port switching test with Ice restart.

Monitoring of allocated relay IP:Port addresses
Real-Time WebRTC Stats

Live Stream, Bitrate & RTT Latency Telemetry

Per-second collection of inbound-rtp and candidate-pair metrics for each peer plus an aggregate load dashboard.

Visual status indicators for ICE and Signaling negotiation
Single Binary & Docker Ready

Single Static Binary & Instant Docker Deployment

Standalone Go server with embedded web assets, signaling node, and automatic workspace state persistence.

Saves active tab and all form fields in localStorage
Testing in 4 Steps

How to Test Your Infrastructure with Slyber Inspector

From installing the inspector to launching dozens of simultaneous relayed video sessions with Redis and ICE Restart verification - in under 1 minute.

01 / 02
STEP 01 · Installation

Deploy Slyber Inspector with a single command

The script detects your OS and CPU architecture (amd64/arm64), verifies the SHA256SUMS checksum, installs the binary to /usr/local/bin/slyber_test, and on Linux automatically starts the systemd service on port 8095.

STEP 01
curl -fsSL https://raw.githubusercontent.com/slyber-app/slyber-inspector/main/install.sh | sudo bash
STEP 02 · Node Configuration

Connect your TURN server and verify response

Open the web interface on port 8095, enter your TURN server address, select the authentication mode (secret or redis), and click "Verify server connection" for an instant STUN RTT measurement and key store check.

STEP 02
Turn server address: 99.999.999.99:3478
Realm domain:        turn.local
Ice transport:       relay only (force turn)
Auth mode:           redis (99.999.999.99:6379) or secret (HMAC)
STEP 03 · Media Pool

Load video files in one click

Upload at least two local video files (they are saved in your browser) or click the "Add 4 demo streams" button to immediately generate synthetic audio and video feeds.

STEP 03
// 2 media pool modes available:
1. Upload video files -> Upload your MP4/WebM files with auto-save to IndexedDB
2. Add 4 demo streams -> Generate 4 streams via Canvas 640x360 + Web Audio (220-520 Hz)
STEP 04 · Inspection & Load

Spawn peer pairs and control live sessions

Spawn the desired number of pairs, confirm that green badges appear with allocated relay ports, test on-the-fly port switching with the "Ice restart" button, and verify key removal via "Revoke redis key".

STEP 04
Pairs to spawn: 10 -> [Spawn pairs]
Peer 1: relay 99.999.999.99:49213 | 2557 kbps · 117.86 mb · rtt: 250.0 ms
Peer 2: relay 99.999.999.99:49212 | 1560 kbps · 68.54 mb  · rtt: 230.0 ms
Specifications

Full Technical Specifications of Slyber Inspector

Interface architecture, supported verification modes, internal APIs, and deployment parameters.

Platform Modules
Slyber TURN Server (active: full STUN/TURN, Redis, and media relay inspection), Slyber SFU Server, Slyber Signaling Server
Network Port & Launch Options
8095/TCP by default (environment variable LISTEN_ADDR="0.0.0.0:8095" or CLI flag -addr 127.0.0.1:8095)
Tested Transports & ICE Policies
UDP (turn:3478), TCP (turn:3478), TLS (turns:5349), combined UDP + TCP; iceTransportPolicy options: relay only (forced TURN) and all (STUN + TURN)
Credential Provisioning Modes
Secret Mode (local HMAC-SHA1 generation or HTTP request to /api/turn-credentials) and Redis Mode (writing RFC 5389 MD5 hashes to turn/realm//user//key with TTL)
Internal HTTP & WebSocket Endpoints
POST /api/check (STUN RTT and Redis connectivity check), POST /api/provision (credential issuance for a peer pair), POST /api/revoke (key deletion in Redis), WS /ws (signaling)
Media Stream Sources & Pair Spawner
Local video file uploads (captured via captureStream + Web Audio API) and 4-demo-stream synthesizer (Canvas 640x360 @ 30fps + sine wave oscillators at 220/330/440/520 Hz)
Browser State Persistence
Saves all configuration fields and active tab in localStorage (slyber_test_server_settings_v3); stores uploaded video blobs in IndexedDB (slyber_test_server_db)
Live Telemetry & Session Control
Polls RTCPeerConnection.getStats() every second (bitrate in kbps/mbps, data volume in MB, RTT in ms, relay IP and port); Ice restart, Revoke redis key, and selective Mute controls
Executable Binary & systemd Service
Static binary /usr/local/bin/slyber_test with embedded web assets; automated setup of slyber_test.service running under system user slyber_test (LimitNOFILE=65535)
Supported Platforms & Containerization
Linux (amd64, arm64) and macOS (darwin amd64, arm64) with SHA256SUMS verification; official Docker image ghcr.io/slyber-app/slyber-inspector:latest based on Alpine 3.20 (UID 10001)
Use Cases

Where Slyber Inspector Saves Hours of Engineering Time

01 / 03
01 DevOps & Release QA

Pre-Release Acceptance & TURN Server Auditing

End-to-end verification of a new or updated TURN server before routing production traffic, confirming UDP/TCP relay port allocation, proper external PUBLIC_IP configuration, and media flow.

02 Security & Access Control

Debugging Redis Auth & Instant Session Revocation

Visual verification of dynamic Redis authentication, testing proper RFC 5389 MD5 key provisioning, TTL enforcement, and system behavior when a key is forcibly deleted during an active call.

03 Load & Stress Testing

Bandwidth Load Testing with Real Video Streams

Spawning dozens of simultaneous pairs streaming heavy real-world video files to evaluate total server throughput, bitrate stability, and RTT latency growth under load.

04 Firewall & TLS Verification

Testing Firewall Traversal over TCP & TURNS (TLS)

Verifying client ability to establish relay connections through restrictive firewalls by switching the inspector transport between UDP, TCP, and encrypted TLS (turns:5349).

05 Mobile Roaming QA

Seamless Roaming & ICE Restart Inspection

Verifying make-before-break behavior during network changes by confirming that clicking Ice restart immediately allocates new relay ports without video freezes or audio dropouts.

06 Developer Experience

Permanent Lab Environment for Engineering Teams

A permanently deployed internal testbed for development and technical support teams that reproduces any network scenario in 10 seconds without configuring client applications.

Knowledge Base & FAQ

Frequently Asked Questions about Slyber Inspector

Answers to common technical questions from engineers and QA specialists on visual testing of WebRTC applications, TURN, SFU, and Signaling servers.

Why do I need Slyber Inspector if Slyber TURN Server already has the doctor and bench CLI utilities? +
Unlike CLI utilities that only verify basic STUN responses or send synthetic UDP packets without a real browser media stack, Slyber Inspector establishes full two-way RTCPeerConnection sessions directly in the browser. You visually monitor video and audio transmission between peer pairs, see the actual allocated relay IP:port for each participant, verify codec behavior, test ICE Restart on a live call, and manage Redis keys in one click.
How does Slyber Inspector work with secret (HMAC) and redis authentication modes? +
The inspector supports both production authentication modes. In "secret" mode, it can generate temporary HMAC-SHA1 passwords locally using your TURN_SECRET or request them over the network from the /api/turn-credentials endpoint. In "redis" mode, the inspector backend automatically generates unique credentials for each peer (for example, p1_u1_a8f9c2), computes the RFC 5389 MD5 hash from the username:realm:password string, and writes the turn/realm//user//key record directly to your Redis instance with the specified TTL.
How can I guarantee that traffic between peers in the same tab goes strictly through the remote TURN server rather than directly? +
When you select the "relay only (force turn)" policy, the browser receives the iceTransportPolicy: 'relay' configuration parameter. This completely disables direct local connections (host and srflx candidates), even when both peers run in the same browser tab on the same machine. All video and audio traffic is guaranteed to go out to the external interface of your TURN server and return through allocated relay ports.
Do I need to re-upload video files and re-enter server settings after every page reload? +
Yes, all local video files uploaded via the "Upload video files" button are automatically saved in the browser's built-in IndexedDB database (slyber_test_server_db storage), while connection settings, credentials, and the active tab are stored in localStorage. After reloading the page or restarting the browser, your video pool and UI configuration are restored automatically. If you do not have local videos on hand, the "Add 4 demo streams" button creates 4 procedural streams powered by HTML5 Canvas and Web Audio API tone generators (220-520 Hz).
What exactly does the Ice restart button test inside an active pair card? +
The "Ice restart" button inside a pair card calls the standard WebRTC pc.createOffer({ iceRestart: true }) method, simulating a client switching networks (for example, a smartphone moving from Wi-Fi to 4G/LTE). The browser generates new ice-ufrag and ice-pwd parameters, requests a new pair of relay ports from the TURN server, and seamlessly switches the media stream to the new route using a make-before-break scheme without interrupting video playback.
How do I test forced user disconnection and key revocation in Redis? +
When the "redis" authentication mode is selected, a "Revoke redis key" button appears in each peer card. Clicking it sends a request from Slyber Inspector to its internal /api/revoke endpoint, which immediately executes the DEL command for that user's key in Redis. This lets you visually verify how your TURN server and client application respond to forced access revocation during an active session or an ICE Restart attempt.
Why are at least two video sources required in the pool to spawn pairs? +
Yes, to prevent identical video frames from overlapping and visually confirm proper two-way routing, Slyber Inspector requires at least 2 sources in the media pool. When spawning each pair, the algorithm randomly picks two different video clips: Peer 1 sends video A and receives video B on screen, while Peer 2 sends video B and receives video A. The audio track of any peer can be muted or unmuted individually.
Which modules are included in Slyber Inspector besides TURN server testing? +
Slyber Inspector is designed as a modular platform for the entire Slyber real-time ecosystem. The Slyber TURN Server module is available and fully functional right now, while dedicated workspaces for load testing the Slyber SFU Server media router (Simulcast and subscription verification) and the Slyber Signaling Server node (room and WebSocket event benchmarking) are in active development and will be unlocked in upcoming updates.
WebRTC Verification & Load Testing Guide

Why Reliable WebRTC Infrastructure Requires a Visual Interface

Deploying and maintaining your own real-time infrastructure - whether it is a TURN/STUN relay, a selective forwarding unit (SFU), or a signaling server - always comes with the challenge of end-to-end verification. Console socket checks only show that a port is open, without answering an engineer's core questions: does actual browser video and audio flow through the relay, does Redis authentication work properly, does a call survive an ICE Restart procedure, and how much bandwidth can a node handle when dozens of user pairs are connected simultaneously. Slyber Inspector was built to solve these exact problems.

How Slyber Inspector Works and How It Replaces Custom Testbeds

Typically, verifying a new TURN server requires developers to spin up a test web application, configure signaling exchange, manually generate database credentials, and open multiple browser windows. Slyber Inspector combines all of these components into a single compact Go binary, slyber_test, that deploys in 30 seconds:

  • Built-in WebSocket signaling server and pair spawner: Clicking the Spawn pairs button creates the specified number of independent RTCPeerConnection pairs directly inside your browser tab. The built-in /ws signaling channel immediately exchanges SDP Offer/Answer messages and ICE candidates. Selecting the relay only (force turn) policy blocks direct connections and forces every byte of video and audio through your external TURN server over UDP, TCP, or TLS.
  • Automated credential provisioning in Secret and Redis modes: The internal /api/provision endpoint handles all cryptography. In secret mode, it either computes temporary HMAC-SHA1 tokens locally or requests them from the TURN server's HTTP API (/api/turn-credentials). In redis mode, the inspector automatically connects to your specified Redis instance, calculates the 32-character RFC 5389 MD5 hash, and writes keys matching turn/realm/<REALM>/user/<USERNAME>/key with the required TTL.
  • Real-time access revocation and ICE Restart testing: Every pair card includes a Revoke redis key button that deletes a specific participant's key from Redis mid-call, letting you verify how your infrastructure reacts to revoked permissions. The Ice restart button triggers session renegotiation via createOffer({ iceRestart: true }) and visually demonstrates seamless switching of allocated UDP relay ports without stopping video playback.
  • IndexedDB media pool persistence and synthetic streams: Video files uploaded from your computer are stored in the browser's built-in IndexedDB database, while all connection settings and the selected tab are saved in localStorage. Even after a page reload, your testbed is ready for action. And when you need to quickly verify a server from a clean machine without video files, the built-in generator creates 4 distinct synthetic streams powered by Canvas and the Web Audio API.
Visual WebRTC & TURN Verification Suite

Ready to test your WebRTC infrastructure under real load?

Forget about manually building test WebRTC clients and guessing when debugging network issues. Deploy the single Slyber Inspector binary with a built-in video pair spawner, Redis key inspection, and live telemetry right now.