# Zillow Phone Number Scraper (`scraply/zillow-phone-number-scraper`) Actor

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Zillow** Phone Number Scraper 📱

**Zillow** Phone Number Scraper allows you to collect a wide range of **data** from **Zillow** listings. This includes essential **contact** details and property information that are critical for real estate professionals and businesses.

The tool is a robust property **data** scraping software that simplifies the process of **extract**ing **Zillow** **phone numbers**. It is designed to be user-friendly and highly efficient, making it an ideal **Zillow** lead generation tool.

With **Zillow** Phone Number Scraper, you can scrape **Zillow** **phone numbers** and other valuable **data** without any technical expertise. It is perfect for automating your **data** collection process and ensuring you have access to accurate and up-to-date information.

This tool is a game-changer for anyone looking to streamline their real estate operations and improve their lead generation efforts.

Zillow Phone Number Scraper is a powerful tool designed to help you extract valuable contact information from Zillow listings efficiently. It is the ultimate Zillow data extraction tool for real estate professionals and businesses looking to streamline their lead generation process.

With Zillow Phone Number Scraper, you can easily access phone numbers and other contact details from Zillow, making it an essential real estate phone number scraper. This tool simplifies the process of collecting data, saving you time and effort.

Zillow Phone Number Scraper acts as a Zillow contact information scraper, providing accurate and reliable data for real estate agents, investors, and marketers. It ensures you can focus on growing your business while the tool handles data collection.

### 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 | Extract phone numbers from Zillow listings to connect with property owners or agents directly using this real estate scraping tool. |
| Property Addresses | Collect detailed property addresses to enhance your real estate database and target specific locations. |
| Agent Contact Information | Access agent names, phone numbers, and email addresses with this Zillow contact information scraper. |
| Property Prices | Retrieve current and historical property prices to analyze market trends and make informed decisions. |
| Listing Descriptions | Scrape detailed property descriptions to understand features and amenities offered in each listing. |
| Images and Media Links | Download property images and media links to visually assess properties and enhance your marketing materials. |
| Property Types | Identify property types such as single-family homes, apartments, or commercial spaces for targeted campaigns. |
| Listing Dates | Extract listing dates to track new or updated properties on Zillow effectively. |

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

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

- ⭐ Efficiently extract phone numbers and contact details with **Zillow** Phone Number Scraper ensuring fast and accurate data collection
- ⭐ Easily integrate with other tools as a **Zillow** API alternative providing seamless workflows for data processing
- ⭐ Automate the entire scraping process with this automated **Zillow** data scraper saving time and reducing manual effort
- ⭐ Access detailed property information including prices and descriptions to enhance your real estate strategies
- ⭐ **Secure**ly scrape **Zillow** phone numbers without compromising the integrity of your data collection process
- ⭐ Customize your scraping parameters to focus on specific property types locations or price ranges
- ⭐ Utilize the tool as a **Zillow** lead generation tool to streamline your marketing campaigns and outreach efforts
- ⭐ Export data in various formats making it easy to analyze and integrate into your existing systems
- ⭐ Benefit from a user-friendly interface that simplifies the use of this **Zillow** data extraction tool for all skill levels
- ⭐ Stay compliant with ethical guidelines while using this real estate phone number scraper for your business needs
- ⭐ Leverage advanced filtering options to target high-value properties and potential leads effectively
- ⭐ Ensure data accuracy and reliability with this property data scraping software designed for professional use

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

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

1. ✅ Download and install the **Zillow** Phone Number Scraper software on your device
2. ✅ Log in to your account and configure the tool to match your **Zillow** data extraction tool requirements
3. ✅ Enter the specific search criteria such as location property type or price range to narrow down your target listings
4. ✅ **Start** the scraping process and let the real estate phone number scraper collect data from **Zillow** automatically
5. ✅ Monitor the progress through the user-friendly dashboard and make adjustments if necessary
6. ✅ **Export** the scraped data including phone numbers and contact details into your preferred format
7. ✅ Use the extracted information to enhance your **Zillow** lead generation tool and marketing strategies
8. ✅ Regularly update your scraping configurations to stay aligned with your business goals and market trends

### Use Cases 🎯

Real Estate Professionals
🎯 **Use** **Zillow** Phone Number Scraper to collect contact details for potential buyers and sellers
🎯 Enhance your property listings database with accurate and up-to-date information
🎯 Streamline your outreach efforts by targeting specific neighborhoods or property types

Market Researchers
🎯 **Analyze** property trends and pricing data with this property data scraping software
🎯 Track new listings and market activity to stay ahead in the real estate industry
🎯 Gather data for comprehensive market reports and presentations

Marketing Agencies
🎯 Leverage **Zillow** Phone Number Scraper to create targeted marketing campaigns for real estate clients
🎯 Extract phone numbers from **Zillow** to build a reliable contact database for outreach
🎯 Provide clients with actionable insights based on scraped data

Lead Generation Teams
🎯 **Use** the tool as a **Zillow** lead generation tool to identify high-value prospects
🎯 **Automate** the collection of contact details to save time and improve efficiency
🎯 Focus on converting leads into customers with accurate and verified data

### Why choose us? 💎

**Zillow** Phone Number Scraper is the ultimate solution for extracting contact information from **Zillow**. It is a **reliable** **Zillow** lead generation tool that empowers businesses to streamline their data collection processes.

With this real estate scraping tool, you can extract phone numbers from **Zillow** listings effortlessly. Our software is designed to provide accurate and up-to-date data, ensuring you have the information you need to succeed.

It is a secure and efficient alternative to **Zillow** API alternatives, offering unmatched performance and ease of use. By choosing **Zillow** Phone Number Scraper, you gain access to a powerful tool that saves time, reduces manual effort, and enhances your lead generation capabilities.

It is perfect for real estate professionals, marketers, and researchers looking to optimize their workflows. With our tool, you can focus on growing your business while we handle the data collection for you.

### **Zillow** Phone Number Scraper Scalability 📈

**Zillow** Phone Number Scraper is built to handle **large-scale** data extraction tasks with ease. It is an automated **Zillow** data scraper that ensures efficiency and accuracy, even when dealing with **extensive** datasets.

Our tool is designed to scale with your business needs, making it a perfect **Zillow** API alternative for growing companies. Whether you need to scrape **Zillow** phone numbers for a few listings or thousands, our software can handle the workload **seamless**ly.

It is a robust solution for businesses looking to expand their operations and improve their lead generation efforts. With **Zillow** Phone Number Scraper, you can confidently extract data without worrying about limitations or performance issues.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** you comply with **Zillow**s terms of service when using **Zillow** Phone Number Scraper
⚖️ **Use** the tool ethically and avoid scraping data for unauthorized purposes
⚖️ Respect user privacy and do not misuse the contact information collected
⚖️ **Do not** share or sell the scraped data without proper consent or authorization
⚖️ **Adhere** to local data protection laws and regulations when using this real estate phone number scraper
⚖️ **Use** **Zillow** Phone Number Scraper as a **Zillow** data extraction tool for legitimate business purposes only
⚖️ **Avoid** overloading **Zillow**s servers by setting appropriate scraping intervals
⚖️ Regularly review and update your scraping practices to remain compliant with legal and ethical standards

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

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "platform": "Zillow",
    "keyword": "Zillow Phone Number Scraper",
    "title": "Example Zillow 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 Zillow as the source |
| keyword | Keyword that triggered the result (Zillow Phone Number Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Zillow 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 Zillow **Phone Number Scraper**?

Zillow Phone Number Scraper is a tool designed to extract **phone numbers** and other contact details from Zillow listings efficiently.

#### How does it work?

The tool uses advanced scraping techniques to collect data from Zillow, acting as a property data scraping software for real estate professionals.

#### Is it **legal** to scrape Zillow phone numbers?

**Yes**, as long as you comply with Zillow's terms of service and use the tool ethically for legitimate purposes.

#### Can I **extract** other data besides phone numbers?

**Yes**, the tool can also extract addresses, property prices, agent information, and more.

#### How accurate is the data collected?

Zillow Phone Number Scraper ensures high accuracy by using advanced algorithms to verify the data.

#### Is this tool a Zillow API alternative?

**Yes**, it serves as a reliable alternative to Zillow API for data extraction needs.

#### Can I automate the scraping process?

**Yes**, the tool is an **automated** Zillow data scraper designed to save time and reduce manual effort.

#### What formats are supported for **export**ing data?

You can export data in various formats, including **CSV** and Excel, for easy integration.

#### Can I customize the scraping parameters?

**Yes**, you can set specific criteria such as location, property type, or price range to target your scraping efforts.

#### Is the tool user-friendly?

**Yes**, Zillow Phone Number Scraper is designed with a simple interface, making it accessible for users of all skill levels.

#### What industries can benefit from this tool?

Real estate professionals, marketers, researchers, and lead generation teams can all benefit from using this tool.

#### How often should I update my scraping configurations?

It is recommended to update configurations regularly to align with your business goals and market trends.

#### Is **customer support** available?

**Yes**, we provide **dedicated support** to help you with any issues or questions about the tool.

#### Can I scrape data from multiple listings at once?

**Yes**, the tool is designed to handle bulk data extraction efficiently.

#### Does the tool comply with data protection laws?

**Yes**, when used ethically and in **compliance** with local regulations, the tool adheres to data protection standards.

# Actor input Schema

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

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Phone Number Scraper",
        "version": "0.1",
        "x-build-id": "CrEaDjqv3CSeQA0Fl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraply~zillow-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraply-zillow-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/scraply~zillow-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraply-zillow-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/scraply~zillow-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraply-zillow-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, Zillow usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Zillow"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Zillow via google.com SERP.",
                        "default": "Zillow"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
