Video streaming testing overview
Video streaming loads your infrastructure very differently from a REST API. Each viewer sends a continuous stream of segment-fetch requests for the whole session, not a single call. As your viewer count grows, your CDN, origin and packaging infrastructure must handle a sustained, predictable rise in GET requests, each with strict latency requirements. A single buffering event can lose a viewer. A live event kickoff can take your infrastructure from idle to peak in seconds.
This section shows how to load-test video streaming infrastructure with MaxoPerf. It covers simulating an ABR player fetching HLS or DASH content, modeling thousands of concurrent viewers, and the sudden surge when a live event starts.
VOD vs live streaming
Section titled “VOD vs live streaming”The two main delivery modes have different load shapes:
| Dimension | VOD (Video on Demand) | Live streaming |
|---|---|---|
| Viewer arrival | Spread over time: not everyone starts at once | Synchronized: kickoff spike when the event begins |
| Segment age | Static segments, aggressive CDN caching | Fresh segments every 2–10 s, low cache-hit ratio |
| Manifest requests | Infrequent: once per session startup | Frequent: player polls the live manifest every few seconds |
| Origin load | Low if CDN is warm | High: new segments must be packaged and served continuously |
| Test focus | Startup time, CDN cache-hit ratio, concurrent viewer throughput | Live manifest poll rate, segment freshness latency, kickoff spike |
How ABR streaming works
Section titled “How ABR streaming works”Adaptive Bitrate (ABR) streaming, both HLS and DASH, delivers video in three request layers:
- Master manifest. Describes the available renditions (bitrates, resolutions, codecs). The player fetches it once at session start.
- Variant playlist (rendition manifest). Lists the segments for the chosen bitrate. The player fetches it once at start, and again every segment interval for live streams.
- Segments. Short media chunks (2–10 s each), fetched at real-time cadence: one segment every segment-duration seconds, for as long as the viewer watches.
The request rate per viewer is approximately 1 segment / segment_duration. For a 4-second segment, each viewer sends 15 GET requests per minute to the CDN. At 10,000 concurrent viewers, that is 2,500 segment requests per second, plus manifest polls.
Why streaming load testing matters
Section titled “Why streaming load testing matters”Over-provisioning streaming infrastructure is expensive, and under-provisioning it is dangerous. Load testing lets you:
- Find the CDN cache fill point: how many concurrent viewers it takes before the CDN absorbs the segment load and origin offload begins.
- Find manifest-server bottlenecks. Live manifest generation is stateful and often becomes a scaling bottleneck that light load never shows.
- Check quality of experience (QoE). Measure startup time and segment download time against segment duration. When segment download time approaches segment duration, real viewers buffer.
- Rehearse live-event spikes. A sports kickoff or premiere start opens thousands of viewer sessions at once. Test this before the event, not during it.
- Verify failover: CDN failover, origin redundancy and regional edge behavior under load.
MaxoPerf’s role
Section titled “MaxoPerf’s role”MaxoPerf simulates viewer sessions with virtual users (VUs). Each VU runs the same fetch loop a real ABR player runs: fetch the master manifest, pick a rendition, then loop through segment GETs at the correct real-time cadence. MaxoPerf runs distributed runner fleets across multiple geographic regions, so one test configuration can reproduce a viewer population spread around the world.
| Capability | What it provides for streaming tests |
|---|---|
| Multi-region runners | Simulate viewers from North America, Europe, and Asia-Pacific simultaneously |
| VU-based concurrency | Each VU = one viewer; scale to thousands |
| Ramp profiles | Model the linear viewer ramp for VOD or the instant kickoff spike for live |
| Per-request labeling | Label manifest vs segment requests separately for per-request latency breakdown |
| Failure criteria | Fail the run automatically if p95 segment latency exceeds segment duration |
Decision matrix: where to start
Section titled “Decision matrix: where to start”| You want to… | Start here |
|---|---|
| Understand HLS/DASH player simulation and write your first manifest+segment test | HLS and DASH manifest and segment testing |
| Test multiple bitrate renditions and ABR switching behavior | ABR adaptive bitrate testing |
| Scale a test to thousands of concurrent viewers | Concurrent viewers load |
| Test a live event kickoff spike | Live event streaming load |
| Understand QoE metrics: startup time, rebuffer ratio | Startup time and rebuffering QoE |
| Test signed URLs, tokenized segments, and DRM license requests | DRM and token auth testing |
| Find a pre-built scenario for your streaming use case | Daily streaming scenarios |
| Know the quick do/don’t rules for streaming load tests | Video streaming do and don’t |
Where to go next
Section titled “Where to go next”- HLS and DASH manifest and segment testing: the base page. Start here if you are new to streaming load testing.
- Concurrent viewers load: scaling math and MaxoPerf configuration for large viewer counts.
- Test types: stress, spike, soak and load test types that apply to streaming infrastructure.
- Cookbook: generic load-test patterns you can adapt to CDN and streaming targets.