Validating What You Pay For: Circuit Throughput Testing Done Right
Your company pays for a business internet circuit at a certain speed. Users say the internet is slow. Someone runs a browser speed test from their laptop and gets a number about a third of the contracted rate. They forward you the screenshot with the subject line "we're being robbed." Maybe you are. But if you call the ISP armed with that screenshot, the conversation will last ninety seconds. That is because a browser speed test from a laptop on Wi-Fi proves almost nothing about the circuit — and the ISP's support script knows it.
This guide is about doing it properly: testing a circuit's real throughput with a free tool called iperf3. That means testing under controlled conditions, in both directions, at the right times, several times. And it means writing it all down in a form an ISP engineer cannot wave away. By the end you will know how to run the tests and how to read the numbers honestly. That includes why you will never see 100% of the line rate, and why that is physics rather than fraud. You will also know how to assemble an evidence file that turns "your network is fine" into an actual investigation.
In this guide
- Why browser speed tests mislead
- Meet iperf3: a speed test you control end to end
- Server placement: the decision that makes or breaks the test
- The commands, flag by flag
- Reading the results honestly
- The overhead math: why 100% never happens
- When to test, and how often
- Building an evidence file the ISP cannot wave away
- The test log template
Why browser speed tests mislead
Browser speed tests are fine for one question: "is my home connection roughly working?" For validating a business circuit they mislead in four separate ways, and it is worth knowing each one. They are exactly the objections an ISP will raise against your results.
The server is chosen to flatter the path. A public speed test picks a nearby, well-connected server — often one hosted inside your own ISP's network or a data center it peers with directly. That measures a best-case path the ISP has every incentive to keep fast. Your real traffic goes to cloud services across paths you do not choose. The reverse also happens: a busy or distant test server understates your circuit through no fault of the ISP. Either way, you measured a path, not the circuit.
The Wi-Fi hop caps everything. A laptop on wireless measures the wireless. Signal quality, channel congestion, and sharing the air with every other device routinely limit a Wi-Fi client to a fraction of what the wired circuit can carry. Any test that will be used as evidence must run over a cable.
The LAN is not idle. A test run at 11 AM shares the circuit with the whole company. What you measure is the leftover, not the capacity. That is a useful number for understanding user experience — and a useless one for accusing the ISP.
You cannot see or control the streams. Throughput depends heavily on how many parallel connections a test uses. A single TCP connection over a path with some latency may be unable to fill a large circuit at all (more on that soon). A browser test decides this for you, invisibly, and you cannot document what it did. Unrepeatable and undocumented is another way of saying "not evidence."
Meet iperf3: a speed test you control end to end
iperf3 is a free, open-source throughput tester that runs on Windows, Linux, and macOS. It works as a pair: one machine runs as the server and listens. Another runs as the client, connects, and pushes generated data as fast as the path allows for a set number of seconds. Because the data is generated in memory and discarded on arrival, disks never slow it down. Because you control both ends, you know exactly what ran, when, in which direction, with how many streams. That controllability is the entire point. A browser test is a demonstration; an iperf3 run is a measurement.
Install it from your platform's package manager or the project's published binaries, on both machines. Verify with iperf3 --version. The server side listens on TCP/UDP port 5201 by default, so any firewall between the two machines must allow it. Or use -p to pick another port.
Server placement: the decision that makes or breaks the test
A throughput test measures the weakest hop between its two endpoints. Choose the endpoints carelessly and you will measure your old desktop's network card, or a busy office switch, and blame the ISP for it. Placement is therefore a two-step discipline:
Step 1: prove your own house is clean. Run iperf3 between two wired machines inside the LAN — ideally your test client and a machine plugged into the same switch as the firewall. If the internal result is well above the circuit's contracted rate, your client, cabling, and switching are capable of measuring the circuit. If it is not, fix that first; you cannot measure a fast circuit through a slow LAN. Keep this result — it goes in the evidence file as proof that the bottleneck you later measure is not on your side of the wall.
Step 2: place the far end to isolate the circuit. For internet-path tests, the far server must sit outside your building, and you have three realistic options:
- A small cloud virtual machine in a region near you is the workhorse choice. You control it, it is available at 3 AM, and a modest VM can saturate most business circuits. Check that the VM's advertised network capacity comfortably exceeds your circuit before trusting it. Keep it geographically close so latency stays low and the path stays short. Be honest in your notes: this tests your circuit plus the internet path to that data center. That is exactly the kind of path your real traffic takes.
- An ISP-hosted test server, if your provider offers one, is the gold standard for a dispute, because the path never leaves their network. Ask your account contact; business ISPs often have one, quietly.
- Public iperf3 servers exist and are handy for a quick sanity check. But you cannot control their load or limits, so keep them out of the evidence file.
The client end matters just as much: a wired machine with a network card faster than the circuit. Plug it in directly behind the edge (the firewall or router where the circuit lands). Keep backup jobs, sync clients, and updaters quiet during the run.
Tip: if circuit disputes are a recurring part of your life, keep a dedicated wired test box permanently cabled near the edge. Any retired PC will do. Identical hardware, identical port, identical commands every time makes your results comparable across months, which is precisely what "it's been slow since spring" arguments need.
The commands, flag by flag
On the far machine, start the server. It just listens, and can be left running:
iperf3 -s
On the test client, the basic TCP test:
iperf3 -c test.example.net -t 30
-c means run as client against that server. -t 30 runs the test for 30 seconds instead of the default 10. Longer is better for a circuit test, because TCP spends the first seconds ramping up, and you want the settled cruising speed, not the acceleration. Use 30 to 60 seconds.
By default the client sends to the server, so the command above measures upload. To measure download, add -R (reverse), which asks the server to send to you:
iperf3 -c test.example.net -t 30 -R
Next, parallel streams. -P 4 opens four TCP connections at once and reports each plus the total:
iperf3 -c test.example.net -t 30 -P 4 iperf3 -c test.example.net -t 30 -P 4 -R
Why this matters: a single TCP connection can only keep a limited amount of data "in flight" before it must pause for acknowledgments. So its top speed is roughly that in-flight limit divided by the round-trip time. On a path with noticeable latency, one stream may max out well below the circuit's capacity with nothing wrong anywhere. Real traffic — a whole office of users — behaves like many parallel streams, and parallel streams together can fill a pipe one stream cannot. Testing both ways tells you two different truths. -P 4 (or -P 8) approximates the circuit's aggregate capacity. A single stream approximates what one big download can achieve.
Finally, UDP mode, which measures quality rather than speed:
iperf3 -c test.example.net -t 30 -u -b 100M
-u switches to UDP, which sends packets at a fixed rate without TCP's polite backing-off. And -b 100M sets that rate (here 100 megabits per second). Choose a rate at or below your contracted speed. Because UDP does not retransmit, the report shows exactly what the path did to your packets. It shows the loss percentage and the jitter (variation in packet arrival timing). A circuit that carries 95% of its rated TCP speed but shows meaningful UDP loss is a damaged circuit. And this is the test that proves it.
Reading the results honestly
A TCP run ends with a summary like this (a 30-second download test on a circuit sold as 500 megabits per second):
[ ID] Interval Transfer Bitrate Retr [ 5] 0.00-30.00 sec 1.65 GBytes 473 Mbits/sec 47 sender [ 5] 0.00-30.04 sec 1.65 GBytes 472 Mbits/sec receiver
Read the receiver line for the honest number — data that actually arrived. Retr counts TCP retransmissions on the sender side. A small number is routine, while thousands of them on every run hint at loss worth investigating with the UDP test. A UDP run summarizes differently:
[ ID] Interval Transfer Bitrate Jitter Lost/Total Datagrams [ 5] 0.00-30.00 sec 358 MBytes 100 Mbits/sec 0.084 ms 118/256980 (0.046%)
Here the path carried a fixed 100-megabit stream and lost 0.046% of packets with well under a millisecond of jitter — a healthy result. Sustained loss above roughly 1% at rates the circuit should handle comfortably is the kind of number that belongs in a dispute. That is especially true if voice and video users are already complaining.
Two more honesty rules. First, judge each direction against its own promise. Many access technologies are sold asymmetric — a large download rate and a much smaller upload rate. So an upload test can only be compared to the upload figure in the contract, never the headline number. Second, expect single-stream results below parallel results on any path with real latency, for the in-flight reasons above. If -P 8 reaches the expected ceiling and a single stream does not, the circuit is fine. That is TCP physics, and knowing it will save you an embarrassing support call.
The overhead math: why 100% never happens
A circuit's rated speed counts every bit on the wire. Your test counts useful data delivered. Between those two numbers sits unavoidable packaging. A standard Ethernet-carried packet holds 1,460 bytes of actual TCP payload. That is wrapped in 20 bytes of TCP header, 20 of IP header, and 18 of Ethernet framing. Add 20 bytes of mandatory preamble and inter-frame gap on the wire. That is 1,538 bytes transmitted per 1,460 delivered. Divide them: about 95% is the theoretical best case for TCP payload over Ethernet, before a single packet is lost. VPN tunnels and VLAN tags wrap more packaging and lower the ceiling further.
| Rated line speed | Realistic TCP ceiling (~95%) | Worth a phone call below… |
|---|---|---|
| 100 Mbit/s | ~94–95 Mbit/s | ~85 Mbit/s sustained |
| 500 Mbit/s | ~470–475 Mbit/s | ~425 Mbit/s sustained |
| 1 Gbit/s | ~940–950 Mbit/s | ~850 Mbit/s sustained |
The middle column is what a healthy circuit measures with parallel streams at a quiet hour. The right column is a rule of thumb, not a law. Consider a consistent 10–15% shortfall below the ceiling (not below the marketing number) across many runs. That is where "measurement noise" stops being a plausible explanation. Quoting this math in your dispute does double duty. It shows the shortfall is real after granting the ISP every legitimate excuse. And it signals that the person on your end of the phone cannot be fobbed off with "overhead explains it."
When to test, and how often
One test proves nothing; a pattern proves everything. The schedule that produces a pattern:
- Quiet hours (early morning, late evening, a weekend): the LAN is idle, so this measures the circuit's true capability. If quiet-hour tests hit the ceiling, the circuit itself is sound.
- Busy hours: the same commands at mid-morning and mid-afternoon. Lower numbers here with clean quiet-hour results usually mean your own users are filling the link. Check the utilization graphs before drafting the angry email (the guide on how full is too full covers reading them). But a circuit that sags every evening while your office sits empty points at congestion on the provider's side — a pattern worth documenting.
- Repetition: at least three back-to-back runs per session — record the median, not the best — and sessions across at least three different days. Both directions, single and parallel streams, plus one UDP run per session.
- Conditions: every run gets a log line — timestamp, direction, flags, result, and what else was true (LAN quiet or busy, which client, which server). The log template below makes this a thirty-second habit.
Warning: a throughput test works by filling the circuit — that is the whole idea. So a 60-second run during business hours will genuinely slow everyone down. And a sustained UDP blast at full rate is indistinguishable from an outage. Keep business-hours runs short and few, warn anyone who needs warning, and save the long sessions for quiet hours.
Building an evidence file the ISP cannot wave away
Support lines are triage systems: their first job is to close tickets that might be the customer's own fault. Every element of the evidence file exists to eliminate one escape route, politely and in advance. The file that survives triage contains:
- The setup, stated once: list the client machine and its network card speed, plus the wired connection point directly behind the edge. List the server used and where it sits, and note that all tests were wired. Closes: "have you tried plugging into the router?"
- The LAN baseline result: your internal iperf3 run showing the local path exceeds the circuit rate. Closes: "the bottleneck is your equipment."
- The exact commands, pasted verbatim, with iperf3 named. Closes: "browser tests aren't reliable" — agreed, which is why you did not use one.
- Every run with its timestamp, medians per session, across days and hours, in both directions, single and parallel streams. Closes: "must have been momentary congestion."
- The UDP loss and jitter figures. Closes: "throughput looks fine to us" when the real problem is a lossy line.
- The comparison done fairly: results judged against the ~95% ceiling and the correct per-direction contract figures. Closes: "that's just protocol overhead."
- Raw output preserved: keep every console capture (or run with
--jsonand keep the files) named by date and time, ready to attach on request.
Then write the one-paragraph summary on top: contracted rates, measured medians at quiet hours, the shortfall percentage, and the sentence "methodology and raw results attached." Calm, specific, repeatable — the tone of someone who will still be there next week. Escalations move fastest when the first-line agent can see there is nothing left to triage.
The test log template
Copy this table into a spreadsheet or wiki page and fill a row per run. The first two rows show the habit:
| Date & time | Direction | Protocol / streams | Duration | Result | Loss / Retr | Conditions & notes |
|---|---|---|---|---|---|---|
| Tue 06:10 | Down (-R) | TCP, -P 4 | 30 s | 472 Mbit/s (median of 3) | Retr low | LAN quiet; wired test box; cloud VM east |
| Tue 06:14 | Up | UDP, -b 100M | 30 s | 100 Mbit/s carried | 0.05% / 0.08 ms jitter | Same setup |
Rows accumulate into exactly the pattern a dispute needs — and, pleasantly, into a private record of what "normal" looks like. That record makes the next slowdown a five-minute comparison instead of a fresh investigation.
Where to go next
The method in one breath: prove the LAN first and control both endpoints. Run 30–60 second tests in both directions with single and parallel streams plus a UDP quality check. Repeat across quiet and busy hours on several days. Log everything, and judge the medians against the overhead ceiling rather than the marketing number. Do that, and whichever way the numbers fall you win. Either the circuit is vindicated and you hunt the real bottleneck, or you hold a file the ISP has to answer.
Testing tells you what the circuit can carry; monitoring tells you what it does carry all day, and the two questions belong together. For the monitoring side, start with how full is too full and the 95th percentile explained. Find the rest of the series at Bandwidth & Utilization Monitoring.
Put this into practice with SysPeep Monitor
iperf3 tells you what the circuit can do on test day; SysPeep Monitor watches what it actually carries every other day. It auto-discovers your edge devices, graphs interface utilization over SNMP, and alerts you when the link pins or errors climb. So you will know it is time to break out the test rig before the complaints arrive. The free trial runs on a single Windows machine.
Download Free TrialLearn About SysPeep