What Is Adaptive Bitrate (ABR) Streaming? How ABR Works

Adaptive bitrate (ABR) streaming is a delivery method that encodes a video at several quality levels and lets the player pick one per segment based on your bandwidth and buffer. When your connection dips, the picture steps down instead of the video stalling.

TL;DR:

• ABR encodes one video into a ladder of renditions, lists them in a manifest (an HLS .m3u8 or a DASH .mpd), and lets the player choose a rendition for every segment.
• Players decide from download throughput, from how full the buffer is, or from both. BOLA, a buffer-based algorithm from IEEE INFOCOM 2016, ships in the dash.js player.
• Good ABR also avoids switching too often. AIOZ Stream's docs describe hysteresis, a minimum dwell time on each rung, and capped step sizes for that.
• AIOZ's docs suggest a five-rung starting ladder from 240p at 0.3 Mbps to 1080p at 5 Mbps, and the API caps each resolution, from 0.7 Mbps at 240p to 60 Mbps at 4320p.

Updated Oct 19, 2026: definition-first rewrite, a ladder diagram, the ABR rules in AIOZ's docs, and a fix: the 700 Kbps to 60 Mbps figures are caps, not a ladder.

What is adaptive bitrate streaming?

ABR is the reason a video on your phone gets softer for a few seconds in a lift instead of freezing. Without it, a player downloads one fixed file, say 1080p at 5 Mbps, and stalls whenever your connection drops below that rate. With ABR the platform stores the same video at several bitrates, and the player keeps choosing the one your network can carry right now.

AIOZ's adaptive streaming docs give a simple example: a viewer starts at 720p, and when bandwidth drops near 1.2 Mbps the player steps to 480p to avoid a stall. As the buffer recovers and throughput rises, it climbs back to 720p. Rules such as hysteresis and a minimum dwell time stop it from bouncing up and down in between.

How does adaptive bitrate streaming work?

The AIOZ docs break ABR into six steps, and every major platform follows the same shape:

1. Encode a ladder. One source is transcoded into several renditions, for example 240p to 1080p at rising bitrates. Our bitrate ladder guide covers how to choose them.
2. Package. Each rendition is cut into short segments and listed in an HLS or DASH manifest.
3. Deliver. Segments go out over HTTP from edge servers, or on AIOZ Stream from AIOZ DePIN nodes.
4. Observe. The player measures throughput, buffer level, dropped frames and device limits.
5. Decide. It picks the rendition for the next segment, trading picture quality against the risk of a stall.
6. Report. The player sends events (startup, stalls, rendition changes) that analytics turns into session numbers.

In HLS, the ladder lives in a master playlist where each rendition gets an EXT-X-STREAM-INF line with a BANDWIDTH value. RFC 8216 says that value "MUST be the largest sum of peak segment bit rates that is produced by any playable combination of Renditions." If you set it too low, the player may pick a rendition your viewer's network can't sustain. Our M3U8 guide shows a full master playlist, and the HLS vs MPEG-DASH comparison covers how the DASH manifest differs.

How does a player choose the bitrate?

ABR players fall into three families, and they differ in which signal they trust most.

• Throughput-based players estimate your bandwidth from how fast recent segments downloaded and pick the highest rung that estimate can sustain. They are simple and react quickly, but one slow segment can trigger a downshift your connection didn't need.
• Buffer-based players watch how many seconds of video are already downloaded. A basic version requests the lowest rung when the buffer is nearly empty and the highest when it is comfortably full, with steps in between.
• Hybrid players combine both. BOLA, published by Spiteri, Urgaonkar and Sitaraman at IEEE INFOCOM 2016, picks each segment's rung by maximizing a utility score that rewards quality and penalizes rebuffering, and it ships in the open-source dash.js player.

Pure throughput logic has a known weak spot called bufferbloat. A congested Wi-Fi router can queue packets for a second or more, so your connection looks slow until the queue drains and then fast again. A throughput-only player reads that as a real drop and recovery and switches twice. A buffer-based player reacts less, because the data still arrives and the buffer stays topped up.

Why switching less often matters

Every switch is visible to the viewer, so a player that chases each small change in bandwidth gives a worse session than one that holds a slightly lower rung. AIOZ Stream's docs build three guards into its ABR rules for this reason:

• Hysteresis around switch thresholds, so a reading just over the line doesn't trigger a jump.
• A minimum dwell time at each rung before the player may move again.
• A capped step size on poor networks, to avoid a free fall from 1080p straight to 360p.

Our QoE guide explains why: in a study of more than 400,000 YouTube sessions, even an upward bitrate change raised abandonment compared with holding the rate steady. Stability is one of the terms in AIOZ's own QoE model for the same reason.

How many rungs a bitrate ladder needs

More rungs are not automatically better, because each extra rung costs another encode and more storage. Rungs that sit too close together also give the player more chances to oscillate without a quality gain anyone can see. The AIOZ docs offer this five-rung ladder as a starting point and tell you to tune it against your own catalog:

Each rung roughly doubles the one below it, which keeps every switch large enough to notice. The docs add that HEVC or AV1 ladders can target 20 to 40% lower bitrates at similar quality if you gate them by device support. Content-aware encoding can cut bitrates further on simple scenes, and our VMAF guide shows how to check that each rung still looks good enough.

Don't confuse this ladder with the limits in the Video API. The API caps each resolution at a maximum bitrate, and those caps run 0.7, 1.2, 2 and 4 Mbps for 240p through 720p. From 1080p up they are 6, 12, 30 and 60 Mbps for 1080p, 1440p, 2160p and 4320p. Treat them as ceilings for any rung you define, not as a recommended ladder.

How AIOZ Stream handles ABR

The AIOZ Stream player plays HLS and MPEG-DASH with adaptive bitrate built in. According to the adaptive streaming docs, its switching decisions are QoE-aware. They weigh the expected VMAF gain of a higher rung against stall penalties, use the three stability guards above, and allow device-aware caps and regional default bitrates. The docs don't say whether the core estimate is throughput-based, buffer-based or BOLA-style, and the public API doesn't expose player-side ABR settings.

What you control is the ladder, which you define as renditions in the qualities array when you create a video. This snippet is quoted from the Video API docs for the Node.js SDK and wasn't run for this article; add one object per rung you want.

const video = await client.media.create({
  title: 'My Video',
  type: 'video',              // required, must be 'video'
  qualities: [
    {
      resolution: '720p',     // '240p'|'360p'|'480p'|'720p'|'1080p'|'1440p'|'2160p'|'4320p'
      type: 'hls',            // 'hls' | 'dash'
      containerType: 'mpegts', // hls: 'mpegts'|'mp4'; dash: 'fmp4'
      videoConfig: {
        codec: 'h264',        // 'h264' | 'h265'
        bitrate: 3000000,
        index: 0
      },
      audioConfig: {
        codec: 'aac',
        bitrate: 128000,
        channels: '2',
        sampleRate: 44100,
        language: 'en',
        index: 0
      }
    }
  ]
})

To judge your ladder, the docs suggest tracking rebuffer ratio (aim under 0.5 to 1%) and startup time (under 2 seconds for short videos). They also list average VMAF, time on the highest sustainable rung, and switch count. Our stream health metrics guide defines each one and shows how to read them together. For watch time and retention per video, our video analytics dashboard guide pulls them from the Analytics API. For the full set of rules, read Adaptive streaming (ABR) in the AIOZ Stream docs.

FAQ

Is ABR the same thing as HLS?
No. HLS and MPEG-DASH are the formats that carry an ABR ladder, and ABR is the player behavior of switching between the renditions they list.

Does ABR work on a slow connection?
Yes. The AIOZ docs say the player favors avoiding stalls first, even if that means staying on a low rung for a while. They also recommend keeping audio continuous on the lowest rungs.

Which ABR algorithm does AIOZ Stream use?
The docs describe QoE-aware rules with hysteresis, dwell time and capped steps, but they don't name a throughput, buffer or BOLA algorithm.

Is a denser ladder always better?
No. Extra rungs add encoding and storage cost, and rungs that sit close together cause more switching without a quality gain your viewers can see.

Why does quality change even when the video never buffers?
The player is moving between rungs to stay ahead of your bandwidth, and each change is visible, which is why good ABR logic limits how often it happens.

What metrics tell me whether ABR is working?
Track rebuffer ratio, startup time, average VMAF, time at the highest sustainable rung and switch count, as the AIOZ adaptive streaming docs recommend.

Related Reading

• How to Build a Video Bitrate Ladder: A Practical Guide: where the ladder a player switches between comes from
• What Is QoE in Video Streaming?: the experience model ABR decisions aim to improve
• Stream Health Metrics: Rebuffering Ratio and Startup Time: the numbers that show whether switching works
• What Is Video on Demand (VOD)?: the closed GOPs that make clean switching possible
• What Is an M3U8 File? How HLS Video Segmentation Works: the manifest that lists every rung
• What Is VMAF? How Netflix's Video Quality Score Works: how to check the quality of each rung
• HLS vs MPEG-DASH: Differences and When to Use Each: the two manifest formats compared
• Video Analytics Dashboard for Watch Time and Retention: watch time, retention and impressions from the Analytics API

References

• AIOZ Stream Docs: Adaptive streaming (ABR): the six steps, the 720p to 480p example, the stability guards, the starting ladder and the KPIs
• AIOZ Stream Docs: Video API: the qualities options and per-resolution bitrate caps
• RFC 8216: HTTP Live Streaming: the EXT-X-STREAM-INF and BANDWIDTH rule quoted above
• BOLA: Near-Optimal Bitrate Adaptation for Online Videos (IEEE INFOCOM 2016): the algorithm and its use in dash.js
• Cloudflare: What is adaptive bitrate streaming?: a general introduction