# HTTP/SOCKS Proxy Scraper - Country & Protocol Filter (`xtech/proxy-scraper`) Actor

Scrape and filter HTTP, HTTPS, and SOCKS proxies from across the web. Filter by country and protocol. Provides detailed location data (country, code, city, coordinates) and timeout values. Perfect for web scraping, bypassing geo-blocking, and enhancing online anonymity. Proxy list updated hourly.

- **URL**: https://apify.com/xtech/proxy-scraper.md
- **Developed by:** [Xtech](https://apify.com/xtech) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 85 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Proxy List Scraper & Filter 🌐

> Fetch, filter, and simplify proxy data with this Apify Actor. Get a clean list of proxies scraped from various sources across the web, with details like protocol, host, port, country, city, and more. Ideal for web scraping, bypassing geo-restrictions, and maintaining anonymity.

**Disclaimer:** Proxy availability is checked approximately every hour.

### Features ✨

- **Proxy Data Fetching** 🌐 Retrieves proxy data from multiple sources across the web
- **Filtering Options** ⚙️ Filter proxies by protocol (e.g., HTTP, SOCKS5) and country
- **Data Simplification** 🧹 Flattens and simplifies the proxy data for easy use
- **Geolocation Details** 🌍 Includes country, country code, city, latitude, and longitude
- **Timeout Information** ⏱️ Provides the proxy's timeout value
- **JSON Output** 💾 Returns structured JSON data, ready for integration
- **Error Handling** ✅ Robust error handling with informative messages
- **Logging** 📝 Detailed logs for monitoring and debugging

### Why Use This Proxy Scraper? 🤔

This Actor provides a convenient way to obtain a list of proxies with relevant details, filtered to your specific needs. Whether you're building a web scraper, testing geo-specific content, or need to enhance your online privacy, this tool is a valuable asset.

#### Designed for:

- **Simplicity:** Easy to configure and use, no coding required
- **Flexibility:** Filter by protocol and country to get the proxies you need
- **Reliability:** Robust error handling ensures consistent results
- **Integration:** Seamlessly integrates with other Apify Actors and tools

### Data Output 📦

The Actor returns a JSON dataset with the following fields for each proxy:

| Field          | Description                                           |
| -------------- | ----------------------------------------------------- |
| `protocol`     | The protocol of the proxy (e.g., "http", "socks5")    |
| `host`         | The hostname or IP address of the proxy               |
| `port`         | The port number of the proxy                          |
| `country`      | The country name (English) where the proxy is located |
| `country_code` | The ISO country code (e.g., "US", "GB")               |
| `city`         | The city where the proxy is located (English)         |
| `latitude`     | The latitude of the proxy's location                  |
| `longitude`    | The longitude of the proxy's location                 |
| `timeout`      | The timeout value of the proxy                        |

#### Example Output

```json
[
  {
    "protocol": "http",
    "host": "192.168.1.1",
    "port": 8080,
    "country": "United States",
    "country_code": "US",
    "city": "New York",
    "latitude": 40.7128,
    "longitude": -74.006,
    "timeout": 1000
  },
  {
    "protocol": "socks5",
    "host": "10.0.0.1",
    "port": 1080,
    "country": "United Kingdom",
    "country_code": "GB",
    "city": "London",
    "latitude": 51.5074,
    "longitude": 0.1278,
    "timeout": 500
  }
]
````

### Use Cases 💡

#### Web Scraping 🕷️

- Bypass Rate Limits: Rotate proxies to avoid being blocked
- Geo-Targeted Scraping: Access content from different locations
- Anonymity: Hide your IP address during scraping

#### Security Testing 🛡️

- Penetration Testing: Test your website's security from different locations
- Vulnerability Scanning: Use proxies to simulate attacks from various sources

#### Geo-Specific Content Access 🌍

- Content Verification: Ensure your website content is displayed correctly in different regions
- Market Research: Access geo-restricted data for market analysis

#### Privacy & Anonymity 👤

- Browse Anonymously: Hide your IP address for privacy
- Bypass Censorship: Access blocked content

### Getting Started 🚀

1. Find the "Proxy List Scraper & Filter" in the Apify Store
2. Configure the input:
   - `protocol` (Optional): Filter by proxy protocol (e.g., "http", "socks5")
   - `country` (Optional): Filter by country code (e.g., "US", "GB")
3. Run the Actor
4. Access results in JSON format
5. Optional: Schedule automatic runs, set up webhooks, or integrate with other Apify Actors

### Key Benefits 🏆

- **Easy to Use:** No coding required – just configure the input
- **Flexible Filtering:** Get the specific proxies you need
- **Structured Data:** JSON output for easy integration
- **Robust Error Handling:** Ensures reliable results
- **Apify Platform Integration:** Seamlessly connects with other Apify tools
- **Well Documented:** Logs let you know exactly what is happening

Start getting your filtered proxy lists today! ➡️

# Actor input Schema

## `protocol` (type: `string`):

Filter proxies by protocol (e.g., 'http', 'socks4', 'socks5'). Leave empty for all.

## `country` (type: `string`):

Filter proxies by country using 2-letter ISO code (e.g., 'US', 'GB'). Leave empty for all.

## Actor input object example

```json
{
  "protocol": "",
  "country": ""
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("xtech/proxy-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("xtech/proxy-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call xtech/proxy-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtech/proxy-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HTTP/SOCKS Proxy Scraper - Country & Protocol Filter",
        "description": "Scrape and filter HTTP, HTTPS, and SOCKS proxies from across the web. Filter by country and protocol. Provides detailed location data (country, code, city, coordinates) and timeout values. Perfect for web scraping, bypassing geo-blocking, and enhancing online anonymity. Proxy list updated hourly.",
        "version": "0.0",
        "x-build-id": "spForc7YqIhDYXuom"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtech~proxy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtech-proxy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xtech~proxy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtech-proxy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xtech~proxy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtech-proxy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "protocol": {
                        "title": "Protocol Filter",
                        "enum": [
                            "",
                            "http",
                            "socks4",
                            "socks5"
                        ],
                        "type": "string",
                        "description": "Filter proxies by protocol (e.g., 'http', 'socks4', 'socks5'). Leave empty for all.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country Filter (ISO Code)",
                        "pattern": "^[A-Za-z]{0,2}$",
                        "maxLength": 2,
                        "type": "string",
                        "description": "Filter proxies by country using 2-letter ISO code (e.g., 'US', 'GB'). Leave empty for all.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
