# Restaurant Leads from Google Maps (`nezha/restaurant-google-maps-leads`) Actor

Find restaurant, cafe, brunch, bakery, bar, and coffee shop leads from Google Maps. Export business names, phones, websites, ratings, review counts, addresses, opening hours, price ranges, categories, and local demand signals for restaurant sales outreach, local SEO, and market research.

- **URL**: https://apify.com/nezha/restaurant-google-maps-leads.md
- **Developed by:** [nezha](https://apify.com/nezha) (community)
- **Categories:** Lead generation, SEO tools, Travel
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Restaurant Leads from Google Maps

Find restaurant, cafe, brunch, bakery, bar, and coffee shop leads from Google Maps, then export outreach-ready business records with phones, websites, ratings, review counts, addresses, opening hours, price ranges, categories, and local demand signals.

### What This Actor Does

This Actor is built for teams that sell to restaurants or research local food-service markets. Enter restaurant keywords plus one location, and the Actor returns structured Google Maps leads that you can export to CSV, Excel, or JSON.

It helps when you want to:

- build restaurant prospect lists for sales outreach
- find cafes, bars, bakeries, brunch spots, pizza restaurants, or other food-service businesses in a city
- qualify restaurant leads by phone, website, rating, review count, category, hours, and price range
- compare local restaurant density, review signals, service options, and nearby competitors
- avoid manually copying Google Maps rows into spreadsheets

### Quick Start

1. Keep `maxBusinesses: 1` for the first preview run. This default is intentionally small so Apify automated quality tests and first-time previews finish quickly.
2. Start with one `keyword`, such as `coffee shop`. Add more restaurant terms only after the preview succeeds.
3. Enter one `location`, such as `Austin, Texas`, `New York, New York`, or `London, United Kingdom`.
4. Keep `includeDetails: false` for the fastest preview. Turn it on for production exports when you need opening hours, price range, review signals, and richer qualification fields.
5. Click **Run** and download the dataset from Apify as CSV, Excel, or JSON.

### Use Cases

**Restaurant SaaS sales**  
Build lead lists for POS systems, delivery software, booking tools, review management, loyalty programs, menu platforms, and restaurant operations products.

**Local SEO and marketing services**  
Find restaurants with strong demand signals, weak website coverage, low review volume, or category-specific opportunities for local SEO, ads, or reputation campaigns.

**Food-service market research**  
Compare restaurant density, category mix, ratings, review counts, price ranges, opening hours, service options, and local competitors across cities or neighborhoods.

**Territory planning**  
Export restaurants by target city and category so sales teams can plan outreach routes, account lists, or local campaigns.

### Output Preview

Here is a simplified example of restaurant lead records you can download after a run:

| Business | Category | Phone | Website | Rating | Reviews | Address |
| --- | --- | --- | --- | --- | --- | --- |
| Moonshot Coffee | Coffee shop | +1 206-620-0315 | toasttab.com/moonshotcoffee | 4.8 | 298 | 9622 16th Ave SW, Seattle, WA |
| Ember Table | Restaurant | +1 512-555-0184 | embertable.example | 4.6 | 1,142 | 120 Congress Ave, Austin, TX |
| Northside Bakery | Bakery | +1 718-555-0108 | northsidebakery.example | 4.7 | 624 | 69 Grand St, Brooklyn, NY |

The same record can also include:

| Field group | Example fields |
| --- | --- |
| Lead identity | `title`, `categoryName`, `categories`, `placeId`, `cid` |
| Contact fields | `phone`, `phoneUnformatted`, `website`, `address` |
| Location detail | `street`, `district`, `city`, `postalCode`, `countryCode`, `location.lat`, `location.lng` |
| Restaurant signals | `totalScore`, `reviewCount`, `priceRange`, `currentStatus`, `openingHours` |
| Service options | `delivery`, `additionalInfo`, payment options, accessibility, dine-in or takeout signals |
| Review context | `reviewsDistribution`, `reviewsTags`, optional sample `reviews` when available |
| Market context | `peopleAlsoSearch`, `popularTime`, `imageCategories`, `mainPicture` |

### Example Inputs

#### Fast Preview

```json
{
  "maxBusinesses": 10,
  "keywords": ["restaurant", "coffee shop", "brunch"],
  "location": "New York, New York",
  "includeDetails": true,
  "batchDetailsPerQuery": 3
}
````

#### Restaurant Sales Territory

```json
{
  "maxBusinesses": 50,
  "keywords": ["pizza restaurant", "italian restaurant", "bakery"],
  "location": "Austin, Texas",
  "includeDetails": true,
  "batchDetailsPerQuery": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "countryCode": "US"
  }
}
```

### Pricing

This Actor uses pay-per-event pricing:

- `apify-actor-start`: `$0.00005` for each run
- `apify-default-dataset-item`: `$0.0012` for each restaurant, cafe, bar, bakery, brunch, or coffee shop record saved to the default dataset

In practice:

- A fast QA-safe preview with `maxBusinesses: 1` is typically about `$0.00125`.
- A larger export with `maxBusinesses: 1000` is typically about `$1.20005`.
- `includeDetails` changes how rich each saved lead record is; pricing is still mainly driven by the number of saved restaurant leads.

These event names mirror the current Apify Console pay-per-event configuration. Apify charges the actor start event automatically, and dataset result events are charged when the Actor saves items to the default dataset.

### Best Practices

- Start with one city and 2 to 4 restaurant keywords.
- Use category-specific terms such as `sushi restaurant`, `pizza restaurant`, `bakery`, `bar`, `brunch`, `coffee shop`, or `vegan restaurant`.
- Keep `includeDetails` disabled for QA-safe previews; enable it when you need opening hours, review signals, price range, and richer lead qualification fields.
- Use `maxBusinesses` to control export size and cost.
- Run separate searches for different cities or territories when you need clean segmentation.

### Notes

This Actor extracts public Google Maps business data. Field availability depends on what Google Maps exposes for each business. Phone numbers, websites, opening hours, price ranges, review tags, and sample reviews are not guaranteed for every restaurant.

# Actor input Schema

## `maxBusinesses` (type: `integer`):

Maximum number of restaurant, cafe, bar, bakery, or coffee shop leads to save. Default is 1 so Apify automated quality tests and first previews finish quickly. For production exports, set this value explicitly.

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

Restaurant and food-service categories to search on Google Maps. The default prefill uses one keyword for a fast QA-safe preview. For production runs, add terms such as restaurant, brunch, bakery, bar, pizza restaurant, or sushi restaurant.

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

City, region, or area to search in, for example New York, New York, Austin, Texas, or London, United Kingdom.

## `includeDetails` (type: `boolean`):

Enable this for richer restaurant lead fields such as opening hours, review signals, price range, service options, categories, plus codes, and local business attributes. Default is false for a fast QA-safe preview; turn it on for production exports.

## `batchDetailsPerQuery` (type: `integer`):

Number of restaurant detail pages to open simultaneously when detail fields are enabled. Default is 1 for stable previews; raise it cautiously for larger production runs.

## `requestTimeoutSecs` (type: `integer`):

Timeout in seconds for each geocoding request and geocoding browser fallback request.

## `retryCount` (type: `integer`):

Maximum retry attempts for geocoding requests.

## `requestDelayMs` (type: `integer`):

Delay between geocoding retries or endpoint fallback attempts.

## `nominatimBaseUrl` (type: `string`):

Optional primary Nominatim-compatible base URL, for example https://nominatim.openstreetmap.org or an internal mirror.

## `nominatimFallbackBaseUrls` (type: `array`):

Optional fallback Nominatim-compatible base URLs tried in order when the primary endpoint fails.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "maxBusinesses": 1,
  "keywords": [
    "coffee shop"
  ],
  "location": "Austin, Texas",
  "includeDetails": false,
  "batchDetailsPerQuery": 1,
  "requestTimeoutSecs": 20,
  "retryCount": 3,
  "requestDelayMs": 1000
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview view of scraped restaurant, cafe, bar, bakery, and coffee shop leads.

## `detailed` (type: `string`):

Detailed restaurant lead information view.

## `reviews` (type: `string`):

Restaurant review, rating, and demand signal view.

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

Location details view for restaurant leads.

## `locationFailures` (type: `string`):

Structured geocoding or location preprocessing failures for the current run.

## `outputSummary` (type: `string`):

Summary metadata for the current run.

# 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 = {
    "maxBusinesses": 1,
    "keywords": [
        "coffee shop"
    ],
    "location": "Austin, Texas",
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("nezha/restaurant-google-maps-leads").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 = {
    "maxBusinesses": 1,
    "keywords": ["coffee shop"],
    "location": "Austin, Texas",
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("nezha/restaurant-google-maps-leads").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 '{
  "maxBusinesses": 1,
  "keywords": [
    "coffee shop"
  ],
  "location": "Austin, Texas",
  "includeDetails": false
}' |
apify call nezha/restaurant-google-maps-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Restaurant Leads from Google Maps",
        "description": "Find restaurant, cafe, brunch, bakery, bar, and coffee shop leads from Google Maps. Export business names, phones, websites, ratings, review counts, addresses, opening hours, price ranges, categories, and local demand signals for restaurant sales outreach, local SEO, and market research.",
        "version": "0.1",
        "x-build-id": "sdCPMg7ijIUwK6pLE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nezha~restaurant-google-maps-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nezha-restaurant-google-maps-leads",
                "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/nezha~restaurant-google-maps-leads/runs": {
            "post": {
                "operationId": "runs-sync-nezha-restaurant-google-maps-leads",
                "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/nezha~restaurant-google-maps-leads/run-sync": {
            "post": {
                "operationId": "run-sync-nezha-restaurant-google-maps-leads",
                "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": {
                    "maxBusinesses": {
                        "title": "Max Restaurant Leads",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of restaurant, cafe, bar, bakery, or coffee shop leads to save. Default is 1 so Apify automated quality tests and first previews finish quickly. For production exports, set this value explicitly.",
                        "default": 1
                    },
                    "keywords": {
                        "title": "Restaurant Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Restaurant and food-service categories to search on Google Maps. The default prefill uses one keyword for a fast QA-safe preview. For production runs, add terms such as restaurant, brunch, bakery, bar, pizza restaurant, or sushi restaurant.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Target Location",
                        "minLength": 1,
                        "type": "string",
                        "description": "City, region, or area to search in, for example New York, New York, Austin, Texas, or London, United Kingdom."
                    },
                    "includeDetails": {
                        "title": "Include Restaurant Detail Fields",
                        "type": "boolean",
                        "description": "Enable this for richer restaurant lead fields such as opening hours, review signals, price range, service options, categories, plus codes, and local business attributes. Default is false for a fast QA-safe preview; turn it on for production exports.",
                        "default": false
                    },
                    "batchDetailsPerQuery": {
                        "title": "Concurrent Detail Tabs",
                        "minimum": 1,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Number of restaurant detail pages to open simultaneously when detail fields are enabled. Default is 1 for stable previews; raise it cautiously for larger production runs.",
                        "default": 1
                    },
                    "requestTimeoutSecs": {
                        "title": "Request Timeout (Secs)",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Timeout in seconds for each geocoding request and geocoding browser fallback request.",
                        "default": 20
                    },
                    "retryCount": {
                        "title": "Retry Count",
                        "minimum": 1,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Maximum retry attempts for geocoding requests.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Request Delay (Ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Delay between geocoding retries or endpoint fallback attempts.",
                        "default": 1000
                    },
                    "nominatimBaseUrl": {
                        "title": "Primary Geocoding Base URL",
                        "type": "string",
                        "description": "Optional primary Nominatim-compatible base URL, for example https://nominatim.openstreetmap.org or an internal mirror."
                    },
                    "nominatimFallbackBaseUrls": {
                        "title": "Fallback Geocoding Base URLs",
                        "type": "array",
                        "description": "Optional fallback Nominatim-compatible base URLs tried in order when the primary endpoint fails.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
