SFU vs MCU: WebRTC Architectures Compared
Every group video call needs an answer to one question: who sends what to whom. Here is how SFU, MCU and mesh answer it, and which one fits your app.
SFU vs MCU at a glance
|
SFU |
MCU | |
|---|---|---|
|
What the server does |
Forwards packets; no decoding |
Decodes, mixes and re-encodes every stream |
|
Streams each client uploads |
One (or a few simulcast layers) |
One |
|
Streams each client downloads |
One per other visible participant |
One mixed stream |
|
Server CPU per participant |
Low |
High |
|
Client CPU and download |
Higher; decodes several streams |
Low; decodes one stream |
|
Added latency |
Minimal |
Higher; decode and encode on the server |
|
Layout |
Each client builds its own |
Fixed by the server |
|
Best for |
Most modern WebRTC group calls |
Legacy room systems, weak devices, single-stream output |
What is an SFU?
A selective forwarding unit sits in the middle of a call and routes media. Each participant uploads its audio and video once. The SFU forwards those packets to everyone else who should see them. It doesn't decode or re-encode the video, so the work per stream is cheap.
"Selective" is the important word. The SFU decides what each receiver gets. It can skip video for participants who are off screen, forward only the active speakers' audio, and, with simulcast, send a low-resolution layer to a thumbnail and a high one to the main tile.
Because each client receives separate streams, each client builds its own layout. A phone can show the speaker full screen while a laptop shows a grid of nine.
Audio gets the same treatment. Many SFUs read the audio level of each stream and forward only the few loudest speakers, so a 50-person call doesn't push 49 audio streams to every device.
Most modern WebRTC platforms and open-source media servers are SFUs. RFC 7667 describes the design as a selective forwarding middlebox.
What is an MCU?
A multipoint control unit takes a different approach. It decodes every incoming stream, composes them into one picture (a 2x2 grid, say), mixes the audio, re-encodes the result and sends that single stream to each participant.
Every client does the same work as in a one-to-one call: upload one stream, download one stream, decode one stream. That made MCUs the standard for hardware room systems and SIP or H.323 video conferencing, where endpoints were limited.
The cost moves to the server. Decoding and encoding video for every participant takes far more CPU than forwarding packets, which makes MCUs expensive to scale. The extra processing step also adds latency, and every participant sees the layout the server chose. Some MCUs render a separate layout per participant, for example to leave out your own video, but that means one encode per person.
Mesh: the third option
In a mesh (peer-to-peer) call there is no media server. Every participant opens a direct WebRTC connection to every other participant and sends its stream to each of them.
For two people this is ideal: lowest latency, no media server bill, and only a signaling server and STUN or TURN to help them connect. The trouble starts as the call grows. With N people, each one uploads N-1 copies of its video and encodes them separately. Home and mobile upload links run out quickly, so mesh tends to strain beyond about four participants.
Some apps use mesh for one-to-one calls and switch to an SFU once a third person joins.
Key differences, with numbers
Take a six-person call where each camera sends 1.5 Mbps:
Mesh: each person uploads 5 x 1.5 = 7.5 Mbps and downloads 7.5 Mbps. Most home connections can't upload that.
SFU: each person uploads 1.5 Mbps (a bit more with simulcast) and downloads up to 7.5 Mbps, less when thumbnails get low layers. The server forwards, so its cost is mostly bandwidth.
MCU: each person uploads 1.5 Mbps and downloads one mixed stream of a similar size. The server decodes six streams and encodes up to six outputs, so its cost is mostly CPU.
Other differences follow from that:
Latency: an SFU adds very little. An MCU adds the time to decode, compose and re-encode.
Encryption: WebRTC encrypts each hop with DTLS-SRTP, so an SFU or MCU terminates that encryption. An SFU can still support end-to-end encryption on top (for example with SFrame), because it never needs to read the video. An MCU has to decode the video to mix it, which rules end-to-end encryption out.
Recording: an MCU already produces one composite stream to record. With an SFU, you add a recorder that composes the streams.
When to use an SFU, MCU or mesh
Use mesh for one-to-one calls, and for small calls where you want no media servers at all.
Use an SFU for most group calls, from three people to large meetings and webinars. It is the default for in-app calling in chat products, telehealth, education and marketplaces.
Use an MCU when endpoints can only handle one stream: legacy room systems, SIP phones, very low-end devices, or output to a single RTMP live stream.
Use both when you need to. Many platforms run an SFU for the live call and add a mixer only for recording, live streaming or dial-in phone participants.
Rule of thumb: two people, go peer to peer. Three or more, use an SFU. Reach for an MCU only when the receiving end can handle just one stream.
Limits and pitfalls
SFU download adds up. Without simulcast or layer selection, a large grid forces every client to receive and decode many full-quality streams. Mobile devices feel this first.
SFUs need bandwidth estimation. Forwarding the right layer to each receiver depends on good congestion control. Get it wrong and calls stall.
MCU costs grow with every participant. Each added person means another decode, and possibly another encode if layouts differ.
Mesh fails quietly. It works in a demo with three colleagues on office Wi-Fi and breaks with five users on mobile.
Geography matters. A single SFU in one region adds round-trip time for distant users. Large platforms run servers in several regions and connect them.
NAT traversal still applies. Clients connect to an SFU or MCU with ICE too, and some will need TURN over TCP or TLS to get through strict firewalls.
SFU calling with CometChat
Running an SFU means hosting media servers in several regions, tuning bandwidth estimation and keeping TURN available. If calling is a feature of your app and not the product itself, an SDK takes that work off your plate.
Group voice and video on CometChat's media servers
CometChat Calls is built on WebRTC. According to its docs, group calls use a Selective Forwarding Unit (SFU) architecture with media routed through CometChat's servers, so each participant uploads one stream and receives the others. The SDK adjusts bitrate to network conditions and reconnects after network interruptions, and recording happens on CometChat's media servers. SDKs cover JavaScript, iOS, Android, React Native and Flutter, with pre-built call UI.
Frequently asked questions
Is an SFU better than an MCU?
For most WebRTC group calls, yes. An SFU costs far less server CPU, adds less latency and lets each client choose its own layout. An MCU still wins when devices can only handle one incoming stream.
Does an SFU decode video?
No. An SFU forwards packets and picks which streams or simulcast layers each receiver gets. It does terminate the DTLS-SRTP encryption on each hop, unless you add end-to-end encryption on top.
How many participants can a mesh WebRTC call handle?
It depends on upload bandwidth and CPU, but mesh usually strains beyond about four people, because each participant uploads a separate copy of its video to everyone else.
Do I need an SFU for a one-to-one call?
Not necessarily. Two peers can connect directly with STUN, falling back to a TURN relay. Some platforms still route one-to-one calls through an SFU for recording or consistency.
Can you combine an SFU and an MCU?
Yes. A common setup runs an SFU for the live call and a mixer for recording, live streaming or phone dial-in, where one composite stream is needed.