Free Proxies for Web Scraping and What Actually Works

We pulled the five free proxy lists people recommend for web scraping and sent every address the same request. Between them the lists carry 1,039 distinct proxies. 222 returned the page that was asked for, which is 21.4%. Nine of those padded it with content the origin never sent, and another eight addresses answered 200 with a different page entirely. 94 of the working ones could also handle HTTPS.

Then there is a list whose 64 entries all passed that check and none of which is a proxy.

Fourteen services went into this. Five publish a list a script can read and were tested, three no longer exist, five publish lists only a person can use, and one is the trap in the paragraph above. What follows is which is which.

Two Kinds of Free Proxy Service

Search for free proxies and two different products come back mixed together, which is why half of most lists is useless to whoever is reading it.

A web proxy is a website. You open it, type a URL into a box, and it renders the page for you inside its own frame. It exists so someone can read a blocked news site from an office network, and it cannot be used from code, since there is no address and port to configure and no way to send it a request from a script.

An IP list is a table of addresses and ports. Each row is a machine somewhere that will forward a request, and the list is what a scraper needs, because those two values are what a proxy setting takes. Everything tested in this article is the second kind, and choosing and connecting one is covered separately.

The distinction matters more than it sounds. A list of the best free proxies that opens with web proxy sites is answering a question about browsing anonymously, and a scraper needs the other answer entirely.

What 1,039 Free Proxies Did When Tested

Every proxy got the same two requests. One over HTTP to a small static page whose exact content is known, which shows whether the proxy connects and whether what comes back is the real page. One over HTTPS to the same host, which shows whether it can tunnel at all. The connection timeout was eight seconds and the tests ran in parallel.

The content check is the one that matters. A proxy that answers in a second with a page it rewrote is worse than one that times out, because a scraper cannot tell the difference and neither can the person reading its output.

Everything that passed was then asked for a second page on a different host, and that turned out to matter more than expected.

The bottom row counts list rows rather than proxies. The same addresses circulate from list to list, so the five tables carry 1,039 distinct proxies in 1,240 rows, and the working rate drops from 27.2% of rows to 21.4% of addresses once every proxy is counted once, because the entries the lists copy from one another are disproportionately the live ones. On the same basis, 94 distinct addresses handled HTTPS.

Stacked as shares of each list, the same outcomes show how differently the five sources decay.

Geonode is the result worth stopping on. Its list is served through a clean JSON API, it is cited by name in Google’s own AI answer for these queries, and 17 of 400 of its entries answered. The list is large, current-looking and mostly dead.

The failures divide up in a way that says what these addresses are. Of the 817 distinct addresses that never returned the page, 656 refused every connection, 75 accepted and never answered, 25 refused or hung depending on the attempt, 15 answered with an error from the proxy software itself, and 38 returned HTTP 407, which is a proxy asking for a username and password. Those 38 sit on a free list and are not free. The last eight answered 200 with the wrong page outright. None of these is the 429 that means rate limiting, which is a response from the target rather than from the proxy.

The last column of that table is the one to plan around. Asked again three and a half hours later for a page on a different host, 198 of the 337 answered, so two in five had stopped being useful within an afternoon. Some of that is the second host being unreachable from a given address rather than the address dying, and the direction is the same either way. A list is worth what it returns at the moment of use, not at the moment of publication.

Eight more could not be tested through a script, three because they are gone and five because their lists need a browser, and that is a finding rather than a gap.

Source by Source

Fourteen services went in and five produced addresses a script could test. The rest are below too, because how a list is published, and whether its entries are proxies at all, decides more than how many of them answer.

ProxyScrape

A plain text endpoint returns the addresses one per line, with filters for protocol and format in the query string, so a script needs no HTML parsing at all. It is also the largest list of the five.

The export row is the part that matters for a pipeline. Everything on that page is reachable without opening it, which is not true of the five sources here that need a browser.

699 proxies were published when this ran, 400 were tested, and 140 of those returned the real page. Of the working ones, two in five also handled HTTPS, a smaller share than the curated lists though above Cyber Gateway and Geonode. For a scraper that only needs plain HTTP, this is the source with the most working addresses in absolute terms.

SSL Proxy

The best list of the five. A hundred addresses in an HTML table, half of them working, and four of every five of those able to do HTTPS.

Every row in that table carries yes under Https, which is the selection the site applies before publishing.

It is not a separate pool. sslproxies.org redirects to free-proxy-list.net/ssl-proxy.html, so this is Free Proxy List’s operator publishing its own HTTPS-verified rows under a second name, and 72 of these 100 addresses appear in Free Proxy List’s 300. The filter is the product, and it earns its keep: half of this list worked against 36% of the parent table.

The name is doing real work here. The list is curated for HTTPS support, and the test bears that out, with 40 of the 50 working proxies completing a TLS request against 56 of 140 for ProxyScrape. A short list where half the entries work beats a long one where a third do, because the cost of a free proxy is the time spent discovering it is dead.

Free Proxy List

Three hundred addresses in a table, 108 working, and the fastest median response of the five at 0.94 seconds. It sits between the other two on HTTPS, with just under half of the working proxies completing a TLS request.

The last column reads six seconds ago down most of the table, and 36% of those entries answered when asked.

The table is plain HTML with the address in one cell and the port in the next, so parsing it takes a few lines. There is also a download link and an API for anyone who would rather not parse.

Cyber Gateway

The smallest list tested and the highest working rate of the five, 22 of 40. It is a plain HTML table with the address in one cell and the port in the next, so a script reads it with the same few lines that read the other tables.

Forty addresses is not a pool, and 55% of forty is 22 usable proxies, which runs out fast under any real workload. What it does show is that list length and list quality are unrelated. The 400 entries from Geonode produced 17 working addresses and these 40 produced 22, though the curation leans on the neighbours: 26 of the 40 also sit on Free Proxy List’s table.

Geonode

The list comes from a JSON API with pagination, sorting and per-entry metadata including uptime and last-checked timestamps, more infrastructure than any of the others offer. It is also the worst performer of the five.

The counters at the top of that page are the claim. Proxies online in the thousands, updated minutes ago, across a hundred countries.

None of it helps. 17 of 400 answered, three of them over HTTPS. The metadata says the entries were checked recently and the entries do not work. A freshness timestamp on a free list records when a machine last looked, not what it found. The pool is at least Geonode’s own: 384 of the 400 appear on no other list tested here, so what is dead is its own collection rather than a copy of someone else’s.

Hidemy.name, and why the test target matters

This one is worth the space because it passed everything and is not a proxy list.

Its 64 published addresses all answered the first check, 64 of 64, with a median of 0.29 seconds and content byte-for-byte identical to the origin. No other source came close to a hundred percent. None of them supported HTTPS, which was the first thing that looked wrong.

Asked for a page on a different host, all 64 returned HTTP 409 and forwarded nothing. The addresses are Cloudflare edges. Asked directly, with no proxying involved, every one of the 64 answers with Server: cloudflare and a CF-RAY header, even though only 17 sit inside Cloudflare’s published address ranges, the rest being third-party prefixes routed onto the same network. The test page is itself served through Cloudflare, so a request arriving at an edge with that Host header gets answered on the spot, and nothing is proxied.

That is a trap with teeth. A checker that fetches one known page and compares the bytes marks all 64 as perfect, and they are the fastest entries in the whole study. The fix is cheap: check against a host that is not behind the same CDN as the first one, or two hosts on different infrastructure, and require both.

ProxyNova and SPYS.ONE

Five of the fourteen publish a list a person can read and a script cannot, and these two are the ones most often recommended. ProxyNova builds its table in the browser, so a plain request returns the page furniture and no addresses. SPYS.ONE refuses the request outright with HTTP 403 and obfuscates the port numbers in JavaScript even when it does answer.

Free Proxy, FreeProxy World and ProxyDB are the same shape. All three answer with 200 and a full page, and none of them yields a usable pair of address and port to anything that is not a browser. ProxyDB shows 29 addresses in its text and one readable port among them.

None of the five is broken, and all five are the wrong shape for a pipeline. Automating them means running a headless browser to read a list of proxies, which costs more than the proxies are worth. They belong on a list for someone picking an address by hand.

Open Proxy Space, Proxy-List and Premproxy

Three of the fourteen are gone. openproxy.space answers with HTTP 521, which is Cloudflare reporting that the origin server is not responding, on every path tried. proxy-list.download answers 502 Bad Gateway on both its root and its list pages. premproxy.com/list/ returns 404 and the root of the domain now serves a page headed “premproxy.com - Premium Domain for Sale”.

All three still appear on current recommendation lists elsewhere. That is the shape of this category. Services in it close without announcing it, and the lists that name them keep naming them.

Proxies That Change What Comes Back

Seventeen of the 1,039 returned HTTP 200 and content that was not what the origin serves. Nine sent a page that still contained the expected text but had grown far past the original’s 559 bytes. Eight sent something else entirely while still reporting success.

The nine are fewer actors than they look. Six sit in Alibaba Cloud address space, two of them being ports on the same machine, and every one answered with the same 1,256 bytes. Two more are Amazon addresses that both answered with the same 1,227 bytes, and the last is a Google Cloud address with a size of its own. That is closer to two rewriting gateway deployments than to nine independent operators, and their entries are spread across four of the five lists. The numbers are small, and the failure mode is not. A scraper that receives a rewritten page records whatever the gateway added, and every check it performs, including the status code and the presence of expected fields, can still pass.

Anything running through free proxies wants a content assertion rather than a status check. Fetching one known page through each proxy before trusting it, and comparing the result against what the origin returns directly, costs one request per proxy and catches this. What the rewrite is, an ad frame, a debugging proxy left open, something worse, the byte counts do not say, and a pipeline does not need to know. An address that edits responses stays excluded, since retrying it just fetches another edited copy.

Thirty-three lines do the whole check. This pulls a list, sends every address the same two requests, and keeps only the proxies that returned both real pages.

import concurrent.futures as futures

import requests

# two hosts on different infrastructure: a Cloudflare edge address passes the first and fails the second
CHECKS = [("http://example.com/", "Example Domain"), ("http://info.cern.ch/", "info.cern.ch")]
HEADERS = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                         "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36"}

proxies = requests.get(
    "https://api.proxyscrape.com/v4/free-proxy-list/get"
    "?request=display_proxies&protocol=http&proxy_format=ipport&format=text",
    timeout=30,
).text.split()


def works(proxy):
    routes = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
    for url, marker in CHECKS:
        try:
            response = requests.get(url, proxies=routes, headers=HEADERS, timeout=8)
        except requests.RequestException:
            return False
        if response.status_code != 200 or marker not in response.text:
            return False
    return True


with futures.ThreadPoolExecutor(max_workers=40) as pool:
    checked = list(pool.map(works, proxies[:100]))

usable = [p for p, ok in zip(proxies, checked) if ok]
print(f"{len(usable)} of {len(checked)} checked proxies returned both pages")

Two runs of exactly that script, started half a minute apart on the same list, printed 28 of 100 checked proxies returned both pages and then 30 of 100. The marker comparison is what separates a working proxy from one answering with an interstitial, and the second host is what separates a proxy from an address that merely shares a CDN with the first. Even at that spacing the pool does not return the same answer twice, so the check runs at the moment of use rather than being cached.

When Free Proxies Are Enough

A fifth of them working is fine for some jobs. Rotating through a large pool where individual failures do not matter, scraping targets with no blocking to speak of, or one-off collection where a run can simply be repeated are all cases where the price is right and the failure rate is an inconvenience.

The arithmetic works when a failed request costs nothing but a retry. Pull a thousand addresses, expect two hundred to work, and treat the rest as noise. Add a content check so the rewriting ones drop out, and a short timeout so the dead ones do not hold up the queue.

When They Are Not

A target that blocks by address reputation answers a free proxy with 403 rather than content, since the same addresses appear on every public list and every anti-bot vendor reads those lists too. A job that needs HTTPS loses most of what was working. And anything with a deadline cannot absorb a pool that loses two in five of its working addresses between morning and afternoon.

At that point the choice is between building the infrastructure and buying it. Building means buying addresses that are not public, rotating them, and monitoring which have been burned, on top of the wider set of things a target checks. Buying means an API that owns it. The Web Scraping API keeps the pool, the rotation and the retries behind one endpoint and answers with the page.

The honest comparison is not free against paid. It is a fifth of a public list, no HTTPS on most of it, and a content check you have to write yourself, against a request that either returns the page or bills nothing.

What to Take From This

Of the fourteen services that show up on the lists people recommend, three no longer exist, five publish lists a script cannot read, one is not a proxy list at all, and one of the five that can be tested returns working addresses 4% of the time. The ones that hold up are SSL Proxy for HTTPS work and ProxyScrape for volume. Neither will still be true in a year, and that is the category rather than a fault of either.

Test before trusting, test for content rather than for a status code, and test against two hosts on different infrastructure. Every number here came from sending the same request through every address on five public lists and comparing what came back with what should have. It takes a few minutes to run, it is worth repeating whenever a list is used seriously, and on this run it was the second host that exposed the one list where every entry was a fake.