# Youtube Phone Number Scraper (`scrapio/youtube-phone-number-scraper`) Actor

YouTube Phone Number Scraper helps you collect creator phone numbers directly from YouTube channels. Use the data for sponsorship outreach, partnerships, and PR coordination. Fast, scalable scraping with clean exports.

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

## Pricing

$14.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

### **YouTube** Phone Number Scraper 📱

Youtube Phone Number Scraper allows users to **extract** a variety of **data** from public **YouTube** profiles. This includes essential **contact** information such as **phone numbers**, email addresses, and social media links.

The tool is designed to function as an automated Youtube scraper, ensuring fast and accurate **data** retrieval. With its advanced phone number **extract**ion software, it can identify and collect **phone numbers** from public profiles efficiently.

Youtube **data** mining tools like this scraper are crucial for professionals looking to streamline their **data** collection processes. It is a versatile solution for finding **contact** details and other useful **data** for outreach and marketing purposes.

Youtube Phone Number Scraper is a powerful tool designed to extract contact details from YouTube profiles efficiently. It allows users to extract phone numbers from Youtube channels and accounts with ease.

Using the Youtube Phone Number Scraper, you can streamline your data collection process for lead generation and outreach. This Youtube contact scraper tool is perfect for businesses, marketers, and researchers.

The ability to scrape Youtube user data is essential for accessing valuable information for campaigns and networking. With this tool, you can quickly gather phone numbers and other details from public profiles.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Phone Numbers | Find phone numbers on Youtube profiles for outreach and lead generation. |
| Email Addresses | Extract email addresses from public profiles for marketing campaigns. |
| Channel Names | Collect channel names for detailed analysis and contact purposes. |
| Social Media Links | Retrieve linked social media accounts for expanded networking opportunities. |
| Profile Descriptions | Scrape profile descriptions to understand user interests and niches. |
| Subscriber Counts | Gather subscriber data to evaluate channel influence and reach. |
| Video Links | Extract video URLs for content analysis and engagement tracking. |
| Location Information | Identify location details shared on profiles for targeted outreach. |

### Key Features of **YouTube** Phone Number Scraper

Here are the **standout features** that make the **YouTube** Phone Number Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extract phone numbers from Youtube profiles with high accuracy
- ⭐ Utilize advanced Youtube scraping software to gather data quickly and reliably
- ⭐ **Automated** processes ensure minimal manual effort and maximum efficiency
- ⭐ Easily learn how to scrape Youtube data with user-friendly instructions
- ⭐ Support for bulk data extraction to save time and increase productivity
- ⭐ **Secure** data handling ensures user privacy and compliance with regulations
- ⭐ **Customizable** scraping options for targeted and specific data collection
- ⭐ **Integration** with other Youtube data mining tools for enhanced functionality
- ⭐ **Regular** updates ensure compatibility with **YouTube**s latest platform changes
- ⭐ Detailed logs and reports provide insights into the scraping process and results
- ⭐ Cross-platform compatibility allows use on various devices and operating systems
- ⭐ 247 customer support to assist with any issues or questions about the tool

### How to use **YouTube** Phone Number Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **YouTube** phone numbers today:

1. ✅ Download and install the Youtube Phone Number Scraper on your device
2. ✅ Log in to the tool using your credentials to access the dashboard
3. ✅ Enter the target **YouTube** channel or profile URL into the provided field
4. ✅ **Select** the specific data types you want to extract such as phone numbers
5. ✅ **Configure** the scraping settings to refine your data collection process
6. ✅ Click the start button to begin extracting phone numbers from Youtube profiles
7. ✅ Monitor the progress of the scraping process in real-time on the dashboard
8. ✅ **Export** the collected data into your preferred format such as CSV or Excel
9. ✅ **Review** the extracted information to ensure accuracy and completeness
10. ✅ Use the Youtube contact scraper tool to repeat the process for additional profiles
11. ✅ Leverage the data for lead generation marketing campaigns or research purposes
12. ✅ Access customer support if you encounter any issues or need assistance

### Use Cases 🎯

Business Development
🎯 Generate leads by extracting phone numbers from Youtube profiles of potential clients
🎯 **Use** the tool to gather contact details for outreach and partnership opportunities
🎯 **Analyze** public data to identify influencers and collaborators for your business

Marketing Campaigns
🎯 Scrape Youtube user data to build targeted contact lists for email and SMS campaigns
🎯 Utilize phone number extraction software to streamline your marketing efforts
🎯 **Identify** and connect with key audience segments for personalized promotions

Research and Analysis
🎯 **Use** Youtube data mining tools to collect information for academic or market research
🎯 **Analyze** trends and patterns by extracting data from multiple **YouTube** profiles
🎯 **Study** public user data to gain insights into audience behavior and preferences

Agency Use
🎯 Provide clients with detailed contact lists using the automated Youtube scraper
🎯 Streamline data collection for influencer marketing and campaign management
🎯 Enhance service offerings by leveraging Youtube scraping software for insights

### Why choose us? 💎

Youtube Phone Number Scraper is designed to deliver exceptional results for professionals and businesses. It provides a **reliable** way to find phone numbers on Youtube profiles quickly and accurately.

The tool is **user-friendly**, ensuring anyone can learn how to scrape Youtube data without technical expertise. Its automated Youtube scraper functionality saves time and effort, making it ideal for large-scale data collection.

With our solution, you can leverage Youtube lead generation tools to expand your network and grow your business. We prioritize data security and compliance, ensuring your information is handled responsibly.

Choose us for a seamless, efficient, and effective scraping experience tailored to your needs.

### **YouTube** Phone Number Scraper Scalability 📈

Youtube Phone Number Scraper is built to handle data extraction at any scale. Whether you need to scrape a few profiles or thousands, the tool delivers consistent performance.

Its **advanced** Youtube scraping software ensures fast and reliable results, even for large datasets. You can customize the scraping process to target specific data types, making it versatile for various use cases.

The tool's ability to handle bulk data extraction makes it perfect for businesses and agencies. Learn how to scrape Youtube data **efficient**ly with our comprehensive guides and support.

Our solution grows with your needs, ensuring you can scale your efforts effortlessly.

### **YouTube** Phone Number Scraper Legal Guidelines ⚖️

**Yes**—scraping **YouTube** is **legal** as long as you follow **ethical** and **compliant** practices. The **YouTube** Phone Number Scraper extracts only **publicly available** information from **public** **YouTube** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** you only scrape publicly available data from **YouTube** profiles
⚖️ **Avoid** using the tool to extract phone numbers from private or restricted content
⚖️ **Use** the extracted data responsibly and in compliance with applicable laws
⚖️ **Do not** resell or distribute the data collected without proper permissions
⚖️ Respect **YouTube**s terms of service and guidelines when using the scraper
⚖️ **Obtain** consent from individuals before using their contact information for outreach
⚖️ **Avoid** overloading **YouTube** servers with excessive scraping requests
⚖️ Consult legal counsel to ensure your data collection practices are compliant

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube Phone Number Scraper"],
  "country": "Global",
  "maxPhoneNumbers": 20,
  "platform": "YouTube",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxPhoneNumbers | Maximum phone numbers to collect (default 20) |
| platform | Platform to scrape (YouTube) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "platform": "YouTube",
    "keyword": "Youtube Phone Number Scraper",
    "title": "Example YouTube profile",
    "description": "Example description with phone number",
    "url": "https://www.youtube.com/@example",
    "phone_number": "+1234567890",
    "country": "Global",
    "dial_code": "Auto-detected"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| platform | Identifies YouTube as the source |
| keyword | Keyword that triggered the result (Youtube Phone Number Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct YouTube profile link |
| phone\_number | Extracted phone number with Auto-detected dial code |
| country | Country setting (Global) |
| dial\_code | Dial code (Auto-detected) |

### FAQ ❓

#### What is Youtube **Phone Number Scraper**?

It is a tool designed to extract **phone numbers** and other contact details from public YouTube profiles.

#### How does the tool **extract** phone numbers from Youtube?

It uses advanced algorithms to identify and collect **phone numbers** from public profile information.

#### Is it **legal** to scrape Youtube user data?

**Yes**, as long as you only scrape **publicly available** data and comply with YouTube's terms of service.

#### Can I use this tool for **lead generation**?

**Yes**, the scraper is ideal for building targeted contact lists for marketing and outreach.

#### Does the tool support bulk data **extract**ion?

**Yes**, it is designed to handle large-scale data collection efficiently.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV**, Excel, or **JSON** for easy use.

#### Is the tool compatible with all devices?

**Yes**, it works on various platforms and operating systems for convenience.

#### How do I learn how to scrape Youtube data with this tool?

The tool includes detailed guides and support to help you get started quickly.

#### Can I integrate this tool with other Youtube data mining tools?

**Yes**, it is compatible with various tools to enhance your data collection process.

#### What kind of support is available for the tool?

We offer 24/7 customer support to assist with any issues or questions.

# Actor input Schema

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

A list of keywords, Youtube usernames, or profile URLs to search for. Example: \["marketing", "founder"].

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

Select platform. For now this actor targets Youtube via google.com SERP.

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

Select a country to scrape related phone numbers. The dial code is used to normalize and filter phone numbers.

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

Maximum number of phone numbers to collect per keyword. The scraper will stop once this limit is reached.

## `engine` (type: `string`):

Choose scraping engine. 'cost-effective' uses RESIDENTIAL proxies; 'legacy' uses GOOGLE\_SERP proxy.

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

Configure proxies for this Actor (Apify proxy). The actor will enforce legal GOOGLE\_SERP or RESIDENTIAL groups depending on Engine.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Youtube",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "engine": "legacy"
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapio/youtube-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"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Phone Number Scraper",
        "description": "YouTube Phone Number Scraper helps you collect creator phone numbers directly from YouTube channels. Use the data for sponsorship outreach, partnerships, and PR coordination. Fast, scalable scraping with clean exports.",
        "version": "0.1",
        "x-build-id": "ekKYF8DxE8xAphZkc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~youtube-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-youtube-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/scrapio~youtube-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-youtube-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/scrapio~youtube-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-youtube-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 / Usernames / URLs",
                        "type": "array",
                        "description": "A list of keywords, Youtube usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Youtube"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Youtube via google.com SERP.",
                        "default": "Youtube"
                    },
                    "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. The dial code is used to normalize and filter 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 per keyword. The scraper will stop once this limit is reached.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 'cost-effective' uses RESIDENTIAL proxies; 'legacy' uses GOOGLE_SERP proxy.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor (Apify proxy). The actor will enforce legal GOOGLE_SERP or RESIDENTIAL groups depending on Engine."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
