# Instagram Profile Phone Number Scraper By Keyword (`scraperoka/instagram-profile-phone-number-scraper-by-keyword`) Actor

📞✨ Phone Number Scraper By Keyword finds business contact numbers from targeted sources using keywords. 🔎 Automate lead discovery for sales, outreach & market research—save time, boost accuracy, and reach the right customers faster.

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

## Pricing

from $0.01 / 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 🎯

Manually visiting hundreds of Instagram profiles to find phone numbers wastes hours you don’t have. **Instagram Phone Number Scraper** automates phone-number discovery from public Instagram profiles using your keywords and country filters. This Instagram phone number scraper is built for lead-gen teams, marketers, and researchers who want Instagram phone number data quickly—collecting up to thousands of results in minutes (depending on your input and plan).

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "keyword": "Fitness",
  "title": "Fitness Studio LA",
  "description": "Coach • Personal Training • Call us: (213) 555-0199\nDMs welcome",
  "url": "https://www.instagram.com/fitnessstudio_la/",
  "phone_number": "+12135550199",
  "country": "United States",
  "dial_code": "+1"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which search keyword led to this profile (useful for segmenting your leads) |
| `title` | string | The Instagram profile name shown for the result |
| `description` | string | The text the actor used to detect the phone number (helps with verification) |
| `url` | string | Direct link to the Instagram profile for quick manual follow-up |
| `phone_number` | string | The extracted phone number in E.164 format |
| `country` | string | The target country label applied to the result |
| `dial_code` | string | The dial prefix that matched your selected target country |
| `platform` | string | The platform value used in each pushed row (`Instagram`) |
| `status` | string | A practical success/failure indicator (included in failure-state handling) |
| `error_message` | string | Populated when something goes wrong while collecting or pushing data |

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

***

### Why Instagram Phone Number Scraper?

There are a lot of ways to pull contact data from Instagram—here’s what sets Instagram Phone Number Scraper apart.

#### Keyword-driven discovery

You provide `keywords` and (optionally) `location`, and the actor searches for matching profiles, building an Instagram phone number list based on what’s publicly available.

#### Country and dial-code targeting

By selecting `country`, the actor applies the corresponding dialing context so your output focuses on the regions you care about for outreach.

#### Deduplicated phone numbers

The actor tracks and avoids previously collected phone numbers during the run, helping you build cleaner, non-redundant lead lists.

#### Stops safely at your chosen limit

You control how many numbers to collect with `maxPhoneNumbers`, so your dataset stays aligned with your pipeline and capacity.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["Fitness", "Photographer", "Model"],
  "location": "Los Angeles",
  "country": "United States (+1)",
  "maxPhoneNumbers": 50,
  "scrapeLeadsWithEmail": false
}
```

> Note: The actor’s required input is `keywords`, and it also uses `country` and `maxPhoneNumbers` to control targeting and stopping conditions.

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | List of search terms used to discover relevant Instagram profiles (each keyword is processed separately) |
| `location` | ⬜ | Optional location text to narrow discovery to a specific place; leave empty for broader results |
| `country` | ⬜ | Select the target country whose dialing context will be used for phone number extraction |
| `maxPhoneNumbers` | ⬜ | Stop scraping after this many phone numbers are collected |
| `scrapeLeadsWithEmail` | ⬜ | If enabled, will focus on profiles that have emails in their bio; if disabled, it will find all profiles matching keywords |

***

### Core Capabilities

#### Extracts Instagram profile phone numbers

Instagram Phone Number Scraper extracts phone numbers found in publicly available Instagram profile text and returns them in a consistent dataset row that includes profile context (`title`, `description`, and `url`).

#### Flexible targeting for outreach lists

Use `keywords`, optionally add `location`, and choose a specific `country` to generate an Instagram leads phone number scraper output tailored to your outreach region.

#### Resilient scraping with controlled runtime

The actor is designed to keep runs moving and avoid runaway collection by honoring your `maxPhoneNumbers` stopping rule and handling interruptions via persisted progress.

#### Structured, integration-ready output

Every result pushed to your dataset includes the fields you need to verify and act—most importantly `phone_number` plus the profile `url` and associated `keyword`.

#### Built for automation and scale

This Instagram contact info scraper is ideal for repeatable prospecting runs where you want an Instagram phone number data scraper that plugs into your existing workflow and processes profiles in bulk.

***

### Who Gets the Most Out of This

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

**Influencer marketing managers** — use it to build an account shortlist by keyword, then quickly validate phone contacts from the profile `url` while segmenting results by `keyword`.

**Sales development reps** — run focused keyword searches for their ICP, extract the Instagram business contact number, and compile a usable list for outbound calling without manually opening profile pages.

**Recruiters and talent sourcers** — identify creators, studios, or agencies with specific specialties (for example, “fitness” or “photographer”) and turn profile phone numbers into a targeted outreach pipeline.

**Freelance researchers** — generate an Instagram phone number list scraper dataset with profile context (`title`, `description`, `url`) to support analysis and reporting.

**Data engineers and automation specialists** — schedule repeat runs and push the resulting rows into downstream systems, using the consistent dataset structure for reliable updates and deduplication logic.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Instagram Phone Number Scraper from start to finish:

1. **Open the actor on Apify** — start from the actor’s page on [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — add `keywords`, select your `country`, and set `maxPhoneNumbers` based on how large your Instagram phone number harvesting tool output should be.
3. **Configure proxy settings** — if you’re running larger jobs, enable the available proxy configuration for more reliable scraping.
4. **Hit Run and watch the live log** — monitor progress and confirm the actor is collecting phone numbers for your selected keywords.
5. **View results in the dataset tab** — each result appears with `phone_number`, `url`, `keyword`, and supporting profile text.
6. **Export as JSON, CSV, or Excel** — download directly from the dataset export options to use in your CRM, spreadsheet, or reporting workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Instagram Phone Number Scraper plugs directly into your existing workflow.

You can export your Apify dataset as **JSON, CSV, or Excel** from the dataset tab. If you want to move data into other systems, connect the actor run to your automation stack using Apify API access or no-code automation (for example, Zapier/Make).

For deeper automation (programmatic triggers, retrieving results, and integrating with pipelines), use the Apify API documentation at: https://apify.com/docs/api and pair it with your own webhook or scheduling setup on your side.

***

### Pricing & Free Trial

Instagram Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Apify uses a pay-as-you-go model based on platform compute units, and subscription plans are available for higher-volume usage. Exact pricing and what’s included can be confirmed on the Apify pricing page—this README keeps numbers general so you don’t get misled.

Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Output consistency | Results are pushed incrementally with consistent dataset fields for each discovered phone number |
| Stopping behavior | Your run stops after collecting up to `maxPhoneNumbers` phone numbers |
| Progress resilience | The actor persists progress so runs can resume instead of restarting from scratch |
| Retry resilience | Designed to keep runs going even when some requests fail |
| Deduplication | Avoids collecting the same phone number more than once during the run |

**Limitations:** Private or login-gated Instagram content isn’t accessible, and you can only extract what’s publicly available. Phone numbers won’t be found on profiles that don’t publish them in the accessible bio or profile text.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier for trying Instagram Phone Number Scraper, and you can run smaller tests without committing to paid usage immediately.

#### Do I need to log in to Instagram to use this?

No. Instagram Phone Number Scraper is designed to work with publicly available Instagram profile data, without requiring an Instagram account login.

#### How accurate is the data?

Accuracy depends on what profile owners publish. The actor extracts phone numbers from the profile text it can access and returns them alongside the profile `url` and `description` so you can quickly verify.

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

You control this using `maxPhoneNumbers`. Set it to the number of Instagram phone numbers you want in your dataset, and the actor will stop after reaching that cap.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor. If you need up-to-date Instagram phone number extraction tool results, schedule or re-run the job on your desired cadence.

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

The actor accesses **publicly available data**. Compliance with GDPR, CCPA, platform Terms of Service, and any applicable local regulations is your responsibility when using or storing the collected data.

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

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dashboard, and then import it into any tool that supports those formats.

#### Can I run this on a schedule automatically?

Yes. You can use Apify scheduling options (or your own scheduling via API and webhooks) to run Instagram phone number scraper jobs automatically at set intervals.

#### Can I access this via API?

Yes. You can trigger the actor via the Apify API and retrieve results programmatically. See https://apify.com/docs/api for API details.

#### What happens if the actor hits an error?

If an error occurs for a specific request or row, the run continues as designed and you’ll see the behavior reflected in the dataset output and run logs. The actor also persists progress so you can resume rather than losing all work.

***

### Need Help or Have a Request?

Got a question about Instagram Phone Number Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>.\
We’re happy to discuss improvements—especially things like batch CSV upload workflows and webhook notifications on completion.\
Thanks for building with Instagram phone number extraction tool data responsibly!

***

### Disclaimer & Responsible Use

*Instagram Phone Number Scraper is the fastest, most reliable way to collect publicly available Instagram phone numbers at scale — start your free run today.*

This actor collects **publicly available data** from Instagram profiles and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using or storing the data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter keywords to search for (e.g., 'Model', 'Fitness', 'Photographer').

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

Filter by location (e.g., 'Los Angeles', 'New York'). Leave empty for global search.

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

Select the country to target for phone numbers.

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

Stop scraping after this many phone numbers are collected.

## Actor input object example

```json
{
  "keywords": [
    "Model",
    "Fitness",
    "Photographer"
  ],
  "country": "United States (+1)",
  "maxPhoneNumbers": 20
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "Model",
        "Fitness",
        "Photographer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/instagram-profile-phone-number-scraper-by-keyword").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": [
        "Model",
        "Fitness",
        "Photographer",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/instagram-profile-phone-number-scraper-by-keyword").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": [
    "Model",
    "Fitness",
    "Photographer"
  ]
}' |
apify call scraperoka/instagram-profile-phone-number-scraper-by-keyword --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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