What is MoQT?

Media over QUIC Transport (MoQT) is an IETF protocol for delivering media and data over QUIC connections. It combines the low latency of real-time protocols with the scalability of relay-based distribution.

How MoQT works

MoQT follows a publish/subscribe model. Publishers send objects to a relay, which forwards them to all subscribed clients. Objects are organized into tracks (named streams within a namespace), and each track contains groups of objects. Clients subscribe to tracks with a filter that determines where to start receiving data — the latest object, the next group, or a specific position in history.

Publisher Relay Subscribers

Objects flow from publishers through relays to subscribers over QUIC

What is MoQT used for?

Live streaming

Low-latency video and audio delivery. MoQT's group-based object model maps naturally to GOPs and audio segments, with built-in priority and delivery order controls.

Real-time chat & messaging

Publish/subscribe messaging over QUIC. Each chat room is a namespace, each conversation is a track, and each message is an object.

IoT telemetry

Sensor data ingestion over QUIC connections. MoQT handles high-frequency, small-payload publishing with efficient binary encoding and relay fan-out.

Game state synchronization

Real-time game state updates where priority and delivery order matter. MoQT lets publishers control which data is most important when bandwidth is constrained.

Core concepts

The building blocks of the MoQT protocol.

Tracks

A track is a named stream of objects within a namespace. Tracks are the fundamental unit of subscription — a client subscribes to a track to receive objects as they're published.

Namespace: ["chat", "room1"] — Track: "messages"

Objects, Groups & Subgroups

An object is the smallest unit of data (a message, a video frame, a sensor reading). Objects are organized into groups (a GOP in video, a batch of messages) and optionally subgroups for priority ordering.

Group 42, Object 0: {"author": "alice", "msg": "hello!"}

Subscriptions

Clients subscribe to tracks with a filter that determines where to start receiving: the latest object, the start of the next group, an absolute position, or a range of historical data.

SUBSCRIBE ns=["live"] track="video" filter=latest_group

Relays

A relay is a server that receives objects from publishers and forwards them to subscribers. Relays can be chained, forming a distribution tree. They handle fan-out, subscription aggregation, and caching.

Publisher → Relay → Subscribers (fan-out)

Sessions

A MoQT session runs over a single QUIC connection. The session starts with a CLIENT_SETUP / SERVER_SETUP handshake to negotiate the protocol version and capabilities.

CLIENT_SETUP versions=[draft-07] → SERVER_SETUP version=draft-07

QUIC Transport

MoQT runs over QUIC, which provides encrypted, multiplexed, low-latency transport. QUIC's stream multiplexing eliminates head-of-line blocking, and its built-in congestion control adapts to network conditions.

Bidirectional streams for control, unidirectional streams for data

Control messages

MoQT sessions use a control stream for signaling. Key message types:

Message Purpose
CLIENT_SETUP / SERVER_SETUP Negotiate protocol version and capabilities
SUBSCRIBE Request objects from a track
SUBSCRIBE_OK / SUBSCRIBE_ERROR Accept or reject a subscription
PUBLISH Announce intent to publish a track
FETCH Retrieve historical objects by range
SUBSCRIBE_NAMESPACE Discover available tracks in a namespace
GOAWAY Signal graceful session shutdown
UNSUBSCRIBE Cancel an active subscription

MoQT vs other protocols

MoQT WebRTC HLS/DASH WebSocket
Transport QUIC DTLS/SRTP HTTP/TCP TCP
Topology Relay-based Peer-to-peer CDN/server Client-server
Latency Sub-second Sub-second 5-30 seconds Low
Fan-out Native (relays) SFU required CDN Manual
Priority control Built-in Limited None None
Pub/Sub model Native No No Manual

Why is MoQT debugging hard?

  • 1. QUIC encrypts everything — no passive packet capture without TLS key export
  • 2. Binary encoding — MoQT messages are not human-readable on the wire
  • 3. No browser DevTools support — Chrome shows WebTransport connections but not MoQT semantics
  • 4. No Wireshark dissector — no existing tool decodes MoQT messages
  • 5. Evolving spec — draft versions change message formats, so tools need multi-draft support

moqtap solves these problems by being a MoQT-aware client that connects to any relay and decodes everything for you.

MoQT explained

Focused answers to the questions implementers ask most about the wire protocol.

Track Namespace vs Track Name

The namespace is a tuple that groups tracks; the name identifies one track within it. How they differ and combine.

The SUBSCRIBE message

Field-by-field structure of SUBSCRIBE — filters, forward state, priority — with draft-17/18/19 differences.

SUBSCRIBE_NAMESPACE & prefix matching

How namespace discovery and track namespace prefix matching work, and the draft-18 SUBSCRIBE_TRACKS split.

Frequently asked questions

What is MoQT?
MoQT (Media over QUIC Transport) is an IETF protocol for delivering media and data over QUIC connections. It provides a publish/subscribe model where publishers send objects through relays to subscribers, with built-in support for prioritization, delivery ordering, and low-latency streaming.
What is the difference between Track Namespace and Track Name in MoQT?
The Track Namespace is an ordered tuple of byte-string components that groups related tracks (e.g. ["chat", "room1"]); the Track Name is a byte string that identifies one track within that namespace (e.g. "messages"). Together they form the Full Track Name, which uniquely identifies a track. The namespace supports prefix matching for discovery via SUBSCRIBE_NAMESPACE, while the name is always matched exactly.
How is MoQT different from WebRTC?
WebRTC is peer-to-peer and designed for interactive communication (video calls). MoQT is relay-based and designed for one-to-many or many-to-many scenarios (live streaming, broadcasting, pub/sub data). MoQT uses QUIC for transport, supports relay chains for scalable distribution, and gives publishers explicit control over priority and delivery order.
How is MoQT different from HLS/DASH?
HLS and DASH are HTTP-based streaming protocols with segment-based delivery and typical latencies of 5-30 seconds. MoQT uses QUIC for sub-second latency, delivers individual objects (not segments), and supports bidirectional communication. MoQT is designed for the latency requirements of live streaming, not just VOD.
How is MoQT different from WebSocket?
WebSocket provides a raw bidirectional byte stream over TCP. MoQT provides structured publish/subscribe semantics over QUIC — with named tracks, typed objects, subscription filters, relay fan-out, and priority controls. MoQT handles the distribution and ordering that you'd have to build yourself on top of WebSocket.
What QUIC features does MoQT use?
MoQT uses QUIC stream multiplexing (separate streams for control and data, so they don't block each other), QUIC's built-in encryption (TLS 1.3), 0-RTT connection establishment for fast reconnects, and per-stream flow control. The protocol uses bidirectional streams for the control channel and unidirectional streams for data delivery.
Is MoQT finalized?
MoQT is an active IETF draft, not yet an RFC. The protocol is evolving across draft versions. moqtap supports multiple draft versions so you can test implementations as the specification matures.
How do I debug MoQT?
Use moqtap — a free, cross-platform MoQT protocol debugger. It connects to any relay, decodes binary control messages, subscribes to tracks, fetches data, and shows QUIC transport stats. Download it at moqtap.com/download.
Where can I learn more about MoQT?
The IETF draft specification is the authoritative source. For a practical introduction, see the moqtap documentation at moqtap.com/getting-started/installation/ which walks through connecting to relays, subscribing to tracks, and inspecting messages.

See MoQT in action

Download moqtap and connect to a relay. See every message, every object, every transport metric.

Download moqtap Read the docs