Best Free Proxy Lists for Web Scraping, Ranked (2026)

We ranked each free proxy site on what it publishes about itself: how often it rechecks proxies, whether you can pull the list as plain text, JSON, or an API without signing up, how much data each entry carries, and warning signs such as stale checks, CDN addresses, or paywalled exports. We didn't route traffic through the listed proxies.

We scored each site's own page on five criteria:

Two tie-breakers settled close calls. A filtered, machine-readable feed beats a web table, and a list tracked in the 30-month study gets a mild plus. That only means researchers found it worth collecting from, not that it's safe.

Every list uses the same labels. An elite proxy hides both your IP and the fact that you're using a proxy. An anonymous proxy hides your IP but announces itself with headers. A transparent proxy passes your real IP along, which makes it useless for scraping. HTTP proxies forward plain web requests, HTTPS-capable proxies can open an encrypted tunnel, and SOCKS4 and SOCKS5 proxies relay raw connections for almost any client. MDN explains how proxy servers and tunneling work, and our overview of proxy types for scraping covers HTTP, SOCKS5, residential, and datacenter.

Free lists change by the hour, so read every entry below as a snapshot. Each claim about a site is that site's own claim.

The best free proxy lists for web scraping are ProxyScrape's free list for filtered API feeds, Geonode for uptime and ASN filters, monosans/proxy-list on GitHub for hourly checked plain-text files, and Free Proxy List for quick manual picks. Every free list still needs testing, because most entries fail on any given day.

Best for: scripts that need a filtered list on a schedule.

Why it ranks here: The site says the list is refreshed every minute and verified by automated checkers, and it covers HTTP, HTTPS, SOCKS4, and SOCKS5. You can filter by protocol, anonymity, country, and latency, then export TXT, JSON, or CSV, call a free public API, or pull from a GitHub mirror. In the 30-month study, ProxyScrape was one of the two biggest sources of unique proxies and one of the two with the most proxies working on their first test.

Limits: The size and country figures on the page change constantly. The table loads by JavaScript, so use the API instead of scraping the page.

Risk notes: Like every list here, it aggregates open proxies from public sources. ProxyScrape also sells paid proxies and promotes them on the page. Replacing its paid plans instead? See how to choose a ProxyScrape replacement.

Best for: picking proxies by quality signals.

Why it ranks here: Geonode publishes the richest per-entry data in this set: protocol, anonymity, uptime percentage, last checked, speed, latency, a "Google passed" flag, and the network owner as ORG and ASN. You can filter by uptime band and check recency, then load the filtered list through a URL instead of copying rows. Its rows also looked clean. Geonode was part of the 30-month study's provider set in 2023.

Limits: The page title says the list is updated every minute, but the same page has also shown a "Last Updated 23 min" header. Treat freshness labels as approximate.

Risk notes: Geonode is a commercial vendor, and the free list sits next to paid residential offers. The ASN column is your best defense: drop entries on networks you don't expect, such as a "residential" proxy that sits on a hosting provider.

Best for: CI jobs and pipelines that want plain files.

Why it ranks here: The README says a proxy has to fetch a real URL in full to make the list, and that the list is re-checked every hour. It publishes HTTP, SOCKS4, and SOCKS5 proxies as plain text and as JSON sorted fastest first, with response time, exit IP, ASN, and geolocation for each entry. There's no signup and no API key, and the project is MIT licensed.

Limits: Hourly is slower than the minute-level lists above. One developer maintains it, so there's no service promise if updates stop.

Risk notes: Fetch only the plain-text or JSON files over HTTPS. Never run code from a proxy repository you haven't read.

Best for: a quick manual pick for a one-off test.

Why it ranks here: The site says its free proxies are "just checked and updated every 10 minutes," and each row shows anonymity, HTTPS support, a Google flag, and a last-checked time. A raw list lets you copy everything at once. The rows looked like real proxies on normal ports, and Free Proxy List was in the 30-month study's provider set for the whole study period.

Limits: The list leans heavily toward HTTP. Its app or API download is tied to a paid "proxy list" product, so it's clumsier to automate than the feeds above.

Risk notes: The site's menus push paid proxies and other tools. Use the table and the raw list, and skip the rest.

Best for: high-volume files split by protocol (HTTP, HTTPS, SOCKS4, SOCKS5).

Why it ranks here: The README says the project fetches and validates proxies every 5 minutes and splits them into separate files by protocol and by country, so you can grab only SOCKS5 proxies, for example. It also ships an npm module for Node.js projects.

Limits: The README's count of "working" proxies is far above what research finds working on a typical day, so read that number as proxies collected, not proxies you can use.

Risk notes: The code is GPL-3.0 licensed. Read the license before you bundle the npm module in a commercial product, and fetch only the data files over HTTPS.

Best for: browsing by country, port, and anonymity.

Why it ranks here: Spys.one has some of the most detailed filters on any free list. You can show only elite, anonymous, or transparent proxies, filter by country and port, and see uptime and a check date on every row. The page shows a server update time, calls its lists "realtime updated," and offers a plain-text version.

Limits: Ports are rendered by script, so the page is awkward to automate, and the interface is dated and dense.

Risk notes: Spys.one offers a dedicated list of open proxies on MikroTik routers. The 30-month study found MikroTik software on tens of thousands of proxy IPs, many of them likely hijacked routers. Routing your scraper through someone's compromised router is an ethical problem, not just a speed or reliability one. Skip that list entirely.

Best for: checking speed and uptime by country before a manual test.

Why it ranks here: The page says the list is updated once every 60 seconds and that most proxies are tested at least once every 15 minutes. Each row shows speed, uptime, anonymity, country, and the last check.

Limits: IP addresses are rendered by script and there's no export, so you'll copy by hand. Many of the visible rows had low uptime percentages.

Risk notes: ProxyNova is a general-purpose tools site. Ignore the unrelated downloads.

Best for: average uptime and response-time history.

Why it ranks here: ProxyDB has clean filters for HTTP, HTTPS, SOCKS5, anonymity, and country. Its columns show average uptime and average response time instead of a single snapshot, which helps you spot proxies that have stayed up for a while.

Limits: Most of the visible "checked" times were many hours old. That's too stale for scraping unless you re-test every entry yourself.

Risk notes: It's a small operator with no stated check method, so there's no way to know what "checked" means here.

Best for: filtering by anonymity level in a browser.

Why it ranks here: The site says it checks proxies for ping, type, country, connection speed, anonymity, and uptime, and its filters make it easy to show only the anonymity level you want. It was in the 30-month study's provider set under its old name, HideMyName.

Limits: The site says IP:Port export and API access require a paid subscription, so the free tier is a web table only. A large share of the visible free rows sat in Cloudflare's published IP ranges, mostly on common web ports. Those addresses are unlikely to be real open proxies.

Risk notes: The business is a VPN, and the free list works as a funnel toward it. hidemy.name now redirects to hide.mn.

Best for: a second opinion when cross-checking an IP.

Why it ranks here: It offers broad filters by type, anonymity, speed, and port, and it claims a large proxy count.

Limits: A large share of the visible rows were Cloudflare-range addresses on port 80, which are unlikely to be genuine open proxies and drag its list hygiene to the bottom of this set.

Risk notes: VPN deals and "premium access" ads sit beside the table. Don't click through.

Lists we left out. Open Proxy Space was unavailable, and several once-popular lists now redirect to unrelated sites or fail to load. TheSpeedX/PROXY-List on GitHub updates daily, and its maintainer says they're not in charge of the proxies. It's fine for practice but too stale for real jobs.

Match the list to the job. Use a GitHub text feed or ProxyScrape's API when a script needs fresh proxies on a schedule, Geonode or Spys.one when you need a country or anonymity filter, and Free Proxy List for a one-off manual test. For logins, recurring jobs, or hard targets, no free list fits.

Headless browsers such as Playwright and Puppeteer make things worse. Most free proxies don't support authentication or stable sessions, so you can't pin one browser context to one IP for long. One page load also fans out into dozens of requests for scripts, images, and fonts, all through the same proxy. If any of them stalls, the page breaks, so failure rates multiply instead of averaging out.

Yes, if you want accountability without paying yet. Webshare's free plan gives 10 shared proxies and 1 GB of monthly bandwidth with no card, and our own Scraper API trial includes 5,000 free requests with proxies handled for you. Both need an account, but you get a known operator instead of anonymous strangers.

Webshare free plan. Its pricing page says the free plan includes 10 shared proxies and 1 GB of monthly bandwidth, with HTTP and SOCKS5 support, no time limit, and no credit card required. It's best for learning and light jobs, because a failure means your code, not a dead proxy. The limits show up fast: 10 IPs and 1 GB don't stretch far, and other users share the proxies.

WebScrapingAPI Scraper API free trial. This one is ours, and the trial includes 5,000 free requests. You send a URL, and Scraper API handles the proxies, retries, and optional JavaScript rendering, then returns the page. JavaScript rendering and geotargeting cost no extra credits, and failed requests aren't billed. Use it to test a real target before you build any proxy plumbing.

We didn't rank paid providers' short trials or demos, because they aren't free proxy sites. "Free rotating proxy" offers are almost always trials too, because rotation needs a maintained pool of working IPs, which costs money to run. Here's how IP rotation works in scraping if you want the mechanics.

Only a small fraction. A 30-month academic study of more than 640,000 free proxies from 11 list sites found that an average of about 3.4% passed verification on any given day, and HTTPS-capable proxies averaged only about 2.5% of the number that answered over HTTP. Plan to discard most entries on any list.

The 30-month study collected and tested free proxies daily, and its picture isn't all bleak. About 30.8% of the proxies that worked at least once were seen alive across more than 100 days, so some free proxies last. You just can't tell in advance which ones.

Lists also overlap far more than their claimed counts suggest. In a large-scale analysis of open HTTP proxies, 144,349 listings collected from list sites turned out to be just 65,871 unique proxies. Sites copy from the same public sources, so a bigger number on a homepage doesn't mean more working proxies.

That's why the ranking weighs freshness and hygiene so heavily. A list that rechecks often and filters junk rows saves you testing dead entries, but it can't change how few work on a given day.

Not for anything sensitive. A free proxy's operator can read and change unencrypted traffic, log what you request, and inject ads or scripts, and many free proxies run on hijacked routers. Use them only for public, non-sensitive pages, keep certificate checks on, and never send logins, cookies, or API keys through them.

A proxy sits in the middle of every request, the exact position for a manipulator-in-the-middle attack. Over plain HTTP, the proxy sees and can rewrite the full request and response. For HTTPS, a well-behaved proxy uses the HTTP CONNECT method to open a tunnel and only relays encrypted bytes. It can see which host you're visiting but not the page itself, as long as your client verifies certificates.

The research backs this up. The NDSS study found that about 38% of the proxies it tested modified content in some way, and 5.15% did so maliciously. Of those, 47% injected ads, 39% injected tracking or fingerprinting code, and 12% redirected to malware pages. The 30-month study found that, on average, 5.7% of active proxies returned altered content on each run, plus thousands of known vulnerabilities on the machines behind the proxies.

Never send these through a free proxy:

• Logins and passwords
• Session cookies
• API keys or tokens
• Payment data
• Personal data about you or anyone else

Never set verify=False to "fix" a certificate error through a proxy, and never run a list site's "checker" executable or browser extension. There's a legal and ethical side too: some free proxies run on devices whose owners never agreed to relay your traffic.

Send a few small requests through each proxy to a test endpoint such as httpbin.org. Check that it connects, which IP the site sees, which headers it adds, whether it can open an HTTPS tunnel, and whether a known page comes back unchanged. Keep only proxies that pass every check, and re-test before each run.

Set up a virtual environment and install Requests with SOCKS support:

python -m venv .venv && source .venv/bin/activate
pip install "requests[socks]"

Save this script as free_proxy_check.py:

#!/usr/bin/env python3
"""Check a free proxy list for dead, leaky, HTTP-only, and tampering proxies."""
import csv
import hashlib
import os
import sys
import time
from concurrent.futures import ThreadPoolExecutor

import requests

BASE = os.environ.get("CHECK_BASE", "http://httpbin.org")
HTTPS_URL = os.environ.get("CHECK_HTTPS_URL", "https://httpbin.org/ip")
TIMEOUT = float(os.environ.get("CHECK_TIMEOUT", "8"))
WORKERS = int(os.environ.get("CHECK_WORKERS", "20"))
PROXY_HEADERS = {"via", "x-forwarded-for", "forwarded", "x-real-ip", "client-ip"}


def new_session(proxy=None):
    s = requests.Session()
    s.trust_env = False  # ignore HTTP(S)_PROXY / NO_PROXY from the shell
    if proxy:
        s.proxies = {"http": proxy, "https": proxy}
    return s


def baseline():
    """What the test server sees with no proxy: our IP and the true page hash."""
    s = new_session()
    my_ip = os.environ.get("CHECK_REAL_IP") or s.get(f"{BASE}/ip", timeout=TIMEOUT).json()["origin"]
    page = s.get(f"{BASE}/html", timeout=TIMEOUT).content
    return my_ip, hashlib.sha256(page).hexdigest()


def check(proxy, my_ip, page_hash):
    row = {"proxy": proxy, "verdict": "dead", "exit_ip": "", "latency_ms": "",
           "https": False, "proxy_headers": "", "tampered": False, "error": ""}
    s = new_session(proxy)
    try:
        start = time.perf_counter()
        r = s.get(f"{BASE}/ip", timeout=TIMEOUT)
        r.raise_for_status()
        row["latency_ms"] = round((time.perf_counter() - start) * 1000)
        row["exit_ip"] = r.json()["origin"]

        seen = s.get(f"{BASE}/headers?show_env=1", timeout=TIMEOUT).json()["headers"]
        added = {k: v for k, v in seen.items() if k.lower() in PROXY_HEADERS}
        row["proxy_headers"] = ";".join(f"{k}={v}" for k, v in added.items())
        leaks_ip = my_ip in row["exit_ip"] or any(my_ip in v for v in added.values())
        # httpbin.org's own load balancer adds one X-Forwarded-For hop; more means the proxy added one
        hops = added.get("X-Forwarded-For", "").count(",") + 1 if "X-Forwarded-For" in added else 0
        reveals = "Via" in added or "Forwarded" in added or hops > 1

        page = s.get(f"{BASE}/html", timeout=TIMEOUT).content
        row["tampered"] = hashlib.sha256(page).hexdigest() != page_hash
    except (requests.RequestException, ValueError, KeyError) as exc:
        row["error"] = type(exc).__name__
        return row

    try:
        row["https"] = s.get(HTTPS_URL, timeout=TIMEOUT).ok
    except requests.RequestException:
        row["https"] = False

    if row["tampered"]:
        row["verdict"] = "tampered"
    elif leaks_ip:
        row["verdict"] = "leaks_ip"
    elif not row["https"]:
        row["verdict"] = "http_only"
    elif reveals:
        row["verdict"] = "reveals_proxy"
    else:
        row["verdict"] = "usable"
    return row


def main(path):
    with open(path) as f:
        proxies = [line.strip() for line in f if line.strip() and not line.startswith("#")]
    proxies = [p if "://" in p else f"http://{p}" for p in proxies]
    my_ip, page_hash = baseline()

    with ThreadPoolExecutor(max_workers=WORKERS) as pool:
        rows = list(pool.map(lambda p: check(p, my_ip, page_hash), proxies))

    writer = csv.DictWriter(sys.stdout, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)
    usable = sum(r["verdict"] == "usable" for r in rows)
    print(f"{usable}/{len(rows)} proxies usable", file=sys.stderr)


if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else "proxies.txt")

The script runs five checks on every proxy, in order:

1. Connect and latency. It requests /ip through the proxy and times the round trip. A refused connection or a timeout means dead.
2. Exit IP. It compares the IP httpbin.org sees with your real IP from a direct request. If your own IP shows up, the proxy leaks it.
3. Added headers. It looks for proxy-added headers such as Via, the X-Forwarded-For header, and the standard Forwarded header. These reveal that a proxy is in the path, and sometimes they carry your real IP.
4. Page integrity. It compares the SHA-256 hash of httpbin.org's /html page fetched through the proxy with a direct fetch. Any difference means the proxy changed the page.
5. HTTPS via CONNECT. It requests an HTTPS URL through the proxy. If the tunnel fails, the proxy only works for plain HTTP.

Put your candidates in a text file, one per line. Bare host:port entries are treated as HTTP, and you can add a scheme for SOCKS. The addresses below are reserved documentation IPs, so replace them with entries from your list:

# one proxy per line; bare host:port means HTTP
203.0.113.10:8080
http://198.51.100.24:3128
socks5h://192.0.2.55:1080

Then run the checker:

python free_proxy_check.py proxies.txt > results.csv

The script writes one CSV row per proxy to results.csv and prints a count of usable proxies. Free proxies are slow, so if healthy ones keep timing out, raise the timeout with the CHECK_TIMEOUT environment variable (in seconds).

Two settings in the script matter. Using socks5h:// instead of socks5:// makes the proxy resolve hostnames, which keeps DNS lookups off your own network. Setting trust_env = False stops Requests from picking up proxy settings from your shell, so each check goes only through the proxy under test. The Requests proxies documentation covers both.

Feed the checker a plain-text export from any list above, such as ProxyScrape's API, Geonode's URL loader, or one of the GitHub text files. For ping, curl, IP reputation databases, and anonymity levels, follow our six practical ways to test proxies. New to proxies in Requests? Here's how to set up a proxy in Python Requests, including auth and SOCKS5. When a proxy fails with 407, 502, or a refused CONNECT, read the proxy status error before you blame the target.

Pay when keeping a free list alive costs more than a plan. Clear signals are recurring jobs, success rates you can't predict, a need for HTTPS or a specific country, logins, or hours spent rechecking proxies. Pick residential proxies for hard or local targets, datacenter proxies for tolerant sites, or a scraping API to skip proxy upkeep.

Free proxies are a good way to learn. You see how proxy settings work and why "anonymous" on a list doesn't always mean anonymous. But a free list isn't free. You pay in time spent fetching and testing it, rerunning jobs that died halfway, and checking that your data came back unchanged. Once that time is worth more than a modest plan, free is the expensive option.

Still want a list, just a reliable one? Learn how paid proxy lists are priced and chosen. For consumer IPs and city targeting, compare the best rotating residential proxy providers. For high-volume jobs on tolerant sites, weigh shared versus dedicated datacenter proxies.

WebScrapingAPI offers three paid options that match the table above:

• Residential Proxies. Residential Proxies rotate by default, keep sticky sessions up to 10 minutes, and accept HTTP, HTTPS, or SOCKS5.
• Datacenter Proxies. For throughput on targets that accept datacenter traffic, use Datacenter Proxies with your own client. Pricing is by quote, sized to your traffic.
• Scraper API. Or skip proxy upkeep: Scraper API takes a URL and handles proxies, retries, and optional JavaScript rendering. JavaScript rendering and geotargeting cost no extra credits, and failed requests aren't billed.

Here's the same httpbin.org/ip check from the tester, sent through Scraper API with a US exit. Set your API key in the WSA_API_KEY environment variable first:

import os

import requests

params = {
    "api_key": os.environ["WSA_API_KEY"],
    "url": "https://httpbin.org/ip",
    "country": "us",
}
r = requests.get("https://api.webscrapingapi.com/v2", params=params, timeout=60)
print(r.status_code, r.text[:200])

It depends on the job. ProxyScrape's free list is the strongest all-rounder for scripts, with filters and a free API. Geonode adds uptime and network data, and GitHub feeds such as monosans/proxy-list are easiest to automate. None is reliable enough for production, so test every proxy first.

Only for public, non-sensitive requests. A free proxy's operator can log your traffic and modify anything sent over plain HTTP, and research has caught thousands of free proxies injecting content. Keep certificate checks on, prefer HTTPS targets, never send logins or API keys, and test every proxy before your scraper relies on it.

Usually a small minority. In one 30-month academic study of more than 640,000 free proxies, an average of about 3.4% passed verification on any given day. Results vary by list and by hour, so test each proxy just before you use it and expect to discard most entries.

ProxyScrape offers a free public API plus TXT, JSON, and CSV exports, and Geonode lets you load a filtered list through a URL. GitHub projects such as monosans/proxy-list and Proxifly publish plain-text files you can fetch directly. Hide.mn keeps its export and API behind a paid subscription. Always fetch feeds over HTTPS.

Refresh it right before each run. Some free proxies last for months, but many vanish within days, and you can't tell which in advance. Even a list that rechecks every minute can't tell how a proxy will treat your target, so fetch, test, and use the survivors right away.

Some exist, but they are rare. In the 30-month study, HTTPS-capable proxies averaged only about 2.5% of the number that answered over HTTP. An HTTPS-capable proxy supports the CONNECT method, which tunnels encrypted traffic end to end. Test this directly, because list labels saying "HTTPS" are often wrong or out of date.

Not in any dependable sense. Free lists mix hosting servers with home devices, and many residential-looking IPs are hijacked routers whose owners never agreed to share them. A few providers offer small free plans, such as Webshare's 10 shared proxies, but reliable, ethically sourced residential IPs at scale cost money.

Most "free rotating proxy" services are trials or small free tiers of paid products, not permanently free pools. Rotation needs a maintained pool of working IPs, which costs money to run. If you need rotation for a recurring job, budget for a paid proxy plan or a scraping API that rotates for you.

Paid proxies come with accountability: a known operator, authentication, HTTPS support, location targeting, and someone fixing dead IPs. Free proxies are anonymous, shared, and unmaintained. Free can work for learning. For recurring jobs, paid proxies usually cost less than the hours lost re-testing and re-running failed scrapes.

Using a public proxy isn't illegal in most places, but some free proxies run on compromised devices without the owner's consent, and routing traffic through them raises legal and ethical concerns. The legality of the scraping itself depends on what you collect and where. This isn't legal advice, so check local rules.

Free proxy lists are a good way to learn and a poor foundation for data you depend on. When you're ready to pay, compare Residential Proxies plans, which start at $8.50 per GB pay as you go, or request a Datacenter Proxies quote sized to your traffic. If you'd rather not manage proxies at all, Scraper API plans start with 5,000 free requests. JavaScript rendering and geotargeting cost no extra credits, and failed requests aren't billed.