Free Proxy List Benchmark

A small, reproducible benchmark that measures the reliability, anonymity and performance of the free proxy lists published by commercial proxy providers. It ships each provider's proxies as a fixed IP:PORT snapshot, then probes a sample of those proxies several times in quick succession and reports how many actually work, how fast they are, and whether they can reach real-world destinations like Google and Amazon.

It is the data engine behind the blog post Best Free Proxy List in 2026: We Tested 2,911 Proxies. Everything here is meant to be run, audited and re-run by anyone.

⚠️ Free proxies are operated by unknown parties. This project makes test requests through the proxies to harmless control endpoints only. Do not route sensitive traffic through free proxies. Results describe a single moment in time — free proxies churn by the minute.

---

How it works (snapshot in, report out)

The repository contains no scraping code. Instead it ships a captured snapshot of each list as plain IP:PORT text files under lists/, split per protocol so the protocol is known from the filename:

lists/
  databay/      http.txt  https.txt  socks4.txt  socks5.txt
  proxyscrape/  ...
  geonode/      ...
  floppydata/   ...
  roundproxies/ ...
  nodemaven/    ...
  proxiware/    ...

The benchmark loads those files, probes every proxy through the requested checks across several rounds, and writes a report. Because the input is a fixed, committed snapshot, a run is fully reproducible and auditable — anyone can re-run the exact same proxies and check the numbers.

The snapshots were generated separately (the scraping/list-building tool lives outside this repo). To capture a fresh snapshot you only need new IP:PORT files in lists/<source>/<protocol>.txt.

---

The lists under test

The free proxy lists offered by commercial proxy providers — the lists these companies publish (mostly as lead-gen) alongside their paid plans. databay.com is the subject of the write-up and is benchmarked head-to-head against six other providers (captured 2026-06-11):

List	Snapshot source	Notes
databay.com	/api/v1/proxy-list API	most-recent (sorted by lastChecked)
proxyscrape.com	v4 free-proxy-list API
geonode.com	proxylist.geonode.com API	freshest-first
floppydata.com	geoxy.io JSON API
roundproxies.com	server-rendered HTML table	small list (~100)
nodemaven.com	proxymaven JSON API
proxiware.com	papi.proxiware.com JSON API	protocol-balanced sample

Each list's snapshot keeps the freshest proxies available at capture time (capped at 500/list), so every list is represented at its best rather than by stale entries. List sizes differ (e.g. roundproxies serves only ~100), so compare the rates, not raw counts.

---

What it measures

For every proxy, in each round, the prober runs an ordered battery of checks through the proxy:

Metric	How it's measured	Why it matters
Alive	Relays a request to ip-api.com (HTTP) or api.ipify.org (HTTPS)	The proxy works at all
Latency	Round-trip time of the fastest successful probe (ms)	Speed / usability
HTTPS	Completes an HTTPS CONNECT tunnel	Needed for any modern site
Google pass	https://www.google.com/generate_204 returns HTTP 204	Can reach a major, bot-sensitive host
Amazon pass	https://www.amazon.com/robots.txt returns HTTP 200	Amazon blocks most datacenter/proxy IPs — a hard, real-world test
IP hidden	Exit IP (what the destination sees) ≠ your real IP	Does the proxy actually mask you?
Anonymity	httpbin.org header-judge → elite / anonymous / transparent	Best-effort: does it leak your IP or advertise itself as a proxy?
Exit country	Geolocation of the exit IP (ip-api)	Where the working proxies actually egress

Reliable vs. best-effort. Alive, latency, HTTPS, Google, Amazon, IP-hidden and exit-country are measured directly and have full coverage. The elite/anonymous/transparent split is best-effort: it needs a plain-HTTP header-reflection endpoint (httpbin.org), and many free proxies simply won't relay it (recorded as unknown). The IP-hidden rate is the dependable anonymity headline; treat the three-way split as indicative.

The protocol of each proxy is taken from which file it was loaded from (socks5.txt → SOCKS5, etc.). SOCKS4 is dialed via httpx-socks/python-socks because httpx alone cannot speak SOCKS4.

Multi-round design (reliability vs. stability)

The same loaded snapshot is re-probed across all rounds (default 3 rounds, 90s apart). This separates two different things:

• Reliability — what fraction of the list works (alive rate).
• Stability — of the proxies alive in round 1, how many survive every round. Free proxies are notoriously short-lived; spacing rounds a few minutes apart captures real flakiness, whereas spacing them hours apart would just measure list decay.

Composite score

A single 0–100 number for the leaderboard, a weighted blend (defined in proxybench/analyze.py):

30% alive + 20% Google + 15% Amazon + 10% HTTPS + 10% IP-hidden + 15% latency

Latency is normalised: 0 ms → 1.0, ≥ 5000 ms median → 0.0. The weights are a deliberate choice (reliability first); change them in one place if you disagree.

---

Install

Requires Python 3.9+.

pip install -r requirements.txt

Dependencies: httpx[socks] + httpx-socks (async HTTP with full SOCKS4/5 support). matplotlib is optional and only used to render PNG charts.

---

Usage

# Full benchmark: all lists under ./lists, 3 rounds 90s apart
python run_benchmark.py

# Then build the report (report.md, summary.csv, per_round.csv, charts/)
python analyze_results.py --in results

Quick smoke test against a couple of lists:

python run_benchmark.py --sources databay proxyscrape --rounds 1 --out results_smoke
python analyze_results.py --in results_smoke

Key options (run_benchmark.py --help)

Flag	Default	Meaning
--lists-dir	lists	Directory of <source>/<protocol>.txt files
--proxies-per-list	0 (all)	Optional cap applied at load time (lists are already capped when generated)
--rounds	3	Probe rounds over the same snapshot
--round-delay	90	Seconds between rounds
--concurrency	50	Max proxies probed at once (see Resource safety)
--connect-timeout	4	Per-connection connect timeout (s)
--read-timeout	6	Per-request read timeout (s)
--total-timeout	18	Hard ceiling on total time per proxy (s)
--sources	all	Subset of source dirs, e.g. --sources databay geonode
--no-google / --no-amazon	off	Skip those checks

---

Resource safety (Windows ephemeral ports / TIME_WAIT)

Proxy checking opens a lot of short-lived TCP connections, which on Windows can exhaust the ephemeral-port range (~16k ports) and pile up in TIME_WAIT (~120s) if you blast everything at once. This benchmark stays well clear by design:

• Bounded concurrency (--concurrency, default 50): at most ~50 proxies are in flight, each capped at 2 connections — so ≤ ~100 sockets exist at any instant, regardless of list size.
• Gated probing: dead proxies (the majority of any free list) fail the two cheap reachability checks and are dropped before the heavier Google/Amazon checks ever open a socket.
• Hard per-proxy deadline (--total-timeout, default 18s): no single proxy can hold a slot — or leak sockets — indefinitely.
• Short timeouts so failed connects are reclaimed quickly.

In practice a full 5-list × 500 × 3-round run peaks at a few thousand sockets in TIME_WAIT, comfortably under the default Windows limit. If you raise --concurrency substantially on Windows, consider widening the dynamic port range / lowering TcpTimedWaitDelay.

---

Output files

After a run + analyze, the results directory contains:

results/
├── run_meta.json        # config, timestamps, real IP, per-list loaded counts
├── proxies.json         # the exact set of proxies tested (auditable)
├── raw/round_<n>.jsonl  # one ProbeResult per line, per round
├── summary.csv          # one row per list, headline metrics
├── per_round.csv        # source × round detail
├── report.md            # the human-readable write-up (blog basis)
└── charts/              # composite.png, reliability.png (if matplotlib present)

report.md is regenerated from the raw .jsonl files at any time — re-run analyze_results.py without re-probing.

---

Project layout

lists/             # the IP:PORT snapshot, per source per protocol (the input)
proxybench/
├── models.py      # Proxy and ProbeResult dataclasses
├── loader.py      # read lists/<source>/<proto>.txt -> Proxy records
├── probe.py       # async prober (the probe battery + anonymity classifier)
├── runner.py      # load snapshot, run rounds, write raw results
└── analyze.py     # aggregate raw results → CSV + Markdown report + charts
run_benchmark.py   # CLI entry: run the benchmark
analyze_results.py # CLI entry: build the report

---

Methodology notes & limitations

• Fixed snapshot. The benchmark probes a committed IP:PORT snapshot, not a live re-fetch, so every round and every re-run compares the same proxies. Alive-rate is therefore reliability of that snapshot at capture time.
• Provider list selection. The lists are the free proxy lists published by commercial proxy providers (captured 2026-06-11). databay.com is the subject and is compared head-to-head against the other providers.
• databay uses its most-recent proxies; other API-backed lists are also captured freshest-first, so each list is shown at its best.
• Unequal list sizes. Providers expose different amounts (e.g. roundproxies ~100, others capped at 500). Compare the rates, not raw counts; smaller lists carry wider confidence intervals.
• No advertised metadata. Since the snapshot is bare IP:PORT, advertised country/anonymity labels are not used — every reported figure is measured through the proxy (including the exit-country geolocation).
• Control endpoints can rate-limit/blip. httpbin.org in particular is only intermittently reachable, which is exactly why "alive" never depends on it and the anonymity split has an honest unknown bucket.

---

License

MIT © 2026 Databay. Use it, fork it, re-run it, check our homework.