# Google Maps Lead Enrichment - Emails, Phones, Socials (`thirdwatch/google-maps-lead-enrichment`) Actor

Turn Google Maps searches into sales-ready lead lists with business names, addresses, ratings, websites, public emails, phone numbers, social profiles, contact pages, and optional email-domain validation. You can also enrich existing website or business lists.

- **URL**: https://apify.com/thirdwatch/google-maps-lead-enrichment.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Google Maps Lead Enrichment — Emails, Phones & Social Profiles

Turn a plain Google Maps search into a sales-ready lead list in one run.

Most Google Maps scrapers stop at the map pin: name, address, rating, website. That is a
directory listing, not a lead. This Actor takes the extra step — it opens each business's
website, reads the homepage and the pages a human would click to find a contact
(`/contact`, `/about`, `/impressum`, `/enquiry`), and pulls out the **email addresses,
phone numbers and social profiles** you actually need to start a conversation. It then
checks whether the email's domain can receive mail at all, so obvious placeholder
addresses never reach your CRM.

You give it `plumbers in Austin TX`. You get back rows with
`service@austinplumbing.com`, `+15129004663`, a LinkedIn URL, a Facebook URL, the
coordinates, the rating and the place ID — one row per business.

---

### What you get

| Stage | What happens |
|---|---|
| **1. Find** | Each search query is resolved against Google Maps' structured business search. Up to 20 businesses per request, up to about 120 per query. Name, address, phone, rating, category, coordinates, place ID and website come from here. |
| **2. Enrich** | The business website and its most relevant contact or about pages are checked, up to your page budget. |
| **3. Extract** | Public emails, phone numbers, and social profile URLs are collected and deduplicated. |
| **4. Validate** | The primary email's domain gets a DNS MX lookup, so you can tell a real mailbox domain from a theme placeholder, and you learn which mail provider the business runs on. |

---

### Honest hit rates

Measured across 118 real small-business websites found through Google Maps in six
countries (US, UK, India, Australia), plus a further live verification run:

| Signal | Share of businesses |
|---|---|
| Website reachable | ~89% (up to ~95% with the blocked-site retry enabled) |
| **At least one email address** | **~71–75%** |
| At least one phone number | ~65–85% |
| At least one social profile | ~83–87% |
| At least one contact channel of any kind | ~95% |

**These rates vary a lot by vertical.** In our measurements: US home services (plumbers,
HVAC) landed around **55–60% email**, because those businesses deliberately push
click-to-call and hide email behind JavaScript contact forms. Wellness and design
businesses in Australia and India landed around **85–90% email**. Professional services
(law, dental) sit in between. Plan your list size around the low end of that range, not
the high end.

Around 5% of the email domains we found do not resolve at all — theme placeholders
shipped with a website template. The `email_domain_mx_ok` field flags those for you.

---

### Input parameters

```json
{
  "queries": [
    "dentists in Portland OR",
    "interior designers Bangalore",
    "law firms Manchester UK"
  ],
  "maxResults": 100,
  "maxPagesPerSite": 4,
  "concurrency": 8,
  "verifyEmailDomains": true,
  "onlyWithContact": false,
  "retryBlockedWithProxy": false
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | string\[] | `[]` | Google Maps searches, written exactly as you'd type them into Maps. **Put the location in the text** (`"plumbers in Austin TX"`), not in a separate field. |
| `websites` | string\[] | `[]` | Optional. Enrich these URLs directly and skip the Maps step. Can be combined with `queries`. |
| `businesses` | object\[] | `[]` | Optional. Business objects that each carry a `website` field (e.g. output from a Maps place scraper). Their fields are carried through onto the enriched rows. |
| `maxResults` | integer | `10` | Maximum enriched rows across all queries. Max 1000. |
| `maxPagesPerSite` | integer | `4` | Homepage plus up to 3 ranked contact pages. Capped at 4 — see Limitations. |
| `concurrency` | integer | `8` | Websites fetched in parallel. Max 32. Raise the run's memory to 512 MB before going above 16. |
| `verifyEmailDomains` | boolean | `true` | DNS MX check on the primary email's domain. |
| `onlyWithContact` | boolean | `false` | Drop businesses with no email, phone or social profile at all. Fewer rows, fewer charges. |
| `retryBlockedWithProxy` | boolean | `false` | Retry websites that restrict the first visit. This improves coverage but can make runs slower. |
| `proxyConfiguration` | object | preconfigured | Optional connection settings used only for restricted-site retries. |

You can run with `queries` alone, `websites` alone, or both together.

***

### Output fields

One row per business.

#### Business (from Google Maps)

| Field | Type | Description |
|---|---|---|
| `source_query` | string | The query this business came from (or `direct-input`). |
| `business_name` | string | Business name. |
| `business_address` | string | Full formatted address. |
| `business_phone` | string | Phone listed on the Maps profile. |
| `business_category` | string | Primary category, e.g. `Plumber`. |
| `business_categories` | string\[] | All categories on the listing. |
| `business_rating` | number | Star rating, e.g. `4.8`. |
| `latitude` | number | Decimal latitude. |
| `longitude` | number | Decimal longitude. |
| `place_id` | string | Google place ID. |
| `google_maps_cid` | string | Google Maps CID. |
| `google_maps_url` | string | Absolute link to the Maps listing. |

#### Contact intelligence (from the website)

| Field | Type | Description |
|---|---|---|
| `website` | string | Website as listed on Google Maps. |
| `final_url` | string | URL actually reached after redirects. |
| `emails` | string\[] | All email addresses found, deduplicated, best-signal first. |
| `primary_email` | string | The highest-confidence address. |
| `primary_email_source` | string | `mailto`, `cfemail` (decoded from obfuscated markup) or `text`. |
| `emails_count` | number | Number of distinct emails found. |
| `email_domain` | string | Domain of the primary email. |
| `email_is_freemail` | boolean | `true` for gmail/yahoo/outlook-type addresses — normal and usable for small businesses. |
| `email_domain_mx_ok` | boolean | `true` when the domain has MX records and can receive mail. |
| `email_mx_provider` | string | `google`, `microsoft365`, `zoho`, `godaddy` or `other`. Useful for segmentation. |
| `phones` | string\[] | Phone numbers found on the site, `tel:` links first. |
| `primary_phone` | string | Best phone number, falling back to the Maps phone. |
| `phones_count` | number | Number of distinct phones found. |
| `facebook_url` | string | Facebook profile/page URL. |
| `instagram_url` | string | Instagram profile URL. |
| `linkedin_url` | string | LinkedIn company/person URL. |
| `youtube_url` | string | YouTube channel URL. |
| `x_url` | string | X (Twitter) profile URL. |
| `tiktok_url` | string | TikTok profile URL. |
| `pinterest_url` | string | Pinterest profile URL. |
| `social_profiles_count` | number | How many distinct social networks were found. |
| `contact_pages` | string\[] | The contact/about pages that were actually read. |
| `has_contact` | boolean | `true` if any contact channel was found. |

#### Run diagnostics

| Field | Type | Description |
|---|---|---|
| `fetch_status` | string | `ok`, `http_4xx`, `http_5xx`, `blocked_shell`, `dns_error`, `ssl_error`, `timeout`, `connect_error`, `not_html`, `social_website`, `no_website`. |
| `http_status` | number | HTTP status of the homepage request. |
| `pages_fetched` | number | Pages read for this business. |
| `bytes_fetched` | number | Bytes of HTML read for this business. |
| `elapsed_ms` | number | Wall time spent on this business. |
| `scraped_at` | string | ISO 8601 UTC timestamp. |

### Example output

```json
{
  "source_query": "plumbers in Austin TX",
  "business_name": "Austin Plumbing",
  "business_address": "5115 N Lamar Blvd Ste 100, Austin, TX 78751",
  "business_phone": "(512) 900-4663",
  "business_category": "Plumber",
  "business_categories": ["Plumber", "Drainage service", "Water softening equipment supplier"],
  "business_rating": 4.8,
  "latitude": 30.3189435,
  "longitude": -97.7301705,
  "place_id": "ChIJq0fCfwkpW4YR4EqPvo68RGQ",
  "google_maps_url": "https://www.google.com/maps/place/?q=place_id:ChIJq0fCfwkpW4YR4EqPvo68RGQ",
  "website": "https://austinplumbing.com/",
  "final_url": "https://www.austinplumbing.com/",
  "emails": ["service@austinplumbing.com"],
  "primary_email": "service@austinplumbing.com",
  "primary_email_source": "text",
  "email_domain": "austinplumbing.com",
  "email_is_freemail": false,
  "email_domain_mx_ok": true,
  "email_mx_provider": "microsoft365",
  "phones": ["+15129004663", "5129004663", "(512) 900-4663"],
  "primary_phone": "+15129004663",
  "facebook_url": "https://www.facebook.com/AustinPlumbing512",
  "instagram_url": "https://www.instagram.com/austinplumbingtx/",
  "linkedin_url": "https://www.linkedin.com/company/austin-plumbing/",
  "youtube_url": "https://www.youtube.com/@AustinPlumbingtx",
  "x_url": "https://x.com/austinplumber",
  "tiktok_url": "https://www.tiktok.com/@austinplumbingtx",
  "pinterest_url": "https://www.pinterest.com/austinplumbingtx/_profile/",
  "social_profiles_count": 7,
  "contact_pages": [
    "https://www.austinplumbing.com/contact-us/",
    "https://www.austinplumbing.com/about-us/",
    "https://www.austinplumbing.com/book-appointment/"
  ],
  "fetch_status": "ok",
  "http_status": 200,
  "pages_fetched": 4,
  "bytes_fetched": 415783,
  "elapsed_ms": 5423,
  "has_contact": true,
  "scraped_at": "2026-07-27T22:51:47+00:00"
}
```

***

### Limitations

Read these before you size a campaign.

- **Roughly one business in four yields no email.** That is a real outcome, not a bug.
  18 of 105 successfully-read sites in our measurement had no email address anywhere
  across four pages — many small businesses genuinely only publish a phone number and a
  JavaScript contact form. Those rows still carry phone and social data.
- **Hit rate depends heavily on the vertical.** US home services are the weakest
  (~55–60% email); wellness, design and professional services abroad are the strongest
  (~85–90%). Budget for the low end.
- **Crawl depth is capped at 4 pages per site and this is deliberate.** We tested going
  to 10 pages on the sites that produced no email: it recovered 2 of 18, one of which was
  a regulator's address rather than the business's, while tripling bandwidth per site.
  There is no meaningful yield beyond 4.
- **Email validation is domain-level, not mailbox-level.** `email_domain_mx_ok` proves
  the domain can receive mail. It does not prove `info@` exists. Mailbox-level checks
  require SMTP conversations that are not possible from this environment.
- **A single Maps query saturates at about 120 businesses.** For larger territories,
  split into several narrower queries (by suburb, by adjacent city, by sub-category)
  rather than raising `maxResults` on one broad query.
- **Free-mail addresses are kept, not filtered.** About one in six small businesses uses
  a Gmail or Yahoo address as its real business contact. The `email_is_freemail` flag
  lets you decide; the Actor does not decide for you.
- **Some businesses list a Facebook page as their website.** Those are recorded in
  `facebook_url` with `fetch_status: social_website` rather than crawled.
- **Roughly 5–11% of sites are unreachable** because of dead domains, broken hosting, or
  access restrictions. `fetch_status` records the user-visible outcome.
- **A search that matches nothing returns zero rows and finishes successfully.** It is
  not treated as an error.

***

### Use cases

- Feed the output straight into a CRM or cold-email tool — the rows are flat, typed and
  deduplicated.
- Filter on `email_domain_mx_ok = true` and `has_contact = true` for the cleanest
  outreach list.
- Segment by `email_mx_provider` when you want to target businesses on Google Workspace
  versus Microsoft 365.
- Use `business_rating` and `business_categories` to prioritise before you ever send.

***

### Compliance

This Actor reads only publicly published business contact information from public
websites and public business listings. It does not access private accounts, does not log
in anywhere, and does not attempt to bypass authentication. Business contact data is
still personal data in many jurisdictions — you are responsible for having a lawful basis
for contacting the businesses you collect, and for honouring opt-outs under GDPR, CAN-SPAM,
CASL, DPDP and any other regime that applies to you.

### Compared to alternatives

- **vs. lukaskrivka Google Maps enrichment actors**: This actor combines Maps discovery and website-contact enrichment in one run while keeping the source place fields.
- **vs. a standard Google Maps scraper**: It adds public emails, phones, social profiles, contact pages, and domain-level email signals to each place record.

### FAQ

**Does every business return an email address?**
No. Expect roughly 71–75% email coverage overall, with meaningful variation by industry and country.

**Can I enrich an existing website list?**
Yes. Use `websites`, or use `businesses` to preserve your original business fields.

**Does domain validation prove a mailbox exists?**
No. It confirms that the email domain accepts mail, not that an individual mailbox is active.

Last verified: 2026-07

More lead-generation actors at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

## `queries` (type: `array`):

Local-business searches, exactly as you would type them into Google Maps. Include the location in the text, e.g. "plumbers in Austin TX" or "yoga studios Melbourne AU". Each query returns up to about 120 businesses.

## `websites` (type: `array`):

Optional. Skip the Google Maps step and enrich these website URLs directly. Can be combined with queries.

## `businesses` (type: `array`):

Optional. Business records (objects with a website field, e.g. the output of a Google Maps place scraper). Their fields are carried through onto the enriched rows.

## `maxResults` (type: `integer`):

Maximum number of enriched business rows to produce across all queries.

## `maxPagesPerSite` (type: `integer`):

How many pages to read per business site: the homepage plus the highest-ranked contact/about/impressum pages. Yield saturates at 4 - deeper crawls cost far more bandwidth for almost no extra contacts.

## `concurrency` (type: `integer`):

How many business websites to fetch in parallel. Every target is a different host, so there is no shared rate limit. 8 is safe at the default memory; raise memory to 512 MB before going above 16.

## `verifyEmailDomains` (type: `boolean`):

Look up the MX records of the primary email's domain to confirm it can receive mail. This filters out theme placeholders and dead domains. It does not verify the individual mailbox.

## `onlyWithContact` (type: `boolean`):

Skip businesses where no email, phone or social profile was found anywhere. Reduces the number of billed rows.

## `retryBlockedWithProxy` (type: `boolean`):

Retry websites that restrict the first visit. This can improve coverage but may make the run slower; leave it off unless you need maximum reachability.

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

Optional connection settings used only when retrying restricted websites.

## Actor input object example

```json
{
  "queries": [
    "dentists in Portland OR"
  ],
  "websites": [],
  "businesses": [],
  "maxResults": 10,
  "maxPagesPerSite": 4,
  "concurrency": 8,
  "verifyEmailDomains": true,
  "onlyWithContact": false,
  "retryBlockedWithProxy": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "queries": [
        "dentists in Portland OR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/google-maps-lead-enrichment").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 = { "queries": ["dentists in Portland OR"] }

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/google-maps-lead-enrichment").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 '{
  "queries": [
    "dentists in Portland OR"
  ]
}' |
apify call thirdwatch/google-maps-lead-enrichment --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thirdwatch/google-maps-lead-enrichment",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Lead Enrichment - Emails, Phones, Socials",
        "description": "Turn Google Maps searches into sales-ready lead lists with business names, addresses, ratings, websites, public emails, phone numbers, social profiles, contact pages, and optional email-domain validation. You can also enrich existing website or business lists.",
        "version": "0.1",
        "x-build-id": "y8dSucnvizOUSUBYH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~google-maps-lead-enrichment/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-google-maps-lead-enrichment",
                "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/thirdwatch~google-maps-lead-enrichment/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-google-maps-lead-enrichment",
                "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/thirdwatch~google-maps-lead-enrichment/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-google-maps-lead-enrichment",
                "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",
                "properties": {
                    "queries": {
                        "title": "Google Maps search queries",
                        "type": "array",
                        "description": "Local-business searches, exactly as you would type them into Google Maps. Include the location in the text, e.g. \"plumbers in Austin TX\" or \"yoga studios Melbourne AU\". Each query returns up to about 120 businesses.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "websites": {
                        "title": "Websites to enrich directly",
                        "type": "array",
                        "description": "Optional. Skip the Google Maps step and enrich these website URLs directly. Can be combined with queries.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "businesses": {
                        "title": "Business objects to enrich",
                        "type": "array",
                        "description": "Optional. Business records (objects with a website field, e.g. the output of a Google Maps place scraper). Their fields are carried through onto the enriched rows.",
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of enriched business rows to produce across all queries.",
                        "default": 10
                    },
                    "maxPagesPerSite": {
                        "title": "Pages per website",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "How many pages to read per business site: the homepage plus the highest-ranked contact/about/impressum pages. Yield saturates at 4 - deeper crawls cost far more bandwidth for almost no extra contacts.",
                        "default": 4
                    },
                    "concurrency": {
                        "title": "Concurrent websites",
                        "minimum": 1,
                        "maximum": 32,
                        "type": "integer",
                        "description": "How many business websites to fetch in parallel. Every target is a different host, so there is no shared rate limit. 8 is safe at the default memory; raise memory to 512 MB before going above 16.",
                        "default": 8
                    },
                    "verifyEmailDomains": {
                        "title": "Validate email domains (DNS MX)",
                        "type": "boolean",
                        "description": "Look up the MX records of the primary email's domain to confirm it can receive mail. This filters out theme placeholders and dead domains. It does not verify the individual mailbox.",
                        "default": true
                    },
                    "onlyWithContact": {
                        "title": "Only output leads with a contact channel",
                        "type": "boolean",
                        "description": "Skip businesses where no email, phone or social profile was found anywhere. Reduces the number of billed rows.",
                        "default": false
                    },
                    "retryBlockedWithProxy": {
                        "title": "Retry blocked websites",
                        "type": "boolean",
                        "description": "Retry websites that restrict the first visit. This can improve coverage but may make the run slower; leave it off unless you need maximum reachability.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional connection settings used only when retrying restricted websites.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
