# Swiggy Phone Number Scraper (`scrapebase/swiggy-phone-number-scraper`) Actor

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Swiggy** Phone Number Scraper 📱

The **Swiggy** Phone Number Scraper allows users to **extract** critical **contact** details and other valuable information from the **Swiggy** platform. It is designed to provide accurate and structured **data** to meet various business and research needs.

This tool uses advanced **Swiggy** **data** scraping software to ensure that the **data** **extract**ion process is efficient and reliable. Users can **extract** **Swiggy** **contact** details, such as **phone numbers** and other customer information, with ease.

The scraper also supports **Swiggy** API phone number **extract**ion, making it a robust solution for accessing **data** at scale. Whether you need to gather customer details for marketing or research, this tool simplifies the process and ensures high-quality results.

Swiggy Phone Number Scraper is a powerful tool designed to help you extract essential contact details from the Swiggy platform efficiently. It is ideal for businesses and researchers looking to streamline their data collection process.

This Swiggy Phone Number Scraper acts as a reliable Swiggy contact extractor, enabling users to gather accurate phone numbers and other customer information quickly. It simplifies the process of obtaining valuable data for marketing and outreach purposes.

With the Swiggy Phone Number Scraper, you can access Swiggy customer data scraper functionalities that provide structured and usable information. This tool ensures that you save time and effort while collecting critical contact details.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Customer Phone Numbers | Retrieve accurate and verified phone numbers of Swiggy users for outreach and communication. |
| Customer Names | Extract customer names to personalize your marketing or communication efforts effectively. |
| Order Details | Access order-related information, including order history and preferences, for better insights. |
| Delivery Addresses | Gather delivery address details to enhance logistics and delivery efficiency. |
| User Profiles | Extract Swiggy user information scraper data, including profile details, for targeted marketing campaigns. |
| Restaurant Contact Information | Retrieve restaurant contact details to build partnerships or manage supplier relationships. |
| Customer Feedback | Collect customer reviews and feedback to improve your services and offerings. |
| Loyalty Program Data | Access information on customer loyalty programs to analyze engagement and retention metrics. |

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

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

- ⭐ **Automated** data extraction ensures fast and accurate results for **Swiggy** Phone Number Scraper users
- ⭐ Supports **Swiggy** data mining tool capabilities enabling large-scale data collection for businesses
- ⭐ **Customizable** scraping options allow users to target specific data fields such as phone numbers and addresses
- ⭐ The **Swiggy** Phone Number Scraper integrates with **Swiggy** contact scraping service APIs for seamless data retrieval
- ⭐ User-friendly interface simplifies the extraction process even for non-technical users
- ⭐ **Advanced** filtering options help refine data results ensuring only relevant information is collected
- ⭐ **Secure** and compliant design ensures that data scraping adheres to ethical and legal standards
- ⭐ Real-time data updates provide users with the most current information available on **Swiggy**
- ⭐ Supports bulk data extraction making it ideal for businesses with high-volume data needs
- ⭐ Offers detailed logs and reports to monitor and analyze the scraping process effectively
- ⭐ The **Swiggy** Phone Number Scraper is compatible with multiple platforms and devices for added convenience
- ⭐ **Comprehensive** support and documentation ensure users can maximize the tools potential

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

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

1. ✅ Download and install the **Swiggy** Phone Number Scraper on your preferred device
2. ✅ Log in to your account and configure the scraper settings to match your data extraction needs
3. ✅ **Select** the **Swiggy** contact extractor feature to begin the scraping process
4. ✅ Specify the data fields you want to extract such as phone numbers or customer profiles
5. ✅ Use the **Swiggy** customer data scraper to filter and refine your search results for accuracy
6. ✅ Initiate the scraping process and monitor the progress through the user-friendly dashboard
7. ✅ **Export** the extracted data in your preferred format for further analysis or use
8. ✅ Leverage the **Swiggy** phone number tool to integrate the data into your CRM or marketing systems

### Use Cases 🎯

Business Outreach
🎯 **Use** the **Swiggy** Phone Number Scraper to gather customer phone numbers for targeted marketing campaigns
🎯 Extract **Swiggy** contact details to improve customer communication and engagement strategies

Market Research
🎯 Utilize the **Swiggy** data scraping software to analyze customer preferences and trends
🎯 Leverage extracted data to gain insights into customer behavior and improve service offerings

Partnership Development
🎯 Access restaurant contact information to establish new partnerships or collaborations
🎯 **Use** the **Swiggy** API phone number extraction feature to streamline supplier communication

Agency Services
🎯 Provide **Swiggy** contact scraping service to clients looking for targeted customer data
🎯 **Use** the **Swiggy** data mining tool to deliver actionable insights for marketing and outreach

### Why choose us? 💎

The **Swiggy** Phone Number Scraper stands out as a **reliable** and efficient tool for extracting customer contact details. It offers **advanced** features like **Swiggy** API phone number extraction and customizable scraping options.

The tool is designed to meet the needs of businesses, researchers, and agencies looking for accurate and structured data. With its **user-friendly** interface and robust capabilities, the **Swiggy** Phone Number Scraper simplifies complex data collection tasks.

It ensures compliance with legal and ethical standards, making it a trustworthy choice for data scraping. By using the **Swiggy** Phone Number Scraper, you can access **Swiggy** user information scraper functionalities to enhance your marketing and outreach efforts.

The tool also supports bulk data extraction, making it ideal for businesses with high-volume data requirements. Choose the **Swiggy** Phone Number Scraper for its reliability, scalability, and comprehensive support.

### **Swiggy** Phone Number Scraper Scalability 📈

The **Swiggy** Phone Number Scraper is designed to handle data extraction tasks of any scale. It uses **advanced** **Swiggy** data mining tool capabilities to ensure **efficient** and accurate results.

Whether you need to extract a small dataset or perform **large-scale** scraping, this tool can meet your requirements. The **Swiggy** Phone Number Scraper supports bulk data extraction, making it suitable for businesses with **extensive** data needs.

Its integration with **Swiggy** contact scraping service APIs ensures **seamless** and reliable performance. The tool is optimized for speed and accuracy, allowing users to extract data in real time.

With its scalable architecture, the **Swiggy** Phone Number Scraper can adapt to the growing demands of your business.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that the use of the **Swiggy** Phone Number Scraper complies with local data protection laws
⚖️ **Do not** use the **Swiggy** contact extractor to collect data without proper authorization or consent
⚖️ **Avoid** scraping sensitive or personal information that violates **Swiggy**s terms of service
⚖️ **Use** the **Swiggy** customer data scraper ethically and responsibly to maintain data integrity
⚖️ Respect **Swiggy**s intellectual property rights when using the **Swiggy** phone number tool
⚖️ Always inform users if their data is being collected through the **Swiggy** contact scraping service
⚖️ **Adhere** to **Swiggy**s API usage policies when performing **Swiggy** API phone number extraction
⚖️ Regularly review and update your data scraping practices to ensure compliance with legal standards

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Swiggy Phone Number Scraper"],
  "country": "Global",
  "maxPhoneNumbers": 20,
  "platform": "Swiggy",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxPhoneNumbers | Maximum phone numbers to collect (default 20) |
| platform | Platform to scrape (Swiggy) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "platform": "Swiggy",
    "keyword": "Swiggy Phone Number Scraper",
    "title": "Example Swiggy profile",
    "description": "Example description with phone number",
    "url": "https://www.example.com/example/",
    "phone_number": "+1234567890",
    "country": "Global",
    "dial_code": "Auto-detected"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| platform | Identifies Swiggy as the source |
| keyword | Keyword that triggered the result (Swiggy Phone Number Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Swiggy profile link |
| phone\_number | Extracted phone number with Auto-detected dial code |
| country | Country setting (Global) |
| dial\_code | Dial code (Auto-detected) |

### FAQ ❓

#### What is the Swiggy **Phone Number Scraper**?

The Swiggy Phone Number Scraper is a tool designed to extract customer **phone numbers** and other contact details from the Swiggy platform.

#### How does the Swiggy contact **extract**or work?

The Swiggy contact extractor uses advanced algorithms to identify and retrieve contact information from Swiggy's database.

#### Can I **extract** Swiggy contact details in bulk?

**Yes**, the Swiggy Phone Number Scraper supports bulk data extraction for high-volume needs.

#### Is the Swiggy customer data scraper easy to use?

**Yes**, the Swiggy customer data scraper features a **user-friendly** interface that simplifies the extraction process.

#### Does the Swiggy phone number tool comply with **legal** standards?

**Yes**, the Swiggy phone number tool is designed to adhere to legal and ethical guidelines for data scraping.

#### Can I use the Swiggy data scraping software for research purposes?

**Yes**, the Swiggy data scraping software is ideal for market research and customer analysis.

#### What data formats are supported by the Swiggy API phone number **extract**ion?

The Swiggy API phone number extraction supports various formats, including **CSV** and **JSON**, for easy integration.

#### Is the Swiggy user information scraper customizable?

**Yes**, the Swiggy user information scraper allows you to customize the data fields you want to extract.

#### What industries can benefit from the Swiggy customer phone number finder?

Industries like marketing, logistics, and research can benefit greatly from the Swiggy customer phone number finder.

#### Does the Swiggy data mining tool offer support for **large-scale** scraping?

**Yes**, the Swiggy data mining tool is designed to handle large-scale data extraction efficiently.

#### How **secure** is the Swiggy contact scraping service?

The Swiggy contact scraping service is built with security features to protect user data and ensure **compliance**.

#### Can I integrate the Swiggy **Phone Number Scraper** with other tools?

**Yes**, the Swiggy Phone Number Scraper supports integration with CRM and marketing platforms.

#### What is the accuracy of the data **extract**ed using the Swiggy **Phone Number Scraper**?

The Swiggy Phone Number Scraper ensures high accuracy by using advanced algorithms and real-time updates.

#### Is there a **limit** to the data I can **extract** with the Swiggy **Phone Number Scraper**?

**No**, the Swiggy Phone Number Scraper is scalable and supports unlimited data extraction based on your requirements.

#### Does the Swiggy **Phone Number Scraper** offer **customer support**?

**Yes**, the Swiggy Phone Number Scraper provides comprehensive support and documentation for users.

# Actor input Schema

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

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

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

Select platform. For now this actor targets Swiggy via google.com SERP.

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

Select a country to scrape related phone numbers. The dial code is used to normalize and filter phone numbers.

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

Maximum number of phone numbers to collect per keyword. The scraper will stop once this limit is reached.

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

Choose scraping engine. 'cost-effective' uses RESIDENTIAL proxies; 'legacy' uses GOOGLE\_SERP proxy.

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

Configure proxies for this Actor (Apify proxy). The actor will enforce legal GOOGLE\_SERP or RESIDENTIAL groups depending on Engine.

## Actor input object example

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

# API

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

## JavaScript example

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

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebase/swiggy-phone-number-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "keywords": ["marketing"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapebase/swiggy-phone-number-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ]
}' |
apify call scrapebase/swiggy-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiggy Phone Number Scraper",
        "version": "0.1",
        "x-build-id": "Tr6dJVxfQXjuxomAq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~swiggy-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-swiggy-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/scrapebase~swiggy-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-swiggy-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/scrapebase~swiggy-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-swiggy-phone-number-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords",
                    "country"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords / Usernames / URLs",
                        "type": "array",
                        "description": "A list of keywords, Swiggy usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Swiggy"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Swiggy via google.com SERP.",
                        "default": "Swiggy"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Afghanistan (+93)",
                            "Albania (+355)",
                            "Algeria (+213)",
                            "Andorra (+376)",
                            "Angola (+244)",
                            "Antigua And Barbuda (+1-268)",
                            "Argentina (+54)",
                            "Armenia (+374)",
                            "Australia (+61)",
                            "Austria (+43)",
                            "Azerbaijan (+994)",
                            "Bahamas (+1-242)",
                            "Bahrain (+973)",
                            "Bangladesh (+880)",
                            "Barbados (+1-246)",
                            "Belarus (+375)",
                            "Belgium (+32)",
                            "Belize (+501)",
                            "Benin (+229)",
                            "Bhutan (+975)",
                            "Bolivia (+591)",
                            "Bosnia And Herzegovina (+387)",
                            "Botswana (+267)",
                            "Brazil (+55)",
                            "Brunei (+673)",
                            "Bulgaria (+359)",
                            "Burkina Faso (+226)",
                            "Burundi (+257)",
                            "Cambodia (+855)",
                            "Cameroon (+237)",
                            "Canada (+1)",
                            "Cape Verde (+238)",
                            "Central African Republic (+236)",
                            "Chad (+235)",
                            "Chile (+56)",
                            "China (+86)",
                            "Colombia (+57)",
                            "Comoros (+269)",
                            "Congo (Democratic Republic) (+243)",
                            "Congo (Republic) (+242)",
                            "Costa Rica (+506)",
                            "Croatia (+385)",
                            "Cuba (+53)",
                            "Cyprus (+357)",
                            "Czech Republic (+420)",
                            "Denmark (+45)",
                            "Djibouti (+253)",
                            "Dominica (+1-767)",
                            "Dominican Republic (+1-809)",
                            "East Timor (+670)",
                            "Ecuador (+593)",
                            "Egypt (+20)",
                            "El Salvador (+503)",
                            "Equatorial Guinea (+240)",
                            "Eritrea (+291)",
                            "Estonia (+372)",
                            "Eswatini (+268)",
                            "Ethiopia (+251)",
                            "Fiji (+679)",
                            "Finland (+358)",
                            "France (+33)",
                            "Gabon (+241)",
                            "Gambia (+220)",
                            "Georgia (+995)",
                            "Germany (+49)",
                            "Ghana (+233)",
                            "Greece (+30)",
                            "Grenada (+1-473)",
                            "Guatemala (+502)",
                            "Guinea (+224)",
                            "Guinea-Bissau (+245)",
                            "Guyana (+592)",
                            "Haiti (+509)",
                            "Honduras (+504)",
                            "Hungary (+36)",
                            "Iceland (+354)",
                            "India (+91)",
                            "Indonesia (+62)",
                            "Iran (+98)",
                            "Iraq (+964)",
                            "Ireland (+353)",
                            "Israel (+972)",
                            "Italy (+39)",
                            "Jamaica (+1-876)",
                            "Japan (+81)",
                            "Jordan (+962)",
                            "Kazakhstan (+7)",
                            "Kenya (+254)",
                            "Kiribati (+686)",
                            "Korea, North (+850)",
                            "Korea, South (+82)",
                            "Kuwait (+965)",
                            "Kyrgyzstan (+996)",
                            "Laos (+856)",
                            "Latvia (+371)",
                            "Lebanon (+961)",
                            "Lesotho (+266)",
                            "Liberia (+231)",
                            "Libya (+218)",
                            "Liechtenstein (+423)",
                            "Lithuania (+370)",
                            "Luxembourg (+352)",
                            "Madagascar (+261)",
                            "Malawi (+265)",
                            "Malaysia (+60)",
                            "Maldives (+960)",
                            "Mali (+223)",
                            "Malta (+356)",
                            "Marshall Islands (+692)",
                            "Mauritania (+222)",
                            "Mauritius (+230)",
                            "Mexico (+52)",
                            "Micronesia (+691)",
                            "Moldova (+373)",
                            "Monaco (+377)",
                            "Mongolia (+976)",
                            "Montenegro (+382)",
                            "Morocco (+212)",
                            "Mozambique (+258)",
                            "Myanmar (+95)",
                            "Namibia (+264)",
                            "Nauru (+674)",
                            "Nepal (+977)",
                            "Netherlands (+31)",
                            "New Zealand (+64)",
                            "Nicaragua (+505)",
                            "Niger (+227)",
                            "Nigeria (+234)",
                            "North Macedonia (+389)",
                            "Norway (+47)",
                            "Oman (+968)",
                            "Pakistan (+92)",
                            "Palau (+680)",
                            "Panama (+507)",
                            "Papua New Guinea (+675)",
                            "Paraguay (+595)",
                            "Peru (+51)",
                            "Philippines (+63)",
                            "Poland (+48)",
                            "Portugal (+351)",
                            "Qatar (+974)",
                            "Romania (+40)",
                            "Russia (+7)",
                            "Rwanda (+250)",
                            "Saint Kitts And Nevis (+1-869)",
                            "Saint Lucia (+1-758)",
                            "Saint Vincent And The Grenadines (+1-784)",
                            "Samoa (+685)",
                            "San Marino (+378)",
                            "Sao Tome And Principe (+239)",
                            "Saudi Arabia (+966)",
                            "Senegal (+221)",
                            "Serbia (+381)",
                            "Seychelles (+248)",
                            "Sierra Leone (+232)",
                            "Singapore (+65)",
                            "Slovakia (+421)",
                            "Slovenia (+386)",
                            "Solomon Islands (+677)",
                            "Somalia (+252)",
                            "South Africa (+27)",
                            "South Sudan (+211)",
                            "Spain (+34)",
                            "Sri Lanka (+94)",
                            "Sudan (+249)",
                            "Suriname (+597)",
                            "Sweden (+46)",
                            "Switzerland (+41)",
                            "Syria (+963)",
                            "Taiwan (+886)",
                            "Tajikistan (+992)",
                            "Tanzania (+255)",
                            "Thailand (+66)",
                            "Togo (+228)",
                            "Tonga (+676)",
                            "Trinidad And Tobago (+1-868)",
                            "Tunisia (+216)",
                            "Turkey (+90)",
                            "Turkmenistan (+993)",
                            "Tuvalu (+688)",
                            "Uganda (+256)",
                            "Ukraine (+380)",
                            "United Arab Emirates (+971)",
                            "United Kingdom (+44)",
                            "United States (+1)",
                            "Uruguay (+598)",
                            "Uzbekistan (+998)",
                            "Vanuatu (+678)",
                            "Vatican City (+39-06)",
                            "Venezuela (+58)",
                            "Vietnam (+84)",
                            "Yemen (+967)",
                            "Zambia (+260)",
                            "Zimbabwe (+263)"
                        ],
                        "type": "string",
                        "description": "Select a country to scrape related phone numbers. The dial code is used to normalize and filter phone numbers.",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of phone numbers to collect per keyword. The scraper will stop once this limit is reached.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 'cost-effective' uses RESIDENTIAL proxies; 'legacy' uses GOOGLE_SERP proxy.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor (Apify proxy). The actor will enforce legal GOOGLE_SERP or RESIDENTIAL groups depending on Engine."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
