# Alibaba Phone Number Scraper (`scraperoka/alibaba-phone-number-scraper`) Actor

📱 Alibaba Phone Number Scraper extracts verified phone numbers from Alibaba listings for targeted B2B outreach. 🚀 Save time, improve lead quality, and boost sales & recruitment efforts with efficient data scraping. 💼 Perfect for market research and prospecting.

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

## Pricing

from $2.99 / 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

### Alibaba Phone Number Scraper 🎯
Manually hunting for supplier phone numbers across Alibaba listings wastes hours you don’t have. **Alibaba Phone Number Scraper** pulls phone numbers from Alibaba-related publicly available sources using your keywords and an optional country dial-code filter. This Alibaba phone number scraper is ideal for marketers, recruiters, and growth teams building B2B lead lists—often turning a small keyword set into thousands of extracted contacts in a single run.

---

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

```json
{
  "platform": "Alibaba",
  "keyword": "juicer",
  "title": "Guangzhou Example Trading Co., Ltd.",
  "description": "Fast delivery | WhatsApp +44 7700 900123 | Contact us",
  "url": "https://www.alibaba.com/trade/search?from=1&SearchText=juicer",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44",
  "proxyGroups": ["RESIDENTIAL"]
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Confirms the source platform as “Alibaba” for consistent downstream processing |
| `keyword` | string | Which keyword triggered the extraction, so you can segment leads by intent |
| `title` | string | The listing/profile title linked to where the phone number was found |
| `description` | string | The surrounding public text snippet that contained the phone number (useful for verification) |
| `url` | string | The publicly available page URL tied to the extracted result |
| `phone_number` | string | The extracted phone number formatted to E.164 (ready for CRM/import) |
| `country` | string | Your selected country name (used to label results) |
| `dial_code` | string | The dial code corresponding to your country selection |
| `proxyGroups` | array | The proxy group list used during scraping for run auditing and troubleshooting |

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

***

### Why Alibaba Phone Number Scraper?

There are many ways to pull contact data from Alibaba listings—here’s what sets **Alibaba Phone Number Scraper** apart for reliable B2B lead generation.

#### Keyword-driven phone number extraction

You control what you’re looking for by providing a list of `keywords`. Combined with your `country` selection, the Alibaba contact scraper focuses results toward the phone numbers most relevant to your outreach region.

#### Country dial-code targeting

Use the country selector to target related supplier phone numbers for a specific region (via the selected dial code). This makes an Alibaba supplier phone number scraper more practical for localized lead generation phone lists.

#### Clean, structured, integration-ready output

Each found record is pushed with consistent field names like `phone_number`, `country`, and `dial_code`, making it easy to merge into spreadsheets, CRMs, and research datasets. This Alibaba business contact extractor output is designed to be ready for analysis and follow-up workflows.

#### Deduplication for unique phone numbers

The actor tracks `seen_numbers` and avoids pushing duplicates into the dataset. This helps keep your Alibaba email and phone scraper results cleaner when running longer keyword lists.

***

### Configuring Your Run

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

```json
{
  "keywords": ["juicer", "founder"],
  "platform": "Alibaba",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of terms used to find relevant Alibaba profiles and posts related to your lead criteria |
| `platform` | ⬜ | Selects the platform (the schema offers `Alibaba`; used for logging) |
| `country` | ✅ | Select a country to scrape related phone numbers, using that country’s dial code |
| `maxPhoneNumbers` | ⬜ | Maximum number of phone numbers to collect; stops the run once the limit is reached to control run time and cost |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (leave empty to use default proxy behavior managed by the actor) |

***

### Core Capabilities

#### Search across publicly available Alibaba profiles and posts

Alibaba Phone Number Scraper scans publicly available sources on Alibaba that are related to your provided `keywords`, collecting phone numbers found in the displayed content. It’s built to support Alibaba supplier directory scraper workflows where phone numbers are the key missing field.

#### Targeted extraction with phone-number formatting

Phone numbers are formatted into E.164 (`phone_number`) before being saved. That means your Alibaba trade supplier phone lookup results are consistent and import-friendly for lead lists and outreach tooling.

#### Resilient scraping behavior for better run completion

The actor includes resilience features (including retries/fallback behavior) to improve the chance of completing a run even when some requests fail. It also stops early when it hits your `maxPhoneNumbers` target, which helps avoid overly long scraping sessions.

#### Structured dataset rows pushed in real time

As each result is found, the actor pushes a structured record into the Apify dataset. This makes Alibaba contact details scraper tool outputs easy to monitor and export without waiting for the entire job to finish.

#### Resume support for long runs

The actor persists progress in a key-value store (`progress_li_phone`). If a run is interrupted, it can resume so you don’t have to start from scratch—useful for larger Alibaba marketplace phone number extractor projects.

***

### Who Gets the Most Out of This

Here’s how different teams put **Alibaba Phone Number Scraper** to work:

**B2B marketers and lead-gen teams** use it to build Alibaba lead generation phone numbers lists by running tight keyword sets (for example, product + role terms) and filtering by a target country dial code. The outcome is faster prospecting because the phone field lands ready for importing into outreach tools.

**Sales development reps** use Alibaba contact scraper outputs to enrich account research and reduce manual copy-paste work. They can segment leads by `keyword` and region for cleaner targeting campaigns.

**Researchers and data analysts** benefit from the consistent dataset schema, especially `phone_number`, `country`, `dial_code`, and the associated `url`/`title` context for validation. That makes Alibaba verified supplier contact scraping easier to audit and analyze.

**Automation and integration specialists** can plug the results into data pipelines via the Apify API and schedule repeated runs when needed. The structured, integration-ready output supports reliable downstream processing for an Alibaba phone number data extraction workflow.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open **Alibaba Phone Number Scraper**.
2. **Enter your inputs** — add your `keywords`, and choose your `country` (required fields). Optionally set `maxPhoneNumbers` to cap results for testing.
3. **Configure proxy settings (optional)** — if you want to route requests through proxies, set `proxyConfiguration` accordingly.
4. **Hit Run and watch the live log** — monitor progress as the actor collects phone numbers up to your limit.
5. **View results in the dataset tab** — each pushed record contains `phone_number` plus context fields like `url`, `title`, and `keyword`.
6. **Export as JSON, CSV, or Excel** — download directly from Apify when you’re happy with the dataset.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export results from the Apify dashboard in **JSON**, **CSV**, or **Excel** formats from the dataset tab. This supports everything from manual review to bulk import into spreadsheets.

For automation and delivery, you can connect the actor to your systems using Apify’s **API access** (via Apify API), **webhooks** on run completion, and no-code tools like **Zapier** or **Make**. For deeper setup details and options, refer to the Apify documentation: https://apify.com/docs/api

***

### Pricing & Free Trial

Alibaba Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can start with small keyword tests using the free credits, then scale to larger runs as needed.

Costs are tied to Apify platform usage (compute units / pay-as-you-go model). For current plan options, credits, and pricing, check the Apify pricing page on https://apify.com.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Run resilience | Built-in retries and fallbacks help improve completion rates |
| Blocking and access volatility | Built-in proxy support for reliable scraping across runs |
| Output completeness | The actor pushes structured rows as results are found |
| Long runs | Progress persistence helps resume without losing captured records |
| Run size control | `maxPhoneNumbers` stops the scraper once the collection target is reached |

**Limitations:** This actor works with **publicly available data**. If phone numbers are not present in the public content related to your keywords, the results may be limited. For enterprise-scale use, run configurations may need tuning based on your keyword volume and expected result density.

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

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a **free tier** with credits so you can run Alibaba Phone Number Scraper on smaller tests before scaling up.

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

No. The actor is designed to scrape from **publicly available sources**, so no account login is required for basic usage.

#### How accurate is the data?

Accuracy depends on what phone numbers are publicly displayed in the Alibaba-related content found using your keywords. The actor extracts phone numbers from the publicly available text it encounters and outputs them in a consistent E.164 format.

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

You control the maximum via the `maxPhoneNumbers` input. The scraper will stop once the limit is reached, though higher limits don’t guarantee that many phone numbers will be found.

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

Freshness depends on when you run the actor. If you need the latest Alibaba supplier phone number scraper results, run it on a schedule that matches your outreach cadence.

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

The actor uses **publicly available data** that can be accessed without login. It’s your responsibility to ensure your use of the extracted contact data complies with GDPR, CCPA, and applicable platform rules.

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

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, and then import into Google Sheets or any spreadsheet tool. You can also use Apify integrations to automate delivery into other systems.

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

Yes. With Apify, you can set up scheduled runs so Alibaba Phone Number Scraper executes automatically at times you choose.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically via the Apify API. For details, see https://apify.com/docs/api.

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

If errors occur, the actor uses resilience behavior (including retries/fallbacks) to improve completion. Results are pushed as they’re found, and progress persistence helps with resuming longer runs.

***

### Need Help or Have a Request?

Got a question about **Alibaba Phone Number Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like keyword refinement improvements, batch-based workflows, and webhook notifications on completion. We actively maintain this actor based on user feedback.

***

### Disclaimer & Responsible Use

*Alibaba Phone Number Scraper is the fastest, most reliable way to collect Alibaba supplier phone numbers for outreach — start your free run today.*

The actor uses **publicly available data**. It 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 any applicable local regulations. If you need data removal, 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, marketing, etc.)

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

Select platform.

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

Select a country to scrape related phone numbers.

## `maxPhoneNumbers` (type: `integer`):

Maximum number of phone numbers to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "juicer",
    "founder"
  ],
  "platform": "Alibaba",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20
}
```

# 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": [
        "juicer",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/alibaba-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": [
        "juicer",
        "founder",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Phone Number Scraper",
        "description": "📱 Alibaba Phone Number Scraper extracts verified phone numbers from Alibaba listings for targeted B2B outreach. 🚀 Save time, improve lead quality, and boost sales & recruitment efforts with efficient data scraping. 💼 Perfect for market research and prospecting.",
        "version": "0.1",
        "x-build-id": "nkl4J5n8FvnJZOLQV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~alibaba-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-alibaba-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~alibaba-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-alibaba-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~alibaba-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-alibaba-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, marketing, etc.)",
                        "default": [
                            "juicer",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Alibaba"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Alibaba"
                    },
                    "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)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of phone numbers to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
