# Linktree Phone Number Scraper (`scraper-engine/linktree-phone-number-scraper`) Actor

Linktree Phone Number Scraper extracts publicly listed phone numbers from Linktree pages and linked websites. Build targeted creator contact lists for partnerships, promotions, and direct outreach at scale.

- **URL**: https://apify.com/scraper-engine/linktree-phone-number-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 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

### **Linktree** Phone Number Scraper 📱

The **Linktree** Phone Number Scraper allows users to collect valuable **contact** information from **Linktree** profiles. It focuses on **extract**ing **phone numbers** while maintaining **data** accuracy and reliability.

By using this tool, users can scrape **Linktree** profiles efficiently and gather essential **contact** details. The scraper is tailored to meet the needs of businesses, marketers, and researchers who require precise **data**.

This **Linktree** **data** scraper is equipped with advanced features to automate phone number **extract**ion processes. It ensures that **data** collection is seamless and hassle-free.

Whether you are targeting specific profiles or conducting large-scale **data** scraping, this tool is designed for optimal performance.

Linktree Phone Number Scraper is a powerful tool designed to extract contact information from Linktree profiles quickly and efficiently. It helps users extract phone numbers from Linktree profiles with ease.

With the Linktree Phone Number Scraper, you can automate the process of finding contact details on Linktree. This phone number extraction tool simplifies data collection for businesses and individuals.

The Linktree Phone Number Scraper is ideal for those who need to scrape Linktree profiles for phone numbers. It acts as a reliable Linktree contact scraper to gather essential information.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Phone Numbers | Extract phone numbers listed in Linktree profiles with accuracy using Linktree scraping software. |
| Profile URLs | Collect URLs of Linktree profiles to find contact details on Linktree efficiently. |
| Social Media Links | Scrape social media links embedded in Linktree profiles for additional contact information. |
| Business Information | Extract business-related data from Linktree profiles using the scraper for Linktree contacts. |
| Custom Links | Retrieve custom links shared in Linktree profiles with the Linktree phone number extractor. |
| Profile Descriptions | Collect profile descriptions to understand the context of Linktree users. |
| Embedded Contact Forms | Scrape embedded contact forms in Linktree profiles for comprehensive data collection. |
| Tags and Categories | Extract tags and categories used in Linktree profiles to organize scraped data effectively. |

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

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

- ⭐ **Linktree** Phone Number Scraper provides fast and accurate phone number extraction from **Linktree** profiles
- ⭐ It features automated scraping capabilities to save time and effort during data collection
- ⭐ The scraper for **Linktree** contacts ensures data security and reliability throughout the process
- ⭐ It allows users to customize scraping parameters for targeted data extraction tasks
- ⭐ **Linktree** phone number extractor is compatible with various devices and platforms for seamless use
- ⭐ It offers advanced filtering options to refine extracted data for specific needs
- ⭐ The tool supports large-scale data scraping for businesses and agencies handling multiple profiles
- ⭐ **Linktree** scraping software is designed to handle complex profiles with embedded links and forms
- ⭐ It provides real-time updates and notifications during the scraping process
- ⭐ The scraper ensures compliance with data privacy regulations to protect user information
- ⭐ It includes user-friendly features for beginners and advanced users alike
- ⭐ **Linktree** Phone Number Scraper offers detailed reporting and export options for easy data management

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

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

1. ✅ Download and install the **Linktree** Phone Number Scraper on your device
2. ✅ Log in to the software and configure your scraping preferences
3. ✅ Enter the **Linktree** profile URLs you wish to scrape for phone numbers
4. ✅ **Select** the specific data types you want to extract such as phone numbers or links
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ Use filtering options to refine the extracted data according to your needs
7. ✅ **Export** the collected phone numbers and other data to your preferred format
8. ✅ **Review** the results and ensure all extracted data is accurate and complete

### Use Cases 🎯

Business Outreach
🎯 **Use** the **Linktree** Phone Number Scraper to find contact details on **Linktree** for potential clients
🎯 Extract phone numbers from **Linktree** profiles to build targeted outreach lists
🎯 Scrape **Linktree** profiles to gather business information for networking purposes

Research and Analysis
🎯 Utilize the phone number extraction tool for market research and competitor analysis
🎯 Scrape **Linktree** profiles to collect data for academic or industry studies
🎯 Leverage the **Linktree** data scraper to analyze trends in profile usage and contact sharing

Creator Partnerships
🎯 **Find** contact details on **Linktree** to connect with creators for collaborations
🎯 Extract phone numbers from **Linktree** profiles to reach influencers directly
🎯 **Use** the scraper for **Linktree** contacts to identify potential partners for campaigns

Agency Use
🎯 Employ the **Linktree** scraping software to manage multiple client profiles efficiently
🎯 **Automate** phone number scraper tasks for large-scale data collection projects
🎯 **Use** the **Linktree** phone number extractor to streamline contact management for agencies

### Why choose us? 💎

The **Linktree** Phone Number Scraper is designed to simplify contact data collection from **Linktree** profiles. It offers **advanced** features to automate phone number extraction tasks with precision.

This **Linktree** scraping software ensures **reliable** and secure data collection for users across various industries. By using this tool, businesses can find contact details on **Linktree** quickly and efficiently.

The scraper is built to handle complex profiles, making it ideal for large-scale data scraping projects. It provides real-time updates and customizable options to suit individual needs.

The **Linktree** Phone Number Scraper is **user-friendly** and accessible for both beginners and experts. It guarantees compliance with data privacy regulations while delivering accurate results.

### **Linktree** Phone Number Scraper Scalability 📈

The **Linktree** Phone Number Scraper is equipped to handle **large-scale** data extraction tasks. It can **efficient**ly scrape **Linktree** profiles for phone numbers across multiple profiles simultaneously.

This scraper for **Linktree** contacts is ideal for businesses and agencies managing **extensive** data collection projects. It offers **advanced** automation features to streamline the scraping process for high-volume tasks.

The **Linktree** phone number extractor ensures consistent performance even with complex profiles. It provides **customizable** options to adapt to different scraping requirements.

This tool is designed to scale with your needs, whether you are targeting a few profiles or thousands. It delivers reliable results while maintaining data accuracy and security.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** you have permission to extract phone numbers from **Linktree** profiles before using the scraper
⚖️ Follow all data privacy regulations when using the **Linktree** Phone Number Scraper
⚖️ **Use** the tool responsibly and avoid scraping profiles without consent
⚖️ **Do not** misuse extracted data for illegal or unethical purposes
⚖️ **Avoid** overloading **Linktree** servers by adhering to scraping limits and guidelines
⚖️ **Ensure** compliance with local laws regarding data collection and usage
⚖️ Respect the privacy of **Linktree** users and avoid scraping sensitive information
⚖️ **Use** the **Linktree** contact scraper only for legitimate and approved purposes

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linktree Phone Number Scraper"],
  "country": "Global",
  "maxPhoneNumbers": 20,
  "platform": "Linktree",
  "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 (Linktree) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

| Data Type | Description |
| --- | --- |
| platform | Identifies Linktree as the source |
| keyword | Keyword that triggered the result (Linktree Phone Number Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Linktree 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 the Linktree **Phone Number Scraper**?

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

#### How does the phone number **extract**ion tool work?

The tool automates the process of scraping Linktree profiles for **phone numbers** and organizes the data for easy access.

#### Can I scrape Linktree profiles for other data types?

**Yes**, the Linktree data scraper can extract URLs, social media links, and other profile details.

#### Is the Linktree **Phone Number Scraper** user-friendly?

**Yes**, it is designed with a simple interface suitable for both beginners and advanced users.

#### Does the scraper comply with data privacy regulations?

**Yes**, the Linktree scraping software is built to ensure **compliance** with all relevant privacy laws.

#### Can I use the tool for **large-scale** data collection?

**Yes**, the **automated** phone number scraper supports high-volume scraping tasks efficiently.

#### What are the benefits of using the Linktree **Phone Number Scraper**?

It saves time, ensures accuracy, and simplifies the process of finding contact details on Linktree.

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

**Yes**, the Linktree phone number extractor works on various devices and platforms **seamless**ly.

#### Can I **export** the **extract**ed data to different formats?

**Yes**, the scraper offers export options for organizing and managing extracted data effectively.

#### Is the tool suitable for agencies and businesses?

**Yes**, the scraper for Linktree contacts is ideal for **businesses** and agencies handling multiple profiles.

#### How can I ensure ethical use of the scraper?

Follow all legal guidelines and obtain permission before extracting data from Linktree profiles.

#### Does the tool provide real-time updates during scraping?

**Yes**, the Linktree Phone Number Scraper offers real-time progress tracking and notifications.

#### Can I customize the scraping parameters?

**Yes**, the tool allows users to adjust settings for targeted data extraction tasks.

#### What makes this scraper unique?

Its advanced features, scalability, and **compliance** with privacy regulations set it apart.

#### Is the tool suitable for individual users?

**Yes**, the Linktree Phone Number Scraper is accessible to individuals and small-scale users as well.

# Actor input Schema

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

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

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

Select platform. For now this actor targets Linktr 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": "Linktr",
  "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("scraper-engine/linktree-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("scraper-engine/linktree-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 scraper-engine/linktree-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Phone Number Scraper",
        "description": "Linktree Phone Number Scraper extracts publicly listed phone numbers from Linktree pages and linked websites. Build targeted creator contact lists for partnerships, promotions, and direct outreach at scale.",
        "version": "0.1",
        "x-build-id": "dxWauTK1ayeroFkS8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~linktree-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-linktree-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/scraper-engine~linktree-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-linktree-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/scraper-engine~linktree-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-linktree-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, Linktr usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Linktr"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Linktr via google.com SERP.",
                        "default": "Linktr"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
