The ad-insertion control plane your cloud doesn't own.
broadcast.ad is the portable, inspectable ad-signal & manifest-control layer that lets broadcasters keep linear-grade control of the ad break while plugging into the ad servers and delivery models they already use, on any cloud, CDN, or on-prem they choose.
Not more ad load. Better retained revenue from inventory you already sell.
Broadcaster-owned policy, signal, manifest, and proof layer.
One decision and tracking core for SSAI, SGAI, and hybrid migration.
Decisioning returns AdDecision, not Result.
Streaming ad revenue leaks across the break: missed SCTE markers, underfilled avails, opaque SSAI reports, vendor-locked workflows, cloud-bound render costs, reconciliation disputes, and makegoods.
broadcast.ad gives broadcasters an independent control plane for the ad break: it validates the signal, enforces your policy, asks the ad server you already use what to play, renders SSAI or SGAI output, and proves what happened. The result is not more ad load. It is better retained revenue from the inventory you already sell.
No cloud tax. Stateless Rust workers run anywhere, from a laptop to bare Kubernetes, with no cloud-proprietary primitives in the path.
Bill what actually aired. Per-avail audit records and automatic ad-server reconciliation close the gap that otherwise turns into discrepancy disputes and makegoods.
Bring your own everything. SCTE-35 in, VAST/VMAP decisioning, HLS or DASH out. It works with the ad servers and players you already run.
Broadcasters need dynamic ad insertion across OTT, FAST, vMVPD and D2C. Today they either surrender the insertion logic to a hyperscaler or build bespoke glue with no standards spine, and either way they lose visibility into the dollars.
Yospace, AWS Elemental MediaTailor and Google DAI all do SSAI and SGAI. Their commercial center of gravity is platform-owned insertion; broadcast.ad's is broadcaster-owned policy, signal, manifest, and proof. With theirs, the control plane lives in someone else's stack: a per-stream cost, hard to debug, and only loosely coupled to your broadcast signaling.
The SSAI to SGAI migration is underway and HLS Interstitials are shipping. Incumbents are bolting SGAI onto SSAI cores. A greenfield build can be render-mode-agnostic from day one.
ESAM (SCTE 130-3) was born in a trusted-network era. In multi-tenant cloud workflows there is no broadly adopted ESAM-native security profile, so identity, replay protection, and policy authorization get bolted on per deployment instead.
Deploy-anywhere cloud independence, a render-mode-agnostic core, and signal-integrity as a first-class product: the combination the incumbents structurally cannot offer at once.
Each one keeps control in your hands instead of a vendor's cloud: your infrastructure, your ad servers, your data, your economics. No incumbent closes all five at once, because each wedge removes a lock-in or per-stream revenue stream their platform is built to sell. Doing all five would mean competing with their own economics.
Cut the per-stream cloud tax. Deploy-anywhere: local lab, private cloud, Linode, OCI, customer infra, Kubernetes. Stateless workers, no cloud-proprietary primitives. The transcode backend is bundled and modular (ffmpeg baseline, swappable) so it never reaches for a cloud's transcode service. Rust's low per-stream footprint makes the cost argument real, not philosophical.
Stop revenue leaking through bad signaling. Conformance: a verifiable SCTE-35/224 conditioning pipeline for provable signal integrity from contribution to avail, where day-to-day revenue leakage lives. Trust (SESAME): a proposed ESAM security profile adding identity, replay protection, and authorization to the messaging layer. Hard to copy.
Run SSAI and SGAI from one stack, with no rebuild when the standard shifts. One session / decision / tracking layer; switchable output as stitched segments (SSAI) or interstitial/event signals (SGAI). No mode leaks into the core: SSAI and SGAI are the only implementors of one Renderer trait. The single most important architecture call, made at the start instead of retrofitted.
Stop paying for impressions you can't prove. First-class per-session telemetry and automatic ad-server reconciliation target the impression-discrepancy leakage, the disputes and makegoods, that incumbents treat as an afterthought. Per-avail audit records, tracing, Prometheus metrics. "Wireshark for broadcast ad insertion."
Honor blackouts, affiliate swaps and regional rules automatically. Frame-accurate boundaries. Graceful underfill and slate. Blackout, affiliate replacement and regionalization honored through POIS policy. Built for linear-grade control, not an OTT tool stretched to fit broadcast.
Plug into the ad servers and players you already run. Output conforms to SCTE-35/224, VAST/VMAP, Apple HLS Interstitials, DASH events, OMID, and the Google DAI Pod Serving component model. Maximum compatibility is a hard constraint: no proprietary wire format, ever.
SCTE-35 in, ad-conditioned manifest out. If you own ad ops, the takeaway is short: every break resolves to something playable and every impression is logged. If you own the architecture, here is exactly how, and where each guarantee is enforced.
/// Ad decisioning, behind a timeout + slate fallback.
/// Never errors; underfill/timeout/error = no_fill.
async fn decide(
&self,
avail: &Avail,
ctx: &SessionCtx,
) -> AdDecision;AdDecision, not Result.The ad-decision seam has no error variant. Timeout, upstream failure, or underfill becomes AdDecision::no_fill, which the renderer converts into slate or fallback output.
Type-backed claims are not copywriting. They are design constraints the compiler keeps honest.
A clear stance on each layer of the stack keeps the product a control plane, not another demand platform.
| Layer | Answers | Representative players | Our stance |
|---|---|---|---|
| A · Ad decisioning | "Which ad plays?" | Google Ad Manager, FreeWheel, Magnite, SpringServe | Integrate, never compete |
| B · Session / manifest | "How do I personalize per session?" | MediaTailor, Google DAI, Yospace, Broadpeak, Amagi | Play, lead with portability |
| C · Broadcast signaling | "What does policy require?" | SCTE-35/104, ESAM, POIS, ESNI / SCTE-224 | Own, our head start |
| D · Observability / proof | "Did it work, can I prove it?" | Underserved across all vendors | Own, concrete differentiator |
Small and mid-size broadcasters, FAST and niche-sports operators, and sovereignty-sensitive teams who want broadcast-grade ad insertion that runs identically on a laptop, on Linode, or on their own iron.
Margin at scale. High break volume across many low-ARPU channels means per-stream cloud cost and unfilled avails compound fast. Independence and full fill protect the spread.
Frame-accurate breaks. Tight, high-value windows where a missed SCTE marker or a late ad is lost inventory. Conformance and slate keep every break clean.
Rights enforced automatically. Blackouts and regional swaps driven by POIS policy, so the right ad airs in the right market without manual glue.
Your data, your iron. Run the whole control plane on infrastructure you control, with no viewer or signaling data leaving your boundary.
Maximum compatibility is a hard product constraint. Every output is something an off-the-shelf player or ad server already understands. Each item is tagged by how far along it is.
IMPLEMENTED shipping · PROTOTYPE / MVP TARGET in progress · PLANNED / ROADMAP / ARCHITECTURE-READY ahead · PHASE 2 / PROPOSED CONCEPT on the design board
The same loop runs whether you output SSAI or SGAI: signal in, decision and policy, conditioned ad, rendered break, and a receipt at the end.
Live HLS manifest with SCTE-35 cues, DATERANGE metadata, or upstream policy hints.
The cue detector extracts avails from splice inserts and time signals.
POIS, ESAM and ESNI rules drive blackout, regionalization, suppression, or slate.
A VAST, VMAP or pod-serving adapter asks your ad server what to play, behind a timeout.
Creative is matched to the rendition ladder, or safely rejected with slate fallback.
SSAI, SGAI, or DASH output from the same decision and tracking core.
Audit records, a beacon sink with retry and dedup, Prometheus metrics, reconciliation.
Server-side manifest with discontinuities, ad media, slate, and break-level audit records.
EXT-X-DATERANGE and per-session asset-list output for server-guided ad experiences. The ad plays as a separate session, so its DRM stays independent of the content's, the clean path for protected streams.
Real mid-roll ad insertion as multi-period CMAF (content, ad, slate, then content), live in Shaka Player on the demo's demo-dash channel. The SGAI variant is manifest-signaled via an asset-list event; native client playout pends the DASH-IF interstitials spec.
DRM-aware, not a DRM origin. For protected content the clean path is SGAI, where the ad's DRM stays independent of yours. We sit downstream of your packager and never touch your content keys or license service. Key-boundary SSAI for encrypted streams (clear ads, the same approach AWS MediaTailor uses) now ships for HLS; the DASH variant is next.
We'll run the break on your own stream, stitched or via interstitials, and hand back the audit trail.