Free Proxy List APIs and Scrapers for Web Scraping

We checked 27 free proxy sources on 28 July 2026. Nineteen were usable; eight were dead, blocked, or years stale. Pulling the HTTP lists from six of the live ones gave 5,379 unique ip:port pairs — and when we sent a plain HTTP request through a random sample of 300 of them, 8.0% answered, at a median 2.42 s.

That 8% is the number the rest of this page is built on. Below: the endpoints that still exist and their exact URLs, the per-source live rates we measured, a working aggregator in about 40 lines, and the point where free proxies stop being cheaper than paying.

Key takeaways

• 8 of 27 sources we tested had to be dropped, including two that "best free proxy list" roundups still recommend: proxy-list.download (502) and getproxylist.com (521).
• 8.0% of aggregated free HTTP proxies responded to one request against a plain-HTTP endpoint (300 sampled, 8 s timeout, 2026-07-28). That is before the target site's own bot defenses get a vote.
• Verification claims don't predict live rate. iplocate's list, which revalidates every 30 minutes, measured 11.7% live. ProxyScrape v4, also continuously checked, measured 5.8%. Two other "fresh" lists measured 0/120.
• The lists overlap. Six sources totalling 6,361 rows deduped to 5,379 — about 15% redundancy, and 75% of monosans' pool also appears in TheSpeedX. Adding a seventh source buys you less than you'd think.
• A free proxy is an open relay run by a stranger. Anything you send over plain HTTP through it — URLs, headers, cookies, API keys in query strings — is readable and modifiable by its operator.
• You probably don't need a proxy scraper. The sources above already publish parsed, pre-validated lists. And the most-starred harvesting tool, ProxyBroker, has been unmaintained since March 2024 — its maintained fork proxybroker2 has a quarter of the stars.
• Break-even is low. At 8% live rate you need ~12 attempts just to find a relay that answers, and validation sweeps expire within hours. One engineer-hour a month costs more than a $29 plan.

Which free proxy list APIs still work in 2026?

These four return proxies programmatically, with no signup and no API key. All were verified on 2026-07-28.

ProxyScrape v4 is the most useful single call, because the JSON variant returns anonymity level, uptime, average timeout and full geo/ASN data alongside each proxy, so you can filter before you validate:

# Plain ip:port, one per line
curl 'https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&protocol=http&proxy_format=ipport&format=text'

# Full metadata
curl 'https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&protocol=socks5&proxy_format=protocolipport&format=json'

The older api.proxyscrape.com/v2/ endpoint still responds, but v4 is what you want for new code.

GeoNode is the best JSON API for filtering, with per-proxy upTime, latency, anonymityLevel and lastChecked:

curl -H 'User-Agent: Mozilla/5.0' \
  'https://proxylist.geonode.com/api/proxy-list?limit=100&page=1&sort_by=lastChecked&sort_type=desc&protocols=http'

That User-Agent header is not optional — the endpoint returns 403 to default Python/urllib and curl user agents. This is why we didn't include GeoNode in the sampled live-rate column: our validator was blocked at fetch time, not proxy time, and we won't publish a number we didn't measure.

Proxifly returns one proxy per POST, which is awkward for pool building. Use its repo instead: raw.githubusercontent.com/proxifly/free-proxy-list/main/proxies/protocols/http/data.txt, with socks5 and countries/US variants. Note that its 602 HTTP entries scored 0/120 in our sample despite the repo updating hourly.

iplocate/free-proxy-list was the best performer we measured and now ranks #1 on Google for "free proxy list api". It publishes all-proxies.txt, protocols/{http,https,socks4,socks5}.txt and countries/US/proxies.txt, revalidated every 30 minutes.

GitHub raw lists worth keeping

All updated within hours of our 2026-07-28 check:

Method, so you can reproduce or dispute it: each proxy got one GET http://api.iplocate.io/ip with an 8 s timeout, 60–100 concurrent workers, from a single European vantage point on 2026-07-28. A proxy counted as live if it returned any 2xx. Single vantage point, HTTP only, one target, one attempt — a proxy that a large hosting network blocks will read as dead here, and rates move by the hour. Treat these as one honest snapshot, not a benchmark.

Which free proxy lists are web pages, not APIs?

These have no free programmatic endpoint. You get an HTML table you have to parse.

• free-proxy-list.net and its siblings sslproxies.org, us-proxy.org and socks-proxy.net — one 300-row table each, marked with anonymity level and HTTPS support, stamped "Updated at 2026-07-28 05:32:02 UTC" when we looked. Same operator, largely overlapping data.
• ProxyNova — country-filtered lists with uptime percentages, refreshed every 60 seconds. IPs are assembled in JavaScript, so a plain pd.read_html() won't get them.
• hide.mn (formerly hidemy.name) — good filters, but API access and CSV export are paid only. Don't plan around the free tier.
• spys.one — the largest table, but ports are written by document.write from obfuscated JS specifically to stop scraping. Rendering it needs a headless browser, which costs more than the proxies are worth.
• proxy-list.org and advanced.name/freeproxy — both live, both HTML-only, both small.

If you only need 10 stable IPs rather than a churning pool, Webshare's free tier is a better trade: 10 authenticated proxies, 1 GB/month, HTTP and SOCKS5, no credit card. Authenticated proxies can't be shared with the rest of the internet, which is most of why public lists rot.

Which sources are dead?

Dead links are why proxy-list articles decay. These are the 8 of 27 we dropped on 2026-07-28, most of which still appear in widely-cited roundups:

The stale repos are the dangerous ones: they return 200 and a plausible-looking file, so a naive health check passes while every IP in it is years dead.

How do you build a pool from a free proxy list API?

Fetch from several sources, dedupe, validate concurrently, then rotate over what survived. That is the entire job:

import concurrent.futures
import itertools
import urllib.request

SOURCES = [
    "https://api.proxyscrape.com/v4/free-proxy-list/get"
    "?request=display_proxies&protocol=http&proxy_format=ipport&format=text",
    "https://raw.githubusercontent.com/iplocate/free-proxy-list/main/protocols/http.txt",
    "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
    "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
]

UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"


def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": UA})
    body = urllib.request.urlopen(req, timeout=30).read().decode("utf-8", "ignore")
    for line in body.splitlines():
        host, _, port = line.strip().rsplit("://", 1)[-1].partition(":")
        if port.isdigit():
            yield f"{host}:{port}"


def is_alive(proxy):
    opener = urllib.request.build_opener(
        urllib.request.ProxyHandler({"http": f"http://{proxy}"})
    )
    try:
        opener.open("http://api.iplocate.io/ip", timeout=8).read(200)
        return proxy
    except Exception:
        return None


def build_pool():
    candidates = set(itertools.chain.from_iterable(fetch(u) for u in SOURCES))
    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as pool:
        return [p for p in pool.map(is_alive, candidates) if p]


if __name__ == "__main__":
    alive = build_pool()
    print(f"{len(alive)} live proxies")

Two things people get wrong here. Validate against the protocol you'll actually use — a proxy that relays plain HTTP frequently fails CONNECT for HTTPS, so testing on http:// and then scraping https:// overstates your pool by a wide margin. And re-validate on a schedule, because that 8% decays within hours; a sweep of 5,000 candidates at 100 workers with an 8 s timeout takes roughly 7 minutes, so hourly is feasible and daily is not.

Then rotate, and evict on failure rather than round-robining blindly:

import random
import requests

class Pool:
    def __init__(self, proxies, max_strikes=3):
        self.strikes = dict.fromkeys(proxies, 0)
        self.max_strikes = max_strikes

    def get(self, url, **kwargs):
        for _ in range(5):
            if not self.strikes:
                raise RuntimeError("pool exhausted")
            proxy = random.choice(list(self.strikes))
            try:
                r = requests.get(
                    url, timeout=10,
                    proxies={"http": f"http://{proxy}", "https": f"http://{proxy}"},
                    **kwargs,
                )
                r.raise_for_status()
                self.strikes[proxy] = 0
                return r
            except requests.RequestException:
                self.strikes[proxy] += 1
                if self.strikes[proxy] >= self.max_strikes:
                    del self.strikes[proxy]
        raise RuntimeError("all retries failed")

Pair this with user agent rotation — rotating IPs while sending one static, obviously-scripted User-Agent fingerprints you just as clearly as not rotating at all.

Which proxy scraper and checker tools are worth using?

A proxy scraper harvests ip:port pairs out of sources that don't publish a machine-readable list; a proxy checker validates them. If your sources are the APIs and raw .txt files above, you don't need a scraper at all — they already publish parsed, pre-validated output, and a scraper only adds a parsing layer that breaks when someone changes their HTML. Reach for one only when you want the HTML-only sources (the free-proxy-list.net family, ProxyNova, spys.one) that no API covers.

Everything below was checked on 2026-07-28:

The stars/maintenance gap is the trap here. ProxyBroker has four times the stars of its own successor and outranks it, but hasn't been touched since March 2024. Sort GitHub results by recent commits, not stars.

free-proxy is the shortest path from nothing to a validated proxy:

from fp.fp import FreeProxy
from fp.errors import FreeProxyException

try:
    # country_id, timeout, rand, anonym, elite, google, https
    proxy = FreeProxy(country_id=["US"], timeout=1, rand=True, elite=True).get()
    print(proxy)  # 'http://113.160.218.14:8888'
except FreeProxyException as exc:
    print("no working proxy:", exc)

Catch that exception, because you will hit it. Running the snippet above on 2026-07-28 — and again with the country, timeout and anonymity filters relaxed — returned FreeProxyException: There are no working proxies at this time on all four attempts, from a candidate pool of 100. The library is doing its job correctly; the pool it draws from is simply empty at that moment. Which is the same 8% story from a different angle, and the reason the retry path matters more than the happy path.

Why do free proxies fail in production?

The operator can read and rewrite your traffic. A public proxy is a machine you don't control, terminating connections you don't own. Over plain HTTP the operator sees full URLs, headers, cookies and any credentials in the query string, and can modify the response body before it reaches you. Over HTTPS with CONNECT they see the destination host but not the payload. Never send authenticated requests through a proxy from a public list, and never trust unverified HTML you got back through one.

The IPs are already burned. These addresses are published, so every scraper on the internet is hitting the same few thousand IPs against the same popular targets. By the time a proxy reaches a public list, the sites you care about have usually seen it.

There is no session persistence. Anything requiring a login, a cart, or a multi-step flow needs the same exit IP across requests. Public proxies give you no control over that — you get whichever one your rotator happened to pick.

Uptime is measured in hours. A proxy that validates now can be gone in twenty minutes, which is why validation is a continuous job rather than a setup step.

Legality is about what you scrape, not what you route through. A proxy doesn't change your obligations under a site's terms, and some public proxies are unwitting compromised hosts, which is its own problem. See is web scraping legal for the actual considerations.

What does a free proxy pipeline really cost?

Free proxies are free in dollars only. The honest ledger:

The dollar figure isn't the interesting column. A pipeline like the one above is maybe 120 lines to write and then a recurring tax to keep alive — and at any realistic rate, one engineer-hour per month already exceeds $29. Free proxies win when your time is genuinely worth nothing on this task: learning, one-off experiments, testing that your parser handles a proxied response. They lose the moment the data has a deadline.

Use free proxies when you're prototyping, the target doesn't fingerprint, and a failed run costs you nothing. Stop when you hit a schedule, need a specific country, need the same IP twice, or find yourself debugging your proxy layer instead of your parser. At that point, compare proxy providers — datacenter first, since it's an order of magnitude cheaper and works on most targets, and residential only once you see 403s. If budget is the binding constraint, cheapest residential proxies compares price per GB, and types of proxies explains what you're actually choosing between.

Bringing your own proxies to a scraping API

If you already have a proxy source you trust, you don't have to throw away the rest of your stack to get browser rendering and anti-bot handling. WebScraping.AI's custom_proxy parameter routes through your proxy instead of the built-in pool:

import requests

r = requests.get(
    "https://api.webscraping.ai/html",
    params={
        "api_key": "YOUR_API_KEY",
        "url": "https://example.com",
        "custom_proxy": "http://user:password@your-proxy-host:8000",
        "js": "true",
    },
    timeout=60,
)
print(r.text)

Skipping the pool entirely

If maintaining a proxy layer isn't the part of the problem you want to own, the managed path is one request. You pick the proxy tier and country with parameters; IP rotation within that pool and browser rendering happen server-side:

import requests

r = requests.get(
    "https://api.webscraping.ai/html",
    params={
        "api_key": "YOUR_API_KEY",
        "url": "https://example.com/products",
        "proxy": "residential",   # datacenter (default) | residential | stealth
        "country": "de",
        "js": "true",
        "wait_for": ".product-grid",
    },
    timeout=60,
)
print(r.status_code, len(r.text))

const params = new URLSearchParams({
  api_key: "YOUR_API_KEY",
  url: "https://example.com/products",
  proxy: "datacenter",
  js: "false",
});

const res = await fetch(`https://api.webscraping.ai/html?${params}`);
console.log(await res.text());

Pricing is credit-based and published up front: a datacenter request costs 1 credit without JS rendering and 5 with it, residential 10 and 25, stealth 50. Failed requests cost nothing, which matters here — the 92% miss rate you'd absorb yourself with a public pool is exactly what you're paying to not think about. The free tier is 2,000 credits a month with 2 concurrent connections and no credit card, enough to run the comparison against your own pool honestly. Credits reset monthly and don't roll over.

Beyond raw HTML there are /text, /selected and /selected-multiple for extraction, and /ai/fields for schema-shaped output; the API docs cover every parameter, and there are SDKs for Python, JavaScript, Ruby, PHP, Go, Java and C#.

FAQ

Is there a free proxy list API with no key? Yes — ProxyScrape v4, GeoNode and Proxifly all serve proxies without registration, and iplocate, TheSpeedX and monosans publish raw .txt files on GitHub. All were live on 2026-07-28.

What percentage of free proxies actually work? In our 2026-07-28 sample, 8.0% of 300 aggregated HTTP proxies answered a single request. Best single source was iplocate at 11.7%; two sources returned 0/120.

Are free proxies safe for scraping? Not for anything authenticated. The operator can read plain HTTP traffic and alter responses. Use them for public, non-sensitive pages only.

Can free proxies handle JavaScript-heavy sites? A proxy only moves your traffic; rendering is a separate problem. You still need a headless browser or an API that runs one for you.

What is the best free proxy scraper? For Python, free-proxy (v1.2.2) for the simplest case and proxybroker2 for finding and checking at scale. Avoid the original ProxyBroker — it still ranks first but has been unmaintained since March 2024.

Start with the free sources above, validate hourly, and keep the measurements. When your live rate and your retry count stop justifying the maintenance, try WebScraping.AI free — 2,000 credits, no credit card, and failed requests don't count against them.