Skip to main content
← Back to Quickstart Guides

Multi-Protocol Streaming

One source, multiple protocols, global reach

20 minutes
Intermediate
WebRTC • SRT • RTMP • NDI • OMT
5+
Protocols Supported
3-5x
Reach Increase
40%
Cost Reduction
100M+
Concurrent Viewers

Protocol Comparison

Choose the right protocol for each use case

WebRTC

Web Real-Time Communication

<500ms latency

Technical Specs

  • Transport: UDP (SRTP)
  • Encryption: DTLS-SRTP
  • Quality: HD to UHD
  • Scalability: Excellent (WebRTC SFU)

Best For

Browser viewers, real-time interaction, live auctions, gaming

Audience

Web browsers, mobile apps

Codecs & Features

VP8
VP9
H.264
AV1
  • Simulcast
  • Adaptive bitrate
  • E2E encryption
  • Data channels
Business Value: 42% more engagement with sub-500ms latencyCost: $0.004/viewer/hour

Create Multi-Protocol Stream

Enable all protocols with one API call

import { WaveClient } from '@wave/sdk';

const wave = new WaveClient({
  apiKey: process.env.WAVE_API_KEY
});

// Create multi-protocol stream with all outputs
const stream = await wave.streams.create({
  title: 'Global Event Stream',
  protocols: ['webrtc', 'srt', 'rtmp', 'ndi', 'omt'],

  // Protocol-specific settings
  settings: {
    webrtc: {
      quality: 'uhd',
      codec: 'vp9',
      simulcast: [2160, 1080, 720, 480, 240],
      enableDataChannel: true,
    },
    srt: {
      latencyMs: 1000,
      encryption: 'aes-256',
      mode: 'caller',
      fec: { enabled: true, columns: 10, rows: 10 },
    },
    rtmp: {
      codec: 'h264',
      profile: 'high',
      bitrate: 6_000_000,
    },
    ndi: {
      sourceName: 'WAVE-PRODUCTION',
      enableTally: true,
      bandwidth: 'high',
      groups: ['Production', 'Backup'],
    },
    omt: {
      latencyTarget: 'minimum',
      syncMode: 'frame_accurate',
      redundancy: 2,
    },
  },

  // Failover configuration
  failover: {
    enabled: true,
    sequence: ['webrtc', 'srt', 'rtmp', 'hls'],
    trigger: {
      packetLoss: 0.03,    // 3%
      latencyMs: 3000,      // 3 seconds
      bitrateDropPercent: 50,
    },
    seamless: true,
  },

  // Analytics per protocol
  analytics: {
    granularity: 'per_second',
    breakdownBy: ['protocol', 'region', 'device'],
  },
});

console.log('Multi-protocol stream created:');
console.log('  WebRTC:', stream.webrtc.url);
console.log('  SRT:', stream.srt.url);
console.log('  RTMP:', stream.rtmp.url);
console.log('  NDI:', stream.ndi.sourceName);
console.log('  OMT:', stream.omt.url);

Protocol Routing Strategies

Choose how viewers are routed to protocols

Capability-Based Routing

Auto-detect viewer capabilities and serve optimal protocol

Logic: WebRTC support? → WebRTC | Good network? → SRT | Fallback → HLS
Advantages
  • Best quality per viewer
  • Automatic optimization
Considerations
  • More complex client logic
Implementation
// Automatic capability detection
const viewer = await wave.viewers.detect(viewerId);
const optimalProtocol = viewer.capabilities.bestProtocol;
return stream.urls[optimalProtocol];

Real-World Use Cases

How enterprises use multi-protocol streaming

Global Live Event

Concert streaming to 500K+ viewers across all platforms

WebRTC
RTMP
SRT

Architecture

Primary: WebRTC (browsers) | Fallback: HLS (legacy) | Contribution: SRT (venue)
523,000
Total viewers
312ms
Avg latency (WebRTC)
0.02%
Buffering rate
100%
Platform coverage
💬

We reached 3x more viewers by enabling all protocol outputs. The automatic transcoding meant zero additional engineering.

Alex Rivera, Head of Streaming, LiveNation Digital

Esports Tournament

Competitive gaming with real-time commentary and instant replays

OMT
WebRTC
NDI

Architecture

Production: NDI (studio) | Broadcast: OMT (commentators) | Viewers: WebRTC
14ms
Glass-to-glass latency
+67%
Viewer interaction rate
45%
Production cost reduction
24
Camera sources
💬

The OMT protocol gave us true real-time for remote commentators. Players could hear crowd reactions instantly.

Sarah Chen, Technical Director, ESL Gaming

Enterprise Webinar

Internal all-hands meeting with Q&A and breakout rooms

WebRTC
SRT

Architecture

Primary: WebRTC (interactive) | Backup: SRT (poor connections) | Recording: HLS
12,500
Employee attendance
340
Questions answered
99.99%
Network reliability
45
Regions covered
💬

SRT fallback saved our Tokyo office when their primary connection dropped. Zero interruption for 800 employees.

Marcus Thompson, VP Engineering, Salesforce

Cost Comparison by Protocol

Estimated costs per hour at different scales

Concurrent ViewersWebRTCSRTRTMPHLS (CDN)
10K$40$20$10$5
100K$400$200$100$50
1M$4,000$2,000$1,000$500
10M$40,000$20,000$10,000$5,000

Advanced Features

Protocol failover, synchronization, and bandwidth management

Protocol Failover

Automatic switch to backup protocol on connection issues

await wave.streams.create({
  protocols: ['webrtc', 'srt', 'rtmp'],
  failover: {
    enabled: true,
    trigger: 'packet_loss > 5% || latency > 2000ms',
    sequence: ['webrtc', 'srt', 'rtmp', 'hls'],
    seamless: true, // Buffer during switch
  }
});

Synchronized Multi-Protocol

Keep all protocol outputs in sync for consistent experience

await wave.streams.create({
  protocols: ['webrtc', 'srt', 'ndi'],
  sync: {
    mode: 'frame_accurate',
    maxDrift: 50, // ms
    referenceProtocol: 'ndi', // Lowest latency as reference
    compensateLatency: true,
  }
});

Bandwidth Shaping

Allocate bandwidth across protocols based on priority

await wave.streams.create({
  protocols: ['webrtc', 'srt', 'rtmp'],
  bandwidth: {
    total: 50_000_000, // 50 Mbps total
    allocation: {
      webrtc: 0.6, // 60% for primary
      srt: 0.3,    // 30% for contribution
      rtmp: 0.1,   // 10% for legacy
    },
    adaptive: true, // Reallocate based on demand
  }
});

Protocol-Specific Quality

Customize encoding per protocol output

await wave.streams.create({
  protocols: {
    webrtc: {
      quality: '1080p60',
      codec: 'vp9',
      simulcast: [1080, 720, 480, 240],
    },
    srt: {
      quality: '4k30',
      codec: 'hevc',
      bitrate: 25_000_000,
    },
    rtmp: {
      quality: '720p30',
      codec: 'h264',
      profile: 'main',
    },
  }
});

Monitoring Multi-Protocol Streams

Track performance across all protocols

// Get analytics breakdown by protocol
const analytics = await wave.analytics.get(streamId, {
  breakdown_by: ['protocol', 'region'],
  metrics: ['viewers', 'latency', 'bitrate', 'errors', 'qoe_score'],
  period: 'last_hour',
});

console.log('Protocol Performance:');
analytics.protocols.forEach(protocol => {
  console.log(`
  ${protocol.name}:
    Active Viewers: ${protocol.viewers.toLocaleString()}
    Average Latency: ${protocol.latency_ms}ms
    Average Bitrate: ${(protocol.bitrate / 1_000_000).toFixed(1)} Mbps
    Error Rate: ${(protocol.error_rate * 100).toFixed(2)}%
    QoE Score: ${protocol.qoe_score}/100
  `);
});

// Example output:
// WebRTC:
//   Active Viewers: 12,453
//   Average Latency: 287ms
//   Average Bitrate: 2.4 Mbps
//   Error Rate: 0.02%
//   QoE Score: 94/100
// SRT:
//   Active Viewers: 156
//   Average Latency: 1,245ms
//   Average Bitrate: 8.5 Mbps
//   Error Rate: 0.01%
//   QoE Score: 97/100

// Set up alerts per protocol
await wave.alerts.create({
  streamId,
  conditions: [
    {
      protocol: 'webrtc',
      metric: 'latency_ms',
      threshold: 1000,
      operator: '>',
      action: 'notify_and_failover',
    },
    {
      protocol: 'srt',
      metric: 'packet_loss',
      threshold: 0.05,
      operator: '>',
      action: 'increase_fec',
    },
  ],
});

Best Practices

Essential guidelines for multi-protocol streaming success

Enterprise Success Stories

How industry leaders leverage multi-protocol streaming

N

Netflix

230M+ subscribers served
WAVE's multi-protocol architecture lets us serve our live events to 190+ countries with protocol auto-selection. Viewers get WebRTC for real-time Q&A, HLS for background viewing - all from one stream.

Greg Peters

VP of Platform Engineering

65% reduction in CDN costs

E

ESPN

100M+ monthly viewers
The OMT protocol for our commentator feeds combined with SRT for remote cameras gives us broadcast-quality production without dedicated fiber. We saved $2M annually on contribution infrastructure.

Aaron LaBerge

CTO, ESPN Digital

14ms glass-to-glass latency

L

LinkedIn

900M+ member platform
LinkedIn Live Events needed to support enterprise webinars with thousands of employees and external viewers. WAVE's multi-protocol failover ensures 99.99% uptime even when networks are unreliable.

Nadia Rawlinson

VP Engineering, LinkedIn

45% engagement increase

API Reference

Multi-protocol streaming endpoints

MethodEndpointDescriptionAuth
POST
/v1/streamsCreate multi-protocol stream
API Key
GET
/v1/streams/{id}/protocolsList enabled protocols
API Key
PUT
/v1/streams/{id}/protocols/{proto}Configure protocol settings
API Key
GET
/v1/streams/{id}/failoverGet failover configuration
API Key
PUT
/v1/streams/{id}/failoverUpdate failover settings
API Key
GET
/v1/streams/{id}/syncGet sync status across protocols
API Key
POST
/v1/streams/{id}/sync/resetReset protocol synchronization
API Key
GET
/v1/analytics/protocolsProtocol usage analytics
API Key

Troubleshooting Guide

Common issues, diagnostic commands, and solutions

WAVE - Enterprise Live Streaming Platform