US Free Proxy List 2026: How to Find, Test, and Use American Proxies

US proxies are the most requested proxy type by a wide margin. The reasons are straightforward: the US has the largest e-commerce market, the most active digital advertising ecosystem, and most major platforms - Amazon, Google, Netflix, Hulu, major news sites, streaming services - serve their primary content to US IPs. If you're scraping US pricing data, verifying US ad campaigns, or accessing US-only content, you need a US IP.
The free proxy market for US IPs reflects this demand. There are more US IPs in free proxy lists than any other country - and more burned, blocked, and abused US IPs too. Here's how to find what actually works, how to test it efficiently, and when the free route stops making sense.

Where Free US Proxy Lists Come From

Free US proxies in public lists come from a few sources: open proxy servers accidentally or intentionally exposed to the internet, volunteer-run proxy networks, and scraped lists of proxies that were briefly functional before being flagged. The supply is larger than any other country, but so is the demand - which means US IPs in free lists burn faster than regional IPs.
The best sources for US-specific free proxies in 2026:
free-proxy-list.net - filter by country "US." The largest single source of US IPs in free lists, updated frequently. In practice, alive rate runs 20–30% at any given time.
ProxyScrape API - pull US IPs directly: https://api.proxyscrape.com/v2/?request=getproxies&country=us&protocol=http. Returns a plain text list, easy to feed into a testing script.
Spys.one - filter by United States, shows latency and last check timestamp per IP. One of the better sources for identifying recently verified IPs before testing.
HideMyName.com - country filter for US, with anonymity level and protocol visible. Good for finding "elite" anonymity US IPs specifically.
NodeMaven US free proxy list - maintains a country-filtered list of US HTTP and SOCKS5 proxies updated regularly. Same free-proxy caveats apply, but it saves the step of filtering a global list down to US IPs manually.
GitHub aggregators - search "US proxy list" on GitHub sorted by recently updated. Several repos scrape from multiple sources and commit fresh lists hourly or daily.
The Reality of Free US Proxy Quality
US IPs are the most burned proxy category in any free list. High demand means high abuse rates, which means high block rates. Based on testing 200 free proxies from mixed sources (roughly 80 were US IPs):
Alive rate on US IPs: ~21% (vs ~23% overall)
Average TTFB on alive US IPs: 3.4 seconds
Success rate on Amazon.com (product pages): ~34%
Success rate on Google.com (search): ~9%
Transparent proxies (exposing real IP): ~35%
The Amazon and Google numbers tell the most important story. US e-commerce and US search - two of the primary reasons people want US proxies - have success rates under 35% and 10% respectively on free proxy infrastructure. The IPs are in known datacenter ranges that Amazon and Google flag immediately.
Python Script: Bulk Testing a US Proxy List
For a developer workflow, testing a list of proxies before using them is the difference between a script that runs and one that fails on every request. Here's a complete bulk tester that checks connectivity, anonymity level, and target-specific success:
import requests
import time
import csv
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class ProxyTestResult:
proxy: str
alive: bool = False
ttfb_ms: Optional[float] = None
anonymity: str = "unknown" transparent / anonymous / elite
amazon_ok: bool = False
google_ok: bool = False
error: Optional[str] = None

HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/125.0.0.0 Safari/537.36"
),
"Accept-Language": "en-US,en;q=0.9",
}

def check_anonymity(proxy: str, your_real_ip: str, timeout: int) -> str:
"""Check if proxy leaks real IP via X-Forwarded-For."""
try:
proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
r = requests.get(
"https://httpbin.org/headers",
proxies=proxies,
timeout=timeout
)
headers = r.json().get("headers", {})
forwarded = headers.get("X-Forwarded-For", "")
if your_real_ip in forwarded:
return "transparent"
elif forwarded:
return "anonymous"
else:
return "elite"
except:
return "unknown"

def test_proxy(proxy: str, your_real_ip: str, timeout: int = 10) -> ProxyTestResult:
result = ProxyTestResult(proxy=proxy)
proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}

Step 1: Basic connectivity + TTFB
try:
start = time.perf_counter()
r = requests.get(
"https://httpbin.org/status/200",
proxies=proxies,
headers=HEADERS,
timeout=timeout
)
if r.status_code == 200:
result.alive = True
result.ttfb_ms = round((time.perf_counter() - start) * 1000, 1)
else:
return result
except Exception as e:
result.error = str(e)[:60]
return result

Step 2: Anonymity check
result.anonymity = check_anonymity(proxy, your_real_ip, timeout)
if result.anonymity == "transparent":
return result Skip further tests - IP leaks real address

Step 3: Amazon product page
try:
r2 = requests.get(
"https://www.amazon.com/dp/B08N5WRWNW",
proxies=proxies,
headers=HEADERS,
timeout=timeout
)
result.amazon_ok = r2.status_code == 200 and "Add to Cart" in r2.text
except:
result.amazon_ok = False

Step 4: Google search
try:
r3 = requests.get(
"https://www.google.com/search?q=proxy+test",
proxies=proxies,
headers=HEADERS,
timeout=timeout
)
result.google_ok = r3.status_code == 200 and "

" in r3.text except: result.google_ok = False <div class="highlight"><pre class="highlight plaintext"><code>return result </code></pre></div> def bulk_test(proxy_list: list[str], your_real_ip: str, workers: int = 25) -> list[ProxyTestResult]: results = [] with ThreadPoolExecutor(max_workers=workers) as executor: futures = { executor.submit(test_proxy, p, your_real_ip): p for p in proxy_list } for i, future in enumerate(as_completed(futures), 1): result = future.result() results.append(result) if i % 20 == 0: alive = sum(1 for r in results if r.alive) print(f"Progress: {i}/{len(proxy_list)} tested, {alive} alive") return results def save_results(results: list[ProxyTestResult], filename: str = "proxy_results.csv"): with open(filename, "w", newline="") as f: writer = csv.DictWriter(f, fieldnames=[ "proxy", "alive", "ttfb_ms", "anonymity", "amazon_ok", "google_ok", "error" ]) writer.writeheader() for r in results: writer.writerow({ "proxy": r.proxy, "alive": r.alive, "ttfb_ms": r.ttfb_ms, "anonymity": r.anonymity, "amazon_ok": r.amazon_ok, "google_ok": r.google_ok, "error": r.error }) print(f"Results saved to {filename}") --- Run --- Get your real IP first (to detect transparent proxies) YOUR_IP = requests.get("<a href="https://httpbin.org/ip%22).json()%5B%22origin%22%5D">https://httpbin.org/ip").json()["origin"]</a> Load your US proxy list (one per line: ip:port) with open("us_proxies.txt") as f: proxy_list = [line.strip() for line in f if line.strip()] print(f"Testing {len(proxy_list)} proxies...") results = bulk_test(proxy_list, YOUR_IP) Summary alive = [r for r in results if r.alive] elite = [r for r in alive if r.anonymity == "elite"] amazon_working = [r for r in elite if r.amazon_ok] google_working = [r for r in elite if r.google_ok] print(f"\nResults:") print(f" Alive: {len(alive)}/{len(proxy_list)} ({len(alive)/len(proxy_list)*100:.1f}%)") print(f" Elite anonymity: {len(elite)}/{len(alive)}") print(f" Works on Amazon: {len(amazon_working)}") print(f" Works on Google: {len(google_working)}") save_results(results) <h2> <a name="a-few-design-notes-on-this-implementation" href="#a-few-design-notes-on-this-implementation" class="anchor"> </a> A few design notes on this implementation: </h2> Your real IP detection first. The script fetches your real IP before running tests. This is necessary for the transparency check - if the proxy passes your real IP in X-Forwarded-For, you want to catch that before using the proxy for anything sensitive. Transparency filter. Transparent proxies are skipped after the anonymity check. There's no point testing them on real targets - they expose your real IP to the target, which defeats the purpose. Concurrent testing. 25 workers is a reasonable default. Going higher speeds up the test but can cause false timeouts if your local network can't sustain that many simultaneous connections. Adjust based on your bandwidth. CSV output. The results file lets you sort by TTFB, filter by Amazon or Google success, and build a "clean" list from whatever passes your criteria - without rerunning the full test. Interpreting the Output: What's Actually Usable After running the test, filter for proxies where: alive = True anonymity = elite ttfb_ms < 5000 (under 5 seconds TTFB) That subset is your working pool. For general US geo-checks and accessing US content without heavy bot detection, this list works. For Amazon, Google, or any platform with IP reputation checks, apply the additional filters (amazon_ok = True or google_ok = True) - and expect that subset to be small. From testing 80 US free proxies, the pipeline typically produces: ~17 alive → ~11 elite anonymity → ~4 passing Amazon → ~1 passing Google. Those final numbers represent what you can actually use for serious US scraping targets. US vs UK Free Proxy Availability If you're running operations across both markets, the US and UK free proxy pools behave differently in ways worth knowing. US IPs are far more abundant in free lists but burn faster due to higher abuse rates. UK IPs are scarcer but sometimes have lower block rates on non-streaming targets simply because fewer bots target UK infrastructure. For UK-specific workflows alongside your US operations, the <a href="https://nodemaven.com/free-proxy-list/united-kingdom/">NodeMaven UK free proxy list</a> gives you a country-filtered starting point without sorting through global lists. The same testing script above works for UK proxies - just swap the target URLs for UK-specific endpoints. <h2> <a name="when-free-us-proxies-stop-making-sense" href="#when-free-us-proxies-stop-making-sense" class="anchor"> </a> When Free US Proxies Stop Making Sense </h2> The testing script above gives you a concrete answer: when your working pool (elite anonymity + target success) is too small for your workflow's needs, or when you're spending more time maintaining the pool than running actual operations. For US operations that require consistent residential IPs - ad verification, Amazon seller monitoring, multi-account management on US platforms - free proxies aren't the infrastructure layer that makes this work. The IPs are datacenter-flagged, the pool exhausts quickly, and the engineering overhead of constant pool refresh isn't worth it. For that use case, <a href="https://nodemaven.com/locations/us-proxy/">US proxy</a> residential access through NodeMaven covers major US cities - New York, Los Angeles, Chicago, Houston, Phoenix - with ISP-level targeting (Comcast, AT&T, Verizon, Spectrum) and a 95%+ clean rate. The $3.50 trial at 750 MB is a practical comparison point: run your actual workflow against both the free pool and the trial pool, and the success rate difference on a real target makes the value proposition concrete. The free proxy route is worth running through once with the testing script - it gives you real data on what's available and what passes your specific targets. After that, the numbers tell you whether free infrastructure covers your use case or whether the paid tier is the right starting point.