# Google Maps Scraper — Business Leads & Emails (No API Key) (`nexgendata/google-maps-extractor`) Actor

Google Maps scraper for lead generation — no API key needed. Extract local business leads (name, address, phone, website, rating, reviews + verified emails) for any "keyword in location" search. Export to CSV/JSON/Excel or deliver straight to your Notion CRM in one run.

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

## Pricing

from $7.00 / 1,000 business records

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

## 📍 Google Maps Extractor — Business Leads, Contacts & Emails (No API Key)

> ✅ **No Google API key required.** Extract business leads directly from Google Maps — names, phones, websites, **emails**, ratings, reviews, and hours. Just enter a search query and run. (Supplying your own Google Places API key is optional and switches to the official-API path.)


Pull live business listings from Google Maps for any query + region — names, phones, websites, ratings, reviews, opening hours, latitude / longitude. A drop-in **alternative to** Google Maps Places API, Yelp Fusion, SerpApi Maps, Outscraper, and Bright Data Maps — with no per-call SDK fees.

### Why Google Maps Scraper Beats Places API, Yelp Fusion, SerpApi, Outscraper & Bright Data

| Feature | NexGenData Google Maps Scraper | Google Maps Places API | Yelp Fusion API | SerpApi Maps | Outscraper Maps | Bright Data Maps |
|---|---|---|---|---|---|---|
| Cost | Pay-per-event, no subscription | $17 – $32 per 1,000 calls | Free but limited | $75 – $2,500 / month | Per-result, plan-gated | Enterprise contract |
| Coverage | Global — every Google Maps locale | Global | US + 30 countries | Global | Global | Global |
| Reviews per place | Full review text + author + rating | Limited (5 per call) | Limited | Yes | Yes | Yes |
| Phone + website | Yes | Yes | Yes | Yes | Yes | Yes |
| Hours of operation | Yes | Yes | Yes | Yes | Yes | Yes |
| Lat / long | Yes | Yes | Yes | Yes | Yes | Yes |
| Bulk query input | Unlimited per run | Per-call | Plan-gated | Plan-gated | Plan-gated | Plan-gated |
| Output | CSV / JSON / Excel / API | JSON | JSON | JSON | CSV / JSON | JSON |
| Auth | Apify token | Google Cloud API key + billing | API key + plan | API key + plan | API key | Enterprise SSO |
| Time-to-first-row | < 60 seconds | Billing + project setup | Signup + plan | Signup + plan | Signup | Sales cycle |

Most lead-gen and local-SEO teams pick this scraper because it is **cheaper than** Places API at scale, **simpler than** Bright Data's enterprise contract, and **broader than** Yelp Fusion's 30-country footprint. JSON drops straight into your CRM.

### What You Get

Each place returns:

- **Business name** + Google place_id
- **Category** — primary + secondary tags (e.g., "Italian restaurant", "Pizza takeaway")
- **Address** — street, city, state, ZIP, country
- **Latitude / longitude**
- **Phone number** (formatted)
- **Website URL** + Google Maps URL
- **Hours of operation** — weekly schedule + special hours
- **Average rating** (1–5) + total review count
- **Full review text** — author, rating, date, text per review (configurable depth)
- **Photos** — array of image URLs
- **Plus code** (Google Open Location Code)
- **Price level** (1–4, where shown)
- **Currently open / temporarily closed / permanently closed** flag
- **Owner-claimed flag**
- **Scrape timestamp**

Output streams to a clean Apify dataset — CSV, JSON, Excel, RSS, or hit the API directly.

### Use Cases

- **Outbound sales** — build a list of every dentist / law firm / HVAC company in a city, enriched with phone + website
- **Local SEO agencies** — audit a client's competitors' review counts, ratings, and category overlap
- **Franchise + multi-location ops** — monitor each franchisee's review velocity and rating trend
- **Restaurant tech / delivery** — build a market-coverage map of all eligible merchants per zone
- **Real-estate retail leasing** — source vacant-storefront leads by tracking permanently-closed flags
- **Brand-protection** — detect fake duplicate listings impersonating your brand
- **Travel + hospitality** — build hotel + attraction directories per region with review-sourced sentiment

### Quick Start

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "searchStringsArray": ["dentist in austin tx"],
    "maxCrawledPlacesPerSearch": 100,
    "includeReviews": True,
    "maxReviews": 10,
}
run = client.actor("nexgendata/google-maps-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("name"), item.get("phone"), item.get("rating"))
````

### Pricing

Pay-per-event. Small Actor Start fee + per-place fee for each business written to the dataset. No subscription, no minimum, no seat fee.

Compare to Google Maps Places API at $17-$32 per 1,000 calls (and Place Details charges separately), SerpApi at $75-$2,500 per month, or Bright Data's enterprise contract — this actor pays for itself within the first 1,000-row batch for most teams.

### Related NexGenData Actors

| Use case | Actor |
|----------|-------|
| Yelp business scraper (US + international) | [Yelp Business Scraper](https://apify.com/nexgendata/yelp-business-scraper) |
| Maps API access for AI agents (MCP) | [Google Maps MCP Server](https://apify.com/nexgendata/google-maps-mcp-server) |
| Bulk B2B leads finder | [B2B Leads Finder](https://apify.com/nexgendata/b2b-leads-finder) |
| Detect hiring signals from local businesses | [Hiring Signal Detector](https://apify.com/nexgendata/hiring-signal-detector) |
| Find emails for a company domain | [Company Email Finder](https://apify.com/nexgendata/company-email-finder) |
| Scrape contact info from any URL | [Contact Info Scraper](https://apify.com/nexgendata/contact-info-scraper) |
| Enrich a domain list with leads | [Lead List Enricher](https://apify.com/nexgendata/lead-list-enricher) |
| Validate emails (deliverability) | [Email Validator](https://apify.com/nexgendata/email-validator) |

### FAQ

**Is scraping Google Maps legal?**
This actor reads publicly displayed business listings the same way a regular browser does, throttled and proxied. We do not bypass logins or paywalls.

**How fresh is the data?**
Live on every run. Each invocation pulls the current Google Maps result at runtime.

**Coverage?**
Global — every country and locale Google Maps serves.

**Drop-in for the Places API?**
For data extraction, yes — you get a superset of Places Details (full review text, owner-claimed flag, photos array). For autocomplete / nearby-search SDK use cases inside a native mobile app, you still want Places API directly.

**Can I scrape reviews?**
Yes — set `includeReviews: true` and `maxReviews: N`. Each result returns up to N reviews with author, rating, date, and full text.

**Can I schedule daily?**
Yes — native Apify scheduling + webhook on completion.

**Does it return latitude / longitude?**
Yes — every result includes lat / long, plus Google's plus code.

### About NexGenData

NexGenData publishes 260+ buyer-intent actors covering SEC filings, YC alumni, lead generation, competitive intelligence, stock fundamentals across 30+ exchanges, and more. All pay-per-result. Browse the full catalog at https://apify.com/nexgendata?fpr=2ayu9b

***

### How NexGenData Pricing Works

Every NexGenData actor uses **pay-per-event** pricing — you only pay for results that actually land in your dataset. No monthly minimum, no seat fees, no surprise overage bills.

- **Actor Start:** a single-event charge each time you spin the actor up (scaled to memory size)
- **Result:** charged per item written to the default dataset
- **No charge** for retries, internal proxy rotation, or failed sub-requests — those are absorbed by the platform

If you only need the data once a quarter, you only pay once a quarter. If you scale to millions of records, the unit cost stays the same.

### Apify Platform Bonus

New to Apify? Sign up with the NexGenData [referral link](https://www.apify.com/?fpr=2ayu9b) — you get free platform credits on signup (enough for several thousand free results) and you help fund the maintenance of this actor fleet.

### Integration Surface

Every actor in the NexGenData catalog can be triggered from:

- **Apify console** — point-and-click run
- **Apify API** — REST + webhooks
- **Apify Python / JS SDKs** — programmatic batch
- **Zapier, Make.com, n8n** — official integrations
- **MCP** — many actors are exposed as MCP tools for Claude / ChatGPT / Cursor agents
- **Schedules** — built-in cron for daily / weekly / monthly runs
- **Webhooks** — POST results to any HTTPS endpoint on dataset write

### Support

NexGenData maintains 260+ Apify actors and ships updates regularly. Bug reports via the Apify console issues tab get a response within 24 hours. Roadmap requests are welcome — high-demand features ship in the next version.

Home: [thenextgennexus.com](https://thenextgennexus.com)
Full catalog: [apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b)

### 💰 Pricing Example

This actor uses Pay-Per-Event pricing — you only pay for results.

- **Typical run (small):** 100 results × $0.05 = **$5.00**
- **Medium run:** 500 results × $0.05 = **$25.00**
- **Large run (power user):** 2,000 results × $0.05 = **$100.00**

Free Apify accounts get $5/mo in platform credit. A typical local-business lead gen workflow at this scale typically exceeds the free credit — upgrade to a paid Apify plan for unrestricted use.

### 🔗 Related Actors

Pair with these for a complete workflow:

- [🔍 ⭐ Yelp Lead Scraper — Emails & Phone Numbers](https://apify.com/nexgendata/yelp-business-scraper) — scrape Yelp listings for local-business leads with reviews
- [🎯 B2B Leads Finder — Apollo Alternative | Emails](https://apify.com/nexgendata/b2b-leads-finder) — find B2B prospects by industry + role with verified emails
- [📇 Contact Info Scraper — Emails & Phone Numbers](https://apify.com/nexgendata/contact-info-scraper) — extract emails + phones + socials from any URL
- [⚕️ Doctor Directory Lead Finder](https://apify.com/nexgendata/doctor-directory-lead-finder) — scrape doctor + clinic directories for healthcare lead gen
- [📍 Google Maps MCP — AI Lead Gen & Search](https://apify.com/nexgendata/google-maps-mcp-server) — MCP-server version of this scraper for AI agents

***

### ⭐ Found this useful?

If this Actor saved you time, a quick **[review on the Apify Store](https://apify.com/nexgendata/google-maps-scraper)** genuinely helps other teams discover it. Have a feature request or hit a problem? Open it from the **Issues** tab — we read every one.

### Quick start

**Input:**

```json
{
  "queries": [
    "restaurants in New York"
  ],
  "location": "New York, US",
  "max_results": 20,
  "enrich_contacts": true
}
```

*Supply your own Google Places API key in `google_api_key`.*

**Example output** (one record; representative fields):

```json
{
  "name": "Joe's Pizza",
  "address": "7 Carmine St, New York, NY",
  "phone": "+1 212-555-0100",
  "website": "https://joespizza.com",
  "rating": 4.5,
  "email": "info@joespizza.com",
  "socials": {
    "instagram": "https://instagram.com/joespizza"
  }
}
```

**Pricing:** $0.05 per business returned — about **$50 per 1,000 leads** (with contact enrichment). You pay only for results, billed per run by Apify.

**Data freshness:** Google Places API, queried live at run time — results are as fresh as the moment you run it.

**Use it in a workflow:** chain with related NexGenData actors or use via the [`n8n-nodes-nexgendata`](https://www.npmjs.com/package/n8n-nodes-nexgendata) community nodes. Full [storefront by workflow](https://thenextgennexus.com/actors-by-workflow/).

# Actor input Schema

## `outputMode` (type: `string`):

Choose output format. 'Lead Tracker' adds lead quality scoring (email/phone/website completeness), rating analysis, category breakdown, contact enrichment stats, and a summary report with auto-generated insights about the local market. 'Raw Data' gives flat business records for spreadsheet import.

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

Business searches — include the type and location. Examples: 'plumbers in Chicago', 'dentists Austin TX', 'Italian restaurants Manhattan'. NO Google API key required — results are scraped directly from Google Maps. Aliases accepted: keywords, searchQueries, urls, startUrls, searches. Single strings and comma/newline-separated strings are auto-coerced to a list.

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

Alias of `queries`. List of business search strings, e.g. \['coffee shops in Austin TX'].

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

Add a location to all searches. Useful when your queries don't already include a city. Example: 'San Francisco, CA'.

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

Max businesses per query. 20 for a quick scan, up to 100 for comprehensive local market coverage.

## `max_results` (type: `integer`):

Alias of `maxResults`.

## `enrich_contacts` (type: `boolean`):

Visit each business website to extract emails and social media links. Adds ~1-2 seconds per business but dramatically increases lead value.

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

Proxy used to scrape Google Maps and enrich business websites. Apify RESIDENTIAL proxy is strongly recommended (and used by default) — Google Maps is anti-bot defended.

## `googleApiKey` (type: `string`):

OPTIONAL. Leave blank to scrape Google Maps directly with NO API key (default). If you DO supply a Google Cloud API key with Places API (New) enabled, the faster official-API path is used instead.

## `google_api_key` (type: `string`):

Alias of `googleApiKey`. Optional — leave blank for key-free scraping.

## `searchQueries` (type: `array`):

Alias of `queries` for users coming from other Apify scrapers.

## `urls` (type: `array`):

Alias of `queries` (despite the name). Pass business search strings here.

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

Alias of `queries`. Accepts plain strings or {url: ...} dict items.

## `searches` (type: `array`):

Alias of `queries`.

## `query` (type: `string`):

Alternative — a single business search string when you only need one query.

## `notionConnector` (type: `string`):

Optional. Connect your Notion workspace and the results are also written as a Notion page in the same run — the Actor never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here.

## `notionParentId` (type: `string`):

Optional. The Notion page ID to create the page under. If blank, Notion creates a private page in your workspace.

## Actor input object example

```json
{
  "outputMode": "raw",
  "queries": [
    "coffee shops in Austin TX"
  ],
  "keywords": [],
  "maxResults": 50,
  "max_results": 50,
  "enrich_contacts": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "searchQueries": [],
  "urls": [],
  "startUrls": [],
  "searches": []
}
```

# Actor output Schema

# 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 = {
    "outputMode": "raw",
    "queries": [
        "coffee shops in Austin TX"
    ],
    "keywords": [],
    "location": "",
    "maxResults": 50,
    "max_results": 50,
    "enrich_contacts": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "searchQueries": [],
    "urls": [],
    "startUrls": [],
    "searches": [],
    "query": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/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 = {
    "outputMode": "raw",
    "queries": ["coffee shops in Austin TX"],
    "keywords": [],
    "location": "",
    "maxResults": 50,
    "max_results": 50,
    "enrich_contacts": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "searchQueries": [],
    "urls": [],
    "startUrls": [],
    "searches": [],
    "query": "",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/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 '{
  "outputMode": "raw",
  "queries": [
    "coffee shops in Austin TX"
  ],
  "keywords": [],
  "location": "",
  "maxResults": 50,
  "max_results": 50,
  "enrich_contacts": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "searchQueries": [],
  "urls": [],
  "startUrls": [],
  "searches": [],
  "query": ""
}' |
apify call nexgendata/google-maps-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper — Business Leads & Emails (No API Key)",
        "description": "Google Maps scraper for lead generation — no API key needed. Extract local business leads (name, address, phone, website, rating, reviews + verified emails) for any \"keyword in location\" search. Export to CSV/JSON/Excel or deliver straight to your Notion CRM in one run.",
        "version": "0.0",
        "x-build-id": "vLzT9bEmZ1vPIvq7L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~google-maps-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-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/nexgendata~google-maps-extractor/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-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/nexgendata~google-maps-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-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",
                "properties": {
                    "outputMode": {
                        "title": "Output Mode",
                        "enum": [
                            "tracker",
                            "raw"
                        ],
                        "type": "string",
                        "description": "Choose output format. 'Lead Tracker' adds lead quality scoring (email/phone/website completeness), rating analysis, category breakdown, contact enrichment stats, and a summary report with auto-generated insights about the local market. 'Raw Data' gives flat business records for spreadsheet import.",
                        "default": "raw"
                    },
                    "queries": {
                        "title": "Search Queries",
                        "description": "Business searches — include the type and location. Examples: 'plumbers in Chicago', 'dentists Austin TX', 'Italian restaurants Manhattan'. NO Google API key required — results are scraped directly from Google Maps. Aliases accepted: keywords, searchQueries, urls, startUrls, searches. Single strings and comma/newline-separated strings are auto-coerced to a list."
                    },
                    "keywords": {
                        "title": "Keywords (alias for Search Queries)",
                        "type": "array",
                        "description": "Alias of `queries`. List of business search strings, e.g. ['coffee shops in Austin TX'].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location Context (optional)",
                        "type": "string",
                        "description": "Add a location to all searches. Useful when your queries don't already include a city. Example: 'San Francisco, CA'."
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max businesses per query. 20 for a quick scan, up to 100 for comprehensive local market coverage.",
                        "default": 50
                    },
                    "max_results": {
                        "title": "Maximum Results (alias)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Alias of `maxResults`."
                    },
                    "enrich_contacts": {
                        "title": "Enrich Contact Data",
                        "type": "boolean",
                        "description": "Visit each business website to extract emails and social media links. Adds ~1-2 seconds per business but dramatically increases lead value.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy used to scrape Google Maps and enrich business websites. Apify RESIDENTIAL proxy is strongly recommended (and used by default) — Google Maps is anti-bot defended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "googleApiKey": {
                        "title": "Google API Key (OPTIONAL)",
                        "type": "string",
                        "description": "OPTIONAL. Leave blank to scrape Google Maps directly with NO API key (default). If you DO supply a Google Cloud API key with Places API (New) enabled, the faster official-API path is used instead."
                    },
                    "google_api_key": {
                        "title": "Google API Key (alias, optional)",
                        "type": "string",
                        "description": "Alias of `googleApiKey`. Optional — leave blank for key-free scraping."
                    },
                    "searchQueries": {
                        "title": "Search Queries (alias)",
                        "type": "array",
                        "description": "Alias of `queries` for users coming from other Apify scrapers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Search Strings (alias)",
                        "type": "array",
                        "description": "Alias of `queries` (despite the name). Pass business search strings here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (alias)",
                        "type": "array",
                        "description": "Alias of `queries`. Accepts plain strings or {url: ...} dict items."
                    },
                    "searches": {
                        "title": "Searches (alias)",
                        "type": "array",
                        "description": "Alias of `queries`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Single Query (string alias)",
                        "type": "string",
                        "description": "Alternative — a single business search string when you only need one query."
                    },
                    "notionConnector": {
                        "title": "Deliver to Notion (optional)",
                        "type": "string",
                        "description": "Optional. Connect your Notion workspace and the results are also written as a Notion page in the same run — the Actor never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here."
                    },
                    "notionParentId": {
                        "title": "Notion parent page ID (optional)",
                        "type": "string",
                        "description": "Optional. The Notion page ID to create the page under. If blank, Notion creates a private page in your workspace."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
