WebRTC (Web Real-Time Communication) is the open standard that lets your browser make video calls, voice calls, and share data directly with another browser, without installing anything. It powers the real-time layer underneath tools like Google Meet and browser-based chat apps, quietly handling the hard parts of live communication that most users never think about. If you've ever joined a video call by clicking a link, WebRTC was almost certainly doing the heavy lifting.
What problem WebRTC solves
Before WebRTC landed as a standard around 2011, real-time browser communication required plugins: Flash, Java applets, or proprietary software you had to download and trust. Each approach was fragile, security-prone, and painful to maintain. WebRTC changed that by baking the capability directly into the browser itself.
The core idea is peer-to-peer communication. Rather than routing your video stream through a central server and back out to the other person, WebRTC tries to send data directly from your machine to theirs. Less distance means lower latency and faster calls. It doesn't always succeed at pure peer-to-peer (firewalls and network configurations get in the way), but it tries first and falls back gracefully when it can't.
Understanding how WebRTC handles data at the network level connects directly to how network packets carry your data across the internet, since every frame of your video call travels as a stream of discrete packets between machines.
The three core components
WebRTC is built on three main building blocks, each solving a distinct problem in real-time communication.
MediaStream captures audio and video from your camera and microphone. It hands the browser a live stream of media data that can be processed, displayed, or transmitted. It's the entry point: no MediaStream, no call.
RTCPeerConnection is the workhorse. It manages the full pipeline for sending and receiving audio and video between two peers. RTCPeerConnection handles codec negotiation (working out what video and audio formats both sides can speak), encryption, bandwidth adaptation, and packet loss recovery. It does a lot.
RTCDataChannel handles arbitrary data, not just media. Text, files, game state, cursor positions. Any structured data that two browsers need to exchange in real time can flow through a DataChannel. This is what browser-based file sharing and multiplayer tools use.
How two browsers find each other
The tricky part of WebRTC isn't the media pipeline. It's the initial connection setup. Two browsers sitting behind different routers, firewalls, and network address translators don't know each other's real IP addresses. WebRTC uses a process called ICE (Interactive Connectivity Establishment) to solve this.
ICE gathers a list of possible ways to reach you, called candidates. These include your local network address, your public IP address (discovered via a STUN server), and a relay address provided by a TURN server as a last resort. Both peers exchange their candidate lists through a separate signalling channel, which WebRTC deliberately doesn't specify. That's your job as a developer: use WebSockets, a REST API, or anything else to swap the connection information.
Once candidates are exchanged, ICE runs through them in priority order. Direct peer-to-peer works. If not, it tries NAT traversal. If that fails, it routes through the TURN relay. The whole process typically takes under a second on a good connection.
The signalling step is worth understanding in context. WebRTC uses the Session Description Protocol (SDP) to describe what each peer can send and receive: codecs supported, resolution limits, network candidates. SDP is verbose and technical, but the browser generates it automatically. Developers rarely touch it directly.
Encryption: built in by default
WebRTC encrypts all media and data by default. It uses DTLS (Datagram Transport Layer Security) for the data channel and SRTP (Secure Real-Time Transport Protocol) for audio and video. Neither can be turned off. A WebRTC call that isn't encrypted isn't a valid WebRTC call. This is a meaningful contrast to older voice-over-IP systems where encryption was optional and often skipped.
The encryption model is similar in spirit to what powers HTTPS. If you've read about public key infrastructure, you'll recognise the handshake pattern WebRTC uses during DTLS negotiation to establish a shared secret before any media flows.
What WebRTC doesn't do well
Peer-to-peer works cleanly for two-person calls. Scale it to 10 or 50 participants and the model breaks. Each peer would need to send its video stream to every other participant simultaneously, which destroys upload bandwidth and CPU. That's why large video conferences use a Selective Forwarding Unit (SFU) or Multipoint Control Unit (MCU) server sitting in the middle. The browser still uses WebRTC to connect to the server; the server handles the fan-out. Google Meet, Zoom, and similar services all run infrastructure like this, even though the client-facing technology is still WebRTC.
Latency is also not guaranteed. WebRTC prioritises speed and uses UDP rather than TCP for media, meaning packets can be lost without retransmission. The codec layer compensates with error concealment and forward error correction, but on a congested or high-latency connection, call quality degrades visibly. No amount of clever signalling fixes a genuinely bad internet connection.
Where WebRTC is used today
WebRTC runs inside Google Meet for in-browser calls without a client download. It also powers Discord's browser-based voice and video, the screen-sharing features in browser-based collaboration tools, and real-time customer support widgets embedded on retail and banking websites. Browser-based game streaming experiments use the DataChannel for low-latency input.
Beyond consumer apps, WebRTC has found serious uptake in telehealth. Australian clinics and healthcare platforms use it for browser-based GP consultations, since it removes the friction of asking patients to install software before an appointment.
What you actually need to build with it
A minimal WebRTC implementation needs four things: a STUN server (to discover your public IP), optionally a TURN server (for fallback relay), a signalling mechanism to swap SDPs and ICE candidates, and the WebRTC browser APIs themselves. The browser APIs are built into Chrome, Firefox, Safari, and Edge. STUN is cheap; Google operates public STUN servers developers can use freely. TURN costs more because it relays media bandwidth, so most production apps use a managed service.
The JavaScript API surface is small and well-documented. RTCPeerConnection, getUserMedia(), and RTCDataChannel cover almost every use case. The complexity isn't the API. It's the networking edge cases: symmetric NATs, corporate firewalls, mobile networks that aggressively close idle connections.
WebRTC is a genuinely mature open standard. It's been in production for over a decade, the browser implementations are stable, and the encryption is non-negotiable. For any Australian developer building real-time communication features into a web app, it's the right starting point.

