Video streaming testing overview
Video streaming has a fundamentally different load profile from REST APIs. Every viewer drives a continuous stream of segment-fetch requests throughout their session — not a one-off call. As your viewer count scales, your CDN, origin, and packaging infrastructure must handle a sustained, predictable surge in GET requests, each with strict latency requirements. A single buffering event can lose a viewer; a live event kickoff can spike your infrastructure from idle to peak in seconds.
This section covers how to load-test video streaming infrastructure with MaxoPerf: from simulating an ABR player fetching HLS or DASH content, to modeling thousands of concurrent viewers, to the sudden surge of a live event start.
VOD vs live streaming
Section titled “VOD vs live streaming”The two dominant 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). Fetched once at session start.
- Variant playlist (rendition manifest) — lists the segments for a chosen bitrate. Fetched once at start; re-fetched 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, indefinitely.
The request rate per viewer is approximately 1 segment / segment_duration. For a 4-second segment, each viewer drives 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”Streaming infrastructure is expensive to over-provision and dangerous to under-provision. Load testing lets you:
- Find the CDN cache fill point — determine how many concurrent viewers are needed before the CDN absorbs the segment load and origin offload begins.
- Discover manifest-server bottlenecks — live manifest generation is stateful and often a scaling bottleneck invisible under light load.
- Validate quality-of-experience (QoE) — measure startup time and segment download time relative to segment duration. When segment download time approaches segment duration, real viewers buffer.
- Rehearse live-event spikes — a sports kickoff or premiere start sends thousands of simultaneous viewer sessions. 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 using virtual users (VUs), each running 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. Because MaxoPerf runs distributed runner fleets across multiple geographic regions, you can replicate a globally distributed viewer population from a single test configuration.
| 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 foundation 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 adaptable to CDN and streaming targets.