Best Free Proxy Sites for Web Scraping in 2026

By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: October 22, 2026 · Every site and free tier checked on October 21, 2026

Search for "free proxy list" and you'll find thousands of IP addresses, refreshed every few minutes, free to copy. It looks like the easiest problem in web scraping to solve. Then you paste fifty of them into your scraper and most of them time out, a few return a page that isn't the one you asked for, and the rest are already blocked by the site you wanted.

Free proxies aren't useless. They're good for learning, for a quick geo check, and for testing your code. But "free proxy" covers three very different things, and picking the wrong one costs you more time than it saves.

This guide covers the best free proxy sites for web scraping in 2026: the open lists worth knowing, the paid providers with genuinely free plans, and the scraping APIs whose free tiers include proxies. We also pulled four popular free lists and analysed them, and built a proxy checker you can run on any list before you trust it.

The three kinds of free proxy

"Free proxy" means one of three things. Open proxy lists publish public IP:port addresses anyone can use without signing up. Paid proxy providers offer free plans or trials with a handful of private IPs. Scraping APIs offer free request allowances where the proxies are built in and you never see an IP address.

Swipe sideways to see the full table →

How we checked these sites

We visited every site in this guide on October 21, 2026 and took the numbers from its own pages. We also downloaded four free proxy lists from GitHub and analysed their size, duplicates and overlap. Then we tested our proxy checker against proxies we ran ourselves, including ones that tamper with traffic.

One honest limit: we couldn't test whether the listed proxies actually worked, because our test environment only allows connections to a short list of sites. That's why the checker matters. Run it on any list before you trust it.

A few well-known sites, including ProxyScrape, Spys.one and HideMy.name, didn't load from our test environment, so they aren't reviewed here. Don't read that as a verdict on them either way.

Best free proxy sites at a glance

The best free proxy sites in 2026 split into open lists, free provider plans and API free tiers. Proxifly and Geonode lead the open lists on freshness, Free Proxy World on size. Webshare and Oxylabs give you real IPs for free. GcrawlAI, ZenRows and ScraperAPI include proxies in a free request allowance.

Swipe sideways to see the full table →

The best open free proxy lists

The best open free proxy lists are Proxifly, Geonode, Free Proxy World, ProxyNova and Free Proxy List, plus two GitHub-hosted lists, TheSpeedX and monosans, that are easy to pull into a script. All of them publish public IPs that anyone can use, so treat every address as unverified until you've tested it.

1. Proxifly

Proxifly publishes its free list on GitHub and refreshes it every 5 minutes. Its latest update reported 46,858 working proxies from 141 countries, split into HTTP, HTTPS, SOCKS4 and SOCKS5, in JSON, TXT and CSV. Because it's a plain file on GitHub, it's the easiest list to load straight into code; our HTTP file alone had 4,974 unique entries.

• Good: frequent refresh, separate files per protocol and country, no scraping needed.
• Watch out: "working" means working when it was checked. Re-test before every run.

2. Geonode

Geonode showed 10,173 proxies online across 113 countries when we checked. It says entries are checked every minute and removed after 24 hours, and it has the most useful filters of any open list: protocol, uptime, last-checked time, anonymity, speed and whether the proxy passed a Google check. A generated API link returns the filtered list as ip:port or JSON.

• Good: frequent checks, strong filtering, an honest safety warning on its own page.
• Watch out: the table shows 100 rows at a time; use the API link for bigger pulls.

3. Free Proxy World

Free Proxy World listed 51,347 proxies across 1,027 pages, the largest table we saw, with filters for protocol (HTTP, HTTPS, SOCKS4, SOCKS5), anonymity, country, maximum speed and port. Each row shows city, speed and last-check time.

• Good: size, and a heavy concentration of US addresses (22,531 when we checked).
• Watch out: a bigger pool also means more dead entries. Filter by speed and last check first.

4. ProxyNova

ProxyNova says its list updates every 60 seconds and shows, for each proxy, the percentage of checks it passed in the past 24 hours. That uptime column is the most useful single signal on any open list, because a proxy that was up an hour ago tells you little.

• Good: 24-hour uptime per proxy, per-country counts of working proxies.
• Watch out: only a few dozen rows per page, and no overall total.

5. Free Proxy List

Free Proxy List shows the latest 300 free proxies, with an HTTPS column and a "Get raw list" link that gives you plain IP:port lines to paste into a script. The site says the free list updates every 10 minutes in one place and every 30 minutes in another, so check the timestamp on the raw list.

• Good: the quickest way to get a small raw list.
• Watch out: only 300 entries, and little detail per proxy.

6. TheSpeedX and monosans on GitHub

TheSpeedX/PROXY-List publishes HTTP, SOCKS4 and SOCKS5 files (2,645 HTTP entries in our pull) and is clear that its author isn't in charge of the proxies. monosans/proxy-list is smaller (261 HTTP entries) and was updated the day we checked. Both are easy to automate, and both deserve the same testing as any other open list.

What we found when we analysed four free proxy lists

We downloaded four HTTP proxy lists from GitHub and compared them. They held 8,280 entries but only 5,952 distinct proxies, and 1,880 appeared on more than one list. Most striking, every one of the 400 entries in a list last updated in March 2023 also appears in two lists updated this week.

• Lists recycle each other. Proxifly and TheSpeedX shared 1,784 identical entries. Many free lists are aggregators that collect from the same public sources, so a second list doesn't double your options.
• Old entries never leave. clarketm/proxy-list hasn't changed since March 2023, yet all 400 of its addresses were in both current lists. Either they've survived three and a half years, or, more likely, aggregators still pull from stale sources and re-publish what they find. Either way, a recent update date on a list tells you nothing about each address.
• The same ports keep appearing. 8080, 80, 999 and 3128 were the most common ports on every list. Those are typical of open proxy software and misconfigured devices, which is part of why sites flag them so quickly.
• Junk slips in. Three entries pointed at non-public addresses that can't work as internet proxies at all.

"A free proxy list is a lead list, not a proxy pool. Every address on it is a guess until your own checker says otherwise."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

Free plans from paid proxy providers

If you need a few proxies that keep working, a free plan from a paid provider beats any open list. Webshare gives 10 shared proxies and 1 GB a month with no card, and Oxylabs gives 5 US datacenter IPs and 5 GB a month. These are real, maintained IPs from known companies, in small amounts.

Webshare

Webshare's free plan includes 10 shared proxies and 1 GB of bandwidth a month, with HTTP and SOCKS5 support and no credit card. It's the simplest way to get a small, stable set of proxies for a hobby project or a scheduled job that runs a few hundred requests.

Oxylabs

Oxylabs' free proxies are 5 US datacenter IPs with 5 GB of monthly traffic, 20 concurrent sessions and support for HTTP, HTTPS, HTTP/3 and SOCKS5. You sign up through its dashboard without a card, and the IPs stay valid for a month from activation.

Short trials: Decodo and others

Residential proxies are rarely free for long. Decodo, for example, offers a 3-day residential trial with 100 MB, after which the chosen plan activates unless you cancel. Trials like this are for testing your real target, not for running a project.

Scraping APIs with free tiers

A scraping API's free tier is often the most useful "free proxy" of all, because the proxies come built in. You send a URL and the API handles rotation, retries and blocks. GcrawlAI includes 50 free requests a month, ZenRows 5,000 credits a month, and ScraperAPI a 7-day, 5,000-credit trial, then 1,000 credits a month.

GcrawlAI

GcrawlAI is a scraping API that returns any page as HTML or clean Markdown. One request includes rotating residential proxies with country targeting, JavaScript rendering and anti-bot handling, with no credit multipliers for any of them. The free plan is 50 requests a month with no card, and paid plans cost $1 to $6 per 1,000 requests depending on plan. It's a cloud API with a Python SDK and MCP support for AI agents, and it's open source if you want to run it yourself.

from gcrawl_sdk import GcrawlClient, ScrapeOptions   # pip install gcrawl-sdk

client = GcrawlClient(api_key="gc-YOUR_API_KEY")

# no proxy list to maintain: rotation, country targeting and anti-bot handling happen on GcrawlAI's side
result = client.scrape(
    url="https://example.com/",
    options=ScrapeOptions(markdown_enabled=True, proxy_geo="US"),
    wait=True,
)
print(result.markdown[:300])

ZenRows

ZenRows' free plan is a recurring 5,000 credits a month with no card, where a normal successful page costs 1 credit and failed requests aren't charged. Some features cost more than 1 credit per request, so check how many credits your target pages need before you plan around the allowance.

ScraperAPI

ScraperAPI offers a 7-day trial with 5,000 API credits and no card, then a free plan of 1,000 credits with up to 5 concurrent connections. As with other credit-based APIs, check how many credits your target pages need.

Weighing more than free tiers? Our comparison of the cheapest reliable web scraping APIs for high volume looks at cost at scale.

Are free proxies safe?

Free proxies are not safe for anything sensitive. Whoever runs a proxy can see, log and change the traffic that passes through it, and you usually don't know who that is. Large studies have found many free proxies injecting ads and tracking code, and many running on hacked devices. Use them only for public, low-stakes requests.

The research is consistent:

• A 30-month study, Free Proxies Unmasked, tracked more than 640,600 free proxies from 11 providers. Only 34.5% were active even once during the study, 16,923 manipulated content, and Shodan reported 4,452 distinct vulnerabilities on the proxies' IP addresses.
• An earlier NDSS study of 65,871 open HTTP proxies found that 38% modified content in some way and 5.15% did so maliciously, mostly by injecting ads or tracking and fingerprinting code.
• Geonode's own free list warns that free proxies' operators and logging rules may be unknown, and tells you never to send logins, payment details or private data through them.

For scraping, the practical risks are subtler than stolen passwords. A proxy that rewrites a page can quietly change the prices or text you collect, and you'd never know. Over HTTPS, a proxy can't read or change the page itself, but it still sees which sites you visit. Test for tampering, prefer HTTPS targets, and never log in to anything through a free proxy.

How to test free proxies before you use them

Test every free proxy before you use it: load a list, send each proxy a request to a page that echoes back your IP and headers, and keep only the proxies that answer quickly, hide your real IP, add no proxy headers and return the page unchanged. Re-run the check before each scraping session.

First, load and de-duplicate a list. This pulls Proxifly's HTTP list from GitHub:

import re
import requests

# Proxifly publishes its free list on GitHub, refreshed every few minutes
LIST_URL = "https://raw.githubusercontent.com/proxifly/free-proxy-list/main/proxies/protocols/http/data.txt"

def load_proxies(url=LIST_URL):
    text = requests.get(url, timeout=30).text
    found = re.findall(r"(\d{1,3}(?:\.\d{1,3}){3}):(\d{2,5})", text)
    return sorted({f"{ip}:{port}" for ip, port in found})   # de-duplicate

if __name__ == "__main__":
    proxies = load_proxies()
    print(len(proxies), "unique proxies, e.g.", proxies[:3])

Then check each proxy against httpbin.org/get, which returns the IP and headers it received as JSON. The checker sorts every proxy into one of five verdicts:

import json
import time
from concurrent.futures import ThreadPoolExecutor
import requests

CHECK_URL = "https://httpbin.org/get"     # echoes your IP and headers back as JSON
MY_IP = requests.get(CHECK_URL, timeout=15).json()["origin"]

def check(proxy, timeout=6):
    """Return a verdict for one proxy: dead, slow, leaky, tampering or usable."""
    proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
    start = time.perf_counter()
    try:
        r = requests.get(CHECK_URL, proxies=proxies, timeout=timeout)
    except requests.RequestException:
        return {"proxy": proxy, "verdict": "dead or too slow"}
    seconds = round(time.perf_counter() - start, 2)
    try:
        data = r.json()
    except ValueError:
        return {"proxy": proxy, "verdict": "tampering: response isn't the JSON we asked for", "seconds": seconds}
    if set(data) - {"args", "headers", "origin", "url"}:
        return {"proxy": proxy, "verdict": "tampering: extra fields injected", "seconds": seconds}
    headers = {k.lower() for k in data.get("headers", {})}
    if MY_IP in data.get("origin", "") or {"x-forwarded-for", "via", "forwarded"} & headers:
        return {"proxy": proxy, "verdict": "leaky: reveals you or that it's a proxy", "seconds": seconds}
    return {"proxy": proxy, "verdict": "usable", "seconds": seconds, "exit_ip": data["origin"]}

def check_all(proxy_list, workers=50):
    with ThreadPoolExecutor(max_workers=workers) as pool:
        return list(pool.map(check, proxy_list))

if __name__ == "__main__":
    from load_list import load_proxies
    results = check_all(load_proxies()[:500])
    usable = [r for r in results if r["verdict"] == "usable"]
    print(f"{len(usable)} of {len(results)} usable")
    print(json.dumps(usable[:5], indent=2))

We tested the checker against five proxies we ran ourselves, each behaving like a common kind of free proxy:

It caught all four bad ones: the proxy that slipped an ad script into the response, the one that added X-Forwarded-For and Via headers (so the site knows you're using a proxy, and may learn your real IP), the one that took eight seconds, and the one that wasn't there at all. Only the honest proxy passed.

Once you have a list of proxies that passed, rotate through them and expect failures:

import itertools
import requests
from check_proxies import check_all
from load_list import load_proxies

# keep only proxies that passed every check, fastest first
good = sorted((r for r in check_all(load_proxies()[:500]) if r["verdict"] == "usable"),
              key=lambda r: r["seconds"])
pool = itertools.cycle([r["proxy"] for r in good])

def fetch(url, tries=3):
    """Try a few proxies from the pool; free proxies die often, so expect retries."""
    for _ in range(tries):
        proxy = next(pool)
        try:
            return requests.get(url, proxies={"http": f"http://{proxy}", "https": f"http://{proxy}"}, timeout=10)
        except requests.RequestException:
            continue
    raise RuntimeError("no working proxy in this round, re-run the checker")

print(fetch("https://example.com/").status_code)

Which free proxy option should you choose?

Choose by what you're doing. For learning proxies or testing your code, an open list plus a checker is enough. For a small job that runs every day, a free provider plan like Webshare or Oxylabs is more reliable. For protected or JavaScript-heavy sites, use a scraping API free tier, because open-list IPs are usually blocked already.

Swipe sideways to see the full table →

If your scraper keeps getting blocked even with proxies, the IP may not be the problem. Our guide to fixing 403 Forbidden errors in Python Requests covers headers, sessions and TLS fingerprints, which matter as much as the IP.

"Free proxies are a fine way to learn. The moment the data matters, the cost of a bad proxy is a wrong number in your report, and that's far more expensive than a paid plan."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

When free proxies are the wrong tool

Free proxies are the wrong tool for logged-in sessions, personal or financial data, production pipelines, and sites that already block datacenter traffic. A proxy also changes your IP, not what you're allowed to collect. If you're unsure where the lines are, start with our guide to what web scraping is and when it's legal.