# X/Twitter Phone Number Scraper (`scrapevanta/twitter-phone-number-scraper`) Actor

X/Twitter Phone Number Scraper extracts publicly available phone numbers and contact details from X (Twitter) profiles and posts. Collect profile data, usernames, bios, websites, and phone numbers for lead generation, market research, outreach campaigns, and business prospecting.

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

## Pricing

from $5.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

### Twitter Phone Number Scraper ⚡

Getting phone numbers from Twitter bios, profiles, and posts usually means hours of manual copy‑paste—and still misses key leads. **Twitter Phone Number Scraper** automates Twitter phone number extraction at scale using your keywords and a country dial code, saving you serious time on lead research. Use it to run a Twitter contact scraper workflow for outreach, sales prospecting, and research projects—without building your own scraping pipeline. It’s built for marketers, data analysts, and researchers who need Twitter lead generation phone numbers fast. In one run, you can collect up to your chosen **Max Phone Numbers** cap and stream results into your Apify dataset as they’re found.  

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "platform": "Twitter",
  "keyword": "marketing",
  "title": "Example Profile: Marketing Founder",
  "description": "Founder | 📞 +44 7700 900123 | WhatsApp available",
  "url": "https://x.com/exampleprofile",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44",
  "proxyGroups": [
    "legacy"
  ]
}
````

Here’s what the actor outputs per found phone number:

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Confirms the source platform (always `Twitter`) for consistent downstream processing. |
| `keyword` | string | Which keyword triggered this match—useful for relevance scoring and analysis. |
| `title` | string | The extracted page/search result title, helpful for context when reviewing leads. |
| `description` | string | The text where the phone number was detected (bio/profile/post snippet). |
| `url` | string | The link to the page where the phone number was found. |
| `phone_number` | string | The collected phone number in E.164 format for clean importing into CRMs. |
| `country` | string | The selected country name tied to the dial code filtering. |
| `dial_code` | string | The dial code used while scraping, so you can verify targeting at a glance. |
| `proxyGroups` | array | The proxy configuration used for the run (as provided by the actor input). |
| `status` | — | Status-like handling exists in logging (errors can occur during data push), but output fields are the dataset rows shown above. |
| `error_message` | — | Error details are logged; the dataset rows contain the fields above when data is pushed successfully. |

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"],
  "platform": "Twitter",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords the scraper uses to find Twitter bios, profiles, and posts that relate to your search intent. |
| `platform` | ⬜ | Selects the platform. This actor supports `Twitter` (and defaults to it). |
| `country` | ✅ | Selects the target country whose dial code is used to extract matching phone numbers. |
| `maxPhoneNumbers` | ⬜ | Sets an upper limit for how many phone numbers to collect before stopping. |
| `engine` | ⬜ | Chooses the scraping engine. `Cost Effective (New)` prioritizes speed/efficiency, while `Legacy` prioritizes reliability. |
| `proxyConfiguration` | ⬜ | Lets you configure proxies for the Actor run. |

***

### What It Does

This actor searches Twitter-related public web content connected to your keywords and extracts phone numbers tied to the dial code you select.

#### Extracts phone numbers tied to your dial code

**Twitter Phone Number Scraper** focuses on phone numbers found in Twitter bios, profiles, and posts related to your keywords. It validates and formats detected numbers into E.164, so your dataset is consistent for analysis and importing.

#### Built for Twitter contact scraper workflows

You provide a keyword list and a country, and the actor returns a dataset where each record includes the matched keyword, source text (`description`), and source link (`url`). This makes it straightforward to build lead lists, run QA checks, and compare results across keyword sets.

#### Uses your targeting inputs to reduce noise

Selecting more specific keywords and the right country dial code improves the relevancy of matches you’ll see in results. If you’re aiming for Twitter scrape phone numbers for outreach, this helps keep your dataset concentrated on the segments you care about.

#### Writes results immediately to your Apify dataset

As soon as a phone number is found, the actor pushes a dataset row with fields like `phone_number`, `url`, and `country`. That means you don’t have to wait for the entire run to finish before you can start exporting or reviewing partial results.

#### Handles errors without destroying your whole run

If individual pushes fail, the actor logs the error and continues processing. That makes it more resilient for real-world lead generation phone numbers harvesting jobs where some requests may intermittently fail.

Overall, **Twitter Phone Number Scraper** turns keyword-based Twitter phone number harvesting software workflows into a repeatable, export-ready process.

***

### Why Twitter Phone Number Scraper?

There are plenty of ways to pull contact details from Twitter—here’s why **Twitter Phone Number Scraper** stands out.

#### Faster to get to a usable lead list

Instead of manual extraction, this tool collects phone numbers up to your configured limit and streams structured rows into your dataset. That’s ideal when you need Twitter user phone number finder results quickly to keep outreach moving.

#### Keyword-first results for cleaner relevance

Because you drive the search with your own `keywords`, the dataset is organized around your target themes (for example, marketing, founder, or any list you provide). This supports a Twitter contact details scraper workflow without extra re-tagging.

#### Straightforward, integration-ready output

Each row includes `phone_number`, `url`, and the text snippet (`description`) where it was detected. That makes it easy to export to your tools and keep an audit trail for why a lead was captured.

***

### Real-World Use Cases

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

**Sales Development Teams**\
Your pipeline needs Twitter contact details scraper leads, but manual searching doesn’t scale. You run Twitter Phone Number Scraper with a focused keyword list and the right country dial code, then import the resulting phone numbers into your outreach workflow—so lead follow-up happens faster.

**Marketing Teams Running Outreach Campaigns**\
You’re launching a campaign and need consistent lead data for targeting founders, marketers, and similar niches. The actor helps you extract Twitter lead generation phone numbers by searching for the keywords you care about and exporting clean E.164 numbers for consistent segmentation.

**Freelance Researchers & Data Analysts**\
You have a research brief and a deadline, and you need contact signals collected systematically from publicly available sources. You run Twitter phone number extraction tool jobs with multiple keywords, analyze results by keyword relevance, and deliver exportable datasets.

**Automation & Data Engineers**\
You want an automated step in your data pipeline rather than one-off manual lead scraping. After each run, you export the dataset from the Apify dashboard or retrieve results via the Apify API to feed downstream systems.

***

### How to Run It

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **Twitter Phone Number Scraper**.
2. **Enter your inputs** — set `keywords` (required) and `country` (required), then optionally adjust `maxPhoneNumbers`, `engine`, and `proxyConfiguration`.
3. **Choose proxy settings (optional but recommended for scale)** — configure `proxyConfiguration` for your run.
4. **Start the run** — watch the live logs for progress as the actor searches and extracts phone numbers.
5. **Open the Dataset tab** — results are pushed into the dataset as they’re found.
6. **Export your data** — download from the Apify dataset tab in your preferred format (JSON, CSV, or Excel).
7. **Refine and re-run** — if results seem low, broaden your keyword list and/or increase `maxPhoneNumbers`.

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

***

### Export & Integration Options

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

You can export your full dataset as JSON, CSV, or Excel from the Apify dashboard (from the dataset tab). This makes it easy to move Twitter phone number search tool results into spreadsheets, CRMs, or analytics tools.

If you want automation, you can use Apify API access to fetch results programmatically, or set up no-code flows with Zapier/Make to push data into other apps. For additional orchestration, you can also trigger downstream actions when a run completes using webhooks. For deeper details, refer to the Apify documentation for API, datasets, and integrations.

***

### Pricing

Twitter Phone Number Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier usage is backed by **$5 platform credits** on sign-up, which is often enough for several real test runs.

For heavier workloads, you can scale using Apify’s pay-as-you-go model (billed per Actor compute unit / CU) and upgrade plans for larger teams and larger scraping jobs. Start free at [apify.com](https://apify.com) — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Proxy support | You can configure proxies for the Actor run via `proxyConfiguration`. |
| Engine choice | You can select `engine` between `cost-effective` and `legacy` modes. |
| Result cap | `maxPhoneNumbers` stops the run once your limit is reached. |
| Data streaming | Results are pushed to the dataset as they’re found. |
| Error tolerance | Individual data push errors are logged so processing can continue. |

Limitations: This actor extracts phone numbers from publicly available sources related to Twitter content, but it cannot access private or login-gated data. If Twitter bios/profiles don’t contain phone numbers matching your dial code filters, results may be limited—try broader keywords and/or a higher `maxPhoneNumbers` cap.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier for actors, allowing you to run Twitter Phone Number Scraper with starter credits before scaling.

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

No. The actor is designed to work with publicly available data and does not require an account login as part of the scraping run.

#### How accurate is the extracted data?

Accuracy depends on what phone numbers are actually present in the publicly available Twitter bios, profiles, and posts related to your keywords. The actor extracts and formats phone numbers, and outputs them as dataset rows with the source `url` and `description` for context.

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

You control the maximum with `maxPhoneNumbers`. The scraper will stop once this limit is reached, helping you cap costs and runtime.

#### How fresh is the data?

Freshness depends on what is currently visible in publicly available Twitter content at the time of your run. For up-to-date results, rerun the actor when you need the latest contact details.

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

The actor works with **publicly available data**. Compliance with GDPR, CCPA, and platform Terms of Service is still your responsibility when you collect, store, and use the data.

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

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

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

Yes. With Apify, you can schedule runs and automate repeated scraping workflows, so Twitter phone number extraction tool jobs run on a cadence you define.

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

Yes. You can retrieve results programmatically using the Apify API, making it easy to integrate Twitter contact scraper outputs into your pipelines.

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

The actor logs errors (including issues during dataset push). It is built to keep processing rather than failing the whole run instantly, so you can still collect partial results.

***

### Get Help & Use Responsibly

Got a question about Twitter Phone Number Scraper or a feature you'd like added? Reach out to us at <dataforleads@gmail.com>. We’re happy to help with setup questions, troubleshooting, and improvement requests like better keyword targeting behaviors or workflow improvements.

***

**publicly available data** only — this actor does not access private accounts, login-gated pages, or password-protected content. You’re responsible for complying with GDPR, CCPA, and the relevant platform Terms of Service when collecting and using the data. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for. (Example: John, marketing, etc.)

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

Select platform.

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

Select a country to scrape related phone numbers.

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

Maximum number of phone numbers to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

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

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "marketing",
    "founder"
  ],
  "platform": "Twitter",
  "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",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapevanta/twitter-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("scrapevanta/twitter-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 scrapevanta/twitter-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X/Twitter Phone Number Scraper",
        "description": "X/Twitter Phone Number Scraper extracts publicly available phone numbers and contact details from X (Twitter) profiles and posts. Collect profile data, usernames, bios, websites, and phone numbers for lead generation, market research, outreach campaigns, and business prospecting.",
        "version": "0.1",
        "x-build-id": "3lWbHL42Udpd8YT0r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~twitter-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-twitter-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/scrapevanta~twitter-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-twitter-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/scrapevanta~twitter-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-twitter-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": "A list of keywords to search for. (Example: John, marketing, etc.)",
                        "default": [
                            "marketing",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Twitter"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Twitter"
                    },
                    "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.",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of phone numbers to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
