# Smart Website Contact Extractor & B2B Lead Scraper (`scrapepilot/wepsite-phone-number-34`) Actor

Extract verified emails, phone numbers, addresses, and social profiles from any domain list. Features ultra-fast async crawling, automated lead quality scoring, tech stack detection, and state recovery. Ultra-lightweight and cost-efficient (runs browserless to save compute!)

- **URL**: https://apify.com/scrapepilot/wepsite-phone-number-34.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 📞 Website Contact Scraper — Phone Number Extractor & Lead Generation Scraper

> **The most complete Website Contact Scraper on Apify.** Crawl any website and extract phone numbers, email addresses, physical addresses, social media profiles, company name, tech stack, contact page URLs, and a lead quality score — from every page automatically. Multi-domain batch. Contact page priority crawl. Checkpoint resume. Pay only for results.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Website Contact Scraper?](#why-use-this-website-contact-scraper)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Lead Quality Score](#lead-quality-score)
- [Pricing](#pricing)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Website Contact Scraper** is a production-ready Apify actor that crawls any website and extracts complete contact intelligence — phone numbers, email addresses, physical addresses, social media profiles, company name, technology stack, and contact page URLs — from every page automatically.

Provide one or many website URLs and receive back a structured lead record for every page scanned: all contact data found on that page, plus a calculated **lead quality score** (High / Medium / Low) based on how much contact information was successfully extracted. A final summary record per domain consolidates all unique phone numbers and emails found across the entire crawl.

This **phone number extractor** uses the `phonenumbers` library for international number parsing and validation — supporting E.164 format output with regional hint configuration for accurate extraction across any country. This **lead generation scraper** automatically prioritizes contact, about, support, and help pages — the highest-density pages for business contact data on any website.

---

### 🚀 Why Use This Website Contact Scraper?

| Feature | This Actor | Manual Research | Basic Email Scrapers | Hunter.io |
|---|---|---|---|---|
| **Phone number extraction** | ✅ International | ❌ | ❌ | ❌ |
| **Email extraction** | ✅ | ❌ | ✅ | ✅ Paid |
| **Physical address extraction** | ✅ | ❌ | ❌ | ❌ |
| **Tech stack detection** | ✅ 10 technologies | ❌ | ❌ | ❌ |
| **Social profile extraction** | ✅ 9 platforms | ❌ | ❌ | ❌ |
| **Lead quality score** | ✅ Auto-calculated | ❌ | ❌ | ⚠️ |
| **Contact page priority crawl** | ✅ Built-in | ❌ | ❌ | N/A |
| **Full website crawl** | ✅ Up to 20 pages | ❌ | ❌ | N/A |
| **Multi-domain batch** | ✅ | ❌ | ⚠️ | ✅ |
| **Checkpoint resume** | ✅ | N/A | ❌ | N/A |

> **Bottom line:** This **lead generation scraper** is the only actor that combines international phone number validation, physical address extraction, tech stack detection, and auto-calculated lead quality scoring — across a full multi-page website crawl with contact page priority.

---

### 🎯 Use Cases

#### 🏆 B2B Lead Generation & Prospecting
- Crawl target company websites to extract verified phone numbers, emails, and addresses for outreach
- Build enriched prospect lists with tech stack data — identify companies using HubSpot, Shopify, or WordPress
- Use lead quality scores to prioritize which prospects have the most complete contact data

#### 📋 CRM & Database Enrichment
- Enrich existing CRM records with missing phone numbers and email addresses from company websites
- Add tech stack and social profile data to prospect records for better segmentation
- Validate and update contact data across your account database with scheduled runs

#### 🔍 Sales Intelligence & Market Mapping
- Map competitor and prospect contact presence across a market segment
- Identify which companies in a niche have phone numbers vs email-only contact
- Discover technology adoption patterns using the tech stack detection output

#### 🛠️ Agency & Lead Reseller Services
- Deliver enriched contact datasets to clients using this **website contact scraper** at scale
- Build niche lead lists with complete contact intelligence — phone, email, address, social, tech
- Run automated lead qualification using the built-in lead quality score

#### 📊 Data Quality & Compliance
- Audit website contact completeness across a portfolio of managed domains
- Verify that contact pages are correctly indexed and contain valid phone numbers and emails
- Build contact data inventories for GDPR or data governance compliance reviews

#### 🎓 Academic & Business Research
- Study business contact page patterns and contact data completeness across industries
- Analyse technology adoption using website tech stack detection at scale
- Build datasets of business contact profiles for digital marketing or e-commerce research

---

### ⚙️ Input Parameters

```json
{
  "startUrls": [
    { "url": "https://www.example.com" },
    { "url": "https://www.anothercompany.com/contact" }
  ],
  "maxPagesPerDomain": 20,
  "regionHint":        "US",
  "concurrency":       12,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | Demo URL | Websites to crawl — each as `{ "url": "https://..." }`. Multiple domains processed in parallel |
| `maxPagesPerDomain` | integer | `20` | Maximum pages to crawl per domain |
| `regionHint` | string | `"US"` | Country code for phone number parsing — e.g. `"US"`, `"GB"`, `"DE"`, `"AU"`. Improves accuracy for local number formats |
| `concurrency` | integer | `12` | Number of pages fetched in parallel per domain |
| `proxyConfiguration` | object | Optional | Apify proxy config — recommended for high-volume runs |

> **Tip:** Set `regionHint` to the country code where your target companies are based for the most accurate phone number extraction. The actor still extracts international numbers with country codes regardless of this setting.

***

### 📋 Output Fields

This **website contact scraper** produces two types of records per domain:

#### 📄 Per-Page Records

Every page scanned produces a lead record with all contact data found on that specific page:

| Field | Type | Description | Example |
|---|---|---|---|
| `domain` | string | Website domain | `"example.com"` |
| `start_url` | string | The input URL | `"https://www.example.com"` |
| `page_url` | string | URL of the scanned page | `"https://www.example.com/contact"` |
| `page_title` | string | Page title | `"Contact Us — Example Corp"` |
| `company_name` | string | Company name from OG metadata or page title | `"Example Corp"` |
| `website_description` | string | Meta description | `"Leading provider of..."` |
| `phone_numbers` | array | Validated phone numbers in E.164 format | `["+14155552671", "+442071234567"]` |
| `emails` | array | Email addresses found on the page | `["sales@example.com"]` |
| `addresses` | array | Physical addresses detected | `["123 Main Street, New York, NY"]` |
| `social_profiles` | object | Social media profiles by platform | `{"linkedin": "https://...", "twitter": "https://..."}` |
| `technologies` | array | Technologies detected on the website | `["WordPress", "Google Analytics", "HubSpot"]` |
| `contact_pages` | array | Contact-related URLs discovered on this page | `["https://example.com/contact"]` |
| `lead_score` | integer | Numerical lead quality score (0–100) | `75` |
| `lead_quality` | string | Lead quality tier | `"High"`, `"Medium"`, `"Low"` |
| `pages_scanned` | integer | Running scan count for this domain | `8` |

#### 🏆 Final Domain Summary Record

After all pages are crawled, one consolidated summary record is pushed per domain:

| Field | Type | Description |
|---|---|---|
| `domain` | string | Website domain |
| `start_url` | string | The input URL |
| `phone_numbers` | array | All unique phone numbers found across all pages |
| `emails` | array | All unique email addresses found across all pages |
| `pages_scanned` | integer | Total pages scanned |
| `lead_score` | integer | Summary lead quality score |
| `lead_quality` | string | `"High"`, `"Medium"`, or `"Low"` |
| `status` | string | `"completed"` or `"partial"` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "startUrls": [{ "url": "https://www.example.com" }],
  "maxPagesPerDomain": 5,
  "regionHint": "US"
}
```

**Per-page record:**

```json
{
  "domain":              "example.com",
  "start_url":           "https://www.example.com",
  "page_url":            "https://www.example.com/contact",
  "page_title":          "Contact Us — Example Corp",
  "company_name":        "Example Corp",
  "website_description": "Leading provider of business solutions.",
  "phone_numbers":       ["+14155552671"],
  "emails":              ["sales@example.com", "info@example.com"],
  "addresses":           ["123 Main Street, San Francisco, CA 94105"],
  "social_profiles":     { "linkedin": "https://linkedin.com/company/example", "twitter": "https://twitter.com/example" },
  "technologies":        ["WordPress", "Google Analytics", "HubSpot"],
  "contact_pages":       ["https://www.example.com/contact", "https://www.example.com/support"],
  "lead_score":          80,
  "lead_quality":        "High",
  "pages_scanned":       3
}
```

**Final domain summary:**

```json
{
  "domain":        "example.com",
  "start_url":     "https://www.example.com",
  "phone_numbers": ["+14155552671"],
  "emails":        ["info@example.com", "sales@example.com"],
  "pages_scanned": 5,
  "lead_score":    55,
  "lead_quality":  "Medium",
  "status":        "completed"
}
```

***

### 🎯 Lead Quality Score

Every record includes an auto-calculated **lead quality score** based on the contact data successfully extracted:

| Data Found | Points Added |
|---|---|
| Phone numbers | +30 |
| Email addresses | +25 |
| Physical addresses | +15 |
| Social profiles | +10 |
| Contact pages found | +10 |
| Company name | +5 |
| Technologies detected | +5 |

| Score Range | Quality Tier |
|---|---|
| 70–100 | **High** — rich contact data, strong lead |
| 35–69 | **Medium** — partial contact data |
| 0–34 | **Low** — minimal contact information found |

***

### 💰 Pricing

This actor uses **pay-per-event** pricing with two charge events.

| Event | Price |
|---|---|
| **Actor start fee** | $0.10 per run |
| **Per phone number extracted** | $0.012 per number ($12.00 per 1,000 numbers) |
| **Per page successfully scanned** | $0.008 per page ($8.00 per 1,000 pages) |

#### How billing works:

- ✅ The $0.10 start fee applies once per run
- ✅ Each validated phone number extracted is charged at $0.012
- ✅ Each page successfully scanned and pushed is charged at $0.008
- ✅ Pages that fail to load are **not charged**
- ✅ The actor stops automatically when your Apify account charge limit is reached
- ✅ Checkpoint saves progress — restarting after a limit continues from last position

> **Example:** Crawl 5 domains × 10 pages + 50 phone numbers = $0.10 + $0.40 + $0.60 = **$1.10 total**

**2-hour free trial available** — click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Domains | Pages Per Domain | Estimated Time |
|---|---|---|
| 1 | 20 | ~2–5 minutes |
| 10 | 20 | ~10–20 minutes |
| 50 | 20 | ~40–80 minutes |
| 100 | 10 | ~40–70 minutes |

- Up to **12 pages fetched concurrently** per domain
- Contact, about, support, help, and team pages crawled **first** — highest contact data density
- Phone numbers validated in E.164 international format using the `phonenumbers` library
- Checkpoint saved every 10 pages per domain
- Multiple domains processed in parallel

***

### ❓ FAQ

**Q: What format are phone numbers returned in?**
A: All phone numbers are validated and returned in **E.164 international format** (e.g. `+14155552671`, `+442071234567`). This standardized format works directly with dialers, CRMs, and SMS tools without any cleaning.

**Q: What is `regionHint` for?**
A: It improves accuracy for local phone number formats that don't include a country code. For example, a US-formatted number like `(415) 555-2671` is correctly parsed when `regionHint` is set to `"US"`. International numbers with country codes are extracted correctly regardless of this setting.

**Q: How does the lead quality score work?**
A: The score is auto-calculated from the contact data found — phone numbers, emails, addresses, social profiles, contact page URLs, company name, and tech stack. Higher scores mean more complete contact intelligence. See the Lead Quality Score section for the full breakdown.

**Q: What technologies can be detected?**
A: WordPress, Shopify, Wix, Squarespace, Cloudflare, Google Analytics, Meta Pixel, Hotjar, HubSpot, and WooCommerce. Detection is based on known script sources, HTML patterns, and header signals present in the page HTML.

**Q: What happens if a domain has no phone numbers?**
A: The per-page and summary records are still pushed with all other available data — emails, addresses, social profiles, and tech stack. Only successfully extracted phone numbers incur the phone-specific charge. Pages are charged at the standard per-page rate.

**Q: Can I crawl multiple domains in one run?**
A: Yes. Add multiple entries to `startUrls` — all domains are processed in parallel, each with its own crawl queue and final summary record.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Phone number extraction with E.164 validation — international support with regional hint
- ✅ Email extraction from page text and `mailto:` links
- ✅ Physical address detection from page text
- ✅ Social profile extraction — 9 platforms
- ✅ Tech stack detection — 10 technologies
- ✅ Auto-calculated lead quality score (0–100) and tier (High / Medium / Low)
- ✅ Contact and about page priority crawl
- ✅ Full website crawl — up to `maxPagesPerDomain` pages
- ✅ Multi-domain parallel processing
- ✅ Checkpoint/resume — saves every 10 pages
- ✅ Dual pay-per-event billing — per phone number + per page scanned
- ✅ Spending limit respect — stops cleanly when charge limit reached

***

### 🏷️ Tags

`website contact scraper` `phone number extractor` `lead generation scraper` `email extractor` `contact data scraper` `b2b lead scraper` `phone scraper` `lead enrichment` `business contact extractor` `website crawler` `tech stack detector` `crm enrichment scraper`

***

### ⚖️ Legal & Terms of Use

This actor crawls publicly accessible website pages and extracts contact information in the same way a regular user browses those pages.

**Please note:**

- Use extracted contact data only for **lawful purposes** — B2B outreach, CRM enrichment, market research, and lead generation are common legitimate uses
- Always comply with applicable anti-spam and data protection laws — including CAN-SPAM, GDPR, CASL, and CCPA — when using extracted phone numbers or emails for outreach
- Do not use this **lead generation scraper** to harvest personal data for harassment, spam, or any purpose that violates individual privacy rights
- The actor developer is not responsible for how extracted contact data is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most complete Website Contact Scraper — phones, emails, addresses, tech stack, lead scores</em><br/><br/>
  <strong>💰 $0.10 per run + $12 per 1,000 phones + $8 per 1,000 pages · Pay only for results</strong>
</p>

# Actor input Schema

## `startUrls` (type: `array`):

List of websites to extract phone numbers from.

## `maxPagesPerDomain` (type: `integer`):

How many internal pages to crawl per website searching for contact info.

## `regionHint` (type: `string`):

Default country code hint for parsing local numbers (e.g., US, GB, BD).

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

Select Residential Proxies for best results.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com/contact"
    }
  ],
  "maxPagesPerDomain": 10,
  "regionHint": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://apify.com/contact"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/wepsite-phone-number-34").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 = {
    "startUrls": [{ "url": "https://apify.com/contact" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/wepsite-phone-number-34").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 '{
  "startUrls": [
    {
      "url": "https://apify.com/contact"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/wepsite-phone-number-34 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Smart Website Contact Extractor & B2B Lead Scraper",
        "description": "Extract verified emails, phone numbers, addresses, and social profiles from any domain list. Features ultra-fast async crawling, automated lead quality scoring, tech stack detection, and state recovery. Ultra-lightweight and cost-efficient (runs browserless to save compute!)",
        "version": "0.0",
        "x-build-id": "HFJ7kJZvvOg0dMCvI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~wepsite-phone-number-34/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-wepsite-phone-number-34",
                "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/scrapepilot~wepsite-phone-number-34/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-wepsite-phone-number-34",
                "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/scrapepilot~wepsite-phone-number-34/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-wepsite-phone-number-34",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of websites to extract phone numbers from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max Pages Per Domain",
                        "type": "integer",
                        "description": "How many internal pages to crawl per website searching for contact info.",
                        "default": 10
                    },
                    "regionHint": {
                        "title": "Region Hint (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "description": "Default country code hint for parsing local numbers (e.g., US, GB, BD).",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select Residential Proxies for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
