How to Use a Proxy List: Formats, Rotation, Testing and Safe Sources

How-to guide · Last reviewed 28 September 2026 · 11 min read

A proxy list is a text file of proxy addresses, one per line, that your scraper, bot or browser tool reads and rotates through. Knowing how to use a proxy list well, the formats, how to rotate through it, how to test it and when to replace it, decides whether your project runs smoothly or keeps failing. This guide covers all of that, explains why free public lists are a bad idea, and shows how to generate a clean list from a residential proxy account in a few clicks.

What Is a Proxy List?

It is simply a list of proxy servers, each written as an address and port, often with a username and password. Tools read the list and send requests through its entries in turn, so that traffic is spread across many IP addresses instead of one. That helps avoid per-IP rate limits and lets each account, task or thread keep its own IP.

Lists come from two very different places: public “free proxy” websites that collect open proxies found on the internet, and paid proxy providers that generate lists from their own networks. The first kind is unreliable and risky; the second is what professional tools are built for.

Proxy List Formats

If your tool will not accept a list, check three things: the separator (colon, at-sign or comma), whether it expects a scheme such as http:// or socks5://, and whether special characters in passwords need URL-encoding.

Free vs Paid Proxy Lists

How free lists are put together

Free list sites run scanners that probe the internet for machines answering on common proxy ports, then publish whatever responds. Some entries are servers someone configured carelessly; others are routers or computers infected with malware and turned into proxies without their owners knowing. Because the same entries are published to everyone, websites add them to blocklists quickly, and because nobody maintains them, most disappear within hours. The few that stay online the longest are often the ones run deliberately to watch the traffic passing through.

Never send logins, cookies or business data through proxies from a public list. You do not know who runs them, and an open proxy on someone’s machine may be there without their knowledge.

How to Generate a Proxy List

1. Open the Proxy Manager and go to the connection builder, then pick Residential or Mobile.
2. Choose the country and, under advanced settings, the region, city or ISP.
3. Choose rotation: every request, the same IP (sticky), or a custom interval.
4. In the proxy list panel, set the list length and the output format, for example host:port:user:pass, and copy or download the list.

Each line in a sticky list carries its own session ID in the username, so each line keeps its own IP. A 100-line list therefore gives you 100 parallel sticky sessions, each on a different residential or mobile IP, all through the same gateway.

v2.proxyempire.io:5000:USERNAME-country-us-sid-a1b2c3:PASSWORD
v2.proxyempire.io:5000:USERNAME-country-us-sid-d4e5f6:PASSWORD
v2.proxyempire.io:5000:USERNAME-country-us-sid-g7h8i9:PASSWORD

Prefer to ask an AI assistant? Connect Claude, ChatGPT or Cursor to the ProxyEmpire MCP server and ask for the list, for example “50 sticky US residential proxies for 30 minutes”. It returns the same host:port:user:pass lines, up to 100 per request.

Do You Need a List or a Rotating Gateway?

Older proxy setups required a long list because each proxy was a separate server with one IP. A rotating residential gateway changes that: a single host and port can give you a new IP on every request from a pool of more than 30 million. So:

• Use a single rotating endpoint for scrapers and tools that just need a different IP per request.
• Use a list of sticky sessions when each account, profile or thread needs its own stable IP, or when a tool insists on a list.
• Use a list of static IPs for accounts that must keep the same IP for weeks. See static residential proxies.

The two approaches also combine well. A scraper can send most requests through the rotating endpoint and switch to a sticky entry only for the steps that need continuity, such as logging in to your own test account or paging through search results. That keeps the file short, the configuration simple, and each IP working on exactly the kind of task it suits. It also means fewer lines to maintain: when you only keep sticky entries for the jobs that truly need them, refreshing the file after a network change takes seconds instead of an afternoon.

How to Rotate Through a Proxy List

The simplest strategy is round robin: take the next proxy for each request, and start again at the top. Add two refinements and it becomes robust: skip proxies that just failed, and retry the request on a different proxy.

import itertools, time, requests

def load(path):
    out = []
    for line in open(path, encoding="utf-8"):
        host, port, user, pwd = line.strip().split(":", 3)
        out.append(f"http://{user}:{pwd}@{host}:{port}")
    return out

pool = load("proxies.txt")
cycle = itertools.cycle(pool)
cooldown = {}                                   # proxy -> time it may be used again

def fetch(url, tries=4):
    for _ in range(tries):
        p = next(cycle)
        if cooldown.get(p, 0) > time.time():
            continue
        try:
            r = requests.get(url, proxies={"http": p, "https": p}, timeout=30)
            if r.status_code == 200:
                return r
            if r.status_code in (403, 429):
                cooldown[p] = time.time() + 300  # rest this proxy for 5 minutes
        except requests.RequestException:
            cooldown[p] = time.time() + 60
    return None

Other rotation strategies

• Random choice spreads load evenly without keeping state, but can reuse the same entry twice in a row.
• Weighted by success sends more traffic to entries that keep working and less to those that fail, adapting as conditions change.
• Per-domain assignment gives each target website its own subset of entries, so trouble on one site does not affect the others.
• Sticky per identity ties one entry to one account or browser profile for its whole life. This is the right choice for anything that logs in.

Scrapy, httpx and headless browsers work the same way: pick a proxy per request or per session from your list. Our Python web scraping guide shows each of them.

How to Test a Proxy List

1. Check the exit IP and location of a few entries with our proxy checker or curl -x.
2. Test against your real target, not only an IP-check site. A proxy can work in general and still be blocked by one website.
3. Measure the success rate and response time per proxy, and remove the slowest and the failing ones.
4. Re-test during long jobs. Residential devices go offline; sticky entries that stop responding should be replaced with fresh session IDs.

Keep the results. A simple table of entry, target, status code, response time and date lets you compare a new batch with the last one, spot a location or provider that performs worse, and decide on facts rather than impressions when to regenerate. Success rates vary a lot between websites, so compare each site with itself over time rather than against a generic benchmark.

while IFS=: read -r host port user pass; do
  ip=$(curl -s -m 20 -x "http://$user:$pass@$host:$port" https://api.ipify.org)
  echo "$user -> ${ip:-FAILED}"
done < proxies.txt

Using a Proxy List in Common Tools

• Browser extensions: our free Chrome proxy extension supports bulk import and one-click switching between profiles.
• Multi-profile browsers: assign one sticky or static proxy per profile; see our integrations page.
• OpenBullet 2: import the list into a proxy group; see our OpenBullet proxy guide.
• Android: the free ProxyEmpire Proxy Manager app stores several proxy profiles.
• SEO and scraping tools: most accept host:port:user:pass lists in their proxy settings.

Proxy List Best Practices

• One proxy per identity. Never let two accounts share an entry.
• Match locations to targets. Generate lists in the country of the website you are working with, and in the city too when prices, stock or search results change by location.
• Keep credentials out of code. Store the list in a file or secret store, not in your repository, and load it at runtime so a password change never needs a code change.
• Refresh sticky lists when entries start failing, rather than retrying dead sessions.
• Document what each file is for. Name files by country, product and rotation, for example us-resi-sticky-100.txt, and note the date you generated them, so nobody loads the wrong set into a job.
• Respect sites. Spread load, keep concurrency per site reasonable, and collect only public data. ProxyEmpire blocks banking, payment and government sites by default.

Treat the file like a password

Every line contains working credentials for your account. Anyone who gets the file can spend your bandwidth. Keep it out of shared folders and code repositories, give each team member or tool its own sub-user where your provider supports it, and rotate the password if the file leaks. ProxyEmpire lets you create sub-users with their own credentials and bandwidth limits, which makes it easy to see who used what and to cut off access for one tool without touching the others.

If entries return errors, our proxy error codes guide explains what each one means.

Proxy List FAQ

References

1. Requests: Advanced usageProxies in Python requests
2. curl manualThe -x / –proxy option
3. RFC 3986: URI Generic SyntaxUser information and percent-encoding in proxy URLs