WebRTC vs LL-HLS: the latency you actually get, measured
Over WebRTC a viewer sees the picture about 0.27 s after the camera captures it on a local network, and about 0.49 s from a cloud server. Low-latency HLS (LL-HLS) lands near 1.25 s and ordinary HLS near 3.6 s. Choose WebRTC when viewers react to what they see; choose LL-HLS when you need HTTP caching, every device and a few hundred extra milliseconds do not matter.
The numbers, and how they were measured
| Delivery | Glass to glass | Measured |
|---|---|---|
| WebRTC, local network | 0.27 s | Local network test, 2026-10-20 |
| WebRTC, cloud server | 0.49 s | 2026-10-13, 4 vCPU cloud server, see benchmarks |
| LL-HLS | about 1.25 s | Player aimed about 1 s behind live, see low-latency HLS |
| HLS | about 3.6 s | Same tests as LL-HLS, see low-latency HLS |
Glass to glass means from the light hitting the camera to the frame on the viewer's screen: encoder, network, server and player together. The encoder sent a keyframe every second with B-frames off. With B-frames on and a 2-second keyframe interval, every number above grows.
Why WebRTC is faster
WebRTC sends each encoded frame in RTP packets as soon as it exists, over UDP. Lost packets are concealed or briefly re-requested rather than waited for, and the player renders with a jitter buffer of tens of milliseconds. There is no file to finish and no playlist to fetch.
The cost is that every viewer holds a live connection to a media server. The server forwards the same packets to each one, so capacity is set by network bandwidth: on a 1 Gbit/s port, roughly 350 viewers at 1080p and 2.5 Mbit/s.
Why LL-HLS is slower, and still useful
HLS is files over HTTP: a playlist and media segments. Ordinary HLS publishes whole segments of a few seconds, and players start a few segments behind. LL-HLS splits each segment into parts of a few hundred milliseconds, lets the player request the next part before it exists (a blocking playlist reload), and hints the next part's name in advance. That removes most of the wait, but not the packaging and the player's safety buffer.
What LL-HLS keeps is HTTP: any CDN can cache it, it plays natively on Apple devices, and a lost packet costs nothing because TCP resends it. For large audiences that only watch, that usually matters more than one second.
Which one to use
- Auctions, betting, sports with live interaction, two-way conversations: WebRTC. One second decides who wins a bid.
- Large public events, many devices, a CDN in front: LL-HLS, with ordinary HLS as the fallback for old players.
- Both: most productions offer WebRTC to the people who interact and HLS to everyone else, from the same input.
In creekX: every live plays over WebRTC, LL-HLS and HLS from the same input, and the watch page lets the viewer pick. See watch links and embedding and low-latency HLS in practice.
Frequently asked questions
Is WebRTC always faster than LL-HLS?
For delivery to the viewer, yes: WebRTC sends each frame as soon as it exists, while LL-HLS still packages media into parts of a few hundred milliseconds and the player keeps a small buffer.
Can LL-HLS go below one second?
In theory, with very short parts and an aggressive player. In practice, players aimed tighter than about one second behind live were faster on average but sometimes stalled far behind.
Does WebRTC work through a CDN?
Not through an ordinary HTTP CDN. WebRTC viewers connect to a media server or to edge servers you run; HLS and LL-HLS are what HTTP caches carry.