# Realtor & Real Estate Agent Lead Scraper — Verified Emails (`muhammadafzal/realtor-lead-scraper`) Actor

Scrape real estate agent & broker contacts from Google Maps with verified emails & phones. Real-time data from agency websites. Export to HubSpot, Salesforce, or CSV. Built for proptech sales & mortgage marketing.

- **URL**: https://apify.com/muhammadafzal/realtor-lead-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (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 $40.00 / 1,000 enriched real estate leads

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

## Realtor & Real Estate Agent Lead Scraper — Verified Emails

A Google Maps-focused lead generation Actor that scrapes live business listings for real estate professionals — agents, brokers, property managers, mortgage lenders, home inspectors, and title companies — then crawls each business website to extract contact emails, phone numbers, office addresses, and social media profiles. It performs DNS MX lookups and SMTP handshakes to verify email deliverability, enriches and deduplicates records by business identity and location, and produces CRM-ready leads you can export to HubSpot, Salesforce, or CSV.

### Use cases

- Mortgage lenders building referral partner outreach lists of agents and brokers
- Home inspection companies sourcing nearby brokers and agents for referrals
- Real estate SaaS vendors generating segmented prospect lists by city or brokerage size
- Title companies compiling broker contact lists across service counties for email campaigns
- Property management software vendors identifying property managers in metro areas
- Home staging companies targeting agents and brokers who list vacant properties
- PropTech firms prospecting specific metro markets with fresh, verified contacts
- Real estate CRM vendors and marketing agencies building pipelines for product demos and outreach

### Features

- **6 real estate professional types** — Real Estate Agents, Brokers, Property Managers, Mortgage Lenders, Home Inspectors, Title Companies, plus a Custom mode for niche queries
- **Multi-location search** — run a single search across multiple cities, ZIP codes, or regions in one run
- **Email enrichment** — crawls each business website (homepage, contact, about, team pages) and extracts email addresses from HTML, mailto links, and encoded entities
- **Email verification** — DNS MX record lookup + SMTP RCPT TO handshake confirms the mailbox exists before it reaches your list. Detects catch-all domains and role-based addresses (info@, contact@, sales@)
- **Social media extraction** — finds Facebook, Instagram, LinkedIn, Twitter/X, YouTube, and TikTok profile links from business websites
- **CRM export formats** — Full (all fields), HubSpot Import (matching HubSpot CSV column names), or Salesforce Import (matching Salesforce lead fields)
- **Automatic deduplication** — within a single run, duplicate Google Maps place IDs are filtered out
- **Run resumption** — saves checkpoint state so interrupted runs continue from the last processed position
- **Pay-per-result pricing** — $0.04 per enriched lead, with no charge for the actor start event beyond memory

### Input parameters

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `businessType` | enum | Yes | `Real Estate Agent` | Type of real estate professional to target. Options: Real Estate Agent, Real Estate Broker, Property Manager, Mortgage Lender, Home Inspector, Title Company, Custom |
| `locations` | array | Yes | `["Miami, FL"]` | One or more cities, states, ZIP codes, or regions. Use "City, ST" format (e.g., "Austin, TX") |
| `searchQuery` | string | No | — | Raw Google Maps query, only used when `businessType` is "Custom" |
| `maxResults` | integer | No | `50` | Maximum number of leads to collect across all locations |
| `maxResultsPerLocation` | integer | No | `0` | Per-location cap (0 = use global max only) |
| `enrichEmails` | boolean | No | `true` | Visit each business website and extract email addresses |
| `verifyEmails` | boolean | No | `true` | Validate emails via DNS MX + SMTP handshake (requires `enrichEmails`) |
| `enrichSocials` | boolean | No | `true` | Extract social media profile links from business websites |
| `outputFormat` | enum | No | `full` | Output structure: `full`, `hubspot`, or `salesforce` |
| `countryCode` | string | No | `us` | Two-letter country code for Google Maps localization |
| `languageCode` | string | No | `en` | Two-letter language code for results |
| `proxyConfiguration` | object | No | Apify proxy | Proxy settings (defaults to Apify residential proxy) |

### Output data

Each record contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name from Google Maps |
| `category` | string | Google Maps business category |
| `businessType` | string | The input business type used for the search |
| `address` | string | Full street address |
| `phone` | string\|null | Phone number from Google Maps |
| `website` | string\|null | Business website URL |
| `mapsUrl` | string\|null | Direct Google Maps listing link |
| `rating` | number\|null | Google star rating (0–5) |
| `reviewCount` | number\|null | Number of Google reviews |
| `latitude` | number\|null | GPS latitude |
| `longitude` | number\|null | GPS longitude |
| `email` | string\|null | Best email found on the business website |
| `allEmails` | array | All emails found, each with `address`, `verified`, `status`, `verificationNote` |
| `emailVerified` | boolean | Whether the primary email passed verification |
| `emailVerificationStatus` | string | `valid`, `invalid`, `catch_all`, `role_based`, `unknown`, or `not_verified` |
| `emailVerificationNote` | string | Human-readable verification detail (MX host, SMTP response) |
| `socialLinks` | object | Facebook, Instagram, LinkedIn, Twitter/X, YouTube, TikTok URLs |
| `location` | string | The search location that produced this lead |
| `placeId` | string\|null | Google Maps Place ID |
| `sourceUrl` | string | Google Maps search URL |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Sample output

```json
{
    "name": "Premier Realty Group",
    "category": "Real estate agency",
    "businessType": "Real Estate Agent",
    "address": "123 Ocean Dr, Miami, FL 33139, USA",
    "phone": "+1 305-555-0100",
    "website": "https://premierrealty.com",
    "mapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJabc123",
    "rating": 4.8,
    "reviewCount": 127,
    "latitude": 25.7617,
    "longitude": -80.1918,
    "email": "info@premierrealty.com",
    "allEmails": [
        {
            "address": "info@premierrealty.com",
            "verified": true,
            "status": "role_based",
            "verificationNote": "MX: aspmx.l.google.com, SMTP 250 OK (role-based address)"
        }
    ],
    "emailVerified": true,
    "emailVerificationStatus": "role_based",
    "emailVerificationNote": "MX: aspmx.l.google.com, SMTP 250 OK (role-based address)",
    "socialLinks": {
        "facebook": "https://facebook.com/premierrealty",
        "instagram": "https://instagram.com/premierrealty",
        "linkedin": "https://linkedin.com/company/premierrealty",
        "twitter": null,
        "youtube": null,
        "tiktok": null
    },
    "location": "Miami, FL",
    "placeId": "ChIJabc123",
    "sourceUrl": "https://www.google.com/maps/search/Real%20Estate%20Agents%20in%20Miami%2C%20FL",
    "scrapedAt": "2026-06-24T22:00:00.000Z"
}
````

### Pricing

This actor uses **pay-per-event pricing**: **$0.04 per enriched real estate lead**.

#### Cost examples

| Leads | Cost |
|-------|------|
| 10 leads | $0.40 |
| 50 leads | $2.00 |
| 200 leads | $8.00 |
| 1,000 leads | $40.00 |

You only pay for leads actually returned in the dataset — no charge for pages that return zero results or for the actor start event (beyond standard memory usage).

### Code examples

#### Run via Apify SDK (JavaScript)

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('USERNAME/realtor-lead-scraper').call({
    businessType: 'Real Estate Agent',
    locations: ['Miami, FL', 'Austin, TX'],
    maxResults: 100,
    enrichEmails: true,
    verifyEmails: true,
    enrichSocials: true,
    outputFormat: 'full'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} verified real estate leads`);
```

#### Run via REST API (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/USERNAME~realtor-lead-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "businessType": "Real Estate Broker",
    "locations": ["Denver, CO"],
    "maxResults": 50,
    "verifyEmails": true,
    "outputFormat": "hubspot"
  }'
```

#### Export to HubSpot CSV

Set `outputFormat` to `hubspot` in the input. The output records will use HubSpot's column names (`firstname`, `lastname`, `company`, `email`, `phone`, etc.) so you can export the dataset as CSV and import it directly into HubSpot.

### How email verification works

1. **DNS MX lookup** — the actor resolves the domain's MX (Mail Exchange) records. If no MX records exist, the email is marked `invalid`
2. **SMTP handshake** — the actor connects to the mail server on port 25 and performs `HELO` → `MAIL FROM` → `RCPT TO`. If the server responds with a 250 OK code, the email is marked `valid`
3. **Catch-all detection** — if a domain has DNS records but no MX, it may be a catch-all domain (accepts all email addresses). These are marked `catch_all`
4. **Role-based detection** — addresses like `info@`, `contact@`, `sales@` are flagged as `role_based` even when the SMTP check passes, so you can filter them for personalized outreach

### FAQ

#### Why do some leads have no email?

Not every real estate business lists an email on their website. The actor scans the homepage, contact page, about page, and team page, but some sites use contact forms instead of email addresses. These leads will still have phone numbers, addresses, and ratings.

#### What's the difference between "valid" and "role\_based" status?

`valid` means the SMTP server confirmed the mailbox exists. `role_based` means the same, but the address is a generic inbox (like `info@` or `sales@`) rather than a person's name. Both are deliverable, but role-based addresses may have lower engagement for cold outreach.

#### Can I search multiple cities in one run?

Yes. Add multiple entries to the `locations` array. The actor processes each location sequentially and deduplicates results across locations.

#### How many leads can I get per search?

Google Maps typically returns up to ~120 results per search query. Use `maxResultsPerLocation` to balance results across multiple locations.

#### Does the actor work outside the US?

Yes. Set `countryCode` to the appropriate two-letter code (e.g., `ca` for Canada, `gb` for United Kingdom) and `languageCode` as needed.

### Troubleshooting

| Issue | Solution |
|-------|----------|
| Zero results | Check that your location string is recognized by Google Maps. Use "City, ST" format. |
| No emails found | The business may not list an email publicly. Try disabling `verifyEmails` to get unverified emails faster. |
| All emails show "unknown" status | The target mail server may be blocking SMTP probes. This is common with large providers like Google. The emails are likely still valid. |
| Run takes too long | Email verification adds ~1-2 seconds per email. Disable `verifyEmails` for faster runs, or reduce `maxResults`. |
| Serper API error 401/403 | The Serper API key is missing or invalid. Check the `SERPER_API_KEY` environment variable in actor settings. |

# Actor input Schema

## `businessType` (type: `string`):

Select the type of real estate professional to target. The actor builds the Google Maps query automatically — e.g., 'Real Estate Agent' searches for 'Real Estate Agents in \[location]', 'Real Estate Broker' finds broker offices and brokerage firms, and 'Property Manager' returns property management companies. Choose 'Custom' to write your own query for niche searches like 'luxury real estate agents' or 'commercial real estate brokers'.

## `locations` (type: `array`):

One or more cities, states, ZIP codes, or regions to search. Use 'City, ST' format for best results (e.g., 'Austin, TX' or 'Denver, CO'). You can also enter ZIP codes ('90210'), neighborhoods ('South Beach, Miami'), metro areas ('Dallas-Fort Worth'), or any geographic phrase Google Maps recognizes. Each location search returns up to ~120 realtor and broker listings.

## `searchQuery` (type: `string`):

A raw Google Maps search query — only used when Business Type is 'Custom'. Write it exactly as you would type it into Google Maps. Examples: 'luxury real estate agents in Beverly Hills, CA', 'commercial real estate brokers in Chicago, IL', 'real estate attorneys in Manhattan, NY', 'property management companies in Houston, TX'. Ignored when a named Business Type is selected.

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

The maximum number of leads to collect and return. The prefill is set to 3 for a quick test run — increase to 50–200 for production use. Google Maps typically returns up to 120 results per search query; use a smaller number first to verify data quality before scaling up.

## `maxResultsPerLocation` (type: `integer`):

Maximum number of leads to collect from each location before moving to the next. Useful when searching multiple locations and you want balanced coverage. Set to 0 to use the global maxResults cap only.

## `enrichEmails` (type: `boolean`):

When enabled, the actor visits each agent or broker's website and scans contact pages, footers, and about pages for email addresses. This is what transforms raw Google Maps listings into a usable realtor email list. Disable only if you need phone numbers and addresses without website crawling.

## `verifyEmails` (type: `boolean`):

When enabled, each extracted email is validated via DNS MX lookup and SMTP handshake — confirming the mailbox exists before it reaches your list. Recommended for cold outreach to real estate agents and brokers where bounce rates hurt sender reputation. Adds ~1 min to the run. Only applies when 'Find Email Addresses' is enabled.

## `enrichSocials` (type: `boolean`):

When enabled, the actor extracts social media profiles (Facebook, Instagram, LinkedIn, Twitter/X, YouTube, TikTok) from each agent or broker's website. Useful for LinkedIn outreach to realtors, Facebook ads targeting property professionals, or multi-channel ABM campaigns.

## `outputFormat` (type: `string`):

Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).

## `countryCode` (type: `string`):

Two-letter country code for Google Maps search localization (e.g., 'us' for United States, 'ca' for Canada, 'gb' for United Kingdom). Defaults to 'us'.

## `languageCode` (type: `string`):

Two-letter language code for Google Maps results (e.g., 'en' for English, 'es' for Spanish). Defaults to 'en'.

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

Configure proxy usage. Defaults to Apify's residential proxy network which provides the best balance of speed and reliability for Google Maps scraping. Use the editor to switch to custom proxies if needed.

## Actor input object example

```json
{
  "businessType": "Real Estate Agent",
  "locations": [
    "Miami, FL"
  ],
  "maxResults": 3,
  "maxResultsPerLocation": 0,
  "enrichEmails": true,
  "verifyEmails": true,
  "enrichSocials": true,
  "outputFormat": "full",
  "countryCode": "us",
  "languageCode": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Link to the dataset containing all extracted real estate lead records.

# 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 = {
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/realtor-lead-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 = { "maxResults": 3 }

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/realtor-lead-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 '{
  "maxResults": 3
}' |
apify call muhammadafzal/realtor-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Realtor & Real Estate Agent Lead Scraper — Verified Emails",
        "description": "Scrape real estate agent & broker contacts from Google Maps with verified emails & phones. Real-time data from agency websites. Export to HubSpot, Salesforce, or CSV. Built for proptech sales & mortgage marketing.",
        "version": "1.0",
        "x-build-id": "NwNDsophX4pdzJA4M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~realtor-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-realtor-lead-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/muhammadafzal~realtor-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-realtor-lead-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/muhammadafzal~realtor-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-realtor-lead-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": [
                    "businessType",
                    "locations"
                ],
                "properties": {
                    "businessType": {
                        "title": "Business Type",
                        "enum": [
                            "Real Estate Agent",
                            "Real Estate Broker",
                            "Property Manager",
                            "Mortgage Lender",
                            "Home Inspector",
                            "Title Company",
                            "Custom"
                        ],
                        "type": "string",
                        "description": "Select the type of real estate professional to target. The actor builds the Google Maps query automatically — e.g., 'Real Estate Agent' searches for 'Real Estate Agents in [location]', 'Real Estate Broker' finds broker offices and brokerage firms, and 'Property Manager' returns property management companies. Choose 'Custom' to write your own query for niche searches like 'luxury real estate agents' or 'commercial real estate brokers'.",
                        "default": "Real Estate Agent"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "One or more cities, states, ZIP codes, or regions to search. Use 'City, ST' format for best results (e.g., 'Austin, TX' or 'Denver, CO'). You can also enter ZIP codes ('90210'), neighborhoods ('South Beach, Miami'), metro areas ('Dallas-Fort Worth'), or any geographic phrase Google Maps recognizes. Each location search returns up to ~120 realtor and broker listings.",
                        "default": [
                            "Miami, FL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Custom Search Query",
                        "type": "string",
                        "description": "A raw Google Maps search query — only used when Business Type is 'Custom'. Write it exactly as you would type it into Google Maps. Examples: 'luxury real estate agents in Beverly Hills, CA', 'commercial real estate brokers in Chicago, IL', 'real estate attorneys in Manhattan, NY', 'property management companies in Houston, TX'. Ignored when a named Business Type is selected."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of leads to collect and return. The prefill is set to 3 for a quick test run — increase to 50–200 for production use. Google Maps typically returns up to 120 results per search query; use a smaller number first to verify data quality before scaling up.",
                        "default": 50
                    },
                    "maxResultsPerLocation": {
                        "title": "Max Results Per Location",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of leads to collect from each location before moving to the next. Useful when searching multiple locations and you want balanced coverage. Set to 0 to use the global maxResults cap only.",
                        "default": 0
                    },
                    "enrichEmails": {
                        "title": "Find Email Addresses",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each agent or broker's website and scans contact pages, footers, and about pages for email addresses. This is what transforms raw Google Maps listings into a usable realtor email list. Disable only if you need phone numbers and addresses without website crawling.",
                        "default": true
                    },
                    "verifyEmails": {
                        "title": "Verify Email Deliverability",
                        "type": "boolean",
                        "description": "When enabled, each extracted email is validated via DNS MX lookup and SMTP handshake — confirming the mailbox exists before it reaches your list. Recommended for cold outreach to real estate agents and brokers where bounce rates hurt sender reputation. Adds ~1 min to the run. Only applies when 'Find Email Addresses' is enabled.",
                        "default": true
                    },
                    "enrichSocials": {
                        "title": "Find Social Media Links",
                        "type": "boolean",
                        "description": "When enabled, the actor extracts social media profiles (Facebook, Instagram, LinkedIn, Twitter/X, YouTube, TikTok) from each agent or broker's website. Useful for LinkedIn outreach to realtors, Facebook ads targeting property professionals, or multi-channel ABM campaigns.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "full",
                            "hubspot",
                            "salesforce"
                        ],
                        "type": "string",
                        "description": "Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).",
                        "default": "full"
                    },
                    "countryCode": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Two-letter country code for Google Maps search localization (e.g., 'us' for United States, 'ca' for Canada, 'gb' for United Kingdom). Defaults to 'us'.",
                        "default": "us"
                    },
                    "languageCode": {
                        "title": "Language Code",
                        "type": "string",
                        "description": "Two-letter language code for Google Maps results (e.g., 'en' for English, 'es' for Spanish). Defaults to 'en'.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy usage. Defaults to Apify's residential proxy network which provides the best balance of speed and reliability for Google Maps scraping. Use the editor to switch to custom proxies if needed.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
