# Free Proxy List Scraper (`automation-lab/free-proxy-endpoint-list`) Actor

Aggregate public free proxy lists into normalized IP, port, protocol, anonymity, country, source, freshness, and bounded TCP validation records.

- **URL**: https://apify.com/automation-lab/free-proxy-endpoint-list.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 proxy extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Free Proxy List Scraper

Collect a current **free proxy list** from multiple public data sources and export normalized HTTP, HTTPS, SOCKS4, and SOCKS5 endpoint records.

The Actor combines source-reported IP, port, protocol, anonymity, country, organization, and freshness metadata. It can also perform bounded TCP reachability checks for scheduled network-inventory workflows.

> Free public proxies are untrusted third-party servers. Treat every endpoint as potentially unsafe. A reachable port is not proof that a proxy relays traffic, protects privacy, or is suitable for production.

### What does Free Proxy List Scraper do?

The Actor fetches public lists from:

- GeoNode's structured proxy-list API;
- Proxifly's public structured list;
- TheSpeedX protocol-specific public lists.

It then:

1. rejects malformed and non-public IPv4 addresses;
2. normalizes IP addresses, ports, and protocols;
3. filters by protocol, country, and anonymity;
4. deduplicates by protocol, IP, and port;
5. stops at your `maxItems` limit;
6. optionally checks whether each TCP port accepts a connection;
7. saves typed records to the default Apify dataset.

The Actor does not provide a web-browsing proxy, sell proxy traffic, or promise that listed endpoints work beyond the moment they are checked.

### Who is it for?

#### Scraping and automation engineers

Refresh a candidate pool before a controlled test, while keeping the original source and timestamps for auditability.

#### Network operations teams

Build a scheduled inventory of public endpoints and compare exported datasets between runs.

#### Security researchers

Study publicly advertised network services in a bounded, reproducible workflow. Follow your authorization and disclosure obligations.

#### Data analysts

Export normalized endpoint records to JSON, CSV, XML, Excel, or another dataset-supported format without maintaining three source parsers.

### Why use this Actor?

- **Multiple sources:** broaden coverage without mixing incompatible response formats downstream.
- **Normalized records:** every result has a consistent endpoint, IP, port, protocol, source, and timestamp shape.
- **Useful provenance:** trace a record to the public list that supplied it.
- **Freshness fields:** retain source-reported last-seen time and calculate its age when available.
- **Bounded validation:** cap timeout and concurrency for optional TCP checks.
- **Fail-safe input:** malformed country codes, limits, and unsupported sources fail clearly.
- **No paid proxy required:** collection uses direct public HTTP data surfaces.
- **Integration-ready:** use the default dataset with Apify schedules, webhooks, API clients, and MCP.

### What data can you extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `endpointId` | string | Stable protocol/IP/port identity for the current endpoint. |
| `endpoint` | string | URI such as `http://126.209.84.138:5050`. |
| `ip` | string | Public IPv4 address. |
| `port` | integer | Port from 1 through 65535. |
| `protocol` | string | `http`, `https`, `socks4`, or `socks5`. |
| `anonymity` | string or null | Source-reported anonymity label. |
| `countryCode` | string or null | Source-reported two-letter country code. |
| `country` | string or null | Source-reported country name or code. |
| `city` | string or null | Source-reported city. |
| `organization` | string or null | Source-reported organization or ISP. |
| `source` | string | `geonode`, `proxifly`, or `speedx`. |
| `sourceUrl` | string | Public URL fetched by the Actor. |
| `sourceRecordId` | string or null | Upstream record identifier when available. |
| `lastSeenAt` | date or null | Upstream last-check timestamp. |
| `freshnessSeconds` | integer or null | Age of `lastSeenAt` when available. |
| `validationStatus` | string | `reachable`, `unreachable`, or `skipped`. |
| `validationMethod` | string or absent | `tcp-connect` when validation ran; omitted when checks are skipped. |
| `validationLatencyMs` | integer or null | TCP-check elapsed time, including failure time. |
| `validatedAt` | date or null | Time the Actor began its check. |
| `validationError` | string or null | Bounded error message for failed checks. |
| `fetchedAt` | date | Time the Actor assembled the record. |

Missing source metadata remains `null`; it is never invented from another endpoint.

### How to get a free proxy list

1. Open the Actor in Apify Console.
2. Keep GeoNode and Proxifly selected for a balanced default list.
3. Select the protocols you need.
4. Optionally enter ISO country codes such as `US`, `DE`, or `GB`.
5. Set the maximum number of unique endpoints.
6. Leave TCP validation off for the fastest inventory export.
7. Turn it on only when port reachability is useful to your workflow.
8. Click **Start**.
9. Open the **Proxy endpoints** dataset view.
10. Export the records or connect your next automation step.

Default input:

```json
{
  "sources": ["geonode", "proxifly"],
  "protocols": ["http", "https"],
  "maxItems": 100,
  "validateProxies": false
}
```

### Input parameters

#### `sources`

Choose one or more supported public lists.

- `geonode` offers the richest source-reported freshness and location metadata.
- `proxifly` provides broad structured protocol coverage.
- `speedx` provides protocol-specific plain-text endpoint lists.

Default: `geonode` and `proxifly`.

#### `protocols`

Choose any combination of `http`, `https`, `socks4`, and `socks5`.

Protocol values are source claims. TCP validation does not perform a protocol handshake.

#### `countries`

Enter optional ISO 3166-1 alpha-2 codes.

When a country filter is active, records without country metadata are excluded. This means source choice can affect how many matching records are available.

#### `anonymityLevels`

Enter source labels such as `elite`, `anonymous`, or `transparent`.

Labels are normalized to lowercase but remain upstream classifications. Sources can use different testing methods.

#### `maxItems`

Choose from 1 to 5,000 unique records.

The limit applies after validation of record shape, filters, and deduplication.

#### `validateProxies`

When `true`, the Actor attempts a TCP connection to each selected endpoint.

This check answers only: “Did this public IP and port accept a TCP connection within the timeout?”

It does not answer:

- whether the endpoint forwards HTTP requests;
- whether it supports authentication;
- whether it leaks your IP address;
- whether it modifies traffic;
- whether it remains available later;
- whether it is lawful or safe for your use case.

#### `validationTimeoutSecs`

Per-endpoint TCP timeout from 1 through 15 seconds. Default: 3 seconds.

#### `maxValidationConcurrency`

Maximum simultaneous TCP checks from 1 through 100. Default: 20.

### Example inputs

#### Aggregate HTTP and SOCKS endpoints

```json
{
  "sources": ["geonode", "proxifly"],
  "protocols": ["http", "socks4", "socks5"],
  "maxItems": 100,
  "validateProxies": false
}
```

#### Filter GeoNode to US elite endpoints

```json
{
  "sources": ["geonode"],
  "protocols": ["http", "https"],
  "countries": ["US"],
  "anonymityLevels": ["elite"],
  "maxItems": 25,
  "validateProxies": false
}
```

#### Refresh and check a SOCKS inventory

```json
{
  "sources": ["geonode", "proxifly", "speedx"],
  "protocols": ["socks4", "socks5"],
  "maxItems": 20,
  "validateProxies": true,
  "validationTimeoutSecs": 2,
  "maxValidationConcurrency": 10
}
```

### Output example

This record reflects the Actor's current output shape. Endpoint availability changes continuously.

```json
{
  "ip": "126.209.84.138",
  "port": 5050,
  "protocol": "http",
  "anonymity": "transparent",
  "countryCode": "PH",
  "country": "PH",
  "city": "Cebu City",
  "organization": "Infinivan Incorporated",
  "source": "geonode",
  "sourceUrl": "https://proxylist.geonode.com/api/proxy-list",
  "sourceRecordId": "6a789b6600599ef1e71db16e",
  "lastSeenAt": "2026-09-06T14:08:21.000Z",
  "endpointId": "http://126.209.84.138:5050",
  "endpoint": "http://126.209.84.138:5050",
  "freshnessSeconds": 101,
  "validationStatus": "skipped",
  "validationLatencyMs": null,
  "validatedAt": null,
  "validationError": null,
  "fetchedAt": "2026-09-06T14:10:01.753Z"
}
```

### How much does it cost to extract free proxy endpoints?

Pay-per-event pricing has two parts:

- a **$0.005 start fee** for each run;
- **$0.003992 per saved proxy endpoint** on the BRONZE tier.

Examples at BRONZE pricing:

| Saved endpoints | Estimated Actor charge |
| ---: | ---: |
| 1 | $0.008992 |
| 10 | $0.04492 |
| 25 | $0.1048 |
| 100 | $0.4042 |

Only normalized records saved to the dataset incur the per-endpoint event. Rejected source rows, duplicates, and failed fetches are not charged as proxy endpoints.

Apify may also apply your plan's platform usage terms. See the live pricing panel for the tier applicable to your account.

### Schedule recurring proxy inventory refreshes

A schedule turns the Actor into a repeatable inventory feed:

1. save a Task with stable source and filter settings;
2. add an hourly or daily Apify schedule;
3. retain the default dataset for each run;
4. send the dataset URL through a webhook;
5. compare `endpointId`, `lastSeenAt`, and `validationStatus` downstream;
6. alert only after your own confirmation and policy checks.

The Actor itself does not maintain cross-run history or send change alerts. Datasets and schedules provide the building blocks for your workflow.

### Export and integration patterns

#### Spreadsheet inventory

Export the dataset as CSV or Excel and sort by country, protocol, source, or freshness.

#### Database ingestion

Use `endpointId` as a run-level endpoint key and preserve `fetchedAt` for snapshot lineage.

#### Controlled validation queue

Run collection without validation first, choose a bounded subset, then run a validation Task with conservative timeout and concurrency.

#### Source quality analysis

Group records by `source` and compare missing metadata or reachable-port rates over several snapshots.

#### Automation pipeline

Trigger a webhook after the run and feed only explicitly permitted endpoints into your internal review process.

### Run with the Apify API

Replace `<APIFY_TOKEN>` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~free-proxy-endpoint-list/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"sources":["geonode","proxifly"],"protocols":["http"],"maxItems":100}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/free-proxy-endpoint-list').call({
  sources: ['geonode', 'proxifly'],
  protocols: ['http'],
  maxItems: 100,
  validateProxies: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/free-proxy-endpoint-list").call(run_input={
    "sources": ["geonode", "proxifly"],
    "protocols": ["socks5"],
    "maxItems": 100,
    "validateProxies": False,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/free-proxy-endpoint-list"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this HTTP MCP server configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/free-proxy-endpoint-list"
    }
  }
}
```

Example prompts:

- “Collect 50 current HTTP proxy endpoints and return country and source fields.”
- “Create a GeoNode-only US elite proxy inventory without active validation.”
- “Refresh 20 SOCKS5 endpoints and run bounded TCP reachability checks.”

Review generated inputs before starting a run, especially validation limits.

### Reliability, freshness, and source behavior

Public free proxy lists change quickly.

- A source can remove an endpoint between runs.
- One source can temporarily fail while another succeeds.
- Location and anonymity are source-reported, not independently verified.
- `lastSeenAt` can be null when a source publishes no timestamp.
- `freshnessSeconds` is calculated only when `lastSeenAt` is valid.
- Country filters exclude records with unknown countries.
- Deduplication keeps the first normalized occurrence in selected-source order.
- The Actor retries transient source failures with bounded backoff.
- If every selected source fails or yields no valid public endpoint, the run fails instead of returning a misleading success.

### Legality

Use the Actor only for public-data collection and network checks you are authorized to perform. Public listing does not grant permission to route traffic through an endpoint. Respect source terms, destination terms, computer-misuse laws, privacy requirements, and network abuse policies.

### Security and responsible use

Free proxies can observe, modify, delay, or drop traffic.

Never send through an unknown proxy:

- passwords or login cookies;
- personal or health information;
- private API keys;
- payment information;
- confidential business records;
- traffic for systems you are not authorized to test.

Use HTTPS end-to-end, isolate experiments, apply destination allowlists, and independently review every endpoint before use. Follow source terms, destination terms, network abuse policies, export controls, and applicable laws.

The Actor rejects loopback, private, link-local, reserved, multicast, and invalid IPv4 entries before optional TCP checks.

### Limitations

- IPv4 endpoints only; IPv6 rows are currently excluded.
- No guarantee of completeness across all public lists.
- No browser-based web proxy service.
- No credentials or paid proxy pool.
- No HTTP, HTTPS CONNECT, SOCKS4, or SOCKS5 relay handshake validation.
- No anonymity reclassification.
- No malware or reputation screening.
- No historical dataset stored across runs.
- No built-in diff or alert notification.
- Output quality depends on changing third-party public data.
- TheSpeedX lacks country and anonymity metadata, so related filters exclude those rows.

### Troubleshooting

#### Why did I get fewer records than `maxItems`?

Your filters apply after malformed records are removed. A country or anonymity filter can exclude sources that do not publish those fields. Broaden the filters or select GeoNode and Proxifly together.

#### Why is `validationStatus` set to `skipped`?

Set `validateProxies` to `true`. Leaving it off is faster and records source data without active network checks.

#### Why is a reachable endpoint unusable as a proxy?

TCP reachability only confirms that a port accepted a connection. It does not perform a proxy protocol handshake or relay a destination request.

#### Why did the run fail instead of returning an empty dataset?

When every selected upstream source fails or no source supplies valid public endpoints, a failed run avoids presenting infrastructure failure as a naturally empty result.

#### How do I reduce validation time?

Lower `maxItems`, shorten `validationTimeoutSecs`, or raise concurrency carefully within the schema limit. Conservative settings reduce outbound connection bursts.

### FAQ

#### Does this Actor provide free proxy bandwidth?

No. It aggregates public endpoint metadata. Endpoint operation belongs to unrelated third parties.

#### Are all listed proxies live?

No. Public lists are volatile. Use source timestamps and optional TCP checks as bounded signals, then perform your own authorized protocol-level testing.

#### Can I export CSV or Excel?

Yes. Open the default dataset and choose any Apify-supported export format.

#### Can I filter by country?

Yes. Use two-letter codes. Only records with matching source metadata remain.

#### Does validation prove anonymity?

No. Anonymity is copied from the source and TCP validation does not inspect forwarding behavior.

#### Can I schedule it?

Yes. Save the input as a Task and attach an Apify schedule.

### Related Automation Lab Actors

- [IP Geolocation Bulk Lookup](https://apify.com/automation-lab/ip-geolocation-bulk-lookup) can enrich an approved IP list when deeper location fields are needed.
- [HTTP Status Code Checker](https://apify.com/automation-lab/http-status-code-checker) checks authorized destination URLs; it does not validate proxy relays.

Use related Actors only when their independent input and billing contracts match your workflow.

# Actor input Schema

## `sources` (type: `array`):

Public lists to aggregate. GeoNode provides detailed freshness/location fields; Proxifly and TheSpeedX broaden protocol coverage.

## `protocols` (type: `array`):

Keep endpoints advertised with these protocols.

## `countries` (type: `array`):

Optional ISO alpha-2 codes such as US or DE. Records without country metadata are excluded when this filter is set.

## `anonymityLevels` (type: `array`):

Optional source-reported anonymity values, commonly elite, anonymous, or transparent.

## `maxItems` (type: `integer`):

Maximum number of unique protocol, IP, and port records saved after filters.

## `validateProxies` (type: `boolean`):

Attempt a bounded TCP connection to every selected endpoint. Reachable means the port accepted a connection, not that the proxy relays traffic or is safe.

## `validationTimeoutSecs` (type: `integer`):

Per-endpoint timeout for optional TCP reachability checks.

## `maxValidationConcurrency` (type: `integer`):

Maximum simultaneous TCP checks. Lower this when validating a large list against constrained networks.

## Actor input object example

```json
{
  "sources": [
    "geonode",
    "proxifly"
  ],
  "protocols": [
    "http",
    "https"
  ],
  "countries": [],
  "anonymityLevels": [],
  "maxItems": 20,
  "validateProxies": false,
  "validationTimeoutSecs": 3,
  "maxValidationConcurrency": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing normalized proxy endpoint records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sources": [
        "geonode",
        "proxifly"
    ],
    "protocols": [
        "http",
        "https"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/free-proxy-endpoint-list").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sources": [
        "geonode",
        "proxifly",
    ],
    "protocols": [
        "http",
        "https",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/free-proxy-endpoint-list").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sources": [
    "geonode",
    "proxifly"
  ],
  "protocols": [
    "http",
    "https"
  ],
  "maxItems": 20
}' |
apify call automation-lab/free-proxy-endpoint-list --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/free-proxy-endpoint-list"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DWNSLkZCTXYyxD82l/builds/Q3HyzqQQRuZfuf104/openapi.json