# Google Maps Scraper Goat (`goat255/google-maps-extractor`) Actor

Extract business leads from Google Maps at scale. Get business names, phones, emails, websites, structured addresses, ratings, every full review (not just the count), popular times, GPS, and any social profile links found on each business website. Pure HTTP, no browser, no Google API key.

- **URL**: https://apify.com/goat255/google-maps-extractor.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Lead generation, Real estate, Travel
- **Stats:** 25 total users, 13 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 leads

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 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

## Google Maps Scraper - Extract Business Leads, Emails, Reviews & Social Profiles

Extract business leads from Google Maps at scale. Get business names, phones, emails, websites, structured addresses, ratings, **every review (not just the count)**, GPS coordinates, popular times, and **10 social media profiles** per business. No browser needed - runs on pure HTTP for fast, cheap bulk lead generation.

### What this Google Maps scraper does

Enter search queries and locations. The actor scrapes Google Maps results with automatic pagination, then optionally visits each business website to harvest **emails and social profiles across 10 networks** (Instagram, Facebook, LinkedIn, Twitter/X, YouTube, TikTok, Threads, WhatsApp, Telegram). Each `query × location` pair runs in parallel for fast extraction.

Perfect for **lead generation, local SEO research, competitor analysis, CRM enrichment, real-estate research, and sales prospecting**.

### Why use this Google Maps Scraper

- **Pure HTTP, no browser** - 5-10x faster and cheaper than browser-based Maps scrapers.
- **Every review, not just the count** - most Apify Maps actors return only `reviewCount`. This one returns the full text of every review with author, rating, and timestamps.
- **10 social platforms harvested** from each business website - Instagram, Facebook, LinkedIn, Twitter/X, YouTube, TikTok, Threads, WhatsApp, Telegram + email.
- **Knowledge Graph IDs + CID + Plus Code** for de-duping and cross-referencing.
- **Popular times, review topics, reviewsPerStar** breakdown from Place Details.
- **Cloudflare email obfuscation** decoded automatically.
- **Configurable depth** - basic Maps row, full Place Details, full reviews, full website crawl - pay only for what you enable.
- **Subscription-tiered pricing** - lower prices for Apify subscribers.

### What data you get per business

#### Core Maps response (always included)

| Field | Description |
|---|---|
| `name`, `nameLocal` | Business name (English + local language) |
| `category`, `categoryList` | Categories (string + array) |
| `addressFull`, `addressShort`, `structuredAddress` | Full and structured address parts |
| `regionDisplay`, `countryCode` | Human-readable region + ISO country |
| `phone`, `phoneE164` | Phone (display + E.164 format) |
| `website` | Business website URL |
| `averageRating`, `reviewCount` | Stars + total review count |
| `latitude`, `longitude` | GPS coordinates |
| `placeID`, `kgID`, `cID`, `cidDecimal` | Google Place ID + Knowledge Graph ID + CID |
| `ownerUserID`, `profilePhoto` | GMB owner ID + profile photo URL |
| `timezone`, `languagePrimary`, `languageSecondary` | IANA timezone + primary/secondary language |
| `0_Sunday`...`6_Saturday` | Working hours per weekday |

#### Place Details (when enabled)

Adds `description`, `plusCode`, `displayedReviewCount`, `reviewsPerStar` breakdown, `reviewTopics`, `popularTimes` (hourly busy %), `features` (accessibility, amenities, crowd attributes), `inlineReviews`, `previewQuotes`, `owner` info, `canonicalMapsURL`, `categoryIDs`, and granular address parts.

#### Full reviews (when enabled) - **flagship feature**

Returns every review on the place, with full text, author identity, rating, and timestamps.

| Field | Description |
|---|---|
| `reviewID`, `authorName`, `authorPhoto`, `authorID` | Reviewer identity |
| `authorReviewCount`, `authorPhotoCount` | Reviewer contribution stats |
| `rating`, `text` | 1-5 stars + full review text |
| `relativeTime`, `timestamp` | "3 months ago" + unix epoch |
| `photos` | Review photos |
| `ownerReply` | Owner reply (text + timestamp) |

Set `maxReviewsPerPlace: 0` for every review per business.

#### Website crawl (when enabled)

| Field | Description |
|---|---|
| `email` | Business emails (domain-prioritized) |
| `instagram`, `facebook`, `linkedin` | Social profile URLs |
| `twitter`, `youtube`, `tiktok`, `threads` | More social profile URLs |
| `whatsapp`, `telegram` | Click-to-chat URLs |

The crawler decodes Cloudflare email obfuscation, parses `mailto:` and `whatsapp:` href schemes, and (with deep search) follows `/contact`, `/about`, `/team`, etc. up to one level.

### How to use the Google Maps Scraper

1. Click **Try for free** on the actor page.
2. Enter **search queries** (e.g. `restaurants`, `dentists`, `wedding photographers`).
3. Enter **locations** (e.g. `New York, NY`, `London`, `Berlin`).
4. Toggle enrichment features:
   - **Extract Emails & Social Profiles** - crawls each website for contacts (**on by default** - turn off for faster, name/phone-only runs)
   - **Extract Place Details** - adds popular times, reviewTopics, full feature list
   - **Extract Full Review Text** - returns every review per business
5. Set `maxResults` (0 = unlimited) and a `maxTotalChargeUsd` spending limit.
6. Click **Save & start**. Download in JSON, CSV, Excel, XML, or HTML.

### Top use cases

- **Local lead generation** - extract restaurants, dentists, contractors, real estate agents, photographers, lawyers etc. with emails and phones for B2B outreach.
- **Local SEO research** - rank tracking, competitor profile audits, review-topic analysis at scale.
- **Real estate research** - find every business in a neighborhood with categories and contact info.
- **Franchise expansion research** - identify competitor density and gaps by location.
- **Sales prospecting** - build a list of businesses in a city in a category with rating and review filters.
- **Review monitoring** - pull every review for tracked competitors to spot trends and complaints.
- **CRM enrichment** - hydrate existing accounts with Google Place IDs, GPS coords, social profiles.
- **Market research** - business density by category and city, hourly popular-times analysis.

### Output example

```json
{
  "name": "Example Wedding Studio",
  "category": "Wedding photographer;Aerial photographer;Photo booth",
  "addressFull": "123 Example Street, Example City, EX 00000, Example Country",
  "phone": "+1 555-0100",
  "phoneE164": "+15550100",
  "website": "https://example.com/",
  "email": ["info@example.com"],
  "averageRating": 4.7,
  "reviewCount": 489,
  "instagram": ["https://www.instagram.com/example-studio"],
  "facebook": ["https://www.facebook.com/example-studio"],
  "whatsapp": ["https://wa.me/15550100"],
  "latitude": 0.0,
  "longitude": 0.0,
  "timezone": "UTC",
  "placeID": "ChIJxxxxxxxxxxxxxxxxxxxxx",
  "kgID": "/g/xxxxxxxxxxx",
  "cID": "0x0000000000000000:0x0000000000000000",
  "1_Monday": "9 AM-6 PM"
}
````

### Pricing

Pay-per-event with Apify **subscription tier discounts**. You only pay for contact enrichment when we **actually find** an email or social profile - never for an empty crawl.

| Component | Free | Gold+ |
|---|---|---|
| Business lead (name, phone, address, rating, GPS) | $0.004 | $0.003 |
| + Contact enrichment (billed only when an email/social is found) | +$0.003 | +$0.002 |
| + Full review text (optional) | $0.0007 | $0.0005 |

**Example costs (Free tier):**

- 1,000 basic leads, no enrichment: **$4.00**
- 1,000 leads where ~40% return a contact: **~$5.20**
- A lead *with* a verified email: **~$0.007**, with the email, phone, and social profiles included in that price.

Set `maxTotalChargeUsd` before each run to cap budget; the actor stops automatically when reached. Apify's $5 platform free credit applies on first use.

### FAQ

#### Do I need a Google API key?

No. This scraper works directly with Google Maps - no API keys, no quotas, no Google Places API limits.

#### How accurate is the data?

Live - exactly what's on Google Maps at the moment of the scrape, not cached.

#### Can I scrape full review text?

Yes - enable **Extract Full Review Text** to return every review with author identity, rating, timestamp, photos, and owner replies.

#### How does email extraction work?

For each business with a website, the actor visits the homepage (and optionally `/contact`, `/about`, `/team` pages) to harvest email addresses and social profile URLs across 10 platforms. Cloudflare-obfuscated emails are decoded automatically.

#### How fast is it?

Pure HTTP, no browser - typically 5-10x faster than Puppeteer-based Maps scrapers. A 100-lead run with email enrichment finishes in 1-2 minutes.

#### What about Google rate limits?

Residential proxies handle Google's rate limits. The actor automatically falls back to datacenter or direct connection if residential isn't available.

#### Can I get more than 120 results per area?

Yes - the actor automatically paginates and de-duplicates by Place ID across multiple queries. Combine multiple location strings for full coverage.

#### Can I scrape by direct Google Maps URL?

Yes - paste a Google Maps URL with your desired zoom level for geographic precision.

#### Can I export to Google Sheets / CSV / Excel?

Yes - JSON, CSV, Excel, XML, HTML formats all supported, plus native integrations to Google Sheets, Zapier, Make, Slack, S3, HubSpot.

### Related Apify actors

- 👤 [Instagram Profile Scraper](https://apify.com/goat255/instagram-profile-scraper) - enrich your Maps leads with their Instagram bio, follower count, and contact info.
- 📝 [Instagram Posts Scraper](https://apify.com/goat255/instagram-posts-scraper) - audit business Instagram activity at scale.

### Support

Found a missing field or a bug? Open an issue on the actor page. Reviews are read and replied to.

# Actor input Schema

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

Business types or keywords to search on Google Maps (e.g. "coffee shop", "plumber").

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

Geographic locations to combine with each query (e.g. "New York, NY"). Each query runs for each location.

## `searchUrls` (type: `array`):

Provide direct Google Maps search URLs instead of queries + locations. When provided, queries and locations are ignored.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of results to extract per query-location pair. Set to 0 for unlimited.

## `maxConcurrency` (type: `integer`):

Number of parallel search workers. Higher values are faster but use more proxy bandwidth.

## `extractDetails` (type: `boolean`):

For each business, fetch its Place Details page to enrich with: full business description, Plus Code, more granular structured address (neighborhood/city/state/postal/country), reviews-per-star breakdown (1★/2★/3★/4★/5★ counts), review topic chips, popular times (hourly busy %), feature attributes (wheelchair accessible, LGBTQ-friendly, etc.), owner profile, canonical Maps URL, and category IDs. Adds 1 HTTP request per result.

## `maxDetailsConcurrency` (type: `integer`):

Number of parallel Place Details workers.

## `extractReviews` (type: `boolean`):

Fetch every review's full text per place — includes author name, profile photo, rating, relative time, exact timestamp, review text, photos posted with the review, and any owner reply (with reply text and time). Adds 1+ HTTP requests per place (paginated). Marquee feature — most Apify Maps actors only return review COUNT.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to fetch per business. Set to 0 for unlimited (every review). Default 20 covers most use cases at low cost.

## `maxReviewsConcurrency` (type: `integer`):

Parallel review fetchers. Lower than search/details to avoid rate-limiting on the reviews endpoint.

## `collectEmails` (type: `boolean`):

Visit each business website to extract email addresses and social media profiles across 10 platforms (Instagram, Facebook, LinkedIn, Twitter/X, YouTube, TikTok, Threads, WhatsApp, Telegram). On by default — emails are the #1 reason people scrape Maps. Turn off for faster, cheaper runs when you only need names/phones.

## `deepEmailSearch` (type: `boolean`):

When email extraction is enabled, also crawl contact/about pages on each website for more thorough results. Slower but finds more emails.

## `maxEmailConcurrency` (type: `integer`):

Number of parallel email extraction workers.

## `emailTimeout` (type: `integer`):

Timeout in milliseconds for fetching each business website during email extraction.

## `language` (type: `string`):

Language code for Google Maps results (ISO 639-1).

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

Country code for Google Maps results (ISO 3166-1 alpha-2).

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

Residential proxies recommended for best results.

## Actor input object example

```json
{
  "queries": [
    "restaurants"
  ],
  "locations": [
    "New York, NY"
  ],
  "maxResultsPerQuery": 20,
  "maxConcurrency": 10,
  "extractDetails": false,
  "maxDetailsConcurrency": 10,
  "extractReviews": false,
  "maxReviewsPerPlace": 20,
  "maxReviewsConcurrency": 5,
  "collectEmails": true,
  "deepEmailSearch": true,
  "maxEmailConcurrency": 20,
  "emailTimeout": 15000,
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Extracted business leads with name, phone (raw + E.164), email, website, full + structured address, rating + review count, social profiles across 10 platforms, profile photo, timezone, language, and GPS coordinates

# 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": [
        "restaurants"
    ],
    "locations": [
        "New York, NY"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/google-maps-extractor").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": ["restaurants"],
    "locations": ["New York, NY"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/google-maps-extractor").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": [
    "restaurants"
  ],
  "locations": [
    "New York, NY"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call goat255/google-maps-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper Goat",
        "description": "Extract business leads from Google Maps at scale. Get business names, phones, emails, websites, structured addresses, ratings, every full review (not just the count), popular times, GPS, and any social profile links found on each business website. Pure HTTP, no browser, no Google API key.",
        "version": "2.0",
        "x-build-id": "oB7D7eCYtt1aDRAta"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~google-maps-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-google-maps-extractor",
                "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/goat255~google-maps-extractor/runs": {
            "post": {
                "operationId": "runs-sync-goat255-google-maps-extractor",
                "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/goat255~google-maps-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-google-maps-extractor",
                "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": [
                    "queries",
                    "locations"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Business types or keywords to search on Google Maps (e.g. \"coffee shop\", \"plumber\").",
                        "default": [
                            "restaurants"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Geographic locations to combine with each query (e.g. \"New York, NY\"). Each query runs for each location.",
                        "default": [
                            "New York, NY"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Direct Google Maps URLs",
                        "type": "array",
                        "description": "Provide direct Google Maps search URLs instead of queries + locations. When provided, queries and locations are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of results to extract per query-location pair. Set to 0 for unlimited.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Max Search Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of parallel search workers. Higher values are faster but use more proxy bandwidth.",
                        "default": 10
                    },
                    "extractDetails": {
                        "title": "Extract Place Details (description, plus code, popular times, reviews-per-star)",
                        "type": "boolean",
                        "description": "For each business, fetch its Place Details page to enrich with: full business description, Plus Code, more granular structured address (neighborhood/city/state/postal/country), reviews-per-star breakdown (1★/2★/3★/4★/5★ counts), review topic chips, popular times (hourly busy %), feature attributes (wheelchair accessible, LGBTQ-friendly, etc.), owner profile, canonical Maps URL, and category IDs. Adds 1 HTTP request per result.",
                        "default": false
                    },
                    "maxDetailsConcurrency": {
                        "title": "Max Details Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of parallel Place Details workers.",
                        "default": 10
                    },
                    "extractReviews": {
                        "title": "Extract Full Review Text",
                        "type": "boolean",
                        "description": "Fetch every review's full text per place — includes author name, profile photo, rating, relative time, exact timestamp, review text, photos posted with the review, and any owner reply (with reply text and time). Adds 1+ HTTP requests per place (paginated). Marquee feature — most Apify Maps actors only return review COUNT.",
                        "default": false
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max Reviews Per Place",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per business. Set to 0 for unlimited (every review). Default 20 covers most use cases at low cost.",
                        "default": 20
                    },
                    "maxReviewsConcurrency": {
                        "title": "Max Reviews Concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Parallel review fetchers. Lower than search/details to avoid rate-limiting on the reviews endpoint.",
                        "default": 5
                    },
                    "collectEmails": {
                        "title": "Extract Emails & Social Profiles",
                        "type": "boolean",
                        "description": "Visit each business website to extract email addresses and social media profiles across 10 platforms (Instagram, Facebook, LinkedIn, Twitter/X, YouTube, TikTok, Threads, WhatsApp, Telegram). On by default — emails are the #1 reason people scrape Maps. Turn off for faster, cheaper runs when you only need names/phones.",
                        "default": true
                    },
                    "deepEmailSearch": {
                        "title": "Deep Email Search",
                        "type": "boolean",
                        "description": "When email extraction is enabled, also crawl contact/about pages on each website for more thorough results. Slower but finds more emails.",
                        "default": true
                    },
                    "maxEmailConcurrency": {
                        "title": "Max Email Extraction Concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of parallel email extraction workers.",
                        "default": 20
                    },
                    "emailTimeout": {
                        "title": "Email Fetch Timeout (ms)",
                        "minimum": 3000,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Timeout in milliseconds for fetching each business website during email extraction.",
                        "default": 15000
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "hi",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language code for Google Maps results (ISO 639-1).",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country code for Google Maps results (ISO 3166-1 alpha-2).",
                        "default": "us"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies recommended for best results.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
