# HProxy Free Proxy API
> The free, no-key proxy list API. Source: https://hproxy.com/docs

## Free proxy list API

*GET /api/proxy-list returns every working free proxy we have, currently about 3,000, as txt, JSON or CSV. No key, CORS enabled, filterable by country, protocol, anonymity, network (ASN), port and /24 subnet.*

URL: https://hproxy.com/docs/free-proxy-list

#### GET /api/proxy-list (no key)

**The whole live list in one call.** One GET returns **every working proxy we have**, as `txt`, `json` or `csv`. Not a sample and not a teaser: HTTP, HTTPS, SOCKS4 and SOCKS5, all of it, in a single call. No key, no signup. CORS is enabled, so you can call it straight from a browser. Fair-use rate limit of about 120 requests per minute per IP, with bursts up to 120 (a clean `429` with `Retry-After` beyond that). This is the same data behind the [free proxy list](https://hproxy.com/free-proxy-list).

**How many is that?** Well over **10,000** at any moment, because that is how many public proxies on Earth are actually answering right now. It moves every few minutes as proxies die and new ones are found, so treat any number written here as a rough order of magnitude and never as the truth. `X-Total-Available` on the response is the exact count matching your filter, and `X-Total-Count` is how many came back in this particular response. If the two are equal you already have everything and there is no next page.

**Why you will see 10,000 mentioned below.** That is the most rows a single response will carry *when you ask for a specific number*. It is a page size, not a cap on what you are allowed to have. **Omit `limit` entirely and you get the complete matching set in one response**, however large it is. The page size only comes into play when you pass `limit` yourself, or on a set big enough that we page it for you (`recent=true`).

| Field | Type | Description |
| --- | --- | --- |
| `format` | `txt | json | csv` | Response shape. Default txt (one ip:port per line). |
| `protocol` | `http | https | socks4 | socks5` | Filter by protocol. Comma-separated allowed (e.g. http,https), which matches a proxy supporting ANY of them. |
| `country` | `ISO-3166 alpha-2` | Filter by country, e.g. US, DE, GB. |
| `anonymity` | `elite | anonymous | transparent` | Filter by anonymity grade. Proxies we have not been able to grade yet are excluded. |
| `asn` | `number` | Filter by autonomous system, e.g. 14061 for DigitalOcean. Same data as the per-network pages on the free list. |
| `port` | `1 - 65535` | Only proxies answering on this exact port, e.g. 8080 or 1080. |
| `subnet` | `a.b.c (first three octets)` | Only proxies inside one /24 block, e.g. subnet=45.61.188 for 45.61.188.0/24. Open proxies cluster in blocks, so this finds a machine's neighbours. |
| `min_uptime_pct` | `0 - 100` | Only proxies whose lifetime uptime is at least this. The single most useful filter if you want proxies that stay up. |
| `max_latency_ms` | `1 - 120000` | Only proxies at or below this latency, in milliseconds. |
| `sort` | `uptime` | Order the whole pool by reliability before paging, so page 1 is the best proxies overall. Omit for the default order (alive first, then fastest). |
| `limit` | `1 - 10000` | Rows in THIS response, not a limit on your total. Leave it out and you receive the complete matching set in one call, which is what most callers want. Pass a number and this response stops at that many rows (10000 is the ceiling for one response); use offset to walk the rest. Whatever you do, X-Total-Available still reports how many exist. |
| `offset` | `0+` | Skip this many rows. Needed only when you passed an explicit limit, or on a set too large for one response. Default 0. |
| `recent` | `true | false` | Also include proxies that have gone quiet but answered within the last 48h, taking the set from the live-now pool to several times its size. This WIDENS the list, it does not freshen it: the extra rows come back with status recently_alive and many are not answering right now. Leave it off for the strictly alive-now pool. |

**cURL**

```bash
curl "https://hproxy.com/api/proxy-list?format=json&country=US&protocol=socks5"
```

**Python**

```python
import requests

# The most reliable proxies first: at least 70% lifetime uptime,
# under a second, ordered by reliability across the whole pool.
r = requests.get("https://hproxy.com/api/proxy-list", params={
    "format": "json",
    "protocol": "http,socks5",
    "min_uptime_pct": 70,
    "max_latency_ms": 1000,
    "sort": "uptime",
    "limit": 200,
})
proxies = r.json()
print(len(proxies), "of", r.headers["X-Total-Available"], "matching proxies")
```

**Node.js**

```js
// Page through everything that matches, 5000 at a time.
const all = [];
for (let offset = 0; ; offset += 5000) {
  const res = await fetch(
    `https://hproxy.com/api/proxy-list?format=json&protocol=https&limit=5000&offset=${offset}`
  );
  const page = await res.json();
  all.push(...page);
  if (all.length >= Number(res.headers.get("X-Total-Available"))) break;
}
console.log(all.length, "proxies");
```

**JSON row**

```json
{
  "ip": "203.0.113.7",
  "port": 1080,
  "protocols": ["socks4", "socks5"],
  "anonymity": "elite",
  "country_code": "US",
  "region": "New York",
  "city": "New York",
  "latitude": 40.71,
  "longitude": -74.0,
  "asn": 14061,
  "asn_org": "DigitalOcean, LLC",
  "is_datacenter": true,
  "latency_ms": 142,
  "last_verified_at": "2026-07-22T15:41:09Z",
  "last_alive_at": "2026-07-22T15:41:09Z",
  "status": "alive",
  "uptime_pct": 71.4,
  "uptime_24h": 83.3,
  "uptime_7d": 74.9,
  "status_since": "2026-07-22T09:12:00Z",
  "reliability": "flaky",
  "verification_count": 321
}
```

The `json` format returns an array of full objects (geo, ASN, latency, uptime and last-checked timestamps; fields the engine hasn't enriched yet are `null`, never fabricated). `txt` is one `ip:port` per line, easiest to pipe into tools. `csv` is spreadsheet-ready with a header row.

Every row carries how the proxy has actually been behaving, so you can judge it before you use it: `status` is `alive` when it is passing checks right now, `uptime_pct` is its lifetime success rate, `uptime_24h` and `uptime_7d` are the recent windows, and `verification_count` is how many times we have tested it. Filter on those with `min_uptime_pct`, or hand the ordering to us with `sort=uptime`. Rows with `status: "recently_alive"` only ever appear when you pass `recent=true`, and mean the proxy has stopped answering but was up within the last 48 hours.

> [!TIP] **Need proxies that don't die?**: Free proxies are shared and unstable by nature. HProxy residential, ISP and mobile proxies stay up, from $0.44/GB. [See plans →](https://hproxy.com/pricing)