# Steam Phone Number Scraper (`scrapeengine/steam-phone-number-scraper`) Actor

- **URL**: https://apify.com/scrapeengine/steam-phone-number-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Automation, Lead generation, Social media
- **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

### **Steam** Phone Number Scraper 📱

**Steam** Phone Number Scraper allows users to retrieve critical **contact** information from **Steam** profiles. This phone number scraping software is designed to **extract** **phone numbers**, email addresses, and other essential details securely.

As a **Steam** **contact** info **extract**or, it ensures accurate **data** retrieval while maintaining user privacy. Scraping **Steam** user details is made simple with advanced filtering options and customizable **extract**ion settings.

The tool is tailored for businesses, researchers, and agencies seeking reliable **data** collection methods. **Steam** Phone Number Scraper is optimized for **extract**ing relevant information while adhering to ethical guidelines.

Steam Phone Number Scraper is a powerful tool designed to help users extract valuable contact information from Steam profiles efficiently. This Steam account scraper tool simplifies the process of gathering phone numbers and other user data.

With Steam Phone Number Scraper, you can extract phone numbers from Steam profiles quickly and securely. It is a reliable Steam user data scraper that ensures accurate data extraction without compromising privacy.

Steam Phone Number Scraper is ideal for businesses and researchers looking to streamline their data collection processes. This phone number scraping software is optimized for extracting contact details from Steam profiles.

### 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 |
| --- | --- |
| Phone Numbers | Retrieve verified phone numbers from Steam profiles accurately using Steam profile data scraper. |
| Email Addresses | Extract associated email addresses linked to Steam accounts securely. |
| Usernames | Gather Steam usernames for identification and analysis purposes. |
| Profile Links | Access direct links to Steam profiles for further exploration. |
| Location Information | Extract location details shared by Steam users in their profiles. |
| Account Creation Dates | Retrieve account creation dates to analyze user activity trends. |
| Game Libraries | Extract information about games owned by Steam users for research purposes. |
| Social Media Links | Identify social media links shared by users on their Steam profiles. |

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

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

- ⭐ **Steam** Phone Number Scraper provides fast and accurate phone number extraction from **Steam** profiles
- ⭐ Retrieve phone numbers from **Steam** efficiently with advanced filtering options for precise results
- ⭐ **Steam** data extraction tool ensures secure and ethical scraping of user contact information
- ⭐ **Customizable** extraction settings allow users to tailor the process to specific data needs
- ⭐ **Steam** Phone Number Scraper supports bulk data extraction for large-scale projects and research
- ⭐ The tool integrates seamlessly with existing workflows for enhanced productivity and ease of use
- ⭐ **Steam** Phone Number Scraper offers detailed reporting and export options for organized data management
- ⭐ It ensures compliance with legal and ethical standards while extracting **Steam** user details

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

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

1. ✅ Download and install **Steam** Phone Number Scraper on your device
2. ✅ Log in to your **Steam** account to access profile data for scraping
3. ✅ Set your extraction preferences using the customizable settings provided
4. ✅ **Select** the profiles or user groups you want to extract data from
5. ✅ **Start** the scraping process and monitor progress through the user-friendly interface
6. ✅ **Review** the extracted data and verify the accuracy of phone numbers retrieved
7. ✅ **Export** the collected data to your preferred format for further analysis
8. ✅ Use the extracted data responsibly and in compliance with ethical guidelines

### Use Cases 🎯

Business Applications
🎯 **Use** **Steam** Phone Number Scraper to build targeted contact lists for marketing campaigns
🎯 Extract phone numbers from **Steam** profiles to connect with potential clients effectively

Research and Analysis
🎯 Leverage **Steam** user data scraper for academic studies and trend analysis
🎯 Scrape **Steam** user details to understand gaming demographics and preferences

Creator Partnerships
🎯 **Identify** influencers by extracting contact info from **Steam** profiles for collaborations
🎯 **Use** **Steam** contact info extractor to connect with creators in the gaming industry

Agency Use
🎯 Streamline data collection for recruitment purposes using **Steam** Phone Number Scraper
🎯 Utilize phone number scraping software for outreach and campaign management

### Why choose us? 💎

**Steam** Phone Number Scraper is designed to deliver **reliable** and efficient data extraction solutions. It simplifies the process of scraping **Steam** user details while ensuring accuracy and compliance.

The tool provides **advanced** features for extracting phone numbers and other contact information securely. Businesses and researchers benefit from its customizable settings and seamless integration into existing workflows.

**Steam** Phone Number Scraper offers scalability to handle projects of any size, making it ideal for diverse applications. It is optimized for extracting relevant data while adhering to ethical and legal standards.

This **Steam** profile data scraper is trusted for its precision and **user-friendly** interface. Choose **Steam** Phone Number Scraper for a hassle-free and effective data collection experience.

### **Steam** Phone Number Scraper Scalability 📈

**Steam** Phone Number Scraper is built to handle data extraction projects of any scale. Whether you need to retrieve phone numbers from **Steam** profiles individually or in bulk, the tool delivers consistent and accurate results.

It supports **large-scale** data collection for businesses and agencies with **extensive** requirements. **Steam** Phone Number Scraper ensures **efficient** processing without compromising on speed or quality.

The tool adapts to the unique needs of users, offering **customizable** settings for targeted data extraction. **Steam** data extraction tool is optimized for handling high volumes of data securely and reliably.

Its scalability makes it a valuable asset for diverse industries and applications.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Steam**s terms of service when using **Steam** Phone Number Scraper
⚖️ **Obtain** consent from users before extracting phone numbers or other contact details
⚖️ **Use** **Steam** account scraper tool responsibly and for legitimate purposes only
⚖️ **Avoid** scraping data from profiles that explicitly restrict access to their information
⚖️ **Do not** sell or misuse extracted data obtained through **Steam** Phone Number Scraper
⚖️ Follow all local and international data protection laws during the scraping process
⚖️ Implement secure storage practices for the data collected using the tool
⚖️ Regularly review and update your scraping practices to align with ethical standards

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Steam Phone Number Scraper"],
  "country": "Global",
  "maxPhoneNumbers": 20,
  "platform": "Steam",
  "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 (Steam) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "platform": "Steam",
    "keyword": "Steam Phone Number Scraper",
    "title": "Example Steam 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 Steam as the source |
| keyword | Keyword that triggered the result (Steam Phone Number Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Steam 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 Steam **Phone Number Scraper**?

Steam Phone Number Scraper is a tool designed to extract **phone numbers** and other contact information from Steam profiles efficiently.

#### How does Steam **Phone Number Scraper** work?

It uses advanced algorithms to scrape Steam user details **secure**ly and accurately while maintaining **compliance** with ethical standards.

#### Can I **extract** phone numbers from Steam profiles in bulk?

**Yes**, Steam Phone Number Scraper supports bulk data extraction for large-scale projects and research purposes.

#### Is Steam **Phone Number Scraper** **legal** to use?

**Yes**, as long as you comply with Steam's terms of service and obtain user consent where required.

#### What data can I **extract** using Steam **Phone Number Scraper**?

You can retrieve **phone numbers**, email addresses, usernames, profile links, and other relevant details.

#### Is the tool suitable for businesses and agencies?

**Yes**, Steam Phone Number Scraper is ideal for **businesses**, agencies, and researchers seeking reliable data collection methods.

#### How do I ensure ethical data scraping practices?

Follow legal guidelines, obtain user consent, and avoid scraping restricted profiles or misusing data.

#### Can I customize the data **extract**ion settings?

**Yes**, Steam Phone Number Scraper offers customizable settings to tailor the extraction process to your needs.

#### Does the tool provide **export** options for collected data?

**Yes**, you can export extracted data to various formats for further analysis and management.

#### What makes Steam **Phone Number Scraper** unique?

It combines accuracy, efficiency, and **compliance** with ethical standards to deliver reliable data extraction solutions.

#### Can I use Steam **Phone Number Scraper** for academic research?

**Yes**, the tool is suitable for academic studies and analyzing gaming trends and demographics.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, Steam Phone Number Scraper is scalable and optimized for handling high volumes of data **secure**ly.

#### What are the benefits of using Steam **Phone Number Scraper**?

It simplifies data collection, ensures accuracy, and supports ethical practices while extracting Steam user details.

#### Is the tool user-friendly?

**Yes**, Steam Phone Number Scraper features a simple interface for easy navigation and efficient data extraction.

#### Can I scrape social media links from Steam profiles?

**Yes**, the tool allows you to extract social media links shared by users on their Steam profiles.

# Actor input Schema

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

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

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

Select platform. For now this actor targets Steampowered 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": "Steampowered",
  "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("scrapeengine/steam-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("scrapeengine/steam-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 scrapeengine/steam-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Phone Number Scraper",
        "version": "0.1",
        "x-build-id": "xBbryj7gbPb21LC0t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~steam-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-steam-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/scrapeengine~steam-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-steam-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/scrapeengine~steam-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-steam-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, Steampowered usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Steampowered"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Steampowered via google.com SERP.",
                        "default": "Steampowered"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
