What is WebRTC?
WebRTC (Web Real-Time Communication) is an open-source project that provides web browsers and mobile applications with real-time communication capabilities via APIs. It enables audio, video, and data to be transmitted peer-to-peer between browsers without requiring plugins, downloads, or intermediate servers for media relay (in ideal conditions).
Originally developed by Google and standardized by W3C and IETF, WebRTC has revolutionized web-based communication. It powers applications like Google Meet, Facebook Messenger video calls, Discord voice chat, and thousands of other real-time communication applications. WebRTC handles the complex networking, codec negotiation, and media processing automatically.
WebRTC Performance Calculator
Memory: 150 MB
Packet Loss: 0.5%
Jitter: 5ms
WebRTC Architecture
MediaStream API
Captures audio/video from user devices
• getDisplayMedia()
• Audio/Video tracks
• Device enumeration
• Constraints handling
RTCPeerConnection
Core API for peer-to-peer connections
• ICE negotiation
• Media transport
• DTLS encryption
• Statistics/monitoring
RTCDataChannel
Peer-to-peer data transfer
• Low latency messaging
• Reliable/unreliable modes
• Binary/text data
• Gaming and file transfer
Connection Flow
1. Signaling Server Setup
↓
2. Media Capture (getUserMedia)
↓
3. Create PeerConnection
↓
4. Add Local Media Streams
↓
5. Create Offer/Answer (SDP)
↓
6. Exchange SDP via Signaling
↓
7. ICE Candidate Exchange
↓
8. DTLS/SRTP Handshake
↓
9. Media/Data Flow Established
NAT Traversal & ICE
The NAT Problem
Most devices are behind NAT/firewalls, making direct peer connections impossible.
Solution: ICE framework with STUN/TURN servers
STUN Servers
Session Traversal Utilities for NAT
• Determine NAT type
• Enable hole punching
• Lightweight and fast
• Works for ~80% of cases
TURN Servers
Traversal Using Relays around NAT
• Fallback for symmetric NAT
• Higher bandwidth cost
• 99%+ success rate
• Increased latency
ICE Candidate Types
• Direct LAN connections
• Lowest latency
• NAT hole punching
• Most common type
• Guaranteed connectivity
• Highest latency/cost
Signaling & Session Negotiation
Offer/Answer Model
Peers negotiate capabilities through SDP (Session Description Protocol) exchange.
// Caller creates offer
const offer = await peerConnection.createOffer();
await peerConnection.setLocalDescription(offer);
// Send offer via signaling server
signalingSocket.send(JSON.stringify({
type: 'offer',
sdp: offer
}));
// Callee receives offer, creates answer
await peerConnection.setRemoteDescription(offer);
const answer = await peerConnection.createAnswer();
await peerConnection.setLocalDescription(answer);
// Send answer back
signalingSocket.send(JSON.stringify({
type: 'answer',
sdp: answer
}));
SDP Example
Session Description Protocol contains media capabilities and network information.
o=- 123456789 2 IN IP4 192.168.1.100
s=-
t=0 0
a=group:BUNDLE 0 1
m=audio 9 UDP/TLS/RTP/SAVPF 111
a=rtpmap:111 opus/48000/2
a=sendrecv
m=video 9 UDP/TLS/RTP/SAVPF 96
a=rtpmap:96 VP8/90000
a=sendrecv
a=candidate:1 1 UDP 2130706431 192.168.1.100 54400
WebRTC Implementation Example
Basic Video Call Setup
class VideoCall {
constructor(signalingSocket) {
this.socket = signalingSocket;
this.peerConnection = new RTCPeerConnection({
iceServers: [
{ urls: 'stun:stun.l.google.com:19302' },
{
urls: 'turn:turn.example.com:3478',
username: 'user',
credential: 'pass'
}
]
});
this.setupEventHandlers();
}
async startCall() {
// Get user media
const stream = await navigator.mediaDevices.getUserMedia({
video: { width: 1280, height: 720 },
audio: true
});
// Add tracks to peer connection
stream.getTracks().forEach(track => {
this.peerConnection.addTrack(track, stream);
});
// Create and send offer
const offer = await this.peerConnection.createOffer();
await this.peerConnection.setLocalDescription(offer);
this.socket.send(JSON.stringify({ type: 'offer', offer }));
}
setupEventHandlers() {
// Handle ICE candidates
this.peerConnection.onicecandidate = (event) => {
if (event.candidate) {
this.socket.send(JSON.stringify({
type: 'ice-candidate',
candidate: event.candidate
}));
}
};
// Handle remote stream
this.peerConnection.ontrack = (event) => {
const remoteVideo = document.getElementById('remoteVideo');
remoteVideo.srcObject = event.streams[0];
};
// Handle connection state
this.peerConnection.onconnectionstatechange = () => {
console.log('Connection state:', this.peerConnection.connectionState);
};
}
}
Data Channel Example
// Create data channel
const dataChannel = peerConnection.createDataChannel('messages', {
ordered: true,
maxRetransmits: 3
});
dataChannel.onopen = () => {
console.log('Data channel opened');
dataChannel.send('Hello from peer!');
};
dataChannel.onmessage = (event) => {
console.log('Received:', event.data);
};
// Handle incoming data channel
peerConnection.ondatachannel = (event) => {
const channel = event.channel;
channel.onmessage = (event) => {
console.log('Data received:', event.data);
};
};
Scaling WebRTC Applications
Mesh Topology
Every peer connects to every other peer
• Low latency
• High bandwidth usage (N²)
• Limited to ~4-6 participants
• CPU scales poorly
SFU (Selective Forwarding Unit)
Central server forwards streams between peers
• Bandwidth efficient
• Low server CPU usage
• Simulcast support
• Quality adaptation
MCU (Multipoint Control Unit)
Server mixes all streams into composite output
• Lowest bandwidth
• High server CPU usage
• Centralized processing
• Layout control
Hybrid Approaches
Combine multiple topologies based on needs
• P2P + SFU fallback
• Regional distribution
• Edge computing
• CDN integration
WebRTC in Production
Google Meet
Large-scale video conferencing with advanced features.
- • SFU architecture with simulcast
- • AI-powered noise cancellation
- • Adaptive bitrate streaming
- • 100+ participants support
Discord Voice
Low-latency voice chat for gaming communities.
- • Opus codec optimization
- • Push-to-talk and voice activity
- • Global edge server network
- • Mobile battery optimization
Telemedicine
HIPAA-compliant video consultations.
- • End-to-end encryption
- • Screen sharing for records
- • Recording capabilities
- • Bandwidth adaptation
Online Education
Interactive classrooms and virtual labs.
- • Whiteboard collaboration
- • Screen sharing and recording
- • Breakout room support
- • Mobile-friendly interfaces
WebRTC Best Practices
✅ Do
- • Implement proper error handling and fallbacks
- • Use both STUN and TURN servers
- • Implement bandwidth adaptation
- • Add connection quality monitoring
- • Handle mobile/battery considerations
- • Use simulcast for scalability
- • Implement proper security measures
❌ Don't
- • Rely only on P2P for large groups
- • Ignore network conditions
- • Skip TURN server provisioning
- • Forget about mobile constraints
- • Neglect codec negotiation
- • Hardcode media constraints
- • Skip connection state monitoring