# Airbnb Phone Number Scraper (`scraperoka/airbnb-phone-number-scraper`) Actor

📞 Airbnb Phone Number Scraper extracts verified host contact numbers from Airbnb listings fast. Perfect for lead generation, market research, and outreach — stay compliant with platform rules. 🚀 Easy to use, efficient, and SEO-friendly.

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

## Pricing

from $0.01 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Airbnb Phone Number Scraper 🚀 — Extract Phone Numbers From Airbnb Profiles at Scale

Manually visiting Airbnb profiles to collect phone numbers wastes hours you don’t have. **Airbnb Phone Number Scraper** automates the extraction of phone numbers from Airbnb bios, profiles, and post content using your keywords and country targeting. This **Airbnb phone number scraper** (and Airbnb lead phone number 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": "Airbnb",
  "keyword": "marketing",
  "title": "Host profile — marketing & partnerships",
  "description": "Host details, availability notes, and a WhatsApp contact: +44 20 7946 0958",
  "url": "https://www.airbnb.com/users/show/123456789",
  "phone_number": "+442079460958",
  "country": "United Kingdom",
  "dial_code": "+44",
  "status": "pushed"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Confirms the source is Airbnb so your pipeline knows what to expect |
| `keyword` | string | Which keyword produced the listing where the phone number was found |
| `title` | string | A page/result title that helps you understand the context behind the contact |
| `description` | string | The surrounding public text where the phone number was detected |
| `url` | string | The original Airbnb page URL for quick verification and auditing |
| `phone_number` | string | The extracted phone number in E.164 format ready for dialing and CRM matching |
| `country` | string | The country label used for targeting and downstream segmentation |
| `dial_code` | string | The dial code associated with your selected country |
| `status` | string | Indicates the result was pushed to the dataset (for your tracking) |
| `error_message` | string | Present when something goes wrong (so you can spot incomplete runs fast) |

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

***

### Why Airbnb Phone Number Scraper?

There are a lot of ways to pull data from Airbnb — here’s what sets **Airbnb Phone Number Scraper** apart for teams doing outreach, lead research, and list building.

#### Built for lead phone number scraping

The actor extracts phone numbers from Airbnb bios, profiles, and post content using your `keywords` and country targeting, which makes it a practical Airbnb contact phone number extractor for prospecting workflows.

#### Country-targeted phone number formatting

By selecting the appropriate `country`, the actor targets phone numbers using the corresponding dial code and outputs them as E.164 `phone_number` values so your results are consistent across records.

#### Clean, structured dataset output

Each discovered contact is pushed with a consistent set of fields (including `url`, `phone_number`, `country`, and `dial_code`) so you can filter, deduplicate, and enrich without heavy reformatting.

#### Resilient long runs with progress tracking

Large scraping tasks may take time; the actor supports resuming and continues collecting until it hits your configured limits, helping you avoid starting over after interruptions.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | Enter keywords to search for (e.g., terms you expect to appear in public Airbnb bios, profiles, and post content). |
| `location` | ⬜ | Filter by location (e.g., `London`, `California`). Leave empty for global search. |
| `country` | ✅ | Select the country to target for phone numbers; drives dial code usage and phone formatting consistency. |
| `maxPhoneNumbers` | ⬜ | Stop scraping after this many phone numbers are found (minimum `1`, maximum `10000`; default is `20`). |

***

### Core Capabilities

#### Keyword-driven extraction from public Airbnb content

**Airbnb Phone Number Scraper** uses your `keywords` to focus the extraction on relevant Airbnb bios, profiles, and post content. This is especially useful when you’re building an Airbnb phone numbers database for specific niches like hosts who mention “marketing”, “founder”, or similar themes.

#### Flexible targeting with country and optional location

You can set a `country` to target phone numbers for a specific region, and optionally add `location` to narrow results further. This makes it easier to run an Airbnb property phone number scraping tool for geographically focused outreach.

#### Consistent deduplicated results

The actor keeps track of unique phone numbers it has already found, so repeated detections don’t flood your dataset. That’s helpful for Airbnb listing phone number scraper use cases where you want clean, usable lists.

#### Dataset-ready output for analysis and outreach

Each pushed record includes the `url`, `phone_number`, and context fields like `keyword`, `title`, `description`, plus `country` and `dial_code`. This structure makes it straightforward to audit sources and map results to your CRM.

#### Resilient collection for bigger projects

Large scraping tasks may take time, and you can cap results with `maxPhoneNumbers` to keep runs predictable. The actor also supports resuming via saved progress so you can continue without restarting from scratch.

***

### Who Gets the Most Out of This

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

**Sales Development Representatives**\
Use it to build an Airbnb host phone number scraper list for targeted outreach. You get a structured dataset you can import into your dialer or CRM to speed up prospecting.

**Growth teams and marketers**\
Run keyword-focused Airbnb phone number harvesting tool batches (for example, host bios that mention specific services). The result is a cleaner lead list to support campaigns and manual verification where needed.

**Recruiters and sourcing researchers**\
If your candidate pool includes Airbnb hosts or service providers with phone contacts publicly listed, you can use this actor to extract relevant phone numbers and compile a contact-ready spreadsheet faster than manual collection.

**Data analysts and enrichment specialists**\
Leverage the consistent output fields (`url`, `phone_number`, `country`, `dial_code`, plus context fields) to join with other datasets. This makes it useful for building a structured dataset for downstream modeling and segmentation.

**Automation & integration developers**\
Trigger runs through the Apify platform, then push results into your workflows for enrichment and outreach automation. Since the actor pushes records incrementally, you can start processing sooner instead of waiting for a full batch.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and search for **Airbnb Phone Number Scraper**.
2. **Enter your inputs** — set `keywords`, choose `country`, and optionally add `location` and `maxPhoneNumbers`.
3. **Configure proxy settings** — in the run page, enable proxy support if you want more reliable scraping for larger tasks.
4. **Hit Run and watch the live log** — monitor progress and see phones being collected until your limit is reached.
5. **View results in the dataset tab** — your pushed records appear as the run progresses.
6. **Export as JSON, CSV, or Excel** — download directly from Apify and load into your tools.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can download results from the Apify dataset tab in **JSON**, **CSV**, or **Excel** format for reporting, deduplication, and analysis. For “scrape Airbnb host contact info” projects, this makes it easy to hand off clean datasets to marketers and data teams.

You can also connect results to automation tools like **Zapier** / Make, and retrieve data programmatically via the **Apify API**. For deeper details on the integrations and automation options, refer to the official Apify documentation: https://apify.com/docs.

***

### Pricing & Free Trial

Airbnb Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier usage includes platform credits that are typically enough for several test runs, so you can validate your Airbnb phone number scraper strategy before scaling.

For larger projects, you can run on paid Apify plans and use pay-as-you-go compute billing as defined by Apify. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Running larger tasks | Supports long-running collection with configurable `maxPhoneNumbers` |
| Resuming interrupted work | Uses saved progress so you can continue without starting over |
| Data consistency | Extracted phone numbers are normalized into E.164 `phone_number` format |
| Duplicate prevention | Avoids pushing the same phone number multiple times |
| Dataset writing | Pushes results incrementally so you keep what was already found |

**Limitations:** The actor extracts phone numbers from publicly available Airbnb content. If publicly shared data is missing, you may receive fewer results than expected for your Airbnb listing phone number scraper use case. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier that includes platform credits so you can run **Airbnb Phone Number Scraper** on smaller tests before scaling up.

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

No. This actor works with publicly available Airbnb content and does not require user login.

#### How accurate is the data?

Accuracy depends on what’s publicly available in Airbnb bios, profiles, and post content. The actor extracts phone numbers that appear in the text it processes and formats them into E.164 `phone_number` values.

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

You control the stopping point using `maxPhoneNumbers`. The actor will stop scraping once it reaches the configured maximum unique phone numbers.

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

The data freshness depends on when Airbnb content is currently published and when you run the actor. Each run collects whatever public information is available at that time.

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

The actor uses **publicly available data** that can be viewed without login. You are responsible for using the collected data in compliance with GDPR, CCPA, platform terms, and applicable local regulations.

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

Yes. You can export the dataset from the Apify dashboard in **JSON**, **CSV**, or **Excel** format, which you can then import into Google Sheets or other tools.

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

Yes. You can schedule actor runs on Apify using Apify’s automation features. This is useful for ongoing Airbnb phone number harvesting tool workflows.

#### Can I access this via API?

Yes. You can access results programmatically using the Apify API. For implementation details, see the Apify API documentation: https://apify.com/docs/api.

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

If an issue occurs, the actor may stop early depending on the failure. Progress is saved and the run can resume so you don’t lose all previously collected results.

***

### Need Help or Have a Request?

Got a question about **Airbnb Phone Number Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests that improve filtering for Airbnb contact phone number extraction, and we actively maintain this actor based on user feedback. If you want ideas implemented (like improved batching or additional export-friendly fields), tell us what you need.

***

### Disclaimer & Responsible Use

*[Airbnb Phone Number Scraper](https://apify.com) is the fastest, most reliable way to extract Airbnb host contact phone numbers from public profiles — 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 ToS, and other applicable laws. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/airbnb-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("scraperoka/airbnb-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 scraperoka/airbnb-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Phone Number Scraper",
        "description": "📞 Airbnb Phone Number Scraper extracts verified host contact numbers from Airbnb listings fast. Perfect for lead generation, market research, and outreach — stay compliant with platform rules. 🚀 Easy to use, efficient, and SEO-friendly.",
        "version": "0.1",
        "x-build-id": "KvDOHSceyaOEdKL70"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~airbnb-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-airbnb-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~airbnb-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-airbnb-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~airbnb-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-airbnb-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
