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

Zillow Phone Number Scraper extracts real estate contact details including agent phone numbers, broker information, property listings, addresses, company names, and URLs from Zillow. Ideal for lead generation, real estate outreach, sales prospecting, market research, and CRM enrichment.

- **URL**: https://apify.com/scrapeflux/zillow-phone-number-scraper.md
- **Developed by:** [ScrapeFlux](https://apify.com/scrapeflux) (community)
- **Categories:** Automation, Lead generation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 🚀

Hunting down phone numbers from Zillow listings and profiles by hand is slow, error-prone, and hard to scale. **Zillow Phone Number Scraper** helps you extract phone numbers from Zillow profile bios, profiles, and post content using your keywords and country targeting. If you’re looking for a *zillow phone number scraper* or *zillow data scraper phone numbers* for outreach, this actor is built for you. Marketers, lead-gen teams, and researchers can turn public Zillow contact details into structured results in one run—saving hours of manual work.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "platform": "Zillow",
  "keyword": "marketing",
  "title": "Property Agent Contact",
  "description": "Call for availability • +44 20 7946 0958",
  "url": "https://www.zillow.com/agent/example/",
  "phone_number": "+44",
  "country": "United Kingdom",
  "dial_code": "+44",
  "status": "success",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Identifies the source platform for routing and filtering in your workflow. |
| `keyword` | string | The keyword that triggered the extraction, so you can attribute lead quality by search intent. |
| `title` | string | A title associated with the extracted result content (useful for context in exports). |
| `description` | string | Text content from where the phone number was detected—helpful for validation and auditing. |
| `url` | string | The page URL related to the extracted phone number. |
| `phone_number` | string | The extracted phone number in E.164 format, deduplicated across the run. |
| `country` | string | The country label used for targeting phone numbers. |
| `dial_code` | string | Dial code paired with the targeted country for quick normalization. |
| `status` | string | Indicates whether the record push succeeded from the actor’s perspective. |
| `error_message` | string | Error details if a record could not be pushed to the dataset. |

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

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["marketing", "founder"],
  "location": "California",
  "country": "United States (+1)",
  "maxPhoneNumbers": 50
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords the actor uses to target Zillow profile bios, profiles, and post content for phone number extraction. |
| `location` | ⬜ | Adds a location filter (for example, “London” or “California”); leave empty for global searching. |
| `country` | ✅ | Chooses the country to target for phone numbers (this drives phone parsing by region). |
| `maxPhoneNumbers` | ⬜ | Sets a stop condition so the actor halts after the specified number of phone numbers are found. |

***

### What It Does

Zillow Phone Number Scraper extracts phone numbers from Zillow-related public page content and writes them to your Apify dataset as structured rows.

#### Extract at Scale with Keyword Targeting

You provide `keywords` and a `country` to steer what the scraper looks for, including phone numbers commonly listed in bios, profiles, and posts. This makes the *zillow listing phone number extraction* use case much faster than manual “copy and paste” workflows.

#### Country-Targeted Phone Parsing

The actor formats detected numbers into E.164 and tags each result with `country` and `dial_code`. This supports downstream cleaning and matching when you run a *zillow phone numbers data extraction* workflow across many sources.

#### Clean Output, Ready to Use

Each discovered record is pushed incrementally to the Apify dataset with fields like `keyword`, `title`, `url`, `phone_number`, `country`, and `dial_code`. That structure makes it easy to export, join with CRM data, and build outreach lists—ideal for a *zillow leads phone number scraper* pipeline.

#### Built-in Resilience for Better Runs

The actor includes logic to handle sparse results and to stop when your `maxPhoneNumbers` limit is reached. If results are fewer than expected, the actor’s guidance is to broaden keywords or adjust country settings.

#### Bulk-Friendly Result Control

With `maxPhoneNumbers`, you can cap output for tests or throttled lead collection. If you’re running a *zillow bulk phone number scraper*, this prevents overshooting and keeps runs predictable.

Overall, Zillow Phone Number Scraper turns public Zillow phone number mentions into a structured dataset you can act on quickly.

***

### Why Zillow Phone Number Scraper?

There are plenty of ways to pull data from Zillow—here’s why Zillow Phone Number Scraper stands out.

#### Designed for Phone Number Leads

Zillow Phone Number Scraper is specifically oriented around extracting phone numbers from Zillow profiles and public content, so you’re not sifting through unrelated fields. This aligns well with *zillow contact info scraper* and outreach-focused teams.

#### Built for Run Control and Practical Limits

You can cap results using `maxPhoneNumbers`, which is useful for campaigns that need a defined lead volume (think *zillow seller contact scraper* or *zillow property owner phone scraper* workflows). That control helps keep extraction time and costs aligned with your plan.

#### Uses Keyword and Country Inputs You Already Know

Instead of forcing complex configuration, you set `keywords`, optionally `location`, and pick a `country` for phone targeting. This is exactly what you need when exploring “how to scrape zillow phone numbers” in a repeatable way.

***

### Real-World Use Cases

Here's how different teams put Zillow Phone Number Scraper to work:

**Sales Teams**\
A sales manager needs a fresh list of property-related leads tied to specific services. They run Zillow Phone Number Scraper with a focused keyword set and a country target, then import the exported dataset into their CRM for faster outreach. The team avoids hours of manual searching and gets phone numbers in a consistent format.

**Marketing Agencies**\
An agency managing multiple campaigns for real estate clients wants to segment prospects by intent. They run Zillow Phone Number Scraper per campaign keyword and use `keyword` attribution to build separate lead buckets for each client. The result is quicker list building using a *zillow listing scrape contact info* approach.

**Freelance Researchers**\
A researcher compiling contact options for a report needs traceable sources and structured outputs. They pull phone numbers from public Zillow pages, keep `url` and `description` for auditability, and export to spreadsheets for analysis. This supports repeatable “zillow phone numbers data extraction” studies.

**Data Engineers & Automation Specialists**\
A developer needs reliable dataset writing to integrate with downstream pipelines. They trigger the actor via the Apify API, then push the dataset rows into their warehouse for enrichment and deduplication. This is a practical *zillow phone number API scraper* style workflow.

**Lead Gen Ops**\
A lead generation operator wants predictable run sizing for testing and iteration. They set `maxPhoneNumbers` during early discovery, then scale up once results look good. This makes *zillow leads phone number scraper* workflows operationally manageable.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor page on Apify**\
   Go to the actor listing on Apify: https://console.apify.com

2. **Enter your inputs**\
   Set `keywords` (required) and `country` (required). Optionally add `location` and a `maxPhoneNumbers` cap.

3. **Configure proxy settings (recommended for reliability)**\
   If the run size is large, enable Apify’s proxy support in the Run options to improve consistency.

4. **Start the run and watch the live log**\
   You’ll see progress as the actor finds phone numbers and writes results incrementally to the dataset.

5. **Open the Dataset tab to see live results**\
   Records appear as they are pushed, so you can stop early or adjust quickly.

6. **Export your results**\
   Download the dataset as JSON, CSV, or Excel from the Apify dashboard.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Zillow Phone Number Scraper fits directly into your existing workflow.

You can export from the Apify dataset tab as JSON, CSV, or Excel for sharing with stakeholders or importing into spreadsheets. For automation, you can connect runs using Apify’s native integrations (including Zapier/Make-style no-code workflows) and trigger downstream steps with webhooks. If you want programmatic access, you can pull results via the Apify API and ingest them into your CRM, data warehouse, or enrichment pipeline.

***

### Pricing

Zillow Phone Number Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier usage provides platform credits that are typically enough for several real test runs.

For larger workloads, Apify uses pay-as-you-go billing per Actor compute unit (CU), so you don’t pay a monthly lock-in. Subscription plans are available for heavier usage. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate limits and intermittent access | Uses built-in proxy support for more reliable scraping. |
| Incomplete/low-yield runs | Helps you stop at `maxPhoneNumbers`, and suggests broader keywords or different country targeting when results are below target. |
| Duplicate numbers | Deduplicates phone numbers within the run before pushing data. |
| Resumable progress | Uses persistent progress storage to resume work after interruptions. |
| Dataset writing failures | Push failures are logged and reflected via error handling behavior. |
| Long tasks | Large scraping tasks may take time; you can adjust the timeout in Run Options. |

Limitations: the actor only extracts from publicly available Zillow content (including profile bios, profiles, and post content). If a page doesn’t contain a detectable phone number for the selected country targeting, it may produce fewer results. For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes, there is a free tier on Apify. It’s intended for testing and smaller runs, and larger extraction jobs may require a paid plan.

#### Do I need to log in or create an account on Zillow?

No. This actor extracts phone numbers from publicly available data on Zillow and does not require login.

#### How accurate is the extracted phone number data?

Accuracy depends on what the content actually publishes. The actor extracts phone numbers from the captured public text and formats them into E.164, so you get consistent output when numbers are present.

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

You can control the maximum number of phone numbers using `maxPhoneNumbers`. For free users, the actor applies a hard cap of 100 phone numbers maximum.

#### How fresh is the data?

Results reflect what the actor can access during the run. If you need the most up-to-date lead lists, schedule the actor to run regularly and export new datasets.

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

You should treat this as public-data collection. The actor only accesses **publicly available data**, but compliance with GDPR, CCPA, and relevant platform rules is your responsibility when storing and using the results.

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

Yes. You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, then import into Google Sheets or any spreadsheet tool.

#### Can I schedule this to run automatically?

Yes. You can schedule actor runs in Apify so the Zillow Phone Number Scraper runs automatically on a cadence you choose.

#### Can I access results via the API?

Yes. Apify supports accessing actor outputs programmatically via the Apify API, so you can integrate the extracted phone numbers into your systems.

#### What happens when the actor encounters an error?

If it fails to push a record to the dataset, the actor logs the issue. The actor also uses persistent progress so you can resume and avoid starting from scratch after interruptions.

***

### Get Help & Use Responsibly

Got a question about Zillow Phone Number Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. Share what you’re trying to build (for example, better keyword setups for a *zillow phone number tool* workflow), and we’ll help you get the most out of the actor—this actor is actively maintained based on user feedback.

**Zillow Phone Number Scraper collects data only from publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You are responsible for following GDPR, CCPA, and Zillow’s Terms of Service when using the dataset. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter keywords to search for (e.g., 'Target Keyword').

## `location` (type: `string`):

Filter by location (e.g., 'London', 'California'). Leave empty for global search.

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

Select the country to target for phone numbers.

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

Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing",
        "founder"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Phone Number Scraper",
        "description": "Zillow Phone Number Scraper extracts real estate contact details including agent phone numbers, broker information, property listings, addresses, company names, and URLs from Zillow. Ideal for lead generation, real estate outreach, sales prospecting, market research, and CRM enrichment.",
        "version": "0.1",
        "x-build-id": "O0EvvHyNnqwKg8Z1n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflux~zillow-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflux-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/scrapeflux~zillow-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflux-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/scrapeflux~zillow-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflux-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",
                        "type": "array",
                        "description": "Enter keywords to search for (e.g., 'Target Keyword').",
                        "default": [
                            "marketing",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by location (e.g., 'London', 'California'). Leave empty for global search."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Afghanistan (+93)",
                            "Albania (+355)",
                            "Algeria (+213)",
                            "Andorra (+376)",
                            "Angola (+244)",
                            "Antigua And Barbuda (+1-268)",
                            "Argentina (+54)",
                            "Armenia (+374)",
                            "Australia (+61)",
                            "Austria (+43)",
                            "Azerbaijan (+994)",
                            "Bahamas (+1-242)",
                            "Bahrain (+973)",
                            "Bangladesh (+880)",
                            "Barbados (+1-246)",
                            "Belarus (+375)",
                            "Belgium (+32)",
                            "Belize (+501)",
                            "Benin (+229)",
                            "Bhutan (+975)",
                            "Bolivia (+591)",
                            "Bosnia And Herzegovina (+387)",
                            "Botswana (+267)",
                            "Brazil (+55)",
                            "Brunei (+673)",
                            "Bulgaria (+359)",
                            "Burkina Faso (+226)",
                            "Burundi (+257)",
                            "Cambodia (+855)",
                            "Cameroon (+237)",
                            "Canada (+1)",
                            "Cape Verde (+238)",
                            "Central African Republic (+236)",
                            "Chad (+235)",
                            "Chile (+56)",
                            "China (+86)",
                            "Colombia (+57)",
                            "Comoros (+269)",
                            "Congo (Democratic Republic) (+243)",
                            "Congo (Republic) (+242)",
                            "Costa Rica (+506)",
                            "Croatia (+385)",
                            "Cuba (+53)",
                            "Cyprus (+357)",
                            "Czech Republic (+420)",
                            "Denmark (+45)",
                            "Djibouti (+253)",
                            "Dominica (+1-767)",
                            "Dominican Republic (+1-809)",
                            "East Timor (+670)",
                            "Ecuador (+593)",
                            "Egypt (+20)",
                            "El Salvador (+503)",
                            "Equatorial Guinea (+240)",
                            "Eritrea (+291)",
                            "Estonia (+372)",
                            "Eswatini (+268)",
                            "Ethiopia (+251)",
                            "Fiji (+679)",
                            "Finland (+358)",
                            "France (+33)",
                            "Gabon (+241)",
                            "Gambia (+220)",
                            "Georgia (+995)",
                            "Germany (+49)",
                            "Ghana (+233)",
                            "Greece (+30)",
                            "Grenada (+1-473)",
                            "Guatemala (+502)",
                            "Guinea (+224)",
                            "Guinea-Bissau (+245)",
                            "Guyana (+592)",
                            "Haiti (+509)",
                            "Honduras (+504)",
                            "Hungary (+36)",
                            "Iceland (+354)",
                            "India (+91)",
                            "Indonesia (+62)",
                            "Iran (+98)",
                            "Iraq (+964)",
                            "Ireland (+353)",
                            "Israel (+972)",
                            "Italy (+39)",
                            "Jamaica (+1-876)",
                            "Japan (+81)",
                            "Jordan (+962)",
                            "Kazakhstan (+7)",
                            "Kenya (+254)",
                            "Kiribati (+686)",
                            "Korea, North (+850)",
                            "Korea, South (+82)",
                            "Kuwait (+965)",
                            "Kyrgyzstan (+996)",
                            "Laos (+856)",
                            "Latvia (+371)",
                            "Lebanon (+961)",
                            "Lesotho (+266)",
                            "Liberia (+231)",
                            "Libya (+218)",
                            "Liechtenstein (+423)",
                            "Lithuania (+370)",
                            "Luxembourg (+352)",
                            "Madagascar (+261)",
                            "Malawi (+265)",
                            "Malaysia (+60)",
                            "Maldives (+960)",
                            "Mali (+223)",
                            "Malta (+356)",
                            "Marshall Islands (+692)",
                            "Mauritania (+222)",
                            "Mauritius (+230)",
                            "Mexico (+52)",
                            "Micronesia (+691)",
                            "Moldova (+373)",
                            "Monaco (+377)",
                            "Mongolia (+976)",
                            "Montenegro (+382)",
                            "Morocco (+212)",
                            "Mozambique (+258)",
                            "Myanmar (+95)",
                            "Namibia (+264)",
                            "Nauru (+674)",
                            "Nepal (+977)",
                            "Netherlands (+31)",
                            "New Zealand (+64)",
                            "Nicaragua (+505)",
                            "Niger (+227)",
                            "Nigeria (+234)",
                            "North Macedonia (+389)",
                            "Norway (+47)",
                            "Oman (+968)",
                            "Pakistan (+92)",
                            "Palau (+680)",
                            "Panama (+507)",
                            "Papua New Guinea (+675)",
                            "Paraguay (+595)",
                            "Peru (+51)",
                            "Philippines (+63)",
                            "Poland (+48)",
                            "Portugal (+351)",
                            "Qatar (+974)",
                            "Romania (+40)",
                            "Russia (+7)",
                            "Rwanda (+250)",
                            "Saint Kitts And Nevis (+1-869)",
                            "Saint Lucia (+1-758)",
                            "Saint Vincent And The Grenadines (+1-784)",
                            "Samoa (+685)",
                            "San Marino (+378)",
                            "Sao Tome And Principe (+239)",
                            "Saudi Arabia (+966)",
                            "Senegal (+221)",
                            "Serbia (+381)",
                            "Seychelles (+248)",
                            "Sierra Leone (+232)",
                            "Singapore (+65)",
                            "Slovakia (+421)",
                            "Slovenia (+386)",
                            "Solomon Islands (+677)",
                            "Somalia (+252)",
                            "South Africa (+27)",
                            "South Sudan (+211)",
                            "Spain (+34)",
                            "Sri Lanka (+94)",
                            "Sudan (+249)",
                            "Suriname (+597)",
                            "Sweden (+46)",
                            "Switzerland (+41)",
                            "Syria (+963)",
                            "Taiwan (+886)",
                            "Tajikistan (+992)",
                            "Tanzania (+255)",
                            "Thailand (+66)",
                            "Togo (+228)",
                            "Tonga (+676)",
                            "Trinidad And Tobago (+1-868)",
                            "Tunisia (+216)",
                            "Turkey (+90)",
                            "Turkmenistan (+993)",
                            "Tuvalu (+688)",
                            "Uganda (+256)",
                            "Ukraine (+380)",
                            "United Arab Emirates (+971)",
                            "United Kingdom (+44)",
                            "United States (+1)",
                            "Uruguay (+598)",
                            "Uzbekistan (+998)",
                            "Vanuatu (+678)",
                            "Vatican City (+39-06)",
                            "Venezuela (+58)",
                            "Vietnam (+84)",
                            "Yemen (+967)",
                            "Zambia (+260)",
                            "Zimbabwe (+263)"
                        ],
                        "type": "string",
                        "description": "Select the country to target for phone numbers.",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
