What Is MPEG-DASH? Dynamic Adaptive Streaming Explained

When YouTube plays a video in Chrome, when Netflix streams to a smart TV, or when a broadcaster delivers a live event to Android phones, the stream is very often MPEG-DASH. DASH is the international standard for adaptive streaming over HTTP. It does the same basic job as Apple’s HLS, but it was designed by a standards body with input from dozens of companies, and it shows in its flexibility.

This guide explains what DASH is, how its manifest is structured, where it is used, how it compares with HLS, and how to create and test a DASH stream.

A short history

By 2010, every big technology company had its own adaptive streaming format: Apple had HLS, Microsoft had Smooth Streaming, Adobe had HTTP Dynamic Streaming. Content owners had to package every video three times. The Moving Picture Experts Group (MPEG), the body behind MP3, MPEG-2 and H.264, set out to create a single open standard. The result, Dynamic Adaptive Streaming over HTTP, was published as ISO/IEC 23009-1 in 2012.

The DASH Industry Forum (DASH-IF) followed, bringing together streaming companies to write interoperability guidelines and to maintain the reference player, dash.js.

How DASH works

The idea is the same as HLS:

1. The video is encoded into several quality levels.
2. Each level is split into short segments, typically 2 to 6 seconds.
3. A manifest describes all levels and where to find the segments.
4. The player downloads the manifest, chooses a quality, fetches segments over HTTP, and switches quality as network conditions change.

That last part is adaptive bitrate streaming, and it is the whole point of DASH.

The main differences are in the manifest and the flexibility of the format.

The MPD manifest

A DASH manifest is an XML file called a Media Presentation Description (MPD). Here is a simplified example:

<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static"
     mediaPresentationDuration="PT10M" minBufferTime="PT2S"
     profiles="urn:mpeg:dash:profile:isoff-live:2011">
  <Period id="1" start="PT0S">
    <AdaptationSet mimeType="video/mp4" segmentAlignment="true">
      <SegmentTemplate timescale="1000" duration="4000"
        initialization="$RepresentationID$/init.mp4"
        media="$RepresentationID$/seg-$Number$.m4s" startNumber="1"/>
      <Representation id="1080p" bandwidth="5000000" width="1920" height="1080" codecs="avc1.640028"/>
      <Representation id="720p" bandwidth="3000000" width="1280" height="720" codecs="avc1.64001f"/>
      <Representation id="480p" bandwidth="1400000" width="854" height="480" codecs="avc1.64001e"/>
    </AdaptationSet>
    <AdaptationSet mimeType="audio/mp4" lang="en">
      <SegmentTemplate timescale="1000" duration="4000"
        initialization="audio/init.mp4" media="audio/seg-$Number$.m4s" startNumber="1"/>
      <Representation id="audio" bandwidth="128000" codecs="mp4a.40.2" audioSamplingRate="48000"/>
    </AdaptationSet>
  </Period>
</MPD>

The structure has four main levels.

Period

A Period is a span of time with a consistent set of content. Most on-demand videos have one period. Multiple periods are used to insert ads, join programmes together, or change the available tracks mid-stream.

Adaptation Set

An Adaptation Set groups interchangeable versions of one piece of content. Typically there is one adaptation set for video, one for each audio language and one for each subtitle language. The player picks one adaptation set per type, such as English audio, and then adapts within it.

Representation

A Representation is one specific encoding: a resolution, bitrate and codec. The player switches between representations in the same adaptation set as the network changes.

Segments

Segments are described using one of three methods:

• SegmentTemplate: a URL pattern with placeholders such as $Number$ or $Time$. The most common method, and the most compact.
• SegmentList: an explicit list of segment URLs.
• SegmentBase: a single file per representation, with byte ranges for each segment given by an index inside the file.

SegmentTemplate with SegmentTimeline is popular for live streams because it can describe segments of varying length precisely.

Static vs dynamic manifests

An MPD with type="static" describes on-demand content. The whole timeline is known. An MPD with type="dynamic" describes a live stream. The player uses availabilityStartTime, the current time and the segment timing to work out which segments exist, and refreshes the manifest based on minimumUpdatePeriod. Getting clocks right matters for live DASH. Players often synchronise with a time server listed in a UTCTiming element.

Codec and container flexibility

DASH is codec-agnostic. The standard does not care what is inside the segments. In practice you will see:

• Video: H.264, H.265/HEVC, VP9, AV1.
• Audio: AAC, Dolby Digital (AC-3), Dolby Digital Plus (E-AC-3), Opus.
• Containers: fragmented MP4 (ISO BMFF) almost always, and WebM in some cases, notably by YouTube.

This openness is one reason DASH was popular with services that adopted VP9 and AV1 early. Our H.264 vs H.265 vs AV1 guide explains the codec choices, and our codec support checker shows what your device can decode.

DRM in DASH

DASH was designed with Common Encryption (CENC) in mind. Each adaptation set can include ContentProtection elements, one per DRM system, identified by a system ID:

• Widevine: urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed
• PlayReady: urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95

Because the encrypted segments are shared, a single DASH stream can be unlocked by Widevine in Chrome and Android and by PlayReady in Edge and on smart TVs. For Apple devices, most services serve HLS with FairPlay from the same CMAF segments. See what is multi-DRM for the whole picture.

Where DASH plays

• Chrome, Firefox, Edge and other desktop browsers through Media Source Extensions and a JavaScript player such as dash.js, Shaka Player, Video.js or commercial players.
• Android through ExoPlayer/Media3, which has excellent DASH support.
• Smart TVs and set-top boxes, including HbbTV devices in Europe, many Samsung and LG models, Android TV and Fire TV.
• Not natively on Apple devices. Safari and iOS do not play DASH directly. Newer iOS versions support the Managed Media Source API, which lets JavaScript players handle DASH on iPhone, but most services still serve HLS there.

Strengths and weaknesses

Strengths

• Open international standard, not controlled by one company.
• Very flexible manifest: multiple periods, rich metadata, precise timelines.
• Codec-agnostic and DRM-friendly.
• Strong support on Android, smart TVs and browsers.
• Mature low-latency mode (LL-DASH) using chunked CMAF.

Weaknesses

• No native playback on Apple devices, so you still need HLS for them.
• The flexibility means more ways to create manifests that one player accepts and another rejects. Following DASH-IF interoperability guidelines helps.
• XML manifests can grow large for long live streams unless managed carefully.

Creating a DASH stream

For on-demand content:

1. Encode a bitrate ladder with aligned keyframes. Our encoding settings guide has one.
2. Package with Shaka Packager, Bento4 (mp4dash), GPAC (MP4Box -dash), FFmpeg’s dash muxer, or a cloud service.
3. Publish the MPD and segments behind a CDN with CORS enabled.
4. Play with a DASH-capable player.

A quick FFmpeg example producing a DASH manifest with fMP4 segments:

ffmpeg -i input.mp4 -map 0:v -map 0:a -c:v libx264 -b:v 3M -g 96 -keyint_min 96 -sc_threshold 0 \
  -c:a aac -b:a 128k -f dash -seg_duration 4 -use_template 1 -use_timeline 1 out/manifest.mpd

In production you would add more renditions and ideally package HLS playlists from the same segments, which CMAF makes possible.

Testing a DASH stream

Paste your MPD URL into our free DASH player. It uses dash.js, lists every video representation, and logs errors so you can see whether a problem is the manifest, the network or the codec. Common issues include missing CORS headers, clock drift on live streams, and codecs the browser cannot decode.

DASH profiles and interoperability

The DASH standard is broad, so the industry defined profiles that narrow it down to combinations players are expected to support. You will see them in the profiles attribute of the MPD:

• ISO BMFF On Demand (urn:mpeg:dash:profile:isoff-on-demand:2011): one file per representation with byte-range segments. Simple for VOD, efficient for CDNs.
• ISO BMFF Live (urn:mpeg:dash:profile:isoff-live:2011): separate segment files using SegmentTemplate. Despite the name, it is used for both live and VOD and is the most common profile today.
• CMAF profile (urn:mpeg:dash:profile:cmaf:2019): signals that segments follow CMAF rules, making HLS and DASH sharing explicit.
• DVB-DASH and HbbTV profiles add rules for European broadcast and TV platforms.

The DASH-IF Interoperability Points (IOPs) go further, recommending exact codec, timing and DRM signalling practices. Following them avoids most “plays in dash.js but not on the TV” problems.

Validating a DASH manifest

Before publishing, run manifests through a validator. The DASH Industry Forum provides a conformance tool that checks MPDs and segments against the standard and IOP rules. Many commercial packagers include validation too. Common errors caught this way include mismatched timescales, missing codecs attributes, overlapping periods and segment timelines that do not match the actual media duration.

DASH for live events: the clock matters

Live DASH depends on the player and server agreeing on the current time. If a viewer’s device clock is off by a few seconds, the player requests segments that do not exist yet (404s) or starts too far behind. The fix is a UTCTiming element in the MPD pointing to a reliable time source, which players such as dash.js and Shaka Player use to correct for clock drift automatically.

Summary

MPEG-DASH is the open international standard for adaptive HTTP streaming. It describes content in an XML MPD made of periods, adaptation sets and representations, supports any codec, and works cleanly with multi-DRM. It dominates on Android, smart TVs and many browser players, while HLS remains necessary for Apple devices. With CMAF, you can serve both from the same files, which is what most modern services do.