CMCD v2 Moves Telemetry Off the CDN. Now the Data Firehose is pointed at you!
Explore how CMCD v2 changes streaming telemetry, the challenges of scaling millions of real-time events, and how Momento handled 1.8 million beacons per second for FOX at Super Bowl LIX.

CMCD v2 is getting some traction. Compared to v1, it lets every player HTTP POST its playback state straight to a collector you run. At a high-stakes live event, that turns millions of viewers into millions of synchronized writers. The standard tells players what to send and how to back off. It doesn't tell you how to absorb millions of reports per second, put each session back together, and get the details to an operator in time to take action. We did that for FOX at Super Bowl LIX, with almost 2 million beacons per second, and the same reactive architecture maps directly onto CMCD v2's Event Mode.
What CMCD v2 actually changes
From piggyback to direct reporting
CMCD v1 attached player state to every segment and manifest request, so the data only existed in CDN logs. The player added keys like bitrate (br), buffer length (bl), measured throughput (mtp) and session ID (sid) as a query argument or CMCD-* headers. That was enough to correlate player behavior with CDN behavior, but it had two blind spots:
- Timing. A stall shows up as a
bs(buffer starvation) flag on the next request, with no start time and no duration. - Latency. You only see the data after each CDN processes and forwards its logs, which takes minutes, sometimes many minutes, and is separate for every CDN in a multi-CDN architecture.
CMCD v2 was published as CTA-5004-A and then CTA-5004-B (April 2026). Its central addition is Event Mode: the player sends CMCD records to one or more endpoints the application chooses, independently of media requests, when events fire or a timer elapses.
The spec defines fundamentally two reporting modes, Request Mode, which is basically CMCD v1, and Event Mode. Several implementations list a third "Response Mode", which is the Event Mode rr (response received) event. The key introduction with Event and Response modes, is that they call a HTTP POST application/cmcd request to one or several URLs configured by the service operator.
Event types (e) include ps play-state change (with sta: starting, playing, rebuffering, paused, ended…), rr response received (with url, rc, ttfb, ttlb), e error (with ec: player error code), t time interval, plus hostname change, mute/unmute, playback-rate change, ad skip, and player expand/collapse.
What a report looks like on the wire
Each record is a Structured Field Values (RFC 8941) dictionary, and v2 adds inner lists so one key can carry a separate value for each object type. This is the spec's own 30-second heartbeat example, showing a player that has started rebuffering (sta=r):
POST /cmcd HTTP/1.1
Content-Type: application/cmcd
bl=(3200),br=(4200;v 256;a),bs,bsd=(720;v),cid="content-id-123",e=t,ec=("MEDIA_ERR_NETWORK"),h="example.com",lb=(523;v 64;a),mtp=(89000;v 52000;a),pb=(4200;v 256;a),pt=59188,sf=d,sid="session-id-123",sn=3,st=v,sta=r,tb=(4200;v 256;a),tpb=(4200;v 256;a),ts=1764752460000,v=2
br=(4200;v 256;a)means 4,200 kbps video and 256 kbps audio bitrates in a single key.snis a per-report sequence number, so the collector can detect gaps and reorder records.- A batch is multiple records joined by line feeds in one POST body.
Why CMCD v2 is hard to scale
1. The volume math
Let’s take a large streaming event, like Super Bowl LIX, where they shared audience numbers. With 15.5M viewers, CMCD v2 record rates range from about 0.5M/s to 17M/s depending on which events you turn on. Request Mode load falls on the CDN that is already serving the segments. Event Mode load is your responsibility.
| Configuration (15.5M viewers) | Records/s | Payload at ~300 B |
|---|---|---|
| FOX MCVBS in production (10 s heartbeat) | 1.55M steady, 1.8M peak | ~0.5 GB/s |
t only, spec default 30 s | ~0.52M | ~155 MB/s |
t at 10 s + ps events | ~1.55M + bursts | ~0.5 GB/s |
+ rr per segment, 6 s segments with separate A/V | ~6.7M | ~2 GB/s (~16 Gbps) |
+ rr with 2 s low-latency segments | ~17M | ~5 GB/s (~40 Gbps) |
- The ~300 B per record comes from the spec's heartbeat example with a real 36-character UUID
sid, before HTTP and TLS overhead. - Client-side batching (e.g.
batchSize: 8) cuts the number of HTTP requests by 8x but leaves records and bytes unchanged. url,norandsmrtcan be large, and the spec suggests sending big payloads as single-record batches of "unconstrained size". Your collector still needs a body-size limit.
2. Synchronized bursts, not averages
At a live event, the audience acts on the same wall clock, so reports arrive in synchronized waves rather than evenly over time. An optimization could be to ask players to randomize the heartbeat interval, but this is not part of the CMCD v2 spec as of writing.
- Kickoff join: the initial burst is going to happen, with millions of sessions starting within minutes, and you need to absorb them. To make things worse, all the sessions starting exactly one minute after the kick off will join the same wave if a heartbeat is fired every t at 30 seconds.
- Ad breaks and halftime: in live SSAI or SGAI, every player crosses the same ad boundary at once, triggering an
asevent (ad start) with acidchange in the same second, to switch to the content ID of the ad, pulled from the VAST or VMAP response. FOX's 15.5M peak came during the halftime show. - Incidents: when a CDN POP degrades, every affected player emits
pswithsta=r(rebuffering) and aneerror withecat the same moment. Volume spikes exactly when the data matters most.
3. Retry semantics amplify failure
A struggling collector receives more traffic, not less. Section 5 of the spec tells players to treat 5xx errors as "batch and retry with a back-off interval". It also tells them to buffer reports while offline and deliver them once connectivity returns.
- A 30-second collector brownout leaves a backlog that millions of clients replay together on recovery, on top of live traffic.
- The spec gives servers two backpressure signals. 429 asks players to back off by growing batch size or lengthening the send interval. 410 tells a player to stop reporting to that target for the rest of the session. These signals only work if the edge can send them consistently while overloaded. A collector that times out sends neither and triggers retries instead.
- Players are expected to treat
204with an empty body as success, which keeps the happy path cheap.
4. Sessions arrive in fragments
To turn reports into QoE, you need every record for a sid, in sn order, even though they arrive late, in batches, and through different edge nodes. A startup delay is the gap between a ps sta=s record and the next ps sta=p. A stall is the gap between sta=r and the following sta=p. If those records land on different collectors, every consumer has to rejoin them. Event Mode also bypasses the CDN, so you can’t count on the CDN to do this work for you.
What we did for FOX at Super Bowl LIX
The problem: fast data-driven decisions
FOX's Media Collection and Viewership Beaconing Service (MCVBS) had every Tubi device send a beacon every 10 seconds, directly to a collector. Each beacon carried device type, stream information and delivery network. This is the same pattern as a CMCD v2 Event Mode t heartbeat, just with a proprietary payload. The first version ran on Amazon API Gateway and worked for smaller events, but at high-viewership events it dropped requests and throttled. FOX also needed answers faster than general-purpose QoE tools like Mux and Conviva could provide during the game (FOX case study). They needed to make data-driven decisions faster, because, on a tentpole event with millions of viewers, every second matters.
The architecture
Momento Gateway received the beacons and wrote each one to two places: precomputed counters for the live view, and compressed columnar files for analysis.
- Ingest: devices connected straight to Momento Gateway, which handled 15.5M concurrent connections.
- Hot path: the Gateway turned each beacon into increments on Momento counters in Momento Cache, acting as materialized views. Dashboard browsers read precomputed values instead of running queries.
- Cold path: the Gateway batched beacons into Parquet files, compressed them with ZSTD and wrote them to Amazon S3. Amazon Athena queried terabytes in seconds and stayed less than 20 seconds behind real time during the game.
- Query cache: Momento Cache also cached frequent Athena results for the dashboard.
- Readiness: the system was load-tested at twice the expected peak audience.
The results
Peak of 1.8M messages/s from 15.5M devices, more than 25B beacons on game day, zero delivery errors, and 100% analytics uptime. The live dashboard showed metrics up to a minute sooner than alternative dashboards. Athena queries were also how the team found and fixed discrepancies in client-side beaconing before game day.
How it maps to CMCD v2
| MCVBS (2025) | CMCD v2 Event Mode equivalent |
|---|---|
| 10s proprietary heartbeat | e=t with app-defined interval (default 30s) |
| Stream information | cid, sid, st, sf, br, bl, sta |
| Delivery network | h hostname, plus rr with rc/ttfb/ttlb |
| Device type | Not in CMCD but can use custom keys such as com.gomomento-d-t |
| One beacon per request | Newline-batched records per POST |
| No standard backpressure | 429 back-off, 410 stop, 5xx retry |
Moving MCVBS to CMCD v2 would make the payload richer and give standard backpressure signals. It would also add new load: rr and ps events on top of the heartbeat, batch replays, and preflights.
A reactive CMCD v2 pipeline on Momento
Start from the decision
The reactive infrastructure pattern runs ingestion, processing, storage and decisioning in a loop, but you design it backwards from the decision. For CMCD v2 that means deciding which signals you need, how quickly the decision has to change the user experience, and how much data loss you can tolerate. Some examples:
- "Alert when rebuffering on one CDN host passes 2% for 60 s" needs ps, h and sid, a budget of seconds, and tolerates sampling.
- "Steer a region off a CDN" needs the same signals plus a region from gateway enrichment, with a budget of tens of seconds.
- "Post-game QoE report" needs everything losslessly, on a budget of hours.
Ingestion: be the Event Mode target
Momento Valkey Router is the internet-facing CMCD endpoint and protects device traffic away from everything behind it.
- TLS and auth: terminate HTTPS with custom certificates and check the per-target
Authorizationtoken the spec asks players to support. - Connection pooling: millions of device connections share a small pool of Valkey connections. This avoids the N×M connection problem that breaks naive collectors.
- Throttling as protocol: map overload to fast 429 responses so compliant players back off by growing batches or lengthening intervals instead of retrying on 5xx. Keep 410 for shutting off a target or cohort deliberately.
Processing: reassemble sessions on a shard
Momento does more than routing the traffic, it also processes it.
First, Momento groups all of a session’s records into a deterministic way, so every record for a given sid lands on the same shard, i.e. the same partition of the data store to minimize the access time. WASM-based Momento Functions parse the Structured Field Values and inner lists, drop invalid values and records with an unknown v, and enrich with geo or ASN. All of this is required by spec Section 6, and none of it needs a join. Gaps in sn reveal loss. Backfilled batches with old ts values are placed by event time, not arrival time.
Also, we keep a raw archive that does not depend on validation, so malformed records can be replayed after a parser fix. This is crucial to detect and fix beaconing bugs.
Decisioning: close the loop, including on CMCD itself
Decisions are computed outside the viewer request path and applied through business logic, an edge function, or an operator. CMCD v2 adds one more control: the spec delivers CMCD configuration to players "via an out-of-band mechanism, such as a configuration file or media manifest". That means the decision layer can also tune the telemetry itself.
- Steer delivery: when one host's rebuffer counter crosses a threshold, publish a new content-steering or CDN-weight decision. The next report’s
h(hostname) values show whether it worked. - Turn down the firehose: near capacity, publish a config with a longer
tinterval, fewerrrevents, or a smaller sampled cohort, and reach for 429 only when that isn't enough. - Turn it up for diagnosis: during an incident, enable
rrfor only the affected region or host to getttfb/ttlbdetail without paying for it across the whole audience. - Keep the published decision stable between updates. Clients should apply cached decisions, not wait for a fresh analytical query.
CMCD v2 standardizes what players say. The hard part is still everything that happens after the POST lands. If you're preparing for your next tent-pole event, we’d be happy to share our experiences with you.