# Redbubble Phone Number Scraper (`scrapebase/redbubble-phone-number-scraper`) Actor

📱 Extract phone numbers from Redbubble efficiently with the Redbubble Phone Number Scraper (redbubble-phone-number-scraper). ⚡ Fast, accurate data for outreach, lead generation & market research. ✅ Streamline prospecting, save time. 🚀

- **URL**: https://apify.com/scrapebase/redbubble-phone-number-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

### **Social Media** Phone Number Scraper 📱

Redbubble Phone Number Scraper allows you to gather crucial **contact** information from Redbubble profiles with ease. This tool focuses on **extract**ing seller **phone numbers**, enabling you to connect with creators or businesses directly.

By scraping Redbubble **contact** info, you can access valuable **data** for marketing, partnerships, or research. The scraper ensures accurate retrieval of Redbubble seller **phone numbers**, streamlining your outreach efforts.

With the Redbubble **contact** information scraper, you can also collect additional details like email addresses or profile links. This tool is perfect for those seeking to build a **data**base of Redbubble **contact**s efficiently and effectively.

Redbubble Phone Number Scraper is the ultimate tool for extracting contact information from Redbubble sellers. It provides a seamless way to gather phone numbers for business or research purposes.

With Redbubble Phone Number Scraper, you can efficiently collect data from Redbubble profiles, making it an essential Redbubble contact scraper for professionals and businesses.

This powerful phone number extractor for Redbubble is designed to save time and effort by automating the data collection process. It is a reliable Redbubble data scraping tool for accessing seller 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 |
| --- | --- |
| Seller Phone Numbers | Extract phone numbers directly from Redbubble seller profiles for outreach or business purposes. |
| Email Addresses | Retrieve email addresses listed on Redbubble profiles for communication or marketing campaigns. |
| Seller Names | Collect the names of Redbubble sellers to personalize your interactions or build a contact list. |
| Profile Links | Gather direct URLs to seller profiles for easy access to their Redbubble storefronts. |
| Shop Names | Extract the names of Redbubble shops to identify specific sellers or brands. |
| Social Media Links | Scrape any social media links shared by sellers on their Redbubble profiles for further engagement. |
| Location Information | Retrieve location details of sellers, if available, to understand their geographic reach. |
| Product Listings | Access details about products listed by sellers to analyze their offerings or trends. |

### Key Features of **Social Media** Phone Number Scraper

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

- ⭐ Quickly extract seller phone numbers with Redbubble Phone Number Scraper for seamless communication
- ⭐ Effortlessly collect email addresses and other contact details with this Redbubble contact scraper
- ⭐ Automate data collection with this phone number extractor for Redbubble saving time and effort
- ⭐ Retrieve accurate and up-to-date information using this reliable Redbubble data scraping tool
- ⭐ Easily scrape Redbubble contact info including profile links and social media handles for better insights
- ⭐ Access Redbubble seller phone numbers and other key data points with a user-friendly interface
- ⭐ Use the Redbubble contact information scraper to build a comprehensive database of sellers efficiently
- ⭐ The Redbubble seller contact extractor ensures high-quality data for marketing or research purposes
- ⭐ Leverage Redbubble scraping software to analyze seller trends and improve your business strategy
- ⭐ **Secure**ly scrape data without compromising on accuracy or compliance with platform guidelines
- ⭐ Customize your data extraction process to focus on specific Redbubble profiles or regions
- ⭐ Enjoy seamless integration with other tools or platforms for enhanced data management

### How to use **Social Media** Phone Number Scraper 🚀

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

1. ✅ Download and install the Redbubble Phone Number Scraper software on your device
2. ✅ Log in to your account and access the tools dashboard to get started
3. ✅ Enter specific keywords or seller profile URLs to target your data scraping process
4. ✅ **Select** the data types you want to extract such as phone numbers or email addresses
5. ✅ Customize filters to narrow down your search focusing on specific sellers or regions
6. ✅ Click the start button to begin scraping Redbubble contact info from the platform
7. ✅ Monitor the progress of the extraction process in real-time on the dashboard
8. ✅ **Export** the collected data including Redbubble seller phone numbers in your preferred format
9. ✅ Use the extracted data for marketing outreach or research purposes as needed
10. ✅ Repeat the process to regularly update your database with fresh Redbubble contact details
11. ✅ Adjust settings to optimize the tools performance and ensure accurate data retrieval
12. ✅ Contact customer support if you encounter any issues while using the scraper

### Use Cases 🎯

Business Outreach
🎯 **Use** Redbubble Phone Number Scraper to collect seller contact details for partnership opportunities
🎯 Reach out to Redbubble sellers for product collaborations or wholesale inquiries
🎯 Build a database of Redbubble seller phone numbers for targeted marketing campaigns

Market Research
🎯 **Analyze** seller data using the Redbubble data scraping tool to identify market trends
🎯 Scrape Redbubble contact info to understand the demographics of sellers and their products
🎯 **Use** the tool to gather insights into popular products and seller strategies

Creator Partnerships
🎯 **Find** Redbubble seller phone numbers to connect with creators for exclusive collaborations
🎯 **Use** the Redbubble contact information scraper to identify potential influencers for your brand
🎯 Build long-term relationships with sellers by accessing their contact details easily

Agency Use
🎯 Leverage Redbubble scraping software to gather data for client campaigns or market analysis
🎯 **Use** the tool to provide clients with detailed insights into Redbubble sellers and trends
🎯 Streamline your agencys data collection process with automated scraping features

### Why choose us? 💎

Redbubble Phone Number Scraper is designed to deliver accurate and **reliable** data for your business needs. It simplifies the process of how to scrape Redbubble data, ensuring you can focus on your goals.

This tool provides a **user-friendly** experience, making it accessible to both beginners and professionals. With the Redbubble email and phone scraper, you can collect essential contact details quickly and efficiently.

Our scraper stands out for its accuracy, speed, and compliance with platform guidelines. Whether you're looking for Redbubble seller phone numbers or other contact information, this tool has you covered.

It is the ideal solution for anyone seeking to streamline their data collection process. Choose Redbubble Phone Number Scraper for a hassle-free and effective scraping experience.

### **Social Media** Phone Number Scraper Scalability 📈

Redbubble Phone Number Scraper is built to handle data extraction at any scale. Whether you need a small list of contacts or a comprehensive database, this tool can accommodate your needs.

The scraper's **advanced** features ensure consistent performance, even with **large-scale** data requirements. It is optimized to extract Redbubble seller contact details **efficient**ly, regardless of the volume.

With Redbubble scraping software, you can customize the process to focus on specific sellers or regions. This flexibility makes it a valuable tool for businesses of all sizes.

The scraper's scalability ensures you can adapt to changing needs or growing demands. It is the perfect solution for reliable and **efficient** data extraction at any scale.

### **Social Media** Phone Number Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ Always comply with Redbubbles terms of service when using the scraper
⚖️ **Ensure** you have permission to collect and use the data extracted from the platform
⚖️ **Use** Redbubble Phone Number Scraper for legitimate purposes such as research or business outreach
⚖️ **Avoid** using the tool to collect data for spamming or other unethical activities
⚖️ Respect the privacy of Redbubble sellers and handle their contact information responsibly
⚖️ Stay updated on data privacy laws in your region to ensure compliance
⚖️ **Do not** attempt to bypass security measures or restrictions on the Redbubble platform
⚖️ **Use** the scraper in moderation to avoid overloading Redbubbles servers or violating platform rules

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

### Output Format 📤

📝 Example Output (JSON)

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

Redbubble Phone Number Scraper is a tool designed to extract contact details like **phone numbers** from Redbubble profiles.

#### How does the tool work?

The scraper automates the process of collecting data by scanning Redbubble profiles for contact information.

#### Can I **extract** email addresses as well?

**Yes**, the Redbubble email and phone scraper allows you to collect email addresses along with **phone numbers**.

#### Is the tool easy to use?

**Yes**, the scraper features a **user-friendly** interface that simplifies how to scrape Redbubble data.

#### Is the data collected accurate?

The scraper is designed to ensure high accuracy when extracting Redbubble seller **phone numbers** and other details.

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

**Yes**, you can customize filters to target specific sellers or regions using the Redbubble contact scraper.

#### Is the tool compliant with Redbubble's rules?

The scraper is designed to operate within Redbubble's terms of service and legal guidelines.

#### What file formats are supported for data **export**?

You can export data collected by the Redbubble scraping software in formats like **CSV** or Excel.

#### Can I use the tool for **large-scale** data scraping?

**Yes**, the scraper is scalable and capable of handling **large volumes** of data efficiently.

#### What if I encounter issues while using the tool?

You can contact customer support for assistance with any problems related to the Redbubble seller contact extractor.

# Actor input Schema

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

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redbubble Phone Number Scraper",
        "description": "📱 Extract phone numbers from Redbubble efficiently with the Redbubble Phone Number Scraper (redbubble-phone-number-scraper). ⚡ Fast, accurate data for outreach, lead generation & market research. ✅ Streamline prospecting, save time. 🚀",
        "version": "0.1",
        "x-build-id": "6Zxld7x3RnMjh6xCn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~redbubble-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-redbubble-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~redbubble-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-redbubble-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~redbubble-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-redbubble-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, Redbubble usernames, or profile URLs to search for. Example: [\"marketing\", \"founder\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Redbubble"
                        ],
                        "type": "string",
                        "description": "Select platform. For now this actor targets Redbubble via google.com SERP.",
                        "default": "Redbubble"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
