# Instagram Phone Number Scraper (`scrapecraze/instagram-phone-number-scraper`) Actor

Instagram Contact Scraper extracts publicly available profile data including bios, usernames, follower counts, website links, and business contact details listed on public accounts. Ideal for lead generation, influencer outreach, marketing research, and building targeted prospect lists.

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

## Pricing

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

### Instagram Phone Number Scraper 🚀

If you’re trying to build targeted leads, manually hunting for phone numbers across Instagram profiles is slow and unreliable. **Instagram Phone Number Scraper** automatically extracts phone numbers from publicly available Instagram bios, profiles, and posts tied to your keywords—then validates them for your selected country dial code. It works great for Instagram lead scraper phone numbers and anyone running an Instagram contact info scraper workflow. It’s ideal for lead gen teams, analysts, and researchers who need a phone number list at scale without the copy-paste grind—often within minutes for real-world batches.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "platform": "Instagram",
  "keyword": "marketing",
  "title": "Marketing Agency Promo",
  "description": "DM us for bookings • WhatsApp +49 170 123 4567",
  "url": "https://www.instagram.com/exampleprofile/",
  "phone_number": "+491701234567",
  "country": "Germany",
  "dial_code": "+49",
  "proxyGroups": ["legacy"],
  "status": "success",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Confirms the source platform for each record (useful when you combine datasets). |
| `keyword` | array item / string | Shows which keyword produced the contact so you can trace results back to your targeting. |
| `title` | string | A short label pulled from the discovered result, helpful for context during review. |
| `description` | string | The text snippet where a phone number was found (great for QA and filtering). |
| `url` | string | The discovered Instagram page link tied to that phone number. |
| `phone_number` | string | The validated phone number in E.164 format, ready to import into CRMs or lists. |
| `country` | string | The selected country label used for phone-number validation. |
| `dial_code` | string | The dial code matched for the phone-number extraction and validation logic. |
| `proxyGroups` | array | Records the proxy configuration used in the run, useful for troubleshooting and auditing. |
| `status` | string | Indicates whether the record was collected successfully (success/failure). |
| `error_message` | string or null | Contains error details when something goes wrong; `null` when successful. |

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. The actor uses these keywords to find matching Instagram content that contains phone numbers. |
| `platform` | ⬜ | Selects the platform to scrape. This actor supports `Instagram` (default). |
| `country` | ✅ | Chooses the country whose dial code format is used to target and validate phone numbers. |
| `maxPhoneNumbers` | ⬜ | Caps how many phone numbers the scraper will collect before stopping to control runtime and cost. |
| `engine` | ⬜ | Chooses the scraping engine. `cost-effective` is designed to use residential proxies for faster/cheaper scraping, while `legacy` is designed to be more reliable but slower and more expensive. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run using Apify Proxy settings. |
| ↳ `proxyConfiguration` (object) | ⬜ | A proxy configuration object (provided by Apify’s proxy editor). |

***

### What It Does

This actor scrapes Instagram phone numbers at scale from publicly available profile content, then outputs a clean, validated dataset you can act on immediately.

#### Keyword-driven Instagram phone number extraction

You provide a list of `keywords`, and the actor searches for Instagram bios, profiles, and posts related to those terms. It then extracts and validates phone numbers for your selected `country` dial code.

#### Validated phone numbers in a consistent format

Collected phone numbers are normalized into E.164 format and deduplicated so you don’t waste time reprocessing the same contact. This makes the resulting Instagram phone number list scraper output easier to import into outreach tools and spreadsheets.

#### Built-in proxy support for reliable scraping

The actor includes proxy configuration support to help keep scraping stable across larger runs. It’s designed to work smoothly when you need volume for Instagram contact scraper tool workflows.

#### Controlled run size to match your budget

With `maxPhoneNumbers`, you can stop after reaching the amount you need (or set it higher for broader mining). This is useful for Instagram lead scraper phone numbers projects where you want predictable execution.

#### Includes retries and fallbacks for resilience

When pages don’t return results as expected, the actor uses retry logic and fallback behavior to recover where possible. This helps keep your Instagram phone number extraction tool runs productive even when content is sparse or access is temporarily limited.

Overall, the **Instagram Phone Number Scraper** turns Instagram phone number mining into a structured dataset you can use for outreach and analysis.

***

### Why Instagram Phone Number Scraper?

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

#### Outputs phone numbers that are ready to use

Instead of collecting messy text, the actor returns validated, deduplicated phone numbers along with the discovery context (like `description` and the source `url`). That’s what makes it effective for Instagram DM phone number scraper and business outreach lists.

#### Scales with your targeting strategy

Using your own `keywords` and `maxPhoneNumbers`, you control how broad the search is and how quickly you get results. This flexibility is especially helpful for Instagram profile phone number finder use cases.

#### Proxy-aware engine options

You can choose between `engine: "cost-effective"` and `engine: "legacy"` depending on your balance of speed vs reliability needs. That makes the Instagram contacts scraping software workflow easier to tune per project.

***

### Real-World Use Cases

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

**Growth and lead generation teams**\
A marketing manager has a shortlist of niches and needs phone numbers quickly for targeted outreach. They run the actor with a set of `keywords` and the correct `country` dial code, then import the resulting phone\_number list into their outreach workflow without manual cleanup.

**Influencer and partnership researchers**\
An agency researcher is building a creator/brand contact database and needs business contact info extracted from publicly available Instagram content. They use Instagram contact info scraper results to evaluate relevance using the returned `description` and `title`, then enrich records with consistent phone\_number formatting.

**Sales teams running outbound campaigns**\
A sales development lead wants to test a new segment in a specific region, but only wants numbers that match that market. They set the `country` (dial code) and use `maxPhoneNumbers` to control volume, producing a reliable list for calling and WhatsApp-style outreach.

**Automation specialists and data engineers**\
A data engineer needs structured output for downstream processing. They schedule repeated runs, export the dataset, and push results into their pipeline—turning Instagram phone number data mining into an automated refresh cycle.

***

### 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 **Instagram Phone Number Scraper**.

2. **Enter your inputs**\
   Fill in `keywords` and `country` first (these are required). Optionally set `maxPhoneNumbers` to cap the run size.

3. **Configure proxy settings (recommended)**\
   If you’re running larger jobs, set up `proxyConfiguration` using Apify’s proxy options in the UI.

4. **Start the run and watch the live log**\
   Launch the actor and monitor progress in the Logs tab to see how the run behaves.

5. **Open the Dataset tab to see live results**\
   As records are found, they appear in your dataset with fields like `phone_number`, `url`, and `description`.

6. **Export in your preferred format**\
   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, Instagram Phone Number Scraper fits directly into your existing workflow.

You can download your results from the Apify dataset tab in common formats (JSON, CSV, or Excel). This is ideal when you want a quick handoff to a marketer’s spreadsheet or an analyst’s notebook.

For automation, you can connect the actor to your stack using Apify’s API and integrations such as Zapier/Make, and you can trigger downstream actions with webhooks when a run completes. For full details, check the Apify documentation for your preferred integration path.

***

### Pricing

Instagram Phone Number Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. On Apify, you generally start with platform credits on sign-up and run real tests to estimate how many results you’ll get for your specific `keywords`, `country`, and `maxPhoneNumbers`.

For heavier workloads, you can scale using Apify’s paid plans and pay-as-you-go compute (billed on Actor compute unit usage). Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Proxy configuration support | You can provide `proxyConfiguration` in the actor input. |
| Multiple engine choices | Use `engine: "cost-effective"` or `engine: "legacy"` depending on your needs. |
| Run-size control | Use `maxPhoneNumbers` to stop once you’ve collected enough data. |
| Resilience for sparse results | Includes retry logic and fallback behavior when results aren’t returned as expected. |
| Duplicate prevention | Phone numbers are deduplicated using a `seen_numbers` tracking approach. |

**Limitations:** The actor works with **publicly available** Instagram content and focuses on extracting phone numbers that appear in bios, profiles, and posts tied to your keywords. Private or login-gated content is not accessible, and results can vary depending on what phone numbers are actually published.

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

***

### Frequently Asked Questions

#### Is there a free plan?

Yes—Apify provides a free tier with monthly usage credits, which is often enough for several real test runs.

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

No. This actor is designed to scrape phone numbers from publicly available Instagram content without requiring login or an account.

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

Phone number accuracy depends on what’s publicly published in the Instagram bios, profiles, and posts related to your keywords. The actor validates and formats phone numbers into E.164 format before outputting them.

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

You control the maximum number of phone numbers via `maxPhoneNumbers`. The scraper will stop once that limit is reached.

#### How fresh is the data?

The data freshness depends on when Instagram content is accessible during your run. Each run collects what’s publicly visible at the time it’s executed.

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

The actor is built to work with **publicly available data** that you can view without logging in. You’re responsible for complying with GDPR, CCPA, platform terms, and local regulations when using and storing the data.

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

Yes. You can export your dataset from the Apify dashboard (JSON, CSV, or Excel). From there, you can import into tools like Google Sheets or any CRM that accepts CSV/Excel.

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

Yes. You can schedule Apify Actors to run automatically on a recurring basis. Use this for periodic refreshes of your Instagram phone number lists.

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

Yes. Results can be accessed programmatically using the Apify API, making it easy to integrate Instagram Phone Number Scraper into a larger data pipeline.

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

When errors occur, the actor uses retry and fallback behavior where possible and continues collecting results. If a record can’t be pushed successfully, the dataset reflects the failure via error handling fields like `error_message`.

***

### Get Help & Use Responsibly

Got a question about Instagram Phone Number Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We welcome requests like “keyword targeting tweaks” and “better filtering for outreach quality,” and we actively maintain this actor based on feedback.

**Disclaimer:** This actor collects **publicly available data** from Instagram. It does not access private accounts, login-gated pages, or password-protected content. You are responsible for complying with GDPR, CCPA, and Instagram’s Terms of Service when using the output. 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": "Instagram",
  "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("scrapecraze/instagram-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("scrapecraze/instagram-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 scrapecraze/instagram-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Phone Number Scraper",
        "description": "Instagram Contact Scraper extracts publicly available profile data including bios, usernames, follower counts, website links, and business contact details listed on public accounts. Ideal for lead generation, influencer outreach, marketing research, and building targeted prospect lists.",
        "version": "0.1",
        "x-build-id": "ULVjxn765Ifj2TG0R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapecraze~instagram-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapecraze-instagram-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/scrapecraze~instagram-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapecraze-instagram-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/scrapecraze~instagram-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapecraze-instagram-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": [
                            "Instagram"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instagram"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
