Convert between speed units, estimate transfer times, and size TCP windows correctly. All calculations run in your browser — paste a link speed, get every number that matters.
The Bandwidth-Delay Product is the maximum amount of data "in flight" on a TCP connection. If your TCP receive window is smaller than the BDP, you cannot fully use the available bandwidth — a 1 Gbps link with default 64 KB TCP window over a 100 ms RTT can only utilize ~5 Mbps. This is why long-haul transfers feel slow.
| Modem (legacy) | 56 Kbps |
| DSL (low) | 1.5–25 Mbps |
| Cable / Fiber (consumer) | 100 Mbps – 1 Gbps |
| Gigabit Ethernet | 1 Gbps |
| 10 GbE (data center) | 10 Gbps |
| 25 / 40 GbE (server uplinks) | 25–40 Gbps |
| 100 GbE (backbone) | 100 Gbps |
| 400 GbE (modern backbone) | 400 Gbps |
| Wi-Fi 6 (theoretical) | ~9.6 Gbps |
| LTE-Advanced | ~150 Mbps |
| 5G (mid-band, real-world) | ~200 Mbps |
| Loopback (localhost) | < 0.1 ms |
| Same rack / VLAN | 0.1–0.5 ms |
| Same data center | 1 ms |
| Same metro area | 2–5 ms |
| Same country (US-East ↔ US-West) | 60–80 ms |
| Trans-Atlantic (NYC ↔ London) | ~75 ms |
| Trans-Pacific (West ↔ Tokyo) | ~110 ms |
| Eu ↔ Australia | ~280 ms |
| Satellite (LEO — Starlink) | ~30 ms |
| Satellite (GEO) | ~600 ms |
| Speed of light through fiber (per 1,000 km) | ~5 ms |
TCP throughput is capped by the receiver's window size relative to the BDP. The product is the smallest in-flight buffer that keeps a link saturated. Example: a 1 Gbps link with 30 ms RTT. Six languages compute the same answer in bytes.
rate_bps = 1_000_000_000 # 1 Gbps
rtt_s = 30 / 1000 # 30 ms
bdp_bits = rate_bps * rtt_s
bdp_bytes = int(bdp_bits / 8)
print(f"Link rate: {rate_bps/1e9:g} Gbps")
print(f"RTT: {int(rtt_s*1000)} ms")
print(f"BDP: {bdp_bytes} bytes ({bdp_bytes/1e6:.2f} MB)")package main
import "fmt"
func main() {
rateBps := 1_000_000_000.0 // 1 Gbps
rttS := 30.0 / 1000.0 // 30 ms
bdpBits := rateBps * rttS
bdpBytes := int(bdpBits / 8)
fmt.Printf("Link rate: %g Gbps\n", rateBps/1e9)
fmt.Printf("RTT: %d ms\n", int(rttS*1000))
fmt.Printf("BDP: %d bytes (%.2f MB)\n",
bdpBytes, float64(bdpBytes)/1e6)
}const rateBps = 1_000_000_000; // 1 Gbps
const rttS = 30 / 1000; // 30 ms
const bdpBits = rateBps * rttS;
const bdpBytes = Math.floor(bdpBits / 8);
console.log(`Link rate: ${rateBps / 1e9} Gbps`);
console.log(`RTT: ${Math.round(rttS * 1000)} ms`);
console.log(`BDP: ${bdpBytes} bytes (${(bdpBytes / 1e6).toFixed(2)} MB)`);#!/usr/bin/env bash
# Bandwidth-Delay Product for a 1 Gbps / 30 ms link.
RATE_BPS=1000000000 # 1 Gbps
RTT_MS=30
# Use awk for floating-point math
read -r GBPS BDP_BYTES BDP_MB <<<"$(awk -v r=$RATE_BPS -v ms=$RTT_MS '
BEGIN {
rtt_s = ms / 1000;
bits = r * rtt_s;
bytes = int(bits / 8);
printf "%g %d %.2f", r/1e9, bytes, bytes/1e6
}')"
printf "Link rate: %s Gbps\n" "$GBPS"
printf "RTT: %d ms\n" "$RTT_MS"
printf "BDP: %d bytes (%s MB)\n" "$BDP_BYTES" "$BDP_MB"public class Bdp {
public static void main(String[] args) {
double rateBps = 1_000_000_000; // 1 Gbps
double rttS = 30.0 / 1000; // 30 ms
double bdpBits = rateBps * rttS;
long bdpBytes = (long) (bdpBits / 8);
System.out.printf("Link rate: %s Gbps%n",
(rateBps / 1e9 == Math.floor(rateBps / 1e9))
? String.valueOf((long)(rateBps / 1e9))
: String.valueOf(rateBps / 1e9));
System.out.printf("RTT: %d ms%n", (int)(rttS * 1000));
System.out.printf("BDP: %d bytes (%.2f MB)%n",
bdpBytes, bdpBytes / 1e6);
}
}#include <stdio.h>
int main(void) {
double rate_bps = 1e9; /* 1 Gbps */
double rtt_s = 30.0/1000; /* 30 ms */
double bdp_bits = rate_bps * rtt_s;
long long bdp_bytes = (long long)(bdp_bits / 8);
printf("Link rate: %g Gbps\n", rate_bps / 1e9);
printf("RTT: %d ms\n", (int)(rtt_s * 1000));
printf("BDP: %lld bytes (%.2f MB)\n",
bdp_bytes, bdp_bytes / 1e6);
return 0;
}Link rate: 1 Gbps RTT: 30 ms BDP: 3750000 bytes (3.75 MB)