WebRTC and sub-second latency

WebRTC is the transport when latency has to be conversational. WAVE runs its own edge WebRTC SFU on Cloudflare — WHIP in, WHEP out — and exposes it through the same open API as every other transport.

WAVE··6 min read
0:00
0:00
WAVE Voice
AudioCaptionsTranscript

There is a class of video where a second of delay breaks the experience: a guest on a live show, an agent answering in a conversation, two operators in a shared control room. For that class, the transport is WebRTC — built for low-latency, two-way media in the browser.

WAVE runs real-time on its own edge. The real-time layer is an edge WebRTC SFU on Cloudflare — WHIP to publish, WHEP to play, terminated close to the user so the round trip stays short. WAVE adds the rest: broadcast transports next to it (NDI, Dante, OMT, MoQ), captions and voice, and one open API over the whole set. Edge-native, open on top.

When to reach for WebRTC

  • Two-way interaction. Anything where both ends talk and latency is felt.
  • Browser-first. No plugin, no app — it runs where the viewer already is.
  • Sub-second targets. When the budget is hundreds of milliseconds, not seconds.

For one-to-many delivery where a few seconds of latency is fine, HLS is cheaper and simpler. WebRTC is the tool when the interaction is the point.

What "sub-second" depends on

Latency is a chain, and the transport is one link:

  • Network path. Pushing media to the edge keeps the round trip short.
  • Encode and decode. Real-time codecs and modest GOP settings over long ones.
  • Jitter buffer. Smaller buffers cut delay and cost a little resilience — a deliberate trade.
  • The far end. A caption that is two seconds late is useless; an agent that takes 800 ms to answer breaks the turn.

WAVE runs this layer edge-native so the path stays short, and exposes the controls through the API instead of burying them in a console.

Using it through WAVE

The real-time transport is one option on the same API as everything else:

{
  "session": { "type": "webrtc", "role": "publisher" },
  "deliver": ["webrtc", "hls"]
}

Start a real-time session, or fan the same source out to HLS for the audience that does not need to interact — one API, two transports. Under the hood that publishes over WHIP and plays back over WHEP at the edge (rt.wave.online), but you address it the same way you address any other transport — by naming it in the call.

Where it fits

WebRTC is the conversational link. WAVE makes it one transport among many, agent-payable through the same gateway, so a real-time call and a broadcast delivery look the same from the API's point of view.

Taggedwebrtccloudflaresfureal-timetransports