# 📞 YouTube Channel Phone Number Scraper (`scrapium/youtube-channel-phone-number-scraper`) Actor

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

## Pricing

$19.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 Channel Phone Number Scraper is a powerful tool for extracting phone numbers and contact information from YouTube profiles. This extract phone numbers from Youtube provides efficient and automated data collection capabilities.

It is designed to collect publicly available contact details while maintaining compliance with platform guidelines. The tool offers user-friendly operation for both beginners and advanced users.

With advanced filtering options, Youtube Channel Phone Number Scraper ensures accurate and relevant data extraction. It supports various output formats for seamless integration with other tools.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com*

### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Phone Numbers | Extracted phone numbers from YouTube profiles |
| Profile Data | Basic profile information and contact details |
| Contact Info | Available contact information from public profiles |

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

Here are the standout features that make the YouTube Phone Number Scraper a reliable tool for data extraction:

- ⭐ Efficient phone number extraction from YouTube
- ⭐ User-friendly interface for easy operation
- ⭐ Automated data collection process
- ⭐ Compliance with YouTube guidelines
- ⭐ Multiple output format support
### 🔗 What are other YouTube scraping tools?

If you want to scrape specific YouTube data, you can use any of the dedicated scrapers below for faster and more targeted results.  
Just enter one or more YouTube URLs, channel names, video IDs, or keywords and start scraping instantly.


| [💬 YouTube Comments Scraper](https://apify.com/scraper-engine/youtube-comments-scraper) | [📝 YouTube Transcript Scraper](https://apify.com/scraper-engine/youtube-transcript-scraper) |
|---|---|
| [🔎 YouTube Search Scraper](https://apify.com/scraper-engine/youtube-search-scraper) | [🎥 YouTube Video Details Scraper](https://apify.com/scraper-engine/youtube-video-details-scraper) |
| [📂 YouTube Playlist Scraper](https://apify.com/scraper-engine/youtube-playlist-scraper) | [🧠 YouTube Video Summarizer](https://apify.com/scraper-engine/youtube-video-summarizer) |
| [📡 YouTube Channel Scraper](https://apify.com/scraper-engine/youtube-channel-scraper) | [👥 YouTube Community Posts Scraper](https://apify.com/scraper-engine/youtube-community-posts-scraper) |
| [⏱️ YouTube Most Replayed Scraper](https://apify.com/scraper-engine/youtube-most-replayed-scraper) | [📊 YouTube Metadata Scraper](https://apify.com/scraper-engine/youtube-metadata-scraper) |
| [🌐 YouTube Video Subtitles Scraper](https://apify.com/scraper-engine/youtube-video-subtitles-scraper) | [🔥 YouTube Trending Scraper](https://apify.com/scraper-engine/youtube-trending-scraper) |
| [🏷️ YouTube Video Scraper by Hashtag](https://apify.com/scraper-engine/youtube-video-scraper-by-hashtag) | [🎬 YouTube Shorts Scraper](https://apify.com/scraper-engine/youtube-shorts-scraper) |
| [📡 YouTube Channel Scraper](https://apify.com/scraper-engine/youtube-channel-scraper) | [📞 YouTube Phone Number Scraper](https://apify.com/scraper-engine/youtube-phone-number-scraper) |
| [📨 YouTube Channel Email Scraper](https://apify.com/scraper-engine/youtube-channel-email-scraper) | [📧 YouTube Email Scraper](https://apify.com/scraper-engine/youtube-email-scraper) |

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

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

1. ✅ Access the YouTube Phone Number Scraper tool
2. ✅ Configure your target YouTube profiles or searches
3. ✅ Set extraction parameters and filters
4. ✅ Start the automated scraping process
5. ✅ Review and export the collected data

### Use Cases 🎯

General Use
🎯 Extract contact information from YouTube profiles
🎯 Build contact databases for business purposes
🎯 Gather data for market research and analysis

### Why choose us? 💎

Youtube Channel Phone Number Scraper offers reliable and efficient YouTube data extraction. Our tool ensures compliance with platform terms while providing comprehensive contact information collection.

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

Youtube Channel Phone Number Scraper is designed to handle various data extraction needs efficiently. The tool provides scalable solutions for both small and large-scale contact data collection.

### **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
⚖️ Follow YouTube terms of service
⚖️ Only collect publicly available information
⚖️ Use extracted data responsibly and ethically
⚖️ Respect user privacy and data protection laws

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Youtube Channel 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 Channel 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 Channel 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 Channel Phone Number Scraper?

Youtube Channel Phone Number Scraper is a tool designed to extract phone numbers and contact information from YouTube profiles efficiently.

#### Is Youtube Channel Phone Number Scraper legal to use?

Yes, as long as it is used in compliance with YouTube terms and applicable data privacy laws.

#### What data can Youtube Channel Phone Number Scraper extract?

Youtube Channel Phone Number Scraper can extract phone numbers, contact details, and profile information from YouTube profiles.

#### How does Youtube Channel Phone Number Scraper work?

Youtube Channel Phone Number Scraper automates the process of collecting contact information from YouTube profiles based on specified parameters.

# Actor input Schema

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

📝 **Search terms to find YouTube channels with phone numbers.**

🔑 Enter one or more keywords, channel usernames, or profile URLs. Examples:
• Business keywords: "plumber", "restaurant", "dentist", "lawyer"
• Industry terms: "marketing", "founder", "consultant"
• Channel names or URLs

The scraper searches Google for YouTube results matching your keywords and extracts contact info from public channel descriptions. 💡 Tip: Use local business keywords for better results!

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

📺 **Select the social platform to scrape.**

🌐 Currently supports YouTube only. The Actor searches Google SERP for YouTube channel results and extracts phone numbers from public profile descriptions. YouTube channels often include contact info in their "About" section — we find and extract that data automatically!

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

🌍 **Select your target country and dial code.**

📍 The dial code (e.g. +44 for UK, +1 for US) is used to:
• Filter phone numbers — only numbers matching the selected country's format
• Normalize output — ensures consistent +XX format
• Find local contacts — targets businesses in your region

Choose the country where you want to find local business contacts. Supports 200+ countries worldwide! 🌎

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

📊 **Maximum phone numbers to collect per keyword.**

🎯 Set a limit between 1 and 10,000. The scraper stops once this limit is reached for each keyword.

• Lower values (10–50): Faster runs, good for testing
• Medium values (50–200): Balanced speed and results
• Higher values (200+): More data, longer run time ⏱️

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

⚙️ **Choose the scraping engine for Google search.**

🔧 **Legacy** — Uses GOOGLE\_SERP proxy, optimized for Google SERP scraping:
• 🔄 3 automatic retries per request (rotates proxy on each retry)
• 🛡️ Bypasses blocks and captchas
• 📞 Best for reliable YouTube phone extraction

Leave as default for optimal results!

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

🔒 **Optional proxy configuration.**

🛡️ The Actor uses GOOGLE\_SERP proxy by default for Google search. Here you can:
• Enable or disable Apify proxy
• Add custom proxy groups
• Configure proxy session settings

💡 Leave as default for best results — the built-in GOOGLE\_SERP proxy is optimized for this use case!

## 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("scrapium/youtube-channel-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("scrapium/youtube-channel-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 scrapium/youtube-channel-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📞 YouTube Channel Phone Number Scraper",
        "version": "0.2",
        "x-build-id": "MrY0IcP9jqYNjHCIy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~youtube-channel-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-youtube-channel-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/scrapium~youtube-channel-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-youtube-channel-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/scrapium~youtube-channel-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-youtube-channel-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": "📝 **Search terms to find YouTube channels with phone numbers.**\n\n🔑 Enter one or more keywords, channel usernames, or profile URLs. Examples:\n• Business keywords: \"plumber\", \"restaurant\", \"dentist\", \"lawyer\"\n• Industry terms: \"marketing\", \"founder\", \"consultant\"\n• Channel names or URLs\n\nThe scraper searches Google for YouTube results matching your keywords and extracts contact info from public channel descriptions. 💡 Tip: Use local business keywords for better results!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "📺 Platform",
                        "enum": [
                            "Youtube"
                        ],
                        "type": "string",
                        "description": "📺 **Select the social platform to scrape.**\n\n🌐 Currently supports YouTube only. The Actor searches Google SERP for YouTube channel results and extracts phone numbers from public profile descriptions. YouTube channels often include contact info in their \"About\" section — we find and extract that data automatically!",
                        "default": "Youtube"
                    },
                    "country": {
                        "title": "🌍 Country & Dial Code",
                        "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 your target country and dial code.**\n\n📍 The dial code (e.g. +44 for UK, +1 for US) is used to:\n• Filter phone numbers — only numbers matching the selected country's format\n• Normalize output — ensures consistent +XX format\n• Find local contacts — targets businesses in your region\n\nChoose the country where you want to find local business contacts. Supports 200+ countries worldwide! 🌎",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "📊 Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "📊 **Maximum phone numbers to collect per keyword.**\n\n🎯 Set a limit between 1 and 10,000. The scraper stops once this limit is reached for each keyword.\n\n• Lower values (10–50): Faster runs, good for testing\n• Medium values (50–200): Balanced speed and results\n• Higher values (200+): More data, longer run time ⏱️",
                        "default": 20
                    },
                    "engine": {
                        "title": "⚙️ Scraping Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "⚙️ **Choose the scraping engine for Google search.**\n\n🔧 **Legacy** — Uses GOOGLE_SERP proxy, optimized for Google SERP scraping:\n• 🔄 3 automatic retries per request (rotates proxy on each retry)\n• 🛡️ Bypasses blocks and captchas\n• 📞 Best for reliable YouTube phone extraction\n\nLeave as default for optimal results!",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "🔒 **Optional proxy configuration.**\n\n🛡️ The Actor uses GOOGLE_SERP proxy by default for Google search. Here you can:\n• Enable or disable Apify proxy\n• Add custom proxy groups\n• Configure proxy session settings\n\n💡 Leave as default for best results — the built-in GOOGLE_SERP proxy is optimized for this use case!"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
