# Aliexpress Phone Number Scraper (`scraperoka/aliexpress-phone-number-scraper`) Actor

📱🔎 Aliexpress Phone Number Scraper extracts verified phone numbers from Aliexpress listings—fast, accurate, and GDPR-ready workflows. Perfect for lead generation, B2B outreach, and market research. 🚀⚡ Save time and boost conversions!

- **URL**: https://apify.com/scraperoka/aliexpress-phone-number-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

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

### AliExpress Phone Number Scraper 🎯
Manually hunting for AliExpress seller contact details takes hours you don’t have. **AliExpress Phone Number Scraper** automates extraction of phone numbers (and associated listing info) from public web data using your keywords, location filter, and a country dial code—perfect for marketers, recruiters, and growth teams that want fast, scalable outreach lists. Use the **AliExpress phone number scraper** (and related AliExpress contact scraper variations) to turn search-ready inputs into thousands of leads in a single run.

---

### What You Get: Sample Output
Here's a sample record from a single run:

```json
{
  "keyword": "Air Fryer",
  "title": "Air Fryer WhatsApp Contact — Seller Listing",
  "url": "https://www.aliexpress.com/item/123456789.html",
  "description": "Wholesale support available. Contact us via phone for order questions.",
  "phone_number": "+447700900123"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword you used to discover this contact lead (useful for grouping) |
| `title` | string | The title text pulled from the result, helping you understand what the lead is about |
| `url` | string | A direct link to the source page for verification and context |
| `description` | string | The surrounding publicly visible text where the phone number was detected |
| `phone_number` | string | The extracted phone number formatted in E.164 for easy dialing and CRM import |
| `success` | string | (May be absent in this actor’s output) If present in your run environment, it indicates whether the run produced results |
| `error_message` | string | (May be absent in this actor’s output) If present, it contains any error details |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why AliExpress Phone Number Scraper?

There are a lot of ways to pull data from ecommerce platforms — here’s what sets AliExpress Phone Number Scraper apart.

#### Clean, Deduplicated Output

This AliExpress phone number scraper deduplicates phone numbers so you don’t waste time cleaning duplicates across keywords. You get one clean lead per unique phone number, formatted consistently.

#### Keyword-Driven Lead Discovery

You provide a list of `keywords`, and the actor uses them to find relevant results. Combined with an optional `location`, this helps you narrow the AliExpress leads phone numbers you collect to the audiences you care about.

#### Country Dial Code Targeting

You choose the `country` you want to scrape, and the actor extracts phone numbers using that country context. This makes the AliExpress customer phone numbers and AliExpress seller contact details you collect more relevant to your target region.

#### Reliability with Fallback Runs

If the actor can’t extract phone numbers under your selected proxy settings, it can automatically fall back to a different proxy approach and try again. This is built for resilience when some scraping sessions are less consistent.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["John", "Air Fryer"],
  "location": "London",
  "platform": "AliExpress",
  "country": "United Kingdom (+44)",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of terms to search for so the actor can find relevant AliExpress results for phone number extraction |
| `location` | ⬜ | Optional text to narrow results to a specific place (leave empty to scrape more broadly) |
| `platform` | ⬜ | Selects the platform; only `AliExpress` is supported (the actor will switch to `AliExpress` if something else is provided) |
| `country` | ✅ | The country to target (used to select the dial code and ISO country context for phone parsing) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (use your preferred Apify Proxy settings) |
| ↳ `proxyConfiguration.proxy support` | ⬜ | When enabled, the actor attempts to route requests through Apify Proxy based on your configuration |
| ↳ `proxyConfiguration.proxy support` | ⬜ | Proxy group selection used when generating the proxy URL from your configuration |

***

### Core Capabilities

#### Phone Number Extraction (E.164)

AliExpress Phone Number Scraper extracts phone numbers and outputs them as `phone_number` formatted in E.164. That makes AliExpress listing scraper phone data immediately usable for dialing, CRM import, and outreach workflows.

#### Flexible Input for Targeting

You can pass multiple `keywords` in one run, optionally add a `location`, and select the `country` dial code you care about. This gives you control over the AliExpress contact scraper outcomes instead of relying on one-size-fits-all scraping.

#### Resilient Data Collection

The actor includes built-in fallback behavior to improve the chance of extracting phone numbers even if one attempt under your proxy setup returns no matches. It’s designed to be practical for real-world lead generation toolchains.

#### Rich Lead Context Alongside Numbers

Each result includes not just the phone number, but also `title`, `url`, and `description`. That means your AliExpress supplier phone number scraper output is easier to validate and categorize for sales or research.

#### Dataset-First Output for Automation

Results are pushed to the Apify dataset for easy export and downstream automation. This makes it straightforward to build an AliExpress phone number finder workflow that feeds analysts, marketing, or outreach systems.

***

### Who Gets the Most Out of This

Here's how different teams put AliExpress Phone Number Scraper to work:

**Sales Development Reps** — Use it to build AliExpress seller contact details lists by running keyword batches and selecting the target `country`. You end up with phone numbers plus source links so your team can validate quickly and start outreach faster.

**Lead Generation Specialists** — Combine multiple `keywords` with an optional `location` filter to focus on relevant niches and regions. The result is a structured list of AliExpress leads phone numbers you can segment for campaigns.

**E-commerce Researchers & Data Analysts** — Export results from the dataset to analyze which keywords correlate with phone numbers most often, and measure coverage by region. The inclusion of `title`, `url`, and `description` makes the dataset auditable.

**Automation & Integration Developers** — Trigger the actor via the Apify platform and pipe dataset outputs into their systems for enrichment and deduping. This is a practical AliExpress contact scraper that fits into repeatable data pipelines.

**Recruiters & Sourcing Teams** — When roles or suppliers are regional, use the `country` selector to focus the phone number extraction context. You get structured leads that can support faster sourcing and screening.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run AliExpress Phone Number Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find AliExpress Phone Number Scraper.
2. **Enter your inputs** — set `keywords`, choose `country`, and optionally add `location` and `platform` (only `AliExpress` is supported).
3. **Configure proxy settings** — set `proxyConfiguration` based on your preferences for reliable scraping runs.
4. **Hit Run and watch the live log** — monitor progress and see extraction activity in real time.
5. **View results in the dataset tab** — each extracted item includes `keyword`, `title`, `url`, `description`, and `phone_number`.
6. **Export as JSON, CSV, or Excel** — download the dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, AliExpress Phone Number Scraper plugs directly into your existing workflow.

You can download results from the Apify dataset tab as **JSON**, **CSV**, or **Excel**. If you’re using a CRM or spreadsheets, that makes the AliExpress phone number extraction tool output easy to import.

For automation, you can connect runs to external systems using Apify’s supported capabilities via API access, webhooks on completion, and no-code automation tools like Zapier or Make. If you want deeper connectivity, use the Apify API to pull results programmatically via [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

AliExpress Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can begin with test runs, then scale as needed based on your project volume and usage.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Platform access consistency | Built-in resilience to handle sessions where extraction yields no matches |
| Output cleanliness | Deduplication so repeated discoveries don’t spam the dataset with the same number |
| Input-driven targeting | Clear filtering via `keywords`, optional `location`, and `country` dial code context |
| Data usability | Phone numbers are output in `phone_number` in E.164 format with source context (`url`, `title`, `description`) |
| Operational transparency | Logs show key runtime decisions and extraction results |

Limitations: This actor extracts phone numbers from publicly available sources and does not provide access to login-gated or private data. If a page doesn’t contain detectable phone numbers in its publicly visible text, fewer results will be returned.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Can I use this for free?

Yes—Apify provides a free tier to get started. You can run AliExpress Phone Number Scraper with test inputs and then upgrade based on your needs.

#### Do I need to log in to AliExpress to use this?

No. The actor works using publicly available web data and does not require an account login from you.

#### How accurate is the extracted phone number data?

It depends on what the source pages publicly display. The actor extracts phone numbers from publicly visible text and returns them in `phone_number` using E.164 formatting, but it cannot guarantee every number is reachable or belongs to the exact entity you’re targeting.

#### How many results can I get per run?

The actor processes results per `keywords` and writes unique extracted items to the dataset. The exact number of results varies based on your input keywords, optional `location`, and the chosen `country` context.

#### How often is the data updated / how fresh is it?

Freshness depends on when the actor run is executed and what the source pages currently show. For the most up-to-date outreach lists, run the AliExpress phone number scraper as close as possible to your outreach timing.

#### Is it legal? Does it comply with GDPR / CCPA?

The actor only extracts **publicly available data**. You are responsible for ensuring your collection, storage, and outreach comply with GDPR, CCPA, platform Terms of Service, and any other applicable regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the dataset as JSON, CSV, or Excel from the Apify dashboard, then import into Google Sheets or your preferred tool.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actor runs so AliExpress contact scraper data refreshes automatically on a cadence you choose.

#### Can I access this via API?

Yes. You can use Apify API access to trigger runs programmatically and retrieve dataset results via [apify.com/docs/api](https://apify.com/docs/api).

#### What happens if the actor hits an error?

If a request fails for a given keyword, the actor logs the error and continues processing the next keyword. Extracted results are still pushed to the dataset for items already collected.

***

### Need Help or Have a Request?

Got a question about AliExpress Phone Number Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor based on user feedback, and we’re especially interested in improvements like webhook notifications on completion and batch CSV upload support.

***

### Disclaimer & Responsible Use

*AliExpress Phone Number Scraper is the fastest, most reliable way to extract targeted AliExpress phone numbers for outreach — start your free run today.*

This actor extracts **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and applicable local regulations when using or storing the results. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for. (Example: John, Air Fryer, etc.)

## `location` (type: `string`):

Optional location to narrow down search results.

## `platform` (type: `string`):

Select platform.

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

Select a country to scrape related phone numbers.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "John",
    "Air Fryer"
  ],
  "location": "",
  "platform": "AliExpress",
  "country": "United Kingdom (+44)"
}
```

# 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 = {
    "keywords": [
        "John",
        "Air Fryer"
    ],
    "location": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/aliexpress-phone-number-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 = {
    "keywords": [
        "John",
        "Air Fryer",
    ],
    "location": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/aliexpress-phone-number-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 '{
  "keywords": [
    "John",
    "Air Fryer"
  ],
  "location": ""
}' |
apify call scraperoka/aliexpress-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Aliexpress Phone Number Scraper",
        "description": "📱🔎 Aliexpress Phone Number Scraper extracts verified phone numbers from Aliexpress listings—fast, accurate, and GDPR-ready workflows. Perfect for lead generation, B2B outreach, and market research. 🚀⚡ Save time and boost conversions!",
        "version": "0.1",
        "x-build-id": "w4DxufwgelsehZ7ON"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~aliexpress-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-aliexpress-phone-number-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/scraperoka~aliexpress-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-aliexpress-phone-number-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/scraperoka~aliexpress-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-aliexpress-phone-number-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",
                "required": [
                    "keywords",
                    "country"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for. (Example: John, Air Fryer, etc.)",
                        "default": [
                            "John",
                            "Air Fryer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location to narrow down search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "AliExpress"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "AliExpress"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Afghanistan (+93)",
                            "Albania (+355)",
                            "Algeria (+213)",
                            "Andorra (+376)",
                            "Angola (+244)",
                            "Antigua And Barbuda (+1-268)",
                            "Argentina (+54)",
                            "Armenia (+374)",
                            "Australia (+61)",
                            "Austria (+43)",
                            "Azerbaijan (+994)",
                            "Bahamas (+1-242)",
                            "Bahrain (+973)",
                            "Bangladesh (+880)",
                            "Barbados (+1-246)",
                            "Belarus (+375)",
                            "Belgium (+32)",
                            "Belize (+501)",
                            "Benin (+229)",
                            "Bhutan (+975)",
                            "Bolivia (+591)",
                            "Bosnia And Herzegovina (+387)",
                            "Botswana (+267)",
                            "Brazil (+55)",
                            "Brunei (+673)",
                            "Bulgaria (+359)",
                            "Burkina Faso (+226)",
                            "Burundi (+257)",
                            "Cambodia (+855)",
                            "Cameroon (+237)",
                            "Canada (+1)",
                            "Cape Verde (+238)",
                            "Central African Republic (+236)",
                            "Chad (+235)",
                            "Chile (+56)",
                            "China (+86)",
                            "Colombia (+57)",
                            "Comoros (+269)",
                            "Congo (Democratic Republic) (+243)",
                            "Congo (Republic) (+242)",
                            "Costa Rica (+506)",
                            "Croatia (+385)",
                            "Cuba (+53)",
                            "Cyprus (+357)",
                            "Czech Republic (+420)",
                            "Denmark (+45)",
                            "Djibouti (+253)",
                            "Dominica (+1-767)",
                            "Dominican Republic (+1-809)",
                            "East Timor (+670)",
                            "Ecuador (+593)",
                            "Egypt (+20)",
                            "El Salvador (+503)",
                            "Equatorial Guinea (+240)",
                            "Eritrea (+291)",
                            "Estonia (+372)",
                            "Eswatini (+268)",
                            "Ethiopia (+251)",
                            "Fiji (+679)",
                            "Finland (+358)",
                            "France (+33)",
                            "Gabon (+241)",
                            "Gambia (+220)",
                            "Georgia (+995)",
                            "Germany (+49)",
                            "Ghana (+233)",
                            "Greece (+30)",
                            "Grenada (+1-473)",
                            "Guatemala (+502)",
                            "Guinea (+224)",
                            "Guinea-Bissau (+245)",
                            "Guyana (+592)",
                            "Haiti (+509)",
                            "Honduras (+504)",
                            "Hungary (+36)",
                            "Iceland (+354)",
                            "India (+91)",
                            "Indonesia (+62)",
                            "Iran (+98)",
                            "Iraq (+964)",
                            "Ireland (+353)",
                            "Israel (+972)",
                            "Italy (+39)",
                            "Jamaica (+1-876)",
                            "Japan (+81)",
                            "Jordan (+962)",
                            "Kazakhstan (+7)",
                            "Kenya (+254)",
                            "Kiribati (+686)",
                            "Korea, North (+850)",
                            "Korea, South (+82)",
                            "Kuwait (+965)",
                            "Kyrgyzstan (+996)",
                            "Laos (+856)",
                            "Latvia (+371)",
                            "Lebanon (+961)",
                            "Lesotho (+266)",
                            "Liberia (+231)",
                            "Libya (+218)",
                            "Liechtenstein (+423)",
                            "Lithuania (+370)",
                            "Luxembourg (+352)",
                            "Madagascar (+261)",
                            "Malawi (+265)",
                            "Malaysia (+60)",
                            "Maldives (+960)",
                            "Mali (+223)",
                            "Malta (+356)",
                            "Marshall Islands (+692)",
                            "Mauritania (+222)",
                            "Mauritius (+230)",
                            "Mexico (+52)",
                            "Micronesia (+691)",
                            "Moldova (+373)",
                            "Monaco (+377)",
                            "Mongolia (+976)",
                            "Montenegro (+382)",
                            "Morocco (+212)",
                            "Mozambique (+258)",
                            "Myanmar (+95)",
                            "Namibia (+264)",
                            "Nauru (+674)",
                            "Nepal (+977)",
                            "Netherlands (+31)",
                            "New Zealand (+64)",
                            "Nicaragua (+505)",
                            "Niger (+227)",
                            "Nigeria (+234)",
                            "North Macedonia (+389)",
                            "Norway (+47)",
                            "Oman (+968)",
                            "Pakistan (+92)",
                            "Palau (+680)",
                            "Panama (+507)",
                            "Papua New Guinea (+675)",
                            "Paraguay (+595)",
                            "Peru (+51)",
                            "Philippines (+63)",
                            "Poland (+48)",
                            "Portugal (+351)",
                            "Qatar (+974)",
                            "Romania (+40)",
                            "Russia (+7)",
                            "Rwanda (+250)",
                            "Saint Kitts And Nevis (+1-869)",
                            "Saint Lucia (+1-758)",
                            "Saint Vincent And The Grenadines (+1-784)",
                            "Samoa (+685)",
                            "San Marino (+378)",
                            "Sao Tome And Principe (+239)",
                            "Saudi Arabia (+966)",
                            "Senegal (+221)",
                            "Serbia (+381)",
                            "Seychelles (+248)",
                            "Sierra Leone (+232)",
                            "Singapore (+65)",
                            "Slovakia (+421)",
                            "Slovenia (+386)",
                            "Solomon Islands (+677)",
                            "Somalia (+252)",
                            "South Africa (+27)",
                            "South Sudan (+211)",
                            "Spain (+34)",
                            "Sri Lanka (+94)",
                            "Sudan (+249)",
                            "Suriname (+597)",
                            "Sweden (+46)",
                            "Switzerland (+41)",
                            "Syria (+963)",
                            "Taiwan (+886)",
                            "Tajikistan (+992)",
                            "Tanzania (+255)",
                            "Thailand (+66)",
                            "Togo (+228)",
                            "Tonga (+676)",
                            "Trinidad And Tobago (+1-868)",
                            "Tunisia (+216)",
                            "Turkey (+90)",
                            "Turkmenistan (+993)",
                            "Tuvalu (+688)",
                            "Uganda (+256)",
                            "Ukraine (+380)",
                            "United Arab Emirates (+971)",
                            "United Kingdom (+44)",
                            "United States (+1)",
                            "Uruguay (+598)",
                            "Uzbekistan (+998)",
                            "Vanuatu (+678)",
                            "Vatican City (+39-06)",
                            "Venezuela (+58)",
                            "Vietnam (+84)",
                            "Yemen (+967)",
                            "Zambia (+260)",
                            "Zimbabwe (+263)"
                        ],
                        "type": "string",
                        "description": "Select a country to scrape related phone numbers.",
                        "default": "United Kingdom (+44)"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
