How to Test Tencent Cloud CDN Video Delivery: Look Beyond Small-File Latency
The key to testing Tencent Cloud CDN video delivery is not finding a small file and checking how quickly it responds. It is verifying that the player receives decodable data promptly and continues to receive enough effective throughput during playback. Fast manifest requests, quick TCP connections, or even a short time to first byte at a particular node do not directly prove fast startup, smooth seeking, or low live streaming latency.
Prioritize three checks: whether test assets represent actual video delivery, whether edge cache hits and origin fetches are measured separately, and whether real-player startup, stalling, and quality changes align with request records. On-demand versus live video, MP4 versus segmented video, and fixed versus adaptive bitrate all affect the test sequence. The methods below apply to Tencent Cloud CDN video workloads. Specific caching rules, log fields, protocols, and product capabilities must be checked against the actual account configuration and relevant product documentation. Do not assume all acceleration domains behave identically.
Why Small-File Latency Does Not Represent Video Experience
Small-file tests primarily expose the fixed costs of DNS, connection establishment, TLS handshakes, and request responses. With very small files, the transfer phase may be too short to reflect sustained network throughput, let alone fluctuations across consecutive media segment downloads. A low small-file TTFB in a region only means that this type of request received its first byte quickly under those conditions. It does not establish that a video lasting several minutes will play without stalls.
Video requests also have explicit dependencies. HLS playback may fetch a master playlist, a media playlist for a specific bitrate, an initialization segment, and then the first media segment. Protected content may also depend on authorization or key services. MP4 progressive download is affected by metadata placement and Range behavior. If any required request is slow, even an excellent speed-test result on the homepage may not improve startup.
More importantly, players need data to arrive before its playback deadline, not just a high average download speed. A long download may average enough throughput to support the video bitrate yet still exhaust the buffer because of pauses, network changes, or individual segment timeouts. Conversely, a player may deliberately throttle downloads or wait until its buffer drops to a certain level before resuming. The resulting gaps between network requests do not automatically indicate a CDN delivery problem.
One finding can change the troubleshooting order: if the same video keeps stalling with a warm edge cache, prioritize segment-level throughput fluctuations, player buffers, and encoding rather than upgrading origin bandwidth first.Requests served from a warm cache generally do not need to fetch the full media content from the organization's origin server each time, so expanding origin capacity may not address the bottleneck. However, confirm the warm-cache state with caching evidence; do not assume it simply because the video has been played once before.
First Identify the Type of Video Delivery Being Tested
Different Acceptance Criteria for On-Demand Video, Live Streaming, and Progressive Download
The following table helps define testing priorities; it does not describe the default behavior of any specific Tencent Cloud product. If you use dedicated live streaming, video-on-demand, or real-time audio/video products, test their actual delivery architecture rather than treating them all as static-file CDNs.
Delivery type | Key request characteristics | Priority observations | Common misinterpretations |
|---|---|---|---|
MP4 progressive download | A single large object that may involve multiple Range requests | Startup, metadata placement, seek response, sustained throughput | Fast full-file downloads do not imply fast random seeking |
HLS and DASH video on demand | Dependencies between manifests, initialization segments, and media segments | First decodable segment, segment download times, bitrate switching | Fast manifests do not imply fast media segments |
Conventional segmented live streaming | Continuously updated manifests and newly generated segments | Distance from the live edge, manifest freshness, stalling | A high cache hit ratio does not imply low live streaming latency |
Low-latency live streaming solutions | May involve partial segments, long-lived requests, or dedicated protocols | Actual end-to-end latency, protocol compatibility, continuous delivery | Ordinary file downloads cannot reproduce protocol behavior |
For on-demand video, measure both initial startup and playback recovery after seeking. For live streaming, include capture, encoding, upload, packaging, delivery, and player buffering in the pipeline. Even when CDN downloads perform normally, viewers will still see delayed video if the player is too far behind the latest playable position.
Use Samples That Reflect the Actual Delivery Structure
Use authorized test media that can be accessed repeatedly, retaining the same encoding, packaging, segment duration, and authentication methods as production. A tiny test image or an arbitrary large file generated for testing can provide a network baseline at most; neither is a valid basis for video acceptance testing.
Samples should also cover different levels of popularity. Popular content may already be distributed across multiple cache tiers, while initial access to long-tail content is more likely to trigger an origin fetch. Stable results from repeatedly testing one popular video cannot be extrapolated to the entire library. For live streaming, successful access to old segments does not establish that the publishing pipeline for the latest manifests and newly generated segments is working.
Do not make production media publicly accessible just to simplify testing. Redact records containing signed URLs, cookies, and authorization headers, and store them in a secure local environment. Authentication policies are part of the delivery path; removing them all does not validate the production experience.
Build Three Layers of Metrics Instead of Reporting a Single “Latency”
Request Layer: Measure First Byte and Full Download Separately
At minimum, retain resolution results, status codes, protocols, remote IP addresses, response sizes, total times, TTFB, and any available cache status and request identifiers. Vendor cache-status headers and log fields may vary by product, protocol, and configuration. Interpret them using the relevant documentation rather than treating any particular response header as a universal standard.
TTFB may include DNS, connection establishment, TLS, edge queuing, and waits for origin fetches; it is not purely origin processing time. A segment may deliver its first byte quickly but stall during the remaining transfer and still miss its playback deadline. Measure full segment download times and effective throughput separately.
Playback Layer: From the Play Action to the Actual Picture
Define the start and end points for startup time, such as the user's play action and the actual presentation of the first frame. Do not treat the player firingloadedmetadataor a successful manifest response as proof that the first frame has appeared. Autoplay restrictions, ads, authorization, decoding, and rendering can all affect this time. State which steps the test includes.
Stalling metrics also need consistent definitions. Generally, separate initial waiting from rebuffering during playback, and record stall counts, stall duration, playback duration, and exit reasons. If calculating a rebuffering ratio, specify whether the denominator is actual playback time or total session time. Also record the actual playback bitrate and quality switches. Otherwise, a player that stays smooth by continually lowering its bitrate may be misreported as showing “excellent network performance.”
For seek tests, record the target position, the buffer state at that moment, and the time to resume playback. Seeking directly into an already buffered range primarily tests local playback, not the efficiency of downloading a new media range.
Service Layer: Do Not Let Averages Hide Failures, Exits, or Live Latency
HTTP 200 does not automatically mean successful video playback. Invalid manifest content, segment decoding failures, application-level errors from authorization APIs, or even error pages returned as media can all appear in “successful request” statistics. Correlate player error codes and media parsing results with request logs.
Report failures and timeouts separately. Latency percentiles for successful requests remain useful, but also provide the total number of attempts, failure rate, and timeout threshold. Do not remove failures just to present an attractive P95. Regional P95 values cannot simply be averaged into an overall P95 either. For aggregate results, combine the raw records after defining the weighting and sampling criteria.
Ideally, verify end-to-end live latency using visible timestamps or capture times that can be aligned, and explain how clocks are synchronized. Manifest download time alone cannot show how far viewers are behind the live event.
Minimal Verification with curl: Check Segments Before Full Playback
Step 1: Fix the URL and Request Conditions
The example below uses an HLS media segment. Before running it, replace the example address with an authorized test asset you control. The path should point directly to the final media object without relying on redirects. The example domain and path are illustrative only. The command uses GET rather than HEAD because HEAD cannot verify actual media transfer.
curl --noproxy '*' -sS \
--connect-timeout 10 --max-time 60 \
-D segment-headers.txt -o /dev/null \
-w 'status=%{http_code}\nremote_ip=%{remote_ip}\nhttp_version=%{http_version}\nbytes=%{size_download}\ndns=%{time_namelookup}\nconnect=%{time_connect}\ntls=%{time_appconnect}\nttfb=%{time_starttransfer}\ntotal=%{time_total}\navg_bytes_per_sec=%{speed_download}\n' \
'https://www.example.com/video/segment-001.m4s'
This command is intended for diagnostic terminals with direct internet access;--noproxy '*'excludes environment-configured proxies. If real users must access the service through a proxy, create a separate test group for that path. Results obtained by bypassing the proxy do not represent their experience. Response headers are saved to a local file; check for sensitive information before sharing it. Retain curl's exit status and error output as well. Do not identify timeouts solely from the printed status code.
The curl timing fields above are cumulative values measured from the start of the request. With no redirects, a direct connection, and a newly established HTTPS connection, usetime_connect - time_namelookupto approximate TCP connection time,time_appconnect - time_connectto approximate TLS time, andtime_total - time_starttransferto observe the transfer phase after the first byte. Do not labeltime_connectdirectly as TCP duration, ortime_starttransferdirectly as server computation time.
speed_downloadis the average byte rate for this download, not the access link's bandwidth limit or a guaranteed rate available to the player over time. Interpret it alongside file size, download duration, and repeated samples. Failed requests or partial responses must not be compared in the same group as fully downloaded, successful segments.
Step 2: Separate New Connections from Consecutive Media Requests
The single curl invocation above generally resembles a new-process, new-connection test. Real players often reuse connections and may use HTTP/2 or HTTP/3. Repeatedly launching curl does not automatically simulate a browser fetching consecutive media segments over the same connection.
Command-line tests are therefore useful for locating slow objects, but real-player network records are still needed to verify connection reuse, concurrency, and protocol negotiation. Testing with one forced protocol does not establish that all users receive identical results. Record redirects separately as well. This example does not use-L; if a 3xx response appears, first confirm whether production playback actually includes that step. Then test delivery after the redirect to avoid conflating timings.
If only the first request is slow and subsequent segments are stable, distinguish new-connection overhead, cold caches, and initial authorization waits. If multiple segments on the same connection experience long pauses, prioritize sustained network delivery and edge processing rather than repeatedly attributing the problem to DNS.
Step 3: Check MP4 Range Behavior
For MP4, use a controlled range request to verify partial reads. The following requests the first 1 MiB and requires a test object large enough to support that range.
curl --noproxy '*' -sS \
--connect-timeout 10 --max-time 60 \
--range 0-1048575 \
-D range-headers.txt -o /dev/null \
-w 'status=%{http_code}\nbytes=%{size_download}\nttfb=%{time_starttransfer}\ntotal=%{time_total}\n' \
'https://www.example.com/video/sample.mp4'
Check for appropriate values in206 Partial Content,Content-Rangeand the corresponding response body size.Accept-Rangesprovides only a clue; the actual range request result is stronger evidence. If the response is 200, check whether the resource lacks range support, a layer ignored Range, or another rule rewrote the request. Do not immediately conclude that the CDN is faulty.
Also test a range from the middle of the file, within its valid length, and verify ranges requested by actual player seeking. If MP4 metadata is at the end of the file, the player may need additional requests before playback can start. This requires coordination between packaging and delivery, not simply switching nodes. After adjusting metadata placement, retest startup and seeking rather than checking only full-file download speed.
How to Test Cold Caches, Warm Caches, and Origin Fetches Separately
Repeated Access Does Not Necessarily Mean a Cache Hit
Repeated requests to the same URL may still follow different paths because of caching policies, request headers, authentication parameters, object size, or segment caching mechanisms. A response header indicating a miss does not necessarily mean the request went directly to the organization's origin server. An upper-tier cache or other origin-fetch tiers may sit in between.
A reliable conclusion requires correlating client records, available CDN logs, and origin access logs by time and request identifier. The absence of an origin request is an important clue, but log sampling, delays, clock skew, or different logging locations may create a false impression that no request occurred. Confirm log coverage first.
Adding arbitrary random query parameters to a URL is not a universal cold-cache testing method. Some cache keys include parameters; others ignore or filter them. Random parameters may also invalidate signatures. A safer approach is to use controlled new test objects and verify cache-key rules. Purging popular videos in production affects subsequent origin load. Do not perform broad purges merely for speed tests.
Compare Edge and Origin Delivery Using the Same Resource
If an HTTPS origin comparison is necessary, retain the domain in the URL so that Host and TLS SNI match normal requests. The following addresses are documentation examples and must be replaced with an authorized test configuration.
curl --noproxy '*' -sS \
--resolve www.example.com:443:203.0.113.10 \
--connect-timeout 10 --max-time 60 \
-o /dev/null \
-w 'status=%{http_code}\nremote_ip=%{remote_ip}\nbytes=%{size_download}\nttfb=%{time_starttransfer}\ntotal=%{time_total}\n' \
'https://www.example.com/video/segment-001.m4s'
This requires the origin to serve the correct certificate and virtual host for that domain and allow access from the diagnostic source. If actual CDN origin requests use a different Host, mTLS, a private network, or dedicated authentication, this command may not reproduce them. Arrange controlled testing through existing security procedures rather than disabling origin protection or skipping certificate verification.
Keep the URL, method, Range, required request headers, and test network identical for edge and origin comparisons, and interleave samples to reduce time-of-day differences. Note that the client-to-origin route differs from the CDN-to-origin route. Direct tests can help establish whether origin objects are readable or responses are abnormal, but cannot replace measurements of the actual origin-fetch path. Direct connection failures may also be expected access-control behavior.
When to Adjust Caching Rules First
If warm-cache playback is stable but new or long-tail content is noticeably slower, and slow requests align with origin-fetch waits, first inspect cacheability, cache-key fragmentation, object publishing, and origin capacity. Switching providers at this point may mask the problem without eliminating the same configuration defects.
Signed URLs require particular attention to both security and cache reuse. Including changing signature parameters in the cache key can reduce shared-cache reuse. However, ignoring those parameters without verification may allow unauthorized access. Consider changes only after confirming that edge authentication precedes cached delivery, authorization boundaries remain intact, and the product supports the required behavior. Never sacrifice access control for cache hit ratios.
Multi-Region Testing: Compare User Networks, Not Node Labels
If most users connect through residential broadband and mobile networks, testing only from cloud hosts in the same region introduces bias. Routes, interconnection, and congestion between cloud egress and the CDN may not represent residential access networks. Group tests by region, carrier, and network type according to your user distribution. Record IPv4 and IPv6 separately; do not combine results simply because they share a geographic location.
Start withwebsite speed testingto establish reachability and response baselines across different probe environments. These baselines cannot replace complete player sessions. Do not assume the tool provides video decoding, end-to-end live latency measurements, or coverage of every carrier. When an issue appears, reproduce it on the affected network using the same media resource and player.
Provider identification results, CNAMEs, IP addresses, and ASNs can help cross-check the actual delivery path, but no single clue establishes the full architecture. Multi-tier distribution, routing changes, or hybrid delivery require closer correlation with domain configurations and request records. When usingprovider identification and node cross-checks, treat the results as supporting evidence, not an official node list.
Sampling need not be large-scale initially, but it should cover multiple independent sessions, different time windows, and predefined network groups, with sample counts disclosed for each group. Record whether tests involve a cold start or continuous playback, whether browser caches are reused, whether quality is fixed, and whether other traffic is running in the background. Browser caching can hide delivery problems, while forcibly disabling it may differ from real repeat-playback behavior. Test both separately.
Correlate Request Evidence with Real-Player Behavior
Use Fixed Bitrates to Diagnose Networks and Adaptive Bitrates to Assess Experience
Start with controlled, fixed-quality playback and compare each segment's full download time with the media duration it contains. If several consecutive segments take nearly as long as, or longer than, their media duration to download, the buffer may struggle to grow. However, one segment exceeding its playback duration does not necessarily cause an immediate stall. Interruption depends on existing buffer levels, concurrency, and subsequent recovery.
Then restore the production adaptive bitrate policy and record bitrate switches, buffer levels, and stalls. Fixed-bitrate tests help expose insufficient network capacity, while adaptive tests better reflect the actual experience. Neither replaces the other. Provider comparisons must also use identical media encoding and player policies. Results are not comparable if one side achieves smoother playback by using a lower bitrate.
Investigate Manifest, Authorization, and Cross-Origin Failures Separately
If media segments download normally but playback still fails, check manifest content, initialization segments, keys or licenses, authorization APIs, and browser cross-origin policies according to the actual dependencies. Successfully fetching a resource with curl does not mean a browser will allow the page to read it. Verify cross-origin errors with developer tools under the actual page origin.
For live streaming, pay particular attention to manifest updates. Excessive caching may leave players reading stale playlists, while very short caching may increase requests and origin load. Do not automatically apply the same caching policy to live manifests and generated media segments, or extend every object's lifetime merely to raise cache hit ratios. Verify update timeliness, behavior during brief origin-fetch failures, and origin load under actual playback conditions.
Use the Results to Target Fixes, Then Validate on a Limited Scale
The observations below help narrow the investigation; no single item is sufficient for a diagnosis. Ensure comparison requests use identical conditions before making changes.
Observed result | Priority checks | Potential areas to fix |
|---|---|---|
Small files are fast, but sustained media segment downloads are slow | Sustained throughput, packet loss or congestion, protocols, and differences between user networks | Request routing and network paths, bitrate ladders, delivery solution |
Warm-cache playback is stable, but cold-cache delivery is noticeably slow | Origin-fetch waits, cache keys, cacheability, origin publishing | Caching rules, origin connections, origin capacity |
Initial playback is slow, but continuous playback is stable | Initial dependency requests, new connections, metadata, initialization segments | Playback startup path, packaging, connection reuse |
Slow only after seeking | New range reads, segment indexes, keyframe positions | Range delivery, media segmentation, encoding |
Requests succeed, but video fails to play | Cross-origin policies, authorization, media formats, decoding errors | Page and API configuration, player, media processing |
Live playback is smooth but behind the live event | Manifest freshness, player buffering, encoding and packaging delays | Manifest policies, target playback position, live streaming pipeline |
Limit changes to test domains, test paths, or a small user group, and record original values and rollback conditions. Changes to cache keys, manifest lifetimes, authentication, and Range behavior require particular care to avoid affecting other services. Minimum acceptance checks should confirm the expected playback improvement, no unauthorized access or content served across authorization boundaries, no increase in failure rates, and acceptable origin load.
After limited validation, retest using the original regions, carriers, address families, and cache states, including peak periods. If there is no evidence that a change affected the intended mechanism, roll it back or revisit the diagnosis rather than layering on more configuration changes.
Provider comparisons or architectural changes become appropriate only when a delivery solution consistently exhibits problems that reasonable configuration changes cannot resolve under identical resources, players, network groups, and measurement criteria. CdnChart'sprovider comparisoncan serve as a starting point for organizing candidate solutions. The final choice should still depend on playback tests for your service and capabilities actually available, not conclusions about video delivery drawn from a small-file latency ranking.
Ultimately, acceptance testing for Tencent Cloud CDN video delivery should answer three questions: Do users see the first frame promptly? Does data delivery keep pace with consumption throughout playback? And when an issue occurs, can it be traced from the player to the specific request and processing layer? Small-file latency remains useful as a baseline, but cannot replace these three answers.
- Tencent Cloud CDN video delivery
- Video CDN speed testing
- Video startup time
- Video stalling troubleshooting
- CDN cold and warm cache testing
- HLS segment speed testing
- MP4 Range requests
- Live streaming latency testing