proxy-scraper

https://proxy-scraper.de/all.txthttps://proxy-scraper.de/http.txthttps://proxy-scraper.de/socks4.txthttps://proxy-scraper.de/socks5.txt

_{http.txt, socks4.txt and socks5.txt hold one ip:port per line, all.txt one type://ip:port. Best first, so head -n 20 gives you the best ones. No signup, no API key, CORS headers included. The badges above are the counts of the last run. The same files are on the proxy-list branch, on jsDelivr and in a repository of their own, free-proxy-list. HTTPS-only, elite, stable, per country, per site, JSON and CSV: every list.}

Check them from your own network before you use them. No install needed, uvx comes with uv (pipx run does the same):

uvx proxy-scraper-cli --pick 3 --verify    # up to 3 proxies from the hourly list that pass right now, from your network

Why this list

Most free proxy lists on GitHub are long, and most of their entries fail when they are checked. This list is shorter because each run publishes only the proxies that passed. The benchmark runs the same checks on the popular lists every hour and shows what share of each one passes:

[Share of checked proxies that passed every check, per popular free proxy list on GitHub, redrawn about every hour]

_{Redrawn about every hour from the hourly runs on a GitHub Actions runner. The date is in the chart. The benchmark page has the counts behind each share, how they are measured and why proxy-scraper's own list isn't in it.}

What a proxy on the list has passed, in the last run, from that runner:

Each check ends as passed, failed, unavailable or skipped, with a reason code, the target and the time, in proxies.json, in the CSV and in the tool's output. A check that didn't run is never shown as passed. Details: check states.

What a pass doesn't tell you. Free proxies are run by strangers. Of one run's list, about a quarter was on the list again 24 runs later (median of the week ending 13 Oct 2026). A pass is one measurement, from one network, against test targets: it is not a promise for the next hour or for the site you care about. The HTTPS check is a verified TLS connection to one test host, not a security rating. Use free proxies for public data and testing, never for logins, payments or anything personal. → What the numbers show and what they don't · Why free proxies fail · How it compares · Who runs free proxies

Used by: the hourly list is a built-in source of monosans/proxy-scraper-checker and gfpcom/free-proxy-list.

Live proxy list

About every hour GitHub Actions runs proxy-scraper and publishes the hits to the proxy-list branch – every entry passed the first request, the second request and the content check in the last run (the HTTPS test is recorded per entry, not required), best first: fast ones that are likely to still be up come on top.

curl -s https://raw.githubusercontent.com/maximilianfeix/proxy-scraper/proxy-list/socks5.txt | head

The same lists live in a repository of their own, maximilianfeix/free-proxy-list: one list per protocol, per country and per site, updated every hour, with the numbers of the last run on the front page. Watch or star it to keep it at hand.

[Working proxies over the last days, stacked by protocol – redrawn with every run]

→ Browse it on the website – search, filter by type, country, HTTPS, provider and latency, see how long each proxy has been on the list and in how many of the week's runs, copy or download exactly the proxies you need.

Every protocol and country also has its own page with a plain download, e.g. SOCKS5 or Germany (country/de/proxies.txt).

[Countries with the most working proxies right now]

Where they come from: which free proxy lists actually work ranks every source of the hourly runs – how many proxies each one lists, how many passed every check and the share. The same as data: sources.json.

Over time: every day the first run's proxies.json is kept for good as a gzipped asset of the release of that year, like snapshots-2026 – proxies-2026-09-27.json.gz and so on, for anyone who wants to look at free proxies over weeks and months.

Every file is also on the website, which isn't rate limited like raw.githubusercontent and sends CORS headers, so it works straight from the browser: https://proxy-scraper.de/socks5.txt. jsDelivr works too, but can lag behind by a few hours.

Or let the tool start from it: proxy-scraper --recheck live downloads the list and checks it again from your network – well under a minute instead of a full scan. How many still work from your network differs a lot from the list's own count, which is the point of checking again. Add --serve and the result is a rotating proxy.

The tool: check proxies from your own network

The list is checked from GitHub's servers. Whether a proxy works from where your code runs is a different question, and proxy-scraper, the tool that builds the list, answers it: it collects public HTTP, SOCKS4 and SOCKS5 proxies from hundreds of lists, runs up to four checks on each one and keeps the outcome of each check for the proxies it lists (for the rest it counts how each check ended).

https://github.com/user-attachments/assets/b99c1d8f-5bce-4a52-a8a9-b9c2c726301b

_{21 seconds · real interface, example numbers, documentation IPs · mp4}

uvx proxy-scraper-cli --pick 3 --verify               # up to 3 proxies from the hourly list that pass right now, from your networkuvx proxy-scraper-cli --diagnose socks5://HOST:PORT   # one proxy, check by check: what it did and what it didn't

_{A real terminal recording, made against six simulated proxies on localhost (reproduce it). It shows how results are reported. It measures nothing about public proxies.}

The package is proxy-scraper-cli on PyPI (the plain name is taken). Once installed, the command is proxy-scraper. --verify and --diagnose need version 1.30 or newer.

Three ways to get proxies, and what "checked" means for each:

What you get

• Every check has an outcome you can read. passed, failed, unavailable or skipped, with a reason code, the target and the time, in the terminal, in JSON and from Python. A check target that is down doesn't turn the proxies checked against it into failures. → Check states
• Fresh when it matters. --pick --verify checks a few proxies from your own network, usually in seconds. --recheck does the same for a list of your own, and --diagnose tells you why one proxy doesn't work.
• More than a list. A rotating local proxy server, a Python API, an MCP server for AI agents, Docker, and exports for curl, proxychains, Clash and sing-box.

Install

Python 3.9 to 3.14.

With pipx (recommended – gives you a proxy-scraper command in its own environment):

pipx install proxy-scraper-cliproxy-scraper

With Homebrew on macOS and Linux:

brew install maximilianfeix/tap/proxy-scraper

The formula follows each release within about a day.

Docker, pip, a faster event loop, the latest main, tab completion and where state and results are stored: every other way to install.

Started without arguments, a wizard asks what you are looking for – a preset (find everything, browsing, maximum anonymity, fast, a few right now, recheck, proxy server right away, …) or step by step: the wizard and its presets.

Keys: ↑↓ select · Space toggle · 1–9 jump · Enter next · Esc back · q quit. In scripts and cron jobs the wizard never shows up – pass options or -y.

Check states

Every check of a proxy ends in one of four states. They are in proxies.json, in the CSV, in --pick --json, in --diagnose, in the Python API (result.checks) and in the MCP results.

Two rules follow from that:

• A check that didn't run is never passed. Before 1.30, a run without a reachable second target kept every proxy as if it had been confirmed, and a missing reference page looked like "content unchanged".
• A check target that is down doesn't fail the proxies checked against it. When a second request, a content request that returned a different page, or an HTTPS test fails, the tool asks the target directly: at most once every 3 seconds however many proxies fail in between, and a "down" answer is reused for 10 seconds. If the target doesn't answer, the proxy's check is unavailable, not failed. For the first request a scan does it differently: it watches the target, switches to another one and checks the affected proxies again. --diagnose and --pick --verify have no such watcher and ask directly, as for the later checks. Two things are never asked about, because the target did answer: a second site that saw a different exit IP, and a proxy that could not be connected to in the first place.

The checks, what each passed does and doesn't mean, the fields and every reason code: docs/check-states.md.

For AI agents (MCP)

proxy-scraper-mcp is an MCP server: Claude Code, Claude Desktop, Cursor, VS Code, Codex and any other MCP client can ask for working proxies and load pages through them.

[proxy-scraper MCP server on Glama]

Things to ask your agent: "Load bbc.com/news as seen from the UK", "Give me 5 SOCKS5 proxies from Germany that aren't in a datacenter", "Check which of these sites block free proxies".

Needs uv – it fetches a suitable Python by itself if yours is older than 3.10. Claude Code:

claude mcp add proxy-scraper -- uvx --python ">=3.10" --from "proxy-scraper-cli[mcp]" proxy-scraper-mcp

Claude Desktop, Cursor and most other clients – add this to the MCP config (Claude Desktop: Settings → Developer → Edit Config, Cursor: ~/.cursor/mcp.json):

{  "mcpServers": {    "proxy-scraper": {      "command": "uvx",      "args": ["--python", ">=3.10", "--from", "proxy-scraper-cli[mcp]", "proxy-scraper-mcp"]    }  }}

VS Code, Codex, Docker, or without uv: setup for every other client. It's also in the official MCP registry as io.github.maximilianfeix/proxy-scraper, so clients that browse the registry can install it from there.

The server tells agents what it tells you: free proxies are run by strangers, so no logins, cookies or personal data through them. Local and private addresses are refused, and results go to proxy-scraper's data folder, not into the project you're working in.

Examples

# 50 proxies that can do HTTPS – then stopproxy-scraper --want 50 --https-only
# only Germany, Austria and Switzerland, the 20,000 most promising candidatesproxy-scraper --country DE,AT,CH -l 20000
# fast elite SOCKS5 proxiesproxy-scraper --types socks5 --anonymity elite --max-latency 1500
# 20 proxies that really reach Google AND Discordproxy-scraper --target google.com --target discord.com --want 20
# only recheck the last hits (plus history) – takes secondsproxy-scraper --recheck
# wizard with defaults – it keeps what you already passedproxy-scraper -i --country DE
# which sources deliver the most?proxy-scraper --list-sources

Running from a clone? Replace proxy-scraper with python3 proxy_scraper.py.

From Python

from proxyscraper import check_proxies, find_proxies
if __name__ == "__main__":  # needed on macOS/Windows, the parser uses a process pool    for p in find_proxies(want=20, https=True, countries=["DE", "NL"], no_datacenter=True):        print(p.url, p.latency, p.country, p.org)
    alive = check_proxies(["socks5://1.2.3.4:1080", "5.6.7.8:3128"])  # your own list

Same run as the command line – sources, learning, every check, result files – just without terminal output. Each result has url, latency, exit_ip, https, anonymity, country, asn, org and hosting. There's an async version of both (find_proxies_async, check_proxies_async).

Don't need a fresh scan? live_proxies takes the live list instead – no checks, one download, done in about a second:

import itertools, requestsfrom proxyscraper import live_proxies
proxies = live_proxies(types=["socks5"], https=True, min_uptime=90)  # the reliable ones this weekpool = itertools.cycle(p.url for p in proxies)r = requests.get("https://api.ipify.org", proxies={"https": next(pool)}, timeout=15)  # pip install "requests[socks]"

It filters by types, countries, https, anonymity, max_latency, no_datacenter and no_blocklisted like find_proxies, plus min_uptime, min_speed (KiB/s), works_on (["google"], "reddit", "amazon", "instagram", "tiktok", "discord") and limit. Every result also has uptime_24h, uptime_7d, first_seen, up_for_hours, sites and speed_kbps.

Or let the library do the retrying: ProxyRotator loads a URL through the list and moves on to the next proxy when one fails, and proxy_url() gives requests, httpx, Playwright or Scrapy one local address that rotates behind the scenes – Python API: rotating through the list.

Rotating proxy server

A list is nice – but usually you just want to enter one proxy address and have something behind it that keeps trying:

proxy-scraper --recheck --serve     # recheck the last hits, then go – takes seconds

curl -x http://127.0.0.1:8899 https://api.ipify.org              # a different IP every timecurl -x socks5h://127.0.0.1:8899 https://api.ipify.org           # SOCKS5 on the same portcurl -x http://country-de:[email protected]:8899 https://api.ipify.org # only German exitscurl -x http://session-cart42:[email protected]:8899 https://shop.example  # same proxy for this sessioncurl http://127.0.0.1:8899/__proxy-scraper/status                # pool and counters as JSONcurl http://127.0.0.1:8899/__proxy-scraper/metrics               # the same for Prometheus/Grafana

Like commercial rotating proxies, the username carries what you want: country-XX, type-http|socks4|socks5 and session-NAME, combinable (country-us-type-socks5-session-a). It works for HTTP (Proxy-Authorization) and SOCKS5 (username/password auth). By default the password is ignored and the server only listens on 127.0.0.1.

To reach it from other machines, give it a password – every client then has to send it, over HTTP and SOCKS5 alike, and the status page wants it as Basic auth:

export PROXY_SCRAPER_SERVE_PASSWORD=$(openssl rand -hex 16)   # the env var keeps it out of `ps`proxy-scraper --recheck --serve --serve-host 0.0.0.0curl -x "http://country-de:$PROXY_SCRAPER_SERVE_PASSWORD@your-server:8899" https://api.ipify.org

Without a password the server refuses to start on any address but 127.0.0.1: that would be an open proxy for anyone who reaches the port (Docker publishes ports past host firewalls like ufw). If a firewall or -p 127.0.0.1:… already keeps others out, say so with --serve-open. The ready-made compose.yaml starts the server in Docker from the live list, with a password, a health check and learned state in a volume: put PROXY_PASSWORD=… into .env, then docker compose up -d.

Rotation strategies, sticky sessions, failover, background refill and the live dashboard: docs/proxy-server.md.

Proxy pool API

Some programs want a proxy address, not a proxy – to hand it to a browser, a worker or a queue. The same port answers plain HTTP requests with one:

curl http://127.0.0.1:8899/get                          # one proxy as JSON, chosen like a connection would becurl "http://127.0.0.1:8899/get?country=DE&https=1&format=txt"   # → http://203.0.113.7:8080curl "http://127.0.0.1:8899/all?protocol=socks5&limit=20"        # the 20 best SOCKS5 proxiescurl "http://127.0.0.1:8899/report?proxy=203.0.113.7:8080&ok=0"  # it failed you – three times and it's out

All endpoints, filters and what's compatible with jhao104/proxy_pool: Proxy pool API.

Discord and Telegram bot

The live list can also come to you: bot/ is a Discord bot that posts every run into a server – a summary with the fastest proxies, the full lists per protocol as files, and slash commands like /proxies type:socks5 country:DE https:true. It sets up its own read-only channels when you invite it, and a GitHub Action deploys it to a server as a systemd service. The same process answers on Telegram too: /proxy de socks5 for one proxy with a curl line, /proxies 10 us https for a short list. Setup in bot/README.md.

Documentation

Everything that used to be further down this README now has its own page – all docs:

Features

What the tool does, check by check and feature by feature: How it works → Features.

Why not just download a list?

A list tells you what worked for its author when it was built. What the tool adds: How it works → Why not just download a list? · how it compares.

How it works

Sources, collecting, prioritizing, the checks, countries and providers, blocklists, learning: docs/how-it-works.md. Your own lists with --source: recipes.

Output

Every run gets its own folder; results/latest.txt always names the newest one – the layout is in docs/options.md.

Recipes

requests, httpx, aiohttp, Scrapy, Selenium, proxychains, Clash / Mihomo, sing-box, PAC, Proxifier, Burp Suite / ZAP / mitmproxy, pipes, a GitHub workflow, Windows: docs/recipes.md.

Options

Every option in one table: docs/options.md. Everything else: proxy-scraper --help

GitHub Actions

The workflows that test, lint, build the hourly list and release: docs/how-it-works.md. To use proxies in your own workflow: the GitHub Action.

FAQ

Who runs free proxies – and should you use them? · almost nothing gets through · Windows · fewer proxies than other lists · logins · how fresh the list is · is it safe: docs/faq.md.

Roadmap

What's next is in the open issues – ideas and wishes are welcome as an issue. During Hacktoberfest there are beginner-friendly issues with pointers on where to start. What shipped in each version: docs/roadmap.md.

Contributing

Bug reports, new sources and pull requests are very welcome – see CONTRIBUTING.md, and docs/ARCHITECTURE.md for how the pieces fit together. The short version:

pip install -e ".[dev]"python3 -m pytest          # runs offline – fake proxies on localhostruff check .python3 docs/make_demo.py  # regenerate the images in this README

The project structure, file by file, is in How it works.

Community

Questions, ideas and things you built with it go to Discussions – bugs to the issues. If this saves you time, a ⭐ helps others find it.

Thanks to everyone who helped build it – new sources, countries, Python 3.14, examples and more:

Want to join? Beginner-friendly issues say where to start.

From the same author: dejabuilt, an agent skill that checks GitHub before you build – it tells you whether a project idea already exists, with the numbers.

Acknowledgements

proxy-scraper stands on the work of the people who publish free proxy lists. Thanks to everyone listed in sources.json, and especially to

• monosans/proxy-scraper-checker and gfpcom/free-proxy-list, whose curated source collections are read as meta sources
• Textualize/rich, which draws the whole terminal UI
• IP Geolocation by DB-IP – the free country database (CC BY 4.0) used for offline country lookups
• httpbin, checkip.amazonaws.com, ifconfig.me, ipinfo.io, wtfismyip.com, ident.me and ip-api.com, used as check targets and for country lookups, and speed.cloudflare.com for the download speed

Legal and acceptable use

proxy-scraper collects proxies that are already listed publicly and checks whether they work. It doesn't scan for open proxies or get into anything: every address comes from one of the public sources.

• The proxies are run by third parties, often without the owner knowing. Use them only for legal purposes, and never for logins, payments or personal data. You are responsible for how you use them: respect the terms of the sites you visit and the laws where you live.
• Your address on the list? Open a removal request or email the address in the Impressum. It goes into removed.txt and is gone from every list, the website and the mirror with the next hourly run.
• Impressum and privacy policy: proxy-scraper.de/legal.html. The website sets no cookies, has no tracking and loads its fonts and scripts from itself.