# Thumbtack Phone Number Scraper (`solid-scraper/thumbtack-phone-number-scraper`) Actor

📞 Thumbtack Phone Number Scraper extracts verified phone numbers from Thumbtack listings fast. Ideal for lead gen, real estate, contractors, and agencies seeking targeted outreach—save time, grow pipelines, and boost conversions 🚀

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

## Pricing

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

### Thumbtack Phone Number Scraper 🔍

**Thumbtack Phone Number Scraper** helps you automatically extract phone numbers from Thumbtack profiles, bios, and post content using your own keywords and country targeting. Whether you’re running lead generation, building a local business phone number scraper pipeline, or doing B2B lead phone number research, this actor focuses on finding the right contact details at scale—so you can stop manual searching and start enriching your outreach lists faster.

---

### 🚀 Why choose Thumbtack Phone Number Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Phone number extraction from Thumbtack content** | Quickly pulls phone numbers from profiles, bios, and post content for your outreach |
| ✅ **Keyword + country targeting** | Improves relevance by using your keywords and selecting the correct country code |
| ✅ **Reliability with resilience** | Includes retries and fallbacks to handle scraping interruptions and reduce failure runs |
| ✅ **Structured dataset output** | Saves results with consistent fields (including URL, country, and dial code) for easy export |
| ✅ **Incremental saving** | Pushes each discovered phone record as it’s found, so you don’t lose progress |
| ✅ **Designed for scale** | Supports multiple keywords in a single run with resuming for long tasks |

---

### 🔑 Key features

- 📌 **Targeted phone number extraction**: Extracts phone numbers from Thumbtack bios, profiles, and post content
- 🎯 **Keyword-driven results**: Uses the keywords you provide to focus the phone number scraper on relevant businesses/contractors
- 🌍 **Country and dial code control**: Lets you target a specific country so extracted numbers match your dialing needs
- 🛡️ **Built-in resilience**: Uses retries and resilient scraping behavior to improve success across large runs
- 💾 **Real-time dataset storage**: Each found phone number record is pushed immediately to the dataset
- 🔄 **Progress resuming support**: Continues where it left off using persisted progress state, helping long jobs complete more smoothly
- ⏱️ **Max phone number limit**: Stops once `maxPhoneNumbers` records are reached (useful for controlled batch collection)
- 📊 **Clean, analysis-ready fields**: Outputs a consistent row structure so you can filter and import into Sheets/CRMs easily

---

### 📝 Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["marketing", "founder"],
  "location": "London",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | List of keywords used to find relevant Thumbtack bios, profiles, and post content for phone number extraction (e.g., `marketing`, `founder`). |
| `location` | ❌ | Optional location filter (e.g., `London`, `California`). Leave empty for global search. |
| `country` | ✅ | Country to target for phone numbers (used to guide dial code and number validation). Choose one from the provided list of countries and formats like `United Kingdom (+44)`. |
| `maxPhoneNumbers` | ❌ | Stop after this many phone numbers are found. Range is `1` to `10000`. Default is `20`. |

***

### 📦 Output

The actor saves each discovered phone number record into the dataset as rows (pushed incrementally).

#### Sample output (dataset row)

```json
{
  "platform": "Thumbtack",
  "keyword": "marketing",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | Source platform label for the record (always `Thumbtack`) |
| `keyword` | string | The keyword used for this extraction run |
| `title` | string | Title text associated with the scraped profile/post result |
| `description` | string | Extracted text content where the phone number was found (may be `No data`) |
| `url` | string | URL associated with the scraped result |
| `phone_number` | string | Extracted phone number in E.164 format (e.g., `+44...`) |
| `country` | string | Target country name used for the extraction |
| `dial_code` | string | Dial code corresponding to the selected country |

> Export note: After the run, you can export the dataset (commonly as JSON/CSV) using the Apify console dataset tools.

***

### 🚀 How to use Thumbtack Phone Number Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** tab.

2. **Find Thumbtack Phone Number Scraper**\
   Search for **Thumbtack Phone Number Scraper** and open the actor details page.

3. **Configure input**\
   In the **INPUT** section, set:
   - `keywords` (required)
   - `country` (required)
   - optionally `location`
   - optionally `maxPhoneNumbers` to control how many unique phone numbers you want back

4. **(Optional) Plan for long runs**\
   Large scraping tasks may take time. You can adjust runtime settings via **Run Options** (the actor description notes a default timeout of `3600s / 1hr`).

5. **Run the actor**\
   Click **Run** to start. You’ll see logs as the actor discovers and pushes records to the dataset.

6. **Monitor results in real time**\
   The actor pushes discovered phone number records incrementally, so your dataset fills as the run progresses.

7. **Open the dataset and export**\
   After completion, open the dataset in the **OUTPUT** tab and export your results for downstream workflows (CRM upload, enrichment, or analytics).

No coding required—you can use this Thumbtack lead scraper to get phone numbers from Thumbtack in minutes. 🚀

***

### 🧠 Advanced features & SEO optimization

- 🔍 **Engineered for “Thumbtack phone number scraper” workflows**: Built specifically to extract phone numbers as part of a Thumbtack contact info scraper process for outreach and B2B enrichment.
- 🌐 **Input normalization support**: Your country selection and targeting logic are used to validate and standardize phone numbers (E.164 output) so your downstream cleanup is faster.
- 💾 **Incremental saving for resilience**: Each discovered phone number is immediately pushed to the dataset, minimizing data loss during long runs.
- 📈 **Built-in stopping control**: Use `maxPhoneNumbers` to cap results for testing or controlled batch extraction.
- 📌 **Resilient scraping behavior**: Includes retries and fallbacks when results are sparse or scraping is interrupted—useful for improving reliability in large batches.

***

### ✅ Best use cases

- 📈 **Sales teams building outreach lists**: Extract Thumbtack contractor contact scraper phone numbers for faster prospecting and follow-ups.
- 🏢 **Local business enrichment**: Use this local business phone number scraper to enrich profiles with dial-ready contacts in bulk.
- 🎓 **Market research & directory studies**: Analyze contact density by keyword and country using structured output fields like `country` and `dial_code`.
- ✉️ **B2B lead phone number scraping for campaigns**: Collect phone numbers and run your own validation before dialing.
- 🧩 **Data pipelines for analysts**: Feed `phone_number`, `url`, and extracted `description` into a spreadsheet or BI workflow for cleanup and matching.
- 🤝 **Agency lead generation at scale**: Run multiple keyword batches, then export the dataset to your CRM as a web scraper for Thumbtack contacts.
- 🛠️ **Compliance-aware contact collection**: Since the actor extracts from publicly available sources, you can incorporate your own consent, suppression, and legal checks into your process.

***

### 🧾 Technical specifications

- **Supported Input Formats**
  - `keywords`: array of strings (required)
  - `location`: string (optional)
  - `country`: string selected from the provided list (required)
  - `maxPhoneNumbers`: integer between `1` and `10000` (optional, default `20`)

- **Proxy Support**
  - ✅ Built-in proxy support for more reliable scraping on larger tasks

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience

- **Dataset Structure**
  - ✅ Outputs dataset rows with fields: `platform`, `keyword`, `title`, `description`, `url`, `phone_number`, `country`, `dial_code`

- **Rate Limits & Performance**
  - ⏱️ Large scraping tasks may take time; the actor supports long-running jobs via timeout settings in **Run Options**

- **Limitations**
  - ❌ Phone numbers are only collected when they appear in the scraped public content
  - ❌ If results are fewer than expected, you may need broader keywords or different country settings

***

### ❓ FAQ

#### Is this a Thumbtack lead scraper or an email scraper?

Thumbtack Phone Number Scraper is specifically designed to extract **phone numbers** from Thumbtack profiles, bios, and post content. If you need emails, this actor is not intended for that purpose.

#### What fields do I get back for each phone number?

Each dataset row includes `phone_number` (E.164 formatted), plus `keyword`, `url`, `title`, `description`, `country`, and `dial_code`—so it’s easy to map contacts back to their source.

#### Can I target a specific country and get matching dial codes?

Yes. You provide `country` (e.g., `United Kingdom (+44)`), and the output includes both `country` and `dial_code`.

#### What does `maxPhoneNumbers` do?

`maxPhoneNumbers` stops the actor once it has found the requested number of phone numbers. Increasing it may extend scraping duration.

#### Do I need to provide a location?

No. `location` is optional. If you leave it empty, the actor performs a global search behavior based on your keywords and country.

#### Is there any resuming support if a run stops?

Yes. The actor uses persisted progress state so it can resume where it left off during multi-keyword or long tasks.

#### How can I use the results in my CRM or spreadsheet?

You can export the Apify dataset after the run. Since each record is a structured row, it’s straightforward to import as JSON/CSV and match using `url` or `phone_number`.

#### Is this tool only for public data?

✅ Yes. The actor extracts from publicly available sources. It does not access private profiles or authenticated content.

***

### 🤝 Support & feature requests

Want to improve your Thumbtack phone number scraper results? We’d love to hear from you. 🚀

- 💡 **Feature Requests**: Ideas like better CSV-friendly formatting, additional output fields, or enhancements to filters for a Thumbtack email and phone scraper-style workflow.
- 📧 **Contact**: For questions or custom scraping needs, email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this Thumbtack outreach contact scraper.

***

### ✨ Thumbtack Phone Number Scraper: Final thoughts

*Thumbtack Phone Number Scraper*\* is an SEO-optimized, purpose-built Thumbtack data scraping software for extracting phone numbers at scale—engineered to help you move from discovery to outreach faster.\*

If you’re looking to get phone numbers from Thumbtack reliably, start a run and let the dataset do the heavy lifting. ✅

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, password-protected pages, or authenticated data.

You are responsible for complying with applicable laws and regulations (for example, GDPR/CCPA), platform terms of service, and any spam/communications rules that may apply to how you store or use the collected data.

For data removal requests, contact: <dataforleads@gmail.com>.

Please use Thumbtack Phone Number Scraper responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

Enter keywords to search for (e.g., 'Target Keyword').

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

Filter by location (e.g., 'London', 'California'). Leave empty for global search.

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

Select the country to target for phone numbers.

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

Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.

## Actor input object example

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

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing",
    "founder"
  ]
}' |
apify call solid-scraper/thumbtack-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thumbtack Phone Number Scraper",
        "description": "📞 Thumbtack Phone Number Scraper extracts verified phone numbers from Thumbtack listings fast. Ideal for lead gen, real estate, contractors, and agencies seeking targeted outreach—save time, grow pipelines, and boost conversions 🚀",
        "version": "0.1",
        "x-build-id": "3kInPqYTKhXoKbwOI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~thumbtack-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-thumbtack-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/solid-scraper~thumbtack-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-thumbtack-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/solid-scraper~thumbtack-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-thumbtack-phone-number-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords",
                    "country"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter keywords to search for (e.g., 'Target Keyword').",
                        "default": [
                            "marketing",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by location (e.g., 'London', 'California'). Leave empty for global search."
                    },
                    "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 the country to target for phone numbers.",
                        "default": "United Kingdom (+44)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
