# All Social Media Phone Number Scraper (`scraperoka/all-social-media-phone-number-scraper`) Actor

📱 All Social Media Phone Number Scraper extracts phone numbers from social profiles fast and accurately. 🔎 Great for lead generation, B2B sales, and targeted outreach. 🚀 Save time, improve outreach, and boost conversions.

- **URL**: https://apify.com/scraperoka/all-social-media-phone-number-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Social media, Automation
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### All-in-One Social Media Phone Number Scraper 🎯
Manually collecting phone numbers from social media profiles, bios, and posts wastes hours you don’t have. **All-in-One Social Media Phone Number Scraper** automates bulk phone number extraction from social platforms using your keywords, location, and country dial code. This **all in one social media contact scraper** is ideal for marketers, recruiters, and growth teams who need thousands of records in minutes.

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

```json
{
  "platform": "Facebook",
  "keyword": "digital marketing",
  "title": "Marketing & Growth — WhatsApp +44 7700 900123",
  "description": "DM for partnerships. WhatsApp: +44 7700 900123",
  "url": "https://facebook.com/example-page",
  "phone_number": "+447700900123",
  "country": "United Kingdom (+44)",
  "dial_code": "+44",
  "location": "London",
  "proxyGroups": [
    "residential"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Which social media platform the phone number was found on |
| `keyword` | string | The keyword that led to this profile/contact result |
| `title` | string | The result title text captured alongside the phone number |
| `description` | string | The snippet text where the phone number was detected |
| `url` | string | The source URL for this specific contact result |
| `phone_number` | string | The normalized phone number in E.164 format |
| `country` | string | The selected country label used to target local numbers |
| `dial_code` | string | The dial code associated with the selected country |
| `location` | string | The optional location filter value you provided |
| `proxyGroups` | array | Proxy configuration information used during scraping |

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

### Why All-in-One Social Media Phone Number Scraper?

There are a lot of ways to pull contact data from social platforms — here’s what sets **All-in-One Social Media Phone Number Scraper** apart.

#### Targeted keyword + dial code filtering

You drive results using your own `keywords`, plus a selected `country` (with its dial code) and optional `location`. That makes this tool a practical fit for lead generation and outreach workflows that need relevance, not just volume.

#### Phone numbers normalized for real-world outreach

The actor validates and formats extracted numbers into a standardized format so you can use them more easily in downstream systems. If you’re building a phone number finder for social profiles, this saves you cleanup time.

#### Built for bulk collection with a hard stop limit

Use `maxPhoneNumbers` to cap how many phone numbers you want per run. This helps control runtime and cost by stopping once you’ve collected enough results for your current campaign.

#### Structured, dataset-first output

Each found phone number is pushed into your Apify dataset as a structured JSON record with platform, keyword context, and source URL. This makes the scraped contacts from Facebook profiles, Instagram profiles, TikTok profiles, and more easier to analyze and import.

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "digital marketing"],
  "location": "London",
  "platform": "Facebook",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of terms used to find relevant public social media content containing phone numbers |
| `location` | ⬜ | Optional location to narrow down results |
| `platform` | ✅ | The social media platform to scrape |
| `country` | ✅ | Select a country to scrape related phone numbers for (includes a dial code like `+44`) |
| `maxPhoneNumbers` | ⬜ | Stops the run after the scraper collects this many phone numbers (useful for controlling runtime) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (residential proxies are used by default) |

### Core Capabilities

#### Keyword-driven social contact harvesting

This all in one social media contact scraper uses your chosen `keywords` to find phone numbers associated with relevant public social media profiles, bios, and posts. For a social media lead generation scraper workflow, it gives you consistent context (keyword + platform) with every result.

#### Platform flexibility with a single run

Select one `platform` (from the supported list in the input schema) and run the extraction. This makes it a convenient extract phone numbers from social media tool when you want platform-specific contact harvesting.

#### Resilient extraction designed for real usage

The actor is set up to keep scraping reliable using proxy support and built-in resilience. For busy marketing teams and data analysts, that means fewer stalled runs when conditions change.

#### Deduplicated phone numbers

Phone numbers are tracked using a `seen_numbers` mechanism so duplicates are skipped during the run. If you’re building a social media contact database scraper, deduping is built into the output collection flow.

#### Dataset-ready records for analysis and import

Every extracted phone number is pushed to your dataset with fields like `platform`, `keyword`, `url`, and `phone_number`. This makes it easy to clean, filter, and join with CRM enrichment steps.

**In short:** the All-in-One Social Media Phone Number Scraper helps you go from search terms to structured phone number records fast, without manual copy-paste.

### Who Gets the Most Out of This

Here’s how different teams put **All-in-One Social Media Phone Number Scraper** to work:

**Outbound and Growth Marketers**\
Use this automated social media contact harvesting tool to build targeted phone outreach lists from public profile content. You can iterate quickly by changing `keywords`, `location`, and the `country` dial code to match your audience.

**Recruiters and Talent Sourcers**\
When you need phone number finder for social profiles, this actor helps you collect phone contacts tied to relevant public bios and posts. That reduces time spent on manual profile checks and helps speed up outreach pipelines.

**Sales Development Representatives**\
This phone number finder for social profiles workflow can generate fresh contact leads tied to your niche keywords. With `maxPhoneNumbers`, you can run controlled batches for different campaigns and territories.

**Freelance Researchers & Data Analysts**\
Scrape contacts from Facebook profiles, Instagram profiles, TikTok profiles, and more into a consistent dataset with source URLs. That makes it easier to conduct studies, evaluate market presence, or assemble contact datasets for downstream analysis.

**Automation Specialists (Technical)**\
If you’re building automated pipelines, the dataset-first output (including `platform`, `keyword`, and `url`) is straightforward to feed into ETL or CRM enrichment steps after the run completes.

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

No coding needed. Here's how to run **All-in-One Social Media Phone Number Scraper** from start to finish:

1. **Open the actor on Apify** — go to <https://console.apify.com> and open the actor page for *All-in-One Social Media Phone Number Scraper*.
2. **Enter your inputs** — set `keywords`, choose `platform`, and select `country`. Add `location` if you want tighter targeting.
3. **Configure proxy settings** — enable or adjust `proxyConfiguration` based on your preference for reliable scraping.
4. **Hit Run and watch the live log** — monitor progress and ensure results are being collected.
5. **View results in the dataset tab** — each extracted phone number appears as a structured record.
6. **Export as JSON, CSV, or Excel** — download the dataset directly from the Apify interface.

The whole process takes under 5 minutes to set up.

### Integrations & Export Options

Once your data is collected, **All-in-One Social Media Phone Number Scraper** plugs directly into your existing workflow.

You can export results from the Apify dataset tab in common formats like JSON, CSV, or Excel. This makes it easy to load scraped contacts into BI tools, spreadsheets, or CRM imports for email and phone number scraper for social media pipelines.

You can also use Apify’s API and automation integrations (including webhook-style workflows and no-code tools like Zapier/Make) to move results into downstream systems automatically. For depth on programmatic access, check Apify’s developer API docs at <https://apify.com/docs/api>.

### Pricing & Free Trial

**All-in-One Social Media Phone Number Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage typically supports several test runs so you can validate results before scaling.

For larger runs, pricing is generally based on Apify platform compute (CU) and available subscription plans. Start free at [apify.com](https://apify.com) and scale when you're ready.

### Reliability & Performance

| What We Handle | How |
|---|---|
| Proxy support for scraping stability | Proxy configuration is built into the run via `proxyConfiguration` |
| Large result collection | You can cap collection with `maxPhoneNumbers` to control runtime |
| Deduplication | Phone numbers are tracked during the run so duplicates are skipped |
| Dataset-first output | Results are pushed into your Apify dataset as they are found |
| Failure-state resilience | If requests fail, the actor continues processing and collects what it can |

**Limitations:** This actor works with publicly available content and extracts phone numbers where they appear in public profile details, bios, and posts. It can only return what’s actually present in accessible public data.

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

### Frequently Asked Questions

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

Yes—Apify provides a free tier on the platform so you can try the **All-in-One Social Media Phone Number Scraper** before committing to bigger workloads. The exact availability depends on your Apify account and current plan settings.

#### Do I need to log in to Facebook, Instagram, TikTok, or other supported platforms to use this?

No. This actor scrapes phone numbers from publicly available sources and does not require logging into the target platform for each run.

#### How accurate is the data?

The output accuracy depends on what phone numbers are actually published in public bios, profile details, and posts that match your `keywords`, `location`, and `country` dial code. The actor formats extracted numbers into a consistent `phone_number` field for easier reuse.

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

You control the maximum number of phone numbers collected using `maxPhoneNumbers`. If matching public content is limited, you may get fewer results than the cap.

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

The data freshness reflects when you run the actor. Each execution scrapes publicly available data at that time, so results can change depending on what’s currently published.

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

You’re responsible for complying with applicable regulations (including GDPR/CCPA) and platform terms when using the collected data. The actor only collects from **publicly available data** that can be accessed without login.

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

Yes. You can export your dataset from the Apify dashboard, including common formats like JSON and CSV (and Excel via download options). You can then import into tools like Excel or connect to spreadsheets via your preferred workflow.

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

Yes. You can schedule actor runs using Apify capabilities so your **social media phone number scraper** runs automatically on a recurring basis.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically via the Apify API. See <https://apify.com/docs/api> for details.

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

The actor is designed to keep collecting what it can while respecting limits like `maxPhoneNumbers`. If some requests fail, you still typically receive successful records already pushed into your dataset.

### Need Help or Have a Request?

Got a question about **All-in-One Social Media Phone Number Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome improvement ideas like batch CSV upload and webhook on completion, and we actively maintain the actor based on user feedback.

### Disclaimer & Responsible Use

*All-in-One Social Media Phone Number Scraper is the fastest, most reliable way to bulk-extract phone numbers for social outreach — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, platform terms, and any applicable laws. 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: marketing job, digital marketing)

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

## `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. Uses residential proxies by default for better success rates.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "digital marketing"
  ],
  "location": "",
  "platform": "Facebook",
  "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": [
        "founder",
        "digital marketing"
    ],
    "location": ""
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "All Social Media Phone Number Scraper",
        "description": "📱 All Social Media Phone Number Scraper extracts phone numbers from social profiles fast and accurately. 🔎 Great for lead generation, B2B sales, and targeted outreach. 🚀 Save time, improve outreach, and boost conversions.",
        "version": "0.1",
        "x-build-id": "CkmqoRQTuefhpBhul"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~all-social-media-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-all-social-media-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~all-social-media-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-all-social-media-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~all-social-media-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-all-social-media-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",
                    "platform",
                    "country"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for. (Example: marketing job, digital marketing)",
                        "default": [
                            "founder",
                            "digital marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location to narrow down search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Facebook",
                            "YouTube",
                            "Instagram",
                            "TikTok",
                            "Telegram",
                            "Snapchat",
                            "LinkedIn",
                            "Twitter/X",
                            "Pinterest",
                            "Reddit",
                            "Spotify",
                            "Douyin",
                            "Amazon",
                            "Alibaba",
                            "Twitch",
                            "Quora",
                            "Medium",
                            "Tripadvisor",
                            "Yelp",
                            "AliExpress",
                            "eBay",
                            "Etsy",
                            "Vimeo",
                            "Github",
                            "SoundCloud",
                            "Goodreads",
                            "Tumblr",
                            "Eventbrite",
                            "Meetup",
                            "Stack Overflow",
                            "Flickr",
                            "DeviantArt",
                            "Patreon",
                            "Kickstarter",
                            "Threads",
                            "Behance",
                            "Dribbble",
                            "Bluesky",
                            "Mastodon",
                            "Last.fm"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Facebook"
                    },
                    "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. Uses residential proxies by default for better success rates."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
