# Facebook Phone Number Scraper (`scrapers-hub/facebook-phone-number-scraper`) Actor

📱 Facebook Phone Number Scraper extracts phone numbers from Facebook profiles quickly & accurately. ✅ Boost outreach for sales, lead gen & B2B research. Secure, efficient, and easy to use—find the right contacts in minutes.

- **URL**: https://apify.com/scrapers-hub/facebook-phone-number-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (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 $1.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

### Facebook Phone Number Scraper 📞

**Facebook Phone Number Scraper** helps you extract phone numbers from publicly available Facebook profiles, bios, and post content using your chosen keywords and country targeting. Whether you’re looking to **scrape Facebook phone numbers**, build **Facebook phone numbers for leads**, or automate a **Facebook lead scraper phone** workflow, this actor streamlines the process so you can find more relevant contacts faster—at scale, without manual copy-paste work.

---

### Why choose Facebook Phone Number Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one Facebook phone extraction** | Scrapes phone numbers from Facebook bios, profiles, and post content in one run |
| ✅ **Keyword + country targeting** | Uses your keywords and country code targeting to improve match quality for a **Facebook contact scraper** workflow |
| ✅ **Reliability with proxy support** | Built-in proxy support for more reliable scraping on large jobs |
| ✅ **Incremental structured dataset** | Each found phone number is pushed immediately into the dataset for faster access |
| ✅ **Scales with batch parameters** | Supports large scraping tasks with a configurable maximum results stop condition |
| ✅ **Clear output structure** | Returns consistent fields like `phone_number`, `url`, and `dial_code` for easy cleanup and CRM import |

---

### Key features

- 🔍 **Keyword-driven extraction:** Uses your provided keywords to guide what the actor looks for in Facebook content (a strong fit for a **Facebook phone number lookup scraper** workflow).
- 🌍 **Country code targeting:** Select a country (e.g., “United Kingdom (+44)”) so extracted numbers are normalized with the intended dial code.
- 🎯 **Stop at max results:** You can set `maxPhoneNumbers` to stop once enough phone numbers are found—ideal for controlled lead lists.
- 💾 **Real-time data saving:** As soon as a phone number is found, the actor pushes a row to the dataset, so you don’t lose progress.
- 🛡️ **Resilience for large runs:** Includes built-in resilience patterns for harder-to-reach pages and continues iterating until limits are met.
- 🔄 **Duplicate prevention:** Tracks seen phone numbers so the dataset focuses on **unique** numbers (useful for **Facebook contact list scraper** cleanups).
- 📊 **Dataset-ready fields:** Outputs fields like `keyword`, `title`, `description`, `url`, `phone_number`, `country`, and `dial_code` for easy downstream use.

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["marketing", "founder"],
  "location": "London",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20
}
````

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `keywords` | Yes | A list of keywords the actor uses to find relevant Facebook content where phone numbers may appear. |
| `location` | No | Filter by location (for example, “London” or “California”). Leave empty for global search. |
| `country` | Yes | Select the country to target for phone numbers (e.g., “United Kingdom (+44)”). This guides the dial code used with extracted numbers. |
| `maxPhoneNumbers` | No | Stop scraping after this many phone numbers are found. Higher limits may extend scraping duration. Accepts values from 1 up to 10000. |

***

### Output

The actor saves each scraped item into a dataset as JSON rows, one record per unique phone number found.

Example output row:

```json
[
  {
    "platform": "Facebook",
    "keyword": "marketing",
    "title": "No title",
    "description": "No data",
    "url": "No URL",
    "phone_number": "+447700900123",
    "country": "United Kingdom",
    "dial_code": "+44"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | Always set to `"Facebook"` for each row. |
| `keyword` | string | The keyword currently being processed when the phone number was found. |
| `title` | string | The title associated with the result item (may be `"No title"` if not available). |
| `description` | string | Text content used for phone number extraction (may be `"No data"` if not available). |
| `url` | string | The URL linked to the result item (may be `"No URL"` if not available). |
| `phone_number` | string | The extracted phone number formatted in E.164 format (e.g., `+44...`). |
| `country` | string | The selected target country name (derived from the `country` input). |
| `dial_code` | string | The dial code associated with the target country (derived from the country mapping). |

After the run, you can export your dataset results to formats like JSON and CSV from the Apify Console dataset tab.

***

### How to use Facebook Phone Number Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and open the actor page for **Facebook Phone Number Scraper**.

2. **Go to the INPUT section**\
   Paste your input JSON in the editor. The actor accepts `keywords`, `location` (optional), `country`, and `maxPhoneNumbers` (optional).

3. **Set your target country and dial code**\
   Choose the appropriate country option (for example, “United Kingdom (+44)”). This helps normalize extracted phone numbers for your outreach lists—great for a **Facebook business page phone number scraper** use case.

4. **Pick useful keywords**\
   Add specific terms that match your audience or offer (for example, **Facebook phone number extraction tool** workflows often benefit from tighter phrases).

5. **Optional: limit how many results you want**\
   If you set `maxPhoneNumbers`, the actor stops after reaching that many unique phone numbers. For example, set 20 for testing, then raise it for bigger lead batches.

6. **Run the actor**\
   Click **Run**. Watch the live logs to see progress and how many numbers are being found.

7. **Open the dataset and export**\
   When the run completes, open the dataset view to review scraped rows (including `phone_number`, `url`, and `dial_code`), then export to JSON/CSV as needed.

No coding required—get more accurate Facebook phone number lists in minutes with **Facebook Phone Number Scraper**. ✅

***

### Advanced features & SEO optimization

- 📌 **Engineered for Facebook phone number scraping:** Specifically built to help you **scrape phone numbers from Facebook** using keywords plus country targeting, aligned with common **Facebook contact scraper** needs.
- 🔁 **Designed for large tasks:** Works with large scraping jobs by letting you control stop conditions (`maxPhoneNumbers`) and adjust how long runs can last via run settings.
- 🧩 **Input normalization for better targeting:** Treats keywords as a list and uses the selected country to apply dial code normalization in the output.
- 💾 **Dataset-first workflow:** Since each found number is pushed immediately, you can start using partial results sooner in your pipeline (CRM enrichment, lead deduping, analytics).

***

### Best use cases

- 📈 **Lead generation teams building phone-based campaigns:** Quickly assemble **Facebook phone numbers for leads** tied to relevant keyword categories.
- 🧪 **Market researchers validating contact coverage:** Measure how many public phone numbers appear for a niche across regions using country targeting.
- 🧠 **Sales development teams researching prospect signals:** Use `url` plus `title`/`description` context to prioritize outreach candidates.
- 🏢 **Agency workflows for multi-client lead lists:** Run **automated Facebook phone scraper** batches with different keywords and country settings.
- 💼 **Recruiters and community managers finding local contacts:** Locate public **Facebook profile phone number scraper** leads by target geography and topic keywords.
- 🧰 **Data analysts enriching datasets:** Import `phone_number`, `dial_code`, and `country` into your analysis tools for segmentation and funnel tracking.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `location` as a string (optional)
  - ✅ `country` as one of the predefined options like `United Kingdom (+44)`
  - ✅ `maxPhoneNumbers` as an integer (1–10000, default: 20)
- **Proxy Support**
  - ✅ Built-in proxy support for more reliable scraping
- **Retry / Resilience**
  - ✅ Includes resilience patterns for more robust runs on difficult pages
- **Dataset Structure**
  - ✅ Dataset rows contain `platform`, `keyword`, `title`, `description`, `url`, `phone_number`, `country`, `dial_code`
- **Rate Limits & Performance**
  - ✅ Large scraping tasks may take time; you can adjust run timeout in **Run Options** (default: 3600s / 1hr)
- **Limitations**
  - ❌ Results depend on **publicly available** phone number data on the target pages

***

### FAQ

#### Does the Facebook Phone Number Scraper only collect publicly available data?

✅ Yes. It collects information only from publicly available sources. It does not access private profiles, authenticated data, or password-protected content.

#### What input fields are required?

✅ You must provide `keywords` and `country`. You can optionally add `location` and `maxPhoneNumbers`.

#### What does `maxPhoneNumbers` do?

✅ `maxPhoneNumbers` stops the run after the actor finds that many phone numbers. Setting a higher limit may increase the overall scraping duration.

#### How are phone numbers returned—are they normalized?

✅ Yes. Output `phone_number` values are formatted in E.164 format, alongside `country` and `dial_code` for consistency.

#### Why might I get fewer phone numbers than expected?

✅ If results are fewer than expected, try broader keywords or different country settings. You can also increase `maxPhoneNumbers` (within your plan limits).

#### Is there a free-tier result limit?

✅ The actor applies a free user maximum of 100 phone numbers maximum. If you’re on a paid plan, that restriction is not applied.

#### Can I use the output in a CRM or spreadsheet?

✅ Yes. Each dataset row includes `phone_number` plus helpful context fields like `url`, `keyword`, and `dial_code`, making it straightforward to export to JSON/CSV and import into other systems.

#### Do you support automation via API or code?

✅ Apify actors are typically easy to automate in your workflows by running them with the same input fields shown above. You can also use Apify’s API tooling to trigger runs and fetch dataset outputs.

***

### Support & feature requests

Want to improve **Facebook Phone Number Scraper**? We’d love to hear from you—especially if you have ideas for how to make the results more useful for your **Facebook phone number scraper** workflow.

- 💡 **Feature Requests:** For example, request enhancements like CSV export options, additional output fields, or tighter filtering behaviors for lead quality.
- 📧 **Contact:** Email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for future improvements to **Facebook Phone Number Scraper**.

***

*If you need an SEO-optimized way to scrape Facebook phone numbers for leads, this **Facebook Phone Number Scraper** is built to deliver dataset-ready results fast.*

***

### Disclaimer

**This tool only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws and regulations (for example, GDPR/CCPA), spam regulations, and the target platform’s terms of service. For any data removal requests, contact <dataforleads@gmail.com>.

Please use **Facebook Phone Number Scraper** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

Enter keywords to search for (e.g., 'Target Keyword').

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

Filter by location (e.g., 'London', 'California'). Leave empty for global search.

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

Select the country to target for phone numbers.

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

Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Phone Number Scraper",
        "description": "📱 Facebook Phone Number Scraper extracts phone numbers from Facebook profiles quickly & accurately. ✅ Boost outreach for sales, lead gen & B2B research. Secure, efficient, and easy to use—find the right contacts in minutes.",
        "version": "0.1",
        "x-build-id": "Dj2BPNTLk5lHqZYmb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~facebook-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-facebook-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/scrapers-hub~facebook-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-facebook-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/scrapers-hub~facebook-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-facebook-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": "Enter keywords to search for (e.g., 'Target Keyword').",
                        "default": [
                            "marketing",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by location (e.g., 'London', 'California'). Leave empty for global search."
                    },
                    "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 the country to target for phone numbers.",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
