Fast Connection, Slow APK Download: Diagnosing the Three Kinds of Throttling
Your speed test shows 300 Mbps but the APK crawls at 40 KB/s. The bottleneck is usually not your line but a CDN edge, a mirror's node, or a per-connection cap. Here is a four-step order that narrows the suspect down one layer at a time using iperf3, ranged curl, and parallel requests.
A familiar scene: you run a speed test, it reports 300 Mbps, and you conclude the problem must be the download site. That reasoning is half right and skips the step that matters — a speed test measures your path to a nearby test node, not your path to the server hosting the APK. Those can be entirely different routes, different CDN edges, different rate policies.
The useful move is to split "my network" from "the download path" and test them separately, eliminating one layer at a time. That is what this article lays out.
Three sources of throttling
Almost every slow APK download falls into one of these:
| Type | Symptom | Who is limiting | Can you work around it |
|---|---|---|---|
| Local / carrier | Everything is slow, speed test also lags | ISP, router QoS, mobile network deprioritization | Change network or router settings |
| Slow CDN edge | One domain is slow, another mirror is fine | The hosting provider's edge scheduling | Switch mirror or DNS |
| Per-connection cap | A single stream plateaus, parallel streams add up | Download site's concurrency/bandwidth policy | Multi-connection downloader |
The fixes are completely different, so order matters: rule out local conditions, then rule out the edge, and only then reach for multi-threading. Skipping the first two usually turns one 200 KB/s stream into four 50 KB/s streams.
Step 1: Rule out your own network
Do not test from a random website in a phone browser. Measure to a node you control so the result is actually meaningful:
# On another machine on the same LAN
iperf3 -s
# From the device under test: 4 parallel streams, 10s
iperf3 -c 192.168.1.50 -t 10 -P 4If LAN throughput is fine, the Wi-Fi link is not the problem. Next, measure a single public endpoint:
curl -o /dev/null -w "speed: %{speed_download} B/s\ntime: %{time_total}s\n" \
"https://speed.cloudflare.com/__down?bytes=50000000"Divide speed_download by 125000 to get MB/s. If that is well below about 60% of your plan's bandwidth, the problem is on your side — check router QoS, whether another device is saturating upload, and whether you are on mobile data or roaming.
If this step comes close to line rate, move on.
Step 2: Is it the CDN edge?
Download only the first 5 MB from several mirrors so you are not waiting for full files. Ranged requests make this fast:
for url in \
"https://d.apkpure.com/b/APK/com.example.app" \
"https://apkpure.net/com.example.app/download" \
"https://www.gptoapk.com/dl/com.example.app"; do
echo "== $url"
curl -L -r 0-5242880 -o /dev/null \
-w " speed: %{speed_download} B/s connect: %{time_connect}s\n" "$url"
doneRead two numbers. A high time_connect points at DNS resolution or a detoured route. A low speed_download with a normal time_connect points at the edge itself being congested or capped — switching mirrors is the highest-leverage fix.
One detail worth knowing: DNS hands different users to different CDN edges. Two people in the same city on different carriers can differ by 3x, so do not benchmark against someone else's screenshot. Verify with a couple of resolvers:
dig +short apkpure.com @223.5.5.5
dig +short apkpure.com @8.8.8.8Different IP ranges mean different edge nodes.
Step 3: Is a single connection capped?
The signature of a per-connection cap is a plateau: the single stream sits at the same value for the whole transfer (say 50 KB/s or 200 KB/s and never moves), while parallel streams together exceed it.
Test it:
# Single stream
curl -L -o /tmp/a.apk -w "single: %{speed_download} B/s\n" "$URL"
# Eight ranged chunks in parallel
seq 0 7 | xargs -P 8 -I{} curl -L -r {}0000000-$(( {} + 1 ))9999999 \
-o /tmp/part{} "$URL"If the eight chunks clearly beat the single stream, a multi-connection downloader is justified. If the total is about the same, bandwidth is being limited overall and switching tools will not help — change the source instead.
With aria2c it is one command:
aria2c -x 8 -s 8 -k 1M -d /tmp -o app.apk "$URL"-x is connections per server, -s is split count. Do not go too high — some servers answer with 403 or 429.
Step 4: Verify the file you actually got
Verification comes after speed, never instead of it. Chunked and resumed downloads are exactly where truncated packages hide behind a "success" message.
# When an official checksum exists
shasum -a 256 app.apk
# At minimum, confirm the archive is structurally sound
unzip -t app.apk | tail -3No errors detected plus AndroidManifest.xml and classes.dex in the listing is a good sign. Then confirm the package identity:
aapt dump badging app.apk | head -2The order to actually follow
iperf3for the LAN, a single-endpointcurlfor the ISP — confirm you are not the bottleneck.- Ranged downloads from three or four mirrors, comparing both
speed_downloadandtime_connect— identify whether one host is slow. - A flat single-stream plateau plus a parallel test — confirm or rule out a per-connection cap.
- After switching source or enabling multi-threading, re-verify checksum and package structure.
The point of this order is that every step removes a chunk of the suspect list, instead of cycling through tools, browsers, and phones. Most "slow APK download" cases end at step 2 — a different mirror is enough, and multi-threading was never needed.