# free-proxy-scraper-checker (`proxy-solutions/free-proxy-scraper-checker`) Actor

Collect free public HTTP and SOCKS5 proxies from open lists, test each one, and get only working proxies with speed, country and IP leak check. Also checks your own proxy list.

- **URL**: https://apify.com/proxy-solutions/free-proxy-scraper-checker.md
- **Developed by:** [Eugen](https://apify.com/proxy-solutions) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Free Proxy Scraper & Checker

Collects free public **HTTP and SOCKS5 proxies** from open lists, tests every one of them and gives you only the working ones, sorted by speed. You can also paste your own proxy list and use the Actor as a plain proxy checker.

### What you get

- Fresh free proxies tested at the moment of the run
- Response time in milliseconds for each working proxy
- Exit IP and country of every working proxy
- IP leak check: does the proxy reveal your real IP or not
- Failed proxies with the reason (timeout, connection error, bad response) if you want them
- Run summary with totals in the key-value store (`SUMMARY`)

### How to use

1. Open the **Input** tab and leave the defaults to scrape and test public lists, or
2. Paste your own proxies into **Your own proxies** to check them (formats below).
3. Click **Start**. A default run keeps testing until it finds 50 working proxies and usually takes 1 to 3 minutes.
4. Download results from the **Output** tab as JSON, CSV, Excel or HTML, or read them through the API.

#### Input

| Field | Description |
|---|---|
| `sources` | Public list URLs with a protocol (`http` or `socks5`). Plain text, one `host:port` per line |
| `proxies` | Your own proxies. Formats: `host:port`, `user:pass@host:port`, `http://host:port`, `socks5://host:port` |
| `maxProxies` | Upper limit of proxies tested per run (default 1000, max 5000) |
| `targetWorking` | Stop after this many working proxies are found (default 50, 0 = test all up to the limit) |
| `concurrency` | Parallel checks (default 200) |
| `timeoutSecs` | Timeout per proxy (default 8 seconds) |
| `onlyWorking` | Return only working proxies (default on) |
| `lookupCountry` | Add country of the exit IP (default on) |

#### Output example

```json
{
  "proxy": "http://203.0.113.10:8080",
  "protocol": "http",
  "status": "working",
  "latencyMs": 842,
  "ip": "203.0.113.10",
  "leaksRealIp": false,
  "country": "Germany",
  "countryCode": "DE",
  "source": "https://example.com/http.txt",
  "checkedAt": "2026-11-10T12:00:00+00:00"
}
```

Credentials of your own proxies are used only for the connection and are never saved to the output.

### How it works

The Actor loads the lists, removes duplicates, mixes them and tests in batches until it finds `targetWorking` working proxies or reaches `maxProxies` (your own proxies always go first). If the chosen lists give too few proxies, extra public lists are added automatically. Every proxy makes an HTTPS request to an IP echo service. A proxy is **working** if it returns a valid answer in time. The exit IP seen by the service is compared with the real IP of the Actor to detect leaks.

### Limits and honest notes

- Free public proxies are slow, short-lived and shared by many people. A proxy that works now may be dead in 10 minutes. Run the Actor right before you use the list.
- Typically only a small share of a public list is alive. If nothing works, the Actor returns one row with the status `no_working_proxies_found`.
- Do not send passwords, payments or personal data through free proxies. The operator of an unknown proxy can see and change unencrypted traffic.
- For serious or long-running tasks such as large-scale scraping, account work or anything that needs stable speed and a clean reputation, use paid proxies chosen for the specific task (residential, ISP, mobile or datacenter depending on the target site).
- SOCKS4 is not supported. The leak check covers your IP address appearing in the response, which is the most common problem with transparent proxies.
- Country detection is based on a public IP database and can be wrong for some addresses.

### FAQ

**Where do the proxies come from?**
From public plain-text lists that you set in `sources`. The defaults point to popular open lists hosted on GitHub. You can replace them with any list you trust.

**Can I check only my own proxies?**
Yes. Set `sources` to an empty list `[]` and paste your proxies into `proxies`.

**Why did I get fewer proxies than I tested?**
Because the rest did not respond in time or returned errors. Turn off `onlyWorking` to see every failed proxy with its reason.

**Can I run it on a schedule?**
Yes. Use Apify Schedules and connect the output to your tools through the API or integrations.

**Is it legal?**
The Actor only reads public lists and tests whether proxies respond. How you use a proxy is your responsibility. Follow the laws and the terms of the sites you visit.

### Feedback

Found a bug or want a new feature, such as another test URL or more output fields? Open an issue on this Actor's page.

# Actor input Schema

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

Plain-text lists with one proxy per line (host:port). Each source needs a URL and a protocol: http or socks5. Leave the list empty to skip scraping and only check your own proxies.

## `proxies` (type: `array`):

One proxy per line. Formats: host:port, user:pass@host:port, http://host:port, socks5://host:port. SOCKS4 is not supported.

## `maxProxies` (type: `integer`):

Upper limit of proxies tested per run. If more are collected, a random sample is tested. Your own proxies are always tested first.

## `targetWorking` (type: `integer`):

The Actor keeps testing until it finds this many working proxies, up to the max limit above. Set 0 to always test the full max limit.

## `concurrency` (type: `integer`):

How many proxies are tested at the same time.

## `timeoutSecs` (type: `integer`):

A proxy that does not answer within this time is marked as failed.

## `onlyWorking` (type: `boolean`):

If off, failed proxies are also saved with the error reason.

## `lookupCountry` (type: `boolean`):

Adds country and country code of the exit IP.

## Actor input object example

```json
{
  "sources": [
    {
      "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
      "protocol": "http"
    },
    {
      "url": "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
      "protocol": "http"
    },
    {
      "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
      "protocol": "socks5"
    },
    {
      "url": "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt",
      "protocol": "socks5"
    }
  ],
  "proxies": [],
  "maxProxies": 1000,
  "targetWorking": 50,
  "concurrency": 200,
  "timeoutSecs": 8,
  "onlyWorking": true,
  "lookupCountry": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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": [
        {
            "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
            "protocol": "http"
        },
        {
            "url": "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
            "protocol": "http"
        },
        {
            "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
            "protocol": "socks5"
        },
        {
            "url": "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt",
            "protocol": "socks5"
        }
    ],
    "proxies": [],
    "maxProxies": 1000,
    "targetWorking": 50,
    "concurrency": 200,
    "timeoutSecs": 8,
    "onlyWorking": true,
    "lookupCountry": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("proxy-solutions/free-proxy-scraper-checker").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": [
        {
            "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
            "protocol": "http",
        },
        {
            "url": "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
            "protocol": "http",
        },
        {
            "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
            "protocol": "socks5",
        },
        {
            "url": "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt",
            "protocol": "socks5",
        },
    ],
    "proxies": [],
    "maxProxies": 1000,
    "targetWorking": 50,
    "concurrency": 200,
    "timeoutSecs": 8,
    "onlyWorking": True,
    "lookupCountry": True,
}

# Run the Actor and wait for it to finish
run = client.actor("proxy-solutions/free-proxy-scraper-checker").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": [
    {
      "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
      "protocol": "http"
    },
    {
      "url": "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
      "protocol": "http"
    },
    {
      "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
      "protocol": "socks5"
    },
    {
      "url": "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt",
      "protocol": "socks5"
    }
  ],
  "proxies": [],
  "maxProxies": 1000,
  "targetWorking": 50,
  "concurrency": 200,
  "timeoutSecs": 8,
  "onlyWorking": true,
  "lookupCountry": true
}' |
apify call proxy-solutions/free-proxy-scraper-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,proxy-solutions/free-proxy-scraper-checker"
        }
    }
}
```

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/djrKOOtNb0wiCi9Ba/builds/qRgcVmPFLaEKysqnH/openapi.json