100% free forever. No signup, no payments. Public proxies are unstable by nature: always test before you trust one.

ProxyNest API Guide: Pull Live Proxies Into Your App

If you still copy proxies from a web page and paste them into your script by hand, you are doing the most boring part of the job for no reason. ProxyNest has a free API. One request returns live, tested proxies as JSON, no key, no signup, no form. Here is every endpoint, the filters that matter, and a complete rotation script you can run today.

A central API hub feeding live proxy data to connected apps and servers | ProxyNest Blog

The problem: hand-copied proxies go stale in hours

You open the proxy list, copy twenty rows into a config file, and wire them into your scraper. Monday it works. By Wednesday half of them are dead, and your script spends more time timing out than scraping. Free proxies die fast, so a list you copied once is a snapshot, not a supply line.

The API fixes that. Your script asks for fresh proxies every time it runs. When I checked the live stats while writing this, the database held 109,415 proxy rows, 70,703 of them tested, and only 4,402 alive. Only about 4 in every 100 rows were alive at that moment. A file you saved last week is mostly a cemetery. A live API call is not. If you only need a one-off file, our guide on exporting proxies into your script covers that route, and how ProxyNest tests every proxy explains where the numbers come from.

Step 1: your first API call in 30 seconds

No signup, no key to paste anywhere. The base URL is https://proxynest.live, and every endpoint is a plain GET request. Try this in your terminal:

curl "https://proxynest.live/api/proxies?protocol=socks5&country=US&limit=3&sort=latency"

You get back JSON shaped like this (trimmed to one proxy):

{
  "status": "success",
  "page": 1,
  "limit": 3,
  "total": 24,
  "totalPages": 8,
  "proxies": [
    {
      "ip": "198.199.86.11",
      "port": 1080,
      "protocol": "socks5",
      "countryCode": "US",
      "country": "United States",
      "anonymity": null,
      "latencyMs": 599.1,
      "uptimePct": null,
      "score": null,
      "tested": 1
    }
  ]
}

That is a real response. I ran that exact call this morning: 24 US SOCKS5 proxies alive, the fastest at 599.1 ms. total tells you how many match, totalPages how many pages exist. The full reference lives on the API docs page.

Prefer watching? This short explainer walks through setting up a proxy and sending your first request through it.

Step 2: filter the list

The full list is huge, so the filters are where the API earns its keep:

  • protocol: http, socks4, socks5, or all. Pick the one your app speaks. Our HTTP vs SOCKS5 guide settles that choice.
  • country: a two-letter code like US or DE. Grab the code from the locations page.
  • limit: 1 to 200 per page, default 50. Ask for what you need, not the maximum.
  • page: page number, default 1.
  • sort: latency, score, port, or ip, with order=asc or desc.
  • search: match against an IP or a port.

Worked example. My scraper needed US SOCKS5 proxies, fastest first, ten of them:

curl "https://proxynest.live/api/proxies?protocol=socks5&country=US&limit=10&sort=latency"

That returned 24 matches: 198.199.86.11 on port 1080 at 599.1 ms on top, 68.71.243.14 on port 4145 at 764.5 ms second. Those numbers were true when I ran the call. Fetch fresh instead of hardcoding them.

Structured JSON data flowing as connected nodes between two servers | ProxyNest Blog

Step 3: read the response fields

Every proxy object carries the same fields:

  • ip, port, protocol: the address your script connects to, like http://ip:port.
  • countryCode, country: where the proxy exits.
  • anonymity: elite, anonymous, transparent, or null. Our elite vs anonymous vs transparent guide explains the difference.
  • latencyMs: connect time in milliseconds. Lower is faster.
  • uptimePct, score: reliability numbers, when we have them.
  • tested: 1 means the proxy matched a real speed-test record. When it is 0, latencyMs, uptimePct, and score come back null. A null latency is not a fast proxy, it is an unmeasured one.

My blunt opinion: filter on tested=1 and drop anything with a null latency before you try it. There is no reason to gamble a request on an unmeasured row.

Step 4: build the rotation loop in Python

This is the script I run when I need a working pool: fetch fresh proxies, try one, drop it on failure, move to the next, refresh when it runs low. Copy it, change the filters, run it.

import random
import requests

API = "https://proxynest.live/api/proxies"

def fresh_pool(protocol="socks5", country="US", limit=50):
    r = requests.get(API, params={
        "protocol": protocol,
        "country": country,
        "limit": limit,
        "sort": "latency",
    }, timeout=15)
    r.raise_for_status()
    proxies = r.json()["proxies"]
    # Keep only proxies with a real measured latency.
    return [p for p in proxies if p.get("tested") == 1
            and p.get("latencyMs") is not None]

def fetch_through(pool, url, tries=5):
    for _ in range(tries):
        p = random.choice(pool)
        scheme = "socks5h" if p["protocol"] == "socks5" else "http"
        proxy_url = f"{scheme}://{p['ip']}:{p['port']}"
        proxies = {"http": proxy_url, "https": proxy_url}
        try:
            r = requests.get(url, proxies=proxies, timeout=10)
            r.raise_for_status()
            return r.text
        except requests.RequestException:
            pool.remove(p)  # Dead proxy: drop it and try the next one.
    raise RuntimeError("Pool ran out of working proxies, refresh it.")

pool = fresh_pool()
print(fetch_through(pool, "https://httpbin.org/ip")[:200])

Three details save you real debugging time. First, socks5h:// instead of socks5:// routes DNS through the proxy too, so your ISP's resolver never sees your target domains. Second, SOCKS support needs the requests[socks] extra installed. Third, every request has a timeout, or one dead proxy hangs your job forever. The requests documentation covers the proxies dict in detail.

Not a Python shop? The same call in Node.js is four lines:

const res = await fetch(
  "https://proxynest.live/api/proxies?protocol=http&limit=20");
const data = await res.json();
const pool = data.proxies.filter(p => p.tested === 1);
console.log(pool.map(p => `http://${p.ip}:${p.port}`).join("\n"));

The API sends Access-Control-Allow-Origin: *, so a browser fetch works. Still, keep rotation server-side: a page that hands raw proxy addresses to every visitor burns through your rate limit for you.

Proxy nodes rotating around a central ring, suggesting a refreshed live pool | ProxyNest Blog

Step 5: the other endpoints

/api/proxies does the heavy lifting, but five more endpoints cover the rest:

  • GET /api/stats: totals, per-protocol counts, and when the list was generated.
  • GET /api/countries: every country in the list, ordered by proxy count.
  • GET /api/mtproto: MTProto proxies for Telegram, with ready-to-use t.me links. The Telegram proxies page shows the same list in the browser.
  • GET /api/verify?target=ip:port: a live check of one proxy. Use it for single proxies, not bulk scanning. The Proxy Checker tool does the same thing in the browser.
  • GET /api/export?format=txt: the full filtered list as a file, in txt, csv, or json.

Rate limits and errors

The only rule is a fair-use limit: 60 requests per minute per IP. Go past it and you get HTTP 429 with a Retry-After: 60 header. Responses also carry Cache-Control: public, max-age=60. Cache the pool for a minute and rotate inside it instead of calling the API for every request.

200 means success, 400 a bad parameter like a limit over 200, 404 an unknown endpoint, 429 the rate limit (wait 60 seconds), and 500 a server error, which is not your code.

My blunt take: if you are hitting the rate limit, your design is wrong, not the API. Fetch once, rotate locally, refresh when the pool runs low. It stays under the limit and skips a round trip per request.

Three mistakes that waste an afternoon

  • Pulling the full list for every request. You hit 429 within a minute. Fetch once, rotate locally, refresh on a timer.
  • Trusting unmeasured proxies. A row with tested=0 and null latency is unknown, not fast. Filter those out first.
  • No timeout, no retry. One dead proxy with no timeout freezes your whole job. Always set a timeout, catch the failure, and move on. When a proxy passes but crawls, our guide on why your proxy is slow walks through the diagnosis.

Go plug it in

That is the whole API: one list endpoint, four filters that matter, a rotation loop, and a rate limit you can stay under by caching. No key, no signup, no bill. Pick your filters, paste the script, and let your app fetch its own proxies from now on.

About the author

Muhammad Imran runs ProxyNest, a free public proxy directory. He writes plain-English guides about proxies, privacy, and staying safe online.

Comments

Loading comments…

Leave a comment

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.