Free Proxy Checker: Test up to 100 HTTP, HTTPS and SOCKS5 Proxies

What the script prints (documentation IPs and ASNs; your figures will differ):

proxy	protocol	status	exit IP or error	country	network	anonymity	response	throughput
198.51.100.20:8080	http	working	203.0.113.45	US	AS64500 Example ISP	elite	612 ms	410 KB/s
http://198.51.100.21:3128	http	working	203.0.113.46	DE	AS64501 Example Hosting	anonymous	388 ms	1150 KB/s
http://198.51.100.22:8080	http	working	203.0.113.47	GB	AS64502 Example Mobile	transparent	240 ms	2050 KB/s
198.51.100.24:1080	socks5h	working	203.0.113.48	FR	AS64503 Example ISP	elite	705 ms	380 KB/s
http://user:[email protected]:8080	http	failed	auth failed (407)	-	-	-	-	-
198.51.100.25:8080	-	failed	timeout	-	-	-	-	-

Put one proxy per line in proxies.txt: host:port or user:pass@host:port (the script tries HTTP, then SOCKS5, then SOCKS4), or a URL with its scheme (http://, https://, socks5h://, socks4://). Run pip install "requests[socks]", then python check.py.

import concurrent.futures as cf, re, sys, time, requests

JUDGE = "http://azenv.net/"   # a public proxy judge; plain HTTP on purpose (over HTTPS a proxy cannot add headers)
SPEED = "https://speed.cloudflare.com/__down?bytes=100000"  # a fixed 100 KB download for throughput; None skips it
GEO = "https://ipinfo.io/{}/json"  # country and network (ASN) of the exit IP, looked up without the proxy; None skips it
PROXY_HEADERS = ("HTTP_VIA", "HTTP_X_FORWARDED_FOR", "HTTP_FORWARDED", "HTTP_X_REAL_IP", "HTTP_CLIENT_IP", "HTTP_PROXY_CONNECTION")
TIMEOUT = 15
REAL_IP = requests.get("https://api.ipify.org", timeout=TIMEOUT).text.strip()  # your own IP, fetched without a proxy

def reason(e):
    msg = str(e).lower()
    return ("timeout" if isinstance(e, requests.Timeout) or "timed out" in msg else
            "auth failed (407)" if "407" in msg else
            "connection refused" if "refused" in msg else
            "TLS error (wrong protocol?)" if "ssl" in msg else type(e).__name__)

def check(line):  # host:port or user:pass@host:port (tried as HTTP, SOCKS5, SOCKS4), or a URL with its scheme
    tries = [line] if "://" in line else [s + line for s in ("http://", "socks5h://", "socks4://")]
    fail = "-", "-", "-", "-", "-"
    for proxy in tries:
        proto = proxy.split("://")[0]
        px = {"http": proxy, "https": proxy}
        try:
            start = time.monotonic()
            r = requests.get(JUDGE, proxies=px, timeout=TIMEOUT)
            ms = round((time.monotonic() - start) * 1000)
        except Exception as e:
            err = reason(e)
            if err in ("timeout", "connection refused", "auth failed (407)"):
                break              # the port is dead or rejects you, whatever the protocol
            continue               # wrong protocol: try the next one
        if r.status_code == 407:
            return line, proto, "failed", "auth failed (407)", *fail
        env = dict(re.findall(r"^(\w+) = (.*?)\s*$", r.text, re.M))
        if "REMOTE_ADDR" not in env:
            return line, proto, "failed", f"bad response ({r.status_code})", *fail
        exit_ip = env["REMOTE_ADDR"]
        others = " ".join(v for k, v in env.items() if k != "REMOTE_ADDR")
        if exit_ip == REAL_IP or REAL_IP in others:
            level = "transparent"          # the site can see your real IP
        elif any(h in env for h in PROXY_HEADERS):
            level = "anonymous"            # proxy headers, but not your IP
        else:
            level = "elite"                # no proxy headers at all
        country = network = speed = "-"
        try:
            if GEO:
                info = requests.get(GEO.format(exit_ip), timeout=TIMEOUT).json()
                country, network = info.get("country", "-"), info.get("org", "-")
        except Exception:
            pass
        try:
            start = time.monotonic()
            if SPEED:
                size = len(requests.get(SPEED, proxies=px, timeout=TIMEOUT * 2).content)
                speed = f"{round(size / 1024 / (time.monotonic() - start))} KB/s"
        except Exception:
            pass
        return line, proto, "working", exit_ip, country, network, level, f"{ms} ms", speed
    return line, "-", "failed", err, *fail

lines = [l.strip() for l in open(sys.argv[1] if len(sys.argv) > 1 else "proxies.txt") if l.strip()]
print("proxy", "protocol", "status", "exit IP or error", "country", "network", "anonymity", "response", "throughput", sep="\t")
with cf.ThreadPoolExecutor(max_workers=50) as ex:
    for row in ex.map(check, lines):
        print(*row, sep="\t")

We ran this script on 2026-10-25 (Python 3, requests 2.34, PySocks 1.7) against local test proxies: HTTP proxies that add no headers, add Via, or pass the client IP in X-Forwarded-For, one that answers 407, and a SOCKS5 proxy given as a bare host:port. It graded the first three elite, anonymous and transparent, detected the SOCKS5 proxy as socks5h, and reported the 407 proxy, a closed port, an unreachable host and an https:// URL to a plain HTTP proxy as auth failed (407), connection refused, timeout and TLS error. The judge is azenv.net, a public page that echoes the headers it receives; it showed Via and X-Forwarded-For on that day. Some header-echo services hide those headers (httpbin.org's /headers does), which would grade every proxy elite. The throughput file is Cloudflare's public speed-test download, and the country and network come from ipinfo.io, which limits lookups without a token; set GEO = None to skip them.

What a failure means

How to read speed

• Response time covers the connection and one small request to the judge. ProxyField residential proxies have under 1 s typical response and mobile under 1.5 s, with an average response of about 400 ms, according to our service data.
• Throughput is 100 KB divided by the download time. A proxy with a fast response but a low KB/s is busy or far from you.
• Distance counts: a proxy far from your machine, or from the judge, shows higher numbers. Residential and mobile IPs are slower than datacenter IPs, because traffic runs through home and carrier connections.
• One run is a sample. Run the list twice a few minutes apart; large swings point to a busy proxy. For a decision, use the 50-request test on your own target below.
• Traffic: each working proxy uses about 100 KB for the throughput test, so 100 proxies use about 10 MB of their own traffic, about 3 cents at $2.95/GB. Set SPEED = None to skip it.

A proxy's anonymity level is what it adds to your requests. To see it by hand, send a plain-HTTP request through the proxy to the judge and read the lines it echoes back:

curl -s -x http://HOST:PORT -U "<login>:<password>" http://azenv.net/

Use plain HTTP: over HTTPS the proxy only tunnels the encrypted connection and cannot add headers, so every proxy looks elite. A SOCKS5 proxy relays bytes and adds no HTTP headers either. The levels in detail: What is an elite proxy? and transparent proxies.

Five checks, in order; the first three take a minute:

1. Paste the proxy into the checker and start the check. Read the result: Working, the exit IP and the country.

2. Confirm the exit IP is not yours. Open an IP lookup without the proxy and compare: if the two match, your traffic is not going through the proxy.

3. Cross-check the country in a second IP database. MaxMind estimates its country answers at 99.8% accuracy, but US city answers at about 66% within 50 km, so a matching country is the pass and the city is approximate. A pass looks like this (documentation IP and ASN):

   ShellCopy Shell code

   curl https://ipinfo.io/EXIT_IP/json
   {
     "ip": "203.0.113.45",
     "city": "New York",
     "region": "New York",
     "country": "US",
     "org": "AS64500 Example ISP",
     "timezone": "America/New_York"
   }

   country is the two-letter code you asked for; org names the network: a home ISP, a mobile carrier or a hosting company.

4. Run a DNS and a WebRTC leak test in the browser you use, with the proxy on: ProxyField's DNS leak test and WebRTC leak test. A pass means your own ISP's DNS servers and your real IP do not appear.

5. Test the site you care about. Some sites use their own location data, cookies, language or time zone, so the right country in a lookup does not guarantee that every site places you there.

When a check fails:

On ProxyField, the country comes from the username; this request should show a New York exit IP:

curl -x gate.proxyfield.io:7000 -U "<login>-country-us-city-new_york:<password>" https://api.ipify.org

Proxy checker results differ because each checker tests from its own server, with its own IP database, its own definition of a proxy and its own timeout. Country answers are the stable part: MaxMind estimates its country accuracy at 99.8%, against about 66% for US cities within 50 km. The same proxy can pass on one checker and fail, or show another country, on the next. There are 7 usual causes:

1. Different test servers. Each checker connects from its own location, so the route, the response time and even the result differ. Fix: compare response times from one checker only.
2. Different geolocation databases. Each checker looks the exit IP up in its own database, updated at its own pace. MaxMind, a geolocation provider, estimates its own accuracy at 99.8% by country, about 80% by US state and about 66% by US city within 50 km, returns an accuracy radius with each answer (100 km in its own example), and says it does not guarantee matches with other providers, which may use different data sources (MaxMind: geolocation accuracy). Some IPs are missing from its databases altogether, often because of privacy opt-out requests, so one checker can show no country while another shows one. IPs in mobile networks may be used by phones across a large distance, so a mobile proxy's city is often coarse. Fix: trust the country; treat the city as approximate, more so for mobile IPs.
3. Different definitions of "proxy". Some checkers flag only known public proxies; others also flag VPNs, hosting ranges or residential proxy IPs (MaxMind: anonymizer and proxy data). Fix: read what each checker means by its label.
4. Rotation. A rotating proxy changes its exit IP between checks, so two checkers test two different IPs. Fix: use a sticky session, or compare the exit IP each one shows.
5. Different paths. Your browser, an app and a script may not all use the proxy, and DNS can go around it. Fix: test from the same tool; with SOCKS5 in scripts, use socks5h:// so DNS goes through the proxy.
6. Timeouts and blocks. A checker with a short timeout fails a slow proxy that another passes, and a site can block a proxy that works elsewhere. For connection errors, see proxy errors and fixes.
7. Headers and CDNs. A checker that reads the connection's IP and one that reads headers can report different IPs for the same request. Cloudflare, for example, passes the connecting IP to a site in CF-Connecting-IP and appends it to any X-Forwarded-For a proxy already sent (Cloudflare: HTTP headers), so through an anonymous or transparent proxy the two can differ. Fix: grade the proxy with the judge script above, which shows both.

A worked diagnosis with two commands: send the same request through the proxy twice and note the exit IP, then look that IP up in two databases and compare the country.

curl -s -x http://HOST:PORT -U "<login>:<password>" https://api.ipify.org; echo
curl -s https://ipinfo.io/EXIT_IP/json

If the exit IP changed between the two runs, the proxy rotates; if the IP is the same and the countries differ, the databases disagree.

The checker shows each working proxy's network (ASN) and IP type: Residential for a home ISP, Mobile for a mobile carrier, Datacenter for a hosting company; in the script, the org field names the network. Blacklist status is a separate reputation lookup. ProxyField sells residential proxies from $1.95/GB, mobile proxies, datacenter proxies and static residential (ISP) proxies.

Speed and success depend on the target, so test on the site you will use: send 50–100 requests through the proxy and count the share of 2xx responses and the median and slowest response times. Replace https://example.com with your target:

for i in $(seq 50); do curl -s -o /dev/null -w "%{http_code} %{time_total}\n" -x gate.proxyfield.io:7000 -U "<login>-country-us-city-new_york:<password>" https://example.com; done

For Google, test on the search pages you need and treat 429 responses and CAPTCHA pages as failures. Run the same test on ProxyField proxies. The pool is clean for Google, checked and segmented. If you need Google results rather than proxies, the Google SERP API returns them as JSON for $1.20 per 1,000 successful results, from $0.80 at volume; contact sales. More: proxies for SEO.

Send several requests through the same gateway and compare the exit IPs: with per-request rotation they change, and with a sticky session they stay the same for the session length (30 s to 36 h on ProxyField).

for i in 1 2 3 4 5; do curl -s -x gate.proxyfield.io:7000 -U "<login>-country-us-city-new_york:<password>" https://api.ipify.org; echo; done

Sticky-session username: -region-<region>, -session-<id> and -ttl-<seconds> (30 to 129,600 seconds, 20 minutes by default) after the location, as in <login>-country-us-region-new_york-city-new_york-session-he9f2qga-ttl-600. See rotating proxies. The loop uses api.ipify.org, a public IP-echo service.

Use this loop, not the gateway pasted 5 times: the checker removes duplicate lines.

The proxy your device uses is in your system or browser proxy settings (how to find your proxy server address); the IP websites see is shown by an IP lookup.

A proxy detection test checks whether an IP or a connection looks like a proxy. This checker does not run one: it shows that a proxy works, not whether a site will flag it. Detection tools usually look at:

• The IP: its ASN (hosting company, home ISP or mobile carrier), known proxy and VPN lists, and a reputation or fraud score.
• Proxy headers: Via or X-Forwarded-For (the anonymity test above).
• Leaks: DNS or WebRTC showing your real IP (DNS leak test, WebRTC leak test).
• Mismatches: a browser time zone or language that does not fit the exit IP's country.

To see what a site can tell about your own connection, with the proxy on, run ProxyField's IP checker, which runs 10 proxy and VPN checks, and the browser leaks test, which runs 40 checks on the browser itself. Test each of these, then count 403, 429 and CAPTCHA responses on your own target. No proxy can promise that sites never detect it. Residential and mobile IPs are registered to home ISPs and mobile carriers, so an ASN lookup shows an ISP or a carrier, but a site can still flag an IP by its reputation or by how it is used.

Telegram SOCKS5 proxies can be checked here (paste them with socks5://); MTProto proxies cannot, because the checker speaks HTTP, HTTPS and SOCKS5 only.

Proxy lists, usernames, passwords and results are not saved. They remain on the page until you close or clear it.

You can check ProxyField proxies or other proxies you are authorized to use. Each check uses a small amount of your proxy traffic: the proxy's own traffic, not a fee. Public proxy lists carry their own risks: are free proxies safe?