# Google Maps Business Scraper - Leads & Reviews (`lazymac/google-maps-business-scraper`) Actor

Scrape Google Maps for business data: names, addresses, phones, websites, ratings, reviews, opening hours, and 20+ fields. Ideal for lead generation, sales prospecting, and market research.

- **URL**: https://apify.com/lazymac/google-maps-business-scraper.md
- **Developed by:** [2x lazymac](https://apify.com/lazymac) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.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

## Google Maps Business Scraper

Extract comprehensive business data from Google Maps at scale. Get business names, addresses, phone numbers, websites, ratings, reviews, opening hours, coordinates, photos, and 20+ data fields for any search query or location.

Built for **sales teams, marketing agencies, lead generation specialists, market researchers**, and anyone who needs structured local business data from Google Maps.

### Why use this scraper?

Google Maps is the world's largest local business directory, with data on over 200 million businesses across every country. This actor lets you extract that data in structured, machine-readable format ready for your CRM, spreadsheet, or data pipeline.

**Key advantages:**
- **Comprehensive data** — 25+ fields per business including contact info, ratings, coordinates, and opening hours
- **Smart filtering** — Filter by rating, review count, phone availability, and website presence
- **Multi-query support** — Search for multiple queries or locations in a single run
- **Review extraction** — Get individual review text, ratings, and author data
- **Photo URLs** — Extract business photos for visual verification
- **Proxy rotation** — Built-in residential proxy support to avoid rate limiting
- **Pay-per-event pricing** — Only pay for results you actually get

### What data can you extract?

Every business listing includes up to 25+ structured fields:

| Field | Description | Example |
|-------|-------------|---------|
| `title` | Business name | "Joe's Pizza" |
| `categoryName` | Business category | "Pizza Restaurant" |
| `address` | Full street address | "123 Main St, New York, NY 10001" |
| `street` | Street address component | "123 Main St" |
| `city` | City name | "New York" |
| `state` | State/province code | "NY" |
| `postalCode` | ZIP/postal code | "10001" |
| `countryCode` | Country code | "US" |
| `phone` | Phone number | "+1 (212) 555-0123" |
| `website` | Business website URL | "https://joespizza.com" |
| `url` | Google Maps URL | "https://google.com/maps/place/..." |
| `totalScore` | Average rating (1-5) | 4.5 |
| `reviewsCount` | Total number of reviews | 342 |
| `priceLevel` | Price range indicator | "$$" |
| `latitude` | GPS latitude | 40.7128 |
| `longitude` | GPS longitude | -74.0060 |
| `placeId` | Google Place ID | "ChIJN1t_tDeuEmsRUsoyG83frY4" |
| `cid` | Google Maps CID | "12345678901234567" |
| `status` | Business status | "OPERATIONAL" |
| `description` | Business description | "Family-owned since 1975..." |
| `imageUrl` | Main business image URL | "https://lh5.googleusercontent.com/..." |
| `permanentlyClosed` | Is permanently closed? | false |
| `temporarilyClosed` | Is temporarily closed? | false |
| `openingHours` | Weekly opening hours | [{day: "Monday", hours: "9 AM - 5 PM"}] |
| `reviews` | Individual review data | [{author, rating, text, date}] |
| `photos` | Photo URLs | ["https://...jpg", ...] |
| `additionalInfo` | Amenities, attributes | {wheelchair: true, wifi: true} |
| `scrapedAt` | Timestamp of extraction | "2026-04-16T12:00:00.000Z" |
| `searchQuery` | Original search query | "restaurants in New York" |

### Use cases

#### Lead Generation for Sales Teams
Extract business contact information (phone numbers, websites, addresses) for targeted outreach campaigns. Filter by rating and review count to focus on established businesses.

````

Search: "dentists in Chicago IL"
Filter: Rating >= 4.0, Has Phone, Has Website
Result: 50 qualified dental practice leads with contact info

```

#### Market Research & Competitive Analysis
Analyze the competitive landscape in any market by extracting all businesses in a category within a geographic area. Compare ratings, review counts, and pricing.

```

Search: "coffee shops in Seattle"
Include: Reviews, Opening Hours, Additional Info
Result: Complete competitive analysis dataset

```

#### Real Estate & Location Intelligence
Map all businesses around a specific address or neighborhood. Understand the commercial density, types of businesses, and walkability scores.

```

Search: "businesses near Times Square New York"
Include: Coordinates, Opening Hours
Result: Geospatial business density data

```

#### Franchise & Expansion Planning
Find areas with high demand but low supply for a specific business type. Identify underserved markets for expansion opportunities.

```

Search: "pizza restaurants in Austin TX"
Compare against: "pizza restaurants in Dallas TX"
Result: Market gap analysis between cities

```

#### Review Monitoring & Reputation Management
Track reviews for businesses in your portfolio or industry. Monitor competitor sentiment and identify trends.

```

Search: "your business name city"
Include: Reviews (max 50), Sort by Newest
Result: Latest customer sentiment data

````

#### Directory & Listing Verification
Verify that business information on your website or directory matches Google Maps data. Identify outdated phone numbers, addresses, or closed businesses.

### Input configuration

#### Search Configuration

##### Search Queries
The primary way to find businesses. Enter one or more search queries, each on a new line. For best results, include the location in your query.

**Examples:**
- `restaurants in San Francisco` — Find all restaurants in SF
- `plumber near 90210` — Find plumbers near a ZIP code
- `hotels in Paris France` — International search
- `car repair shop downtown Denver` — Neighborhood-level search
- `vegan restaurant Manhattan NYC` — Specific cuisine + area

##### Start URLs
For advanced users who already have Google Maps URLs. You can provide:
- **Search result URLs**: `https://www.google.com/maps/search/restaurants+in+chicago/`
- **Individual place URLs**: `https://www.google.com/maps/place/Joe's+Pizza/...`

#### Maximum Results
Control how many results to extract per query. Google Maps typically shows 20-120 results depending on the search. Set to 0 for unlimited.

**Recommended settings:**
- Quick sample: 10-20 results
- Standard search: 50 results (default)
- Comprehensive: 100-200 results
- Full extraction: 0 (unlimited)

#### Localization

##### Language
Set the language for business names, addresses, and descriptions. Uses ISO 639-1 codes:
- `en` — English (default)
- `es` — Spanish
- `fr` — French
- `de` — German
- `ja` — Japanese
- `ko` — Korean
- `zh` — Chinese
- `pt` — Portuguese
- `ar` — Arabic
- `hi` — Hindi

##### Country Code
Two-letter ISO country code to target the correct Google Maps regional domain:
- `US` — United States (default)
- `GB` — United Kingdom
- `CA` — Canada
- `AU` — Australia
- `DE` — Germany
- `FR` — France
- `JP` — Japan
- `KR` — South Korea
- `BR` — Brazil
- `IN` — India

#### Data Extraction Options

##### Include Reviews
When enabled, extracts individual reviews including:
- Reviewer name
- Star rating (1-5)
- Review text
- Review date

**Note:** Enabling reviews significantly increases run time as it requires loading additional data for each business.

##### Review Sort Order
Control which reviews are extracted first:
- **Most Relevant** — Google's default ranking (recommended)
- **Newest First** — Most recent reviews
- **Highest Rating** — 5-star reviews first
- **Lowest Rating** — 1-star reviews first (useful for reputation monitoring)

##### Include Photos
Extract URLs for business photos. Useful for:
- Visual verification of businesses
- Building rich listing pages
- Image-based analysis

##### Include Opening Hours
Get structured weekly opening hours for each business. Returns an array with day name and time range for each day of the week.

##### Include Additional Info
Extract business attributes and amenities like:
- Wheelchair accessibility
- Wi-Fi availability
- Outdoor seating
- Payment methods accepted
- Dining options (dine-in, takeout, delivery)
- Parking availability

#### Filters

##### Minimum Rating Filter
Only include businesses rated at or above this value (0-5). Examples:
- `0` — Include all businesses (default)
- `3.5` — Exclude poorly-rated businesses
- `4.0` — Only well-rated businesses
- `4.5` — Only top-rated businesses

##### Minimum Reviews Count
Only include businesses with at least this many reviews. Useful for filtering out new or inactive businesses:
- `0` — Include all (default)
- `10` — Has some reviews
- `50` — Established business
- `100` — Well-known business

##### Only With Phone Number
When enabled, skips businesses without a listed phone number. Essential for:
- Cold calling campaigns
- Telemarketing outreach
- Phone verification workflows

##### Only With Website
When enabled, skips businesses without a website. Essential for:
- Digital marketing campaigns
- Website audit services
- Online advertising outreach

#### Performance

##### Max Concurrency
Number of pages to process simultaneously. Higher values = faster scraping but higher risk of rate limiting.
- `1-3` — Safe, slow
- `5` — Balanced (default)
- `10-20` — Fast, may trigger blocks

##### Proxy Configuration
Configure proxy settings for reliable scraping. **Residential proxies are strongly recommended** for Google Maps to avoid blocks.

Default: Apify residential proxy group (`RESIDENTIAL`)

### Output example

#### Single business result (JSON)

```json
{
    "title": "Golden Gate Pizza & Pasta",
    "categoryName": "Italian Restaurant",
    "address": "542 Clement St, San Francisco, CA 94118",
    "street": "542 Clement St",
    "city": "San Francisco",
    "state": "CA",
    "postalCode": "94118",
    "countryCode": "US",
    "phone": "+1 (415) 555-0142",
    "website": "https://goldengatepizza.com",
    "url": "https://www.google.com/maps/place/Golden+Gate+Pizza/...",
    "totalScore": 4.6,
    "reviewsCount": 892,
    "priceLevel": "$$",
    "latitude": 37.7829,
    "longitude": -122.4694,
    "placeId": "ChIJd7zN_thfj4AR_06S9VV15FY",
    "status": "OPERATIONAL",
    "permanentlyClosed": false,
    "temporarilyClosed": false,
    "description": "Casual Italian spot with classic pizzas and pasta dishes since 1985.",
    "imageUrl": "https://lh5.googleusercontent.com/p/AF1QipN...",
    "openingHours": [
        { "day": "Monday", "hours": "11:00 AM - 10:00 PM" },
        { "day": "Tuesday", "hours": "11:00 AM - 10:00 PM" },
        { "day": "Wednesday", "hours": "11:00 AM - 10:00 PM" },
        { "day": "Thursday", "hours": "11:00 AM - 10:00 PM" },
        { "day": "Friday", "hours": "11:00 AM - 11:00 PM" },
        { "day": "Saturday", "hours": "11:00 AM - 11:00 PM" },
        { "day": "Sunday", "hours": "12:00 PM - 9:00 PM" }
    ],
    "scrapedAt": "2026-04-16T12:34:56.789Z",
    "searchQuery": "restaurants in San Francisco"
}
````

#### With reviews enabled

```json
{
    "title": "Golden Gate Pizza & Pasta",
    "totalScore": 4.6,
    "reviewsCount": 892,
    "reviews": [
        {
            "author": "Sarah M.",
            "rating": 5,
            "text": "Best pizza in the Richmond district! The margherita is incredible and the pasta is always perfectly al dente. Great family atmosphere.",
            "date": "2026-03-15"
        },
        {
            "author": "James K.",
            "rating": 4,
            "text": "Solid neighborhood spot. Good food, reasonable prices. Can get crowded on weekends.",
            "date": "2026-03-10"
        }
    ]
}
```

### Integration examples

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "searchQueries": [
        "dentists in Chicago IL",
        "dentists in Houston TX",
    ],
    "maxResults": 100,
    "language": "en",
    "countryCode": "US",
    "includeReviews": False,
    "includeOpeningHours": True,
    "filterByRating": 4.0,
    "onlyWithPhone": True,
    "onlyWithWebsite": True,
}

run = client.actor("lazymac2x/google-maps-business-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} | {item['phone']} | {item['website']}")
```

#### Node.js

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

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

const input = {
    searchQueries: ['plumbers in Los Angeles CA'],
    maxResults: 50,
    includeOpeningHours: true,
    onlyWithPhone: true,
};

(async () => {
    const run = await client.actor('lazymac2x/google-maps-business-scraper').call(input);
    const { items } = await client.dataset(run.defaultDatasetId).listItems();

    items.forEach(item => {
        console.log(`${item.title} - ${item.phone} - ${item.totalScore} stars`);
    });
})();
```

#### API (cURL)

```bash
## Start the actor
curl -X POST "https://api.apify.com/v2/acts/lazymac2x~google-maps-business-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["restaurants in Miami FL"],
    "maxResults": 50,
    "includeOpeningHours": true,
    "onlyWithPhone": true
  }'

## Get results (use the datasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

#### Zapier Integration

This actor works seamlessly with Zapier through the official Apify integration:

1. **Add the Apify trigger** in Zapier (or use the "Run Actor" action)
2. **Set the actor** to `lazymac2x/google-maps-business-scraper`
3. **Configure input** with your search queries and filters
4. **Connect to your CRM** — automatically push leads to HubSpot, Salesforce, or Pipedrive
5. **Schedule runs** — set up daily/weekly scraping for fresh leads

#### Google Sheets Export

Export results directly to Google Sheets:

1. Run the actor with your desired input
2. Go to the dataset results page
3. Click "Export" and choose "Google Sheets"
4. Or use the Apify API to programmatically push data to Sheets

#### CSV/Excel Export

All results can be exported in CSV, JSON, XML, Excel, or HTML format:

```bash
## Export as CSV
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -o businesses.csv

## Export as Excel
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=xlsx" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -o businesses.xlsx
```

### Tips for best results

#### Optimizing search queries

- **Be specific with location**: "pizza in Brooklyn NY" works better than "pizza in New York"
- **Use business categories**: "Italian restaurant" finds more results than just "restaurant"
- **Add neighborhoods**: "barber shop Williamsburg Brooklyn" narrows results effectively
- **Try ZIP codes**: "gym near 90210" targets a specific area
- **Combine with qualifiers**: "best rated plumber in Dallas TX" targets top results

#### Controlling costs

- Start with a small `maxResults` (10-20) to test your query
- Disable reviews and photos if you only need contact info
- Use filters (rating, phone, website) to reduce output size
- Set appropriate `maxConcurrency` (default 5 is good for most cases)

#### Avoiding blocks

- Use residential proxies (default configuration)
- Keep `maxConcurrency` at 5 or below for large runs
- Avoid running too many queries simultaneously
- Space out large runs (1000+ results) over time

#### Getting the most data

- Enable `includeReviews` for sentiment analysis
- Enable `includePhotos` for visual verification
- Enable `includeAdditionalInfo` for amenity data
- Set `includeOpeningHours` to true (default) for availability data
- Use `maxReviews: 50` for detailed review analysis

### Pricing

This actor uses **Pay-Per-Event (PPE)** pricing:

- You are charged per result scraped
- No charge for failed or filtered-out results
- Check the actor's pricing page for current rates

**Cost estimation:**

- 50 businesses (basic data): ~$0.50
- 50 businesses (with reviews): ~$1.00
- 100 businesses (basic data): ~$1.00
- 500 businesses (basic data): ~$5.00

### Limitations

- **Google Maps rate limiting**: Google may limit results for very high-volume queries. Use residential proxies and moderate concurrency.
- **Review count**: Maximum ~100 reviews per business can be extracted. Google limits review visibility.
- **Real-time data**: Results reflect Google Maps data at the time of scraping. Business information changes over time.
- **Search result limits**: Google Maps shows a maximum of approximately 120 results per search query. For more results, use multiple overlapping queries with different location modifiers.
- **Coordinates accuracy**: Coordinates extracted from URLs may have reduced precision compared to the Google Places API.

### FAQ

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

Google Maps typically shows 20-120 results per search query depending on the location and category density. For maximum coverage, use multiple specific queries (e.g., search by neighborhood instead of entire city).

#### Can I scrape businesses worldwide?

Yes. Set the `countryCode` to target any country and `language` for localized results. The scraper works with all Google Maps regional domains.

#### How fresh is the data?

Data is extracted in real-time from Google Maps. Each run gives you the most current information Google has for each business.

#### Do I need proxies?

Residential proxies are strongly recommended and enabled by default. Without proxies, Google may block requests after a small number of queries.

#### How do I get phone numbers for all businesses?

Enable the `onlyWithPhone` filter to only include businesses with listed phone numbers. Note that not all businesses on Google Maps have phone numbers listed.

#### Can I search by geographic coordinates?

Yes. Use the `startUrls` input with a Google Maps URL that includes coordinates, such as: `https://www.google.com/maps/search/restaurants/@40.7128,-74.006,15z/`

#### How do I extract reviews?

Set `includeReviews` to `true` and configure `maxReviews` (default 5). Reviews include author name, star rating, text content, and date.

#### What format are the results in?

Results are stored in an Apify dataset and can be exported as JSON, CSV, XML, Excel, HTML, or RSS. You can also access results via the API.

#### Can I schedule regular runs?

Yes. Use Apify's scheduling feature to run the scraper daily, weekly, or at any custom interval. Great for monitoring new businesses or tracking review changes.

#### How do I filter out closed businesses?

The scraper includes `permanentlyClosed` and `temporarilyClosed` fields. You can filter these out in post-processing, or use the rating/review filters to focus on active businesses (closed businesses typically have no recent reviews).

#### Can I use this for lead generation?

Absolutely. This is the primary use case. Combine search queries targeting your ideal customer profile with the `onlyWithPhone` and `onlyWithWebsite` filters to get qualified leads with contact information.

#### Is this legal?

Web scraping of publicly available data is generally legal in most jurisdictions. Google Maps data is publicly visible to anyone. However, you should comply with Google's Terms of Service and your local regulations. This scraper is designed for research and legitimate business purposes.

#### How does pricing work?

This actor uses Pay-Per-Event pricing. You are charged for each successfully scraped business result. Failed requests, filtered-out results, and search page loads are not charged. This means you only pay for actual data you receive.

#### Can I connect this to my CRM?

Yes. Use the Apify API or Zapier integration to push results directly to HubSpot, Salesforce, Pipedrive, or any CRM with an API. You can also use webhook notifications to trigger workflows when a run completes.

### Changelog

#### v1.0.0 (2026-04-16)

- Initial release
- Search by query or direct Google Maps URLs
- 25+ data fields per business
- Review extraction with sort options
- Photo URL extraction
- Opening hours extraction
- Rating, review count, phone, and website filters
- Multi-query support
- Residential proxy support
- Pay-per-event pricing
- Python, Node.js, cURL, and Zapier integration examples

### Support

If you encounter any issues or have feature requests:

- Open an issue on the actor's GitHub repository
- Contact us through Apify's messaging system
- Check the FAQ section above for common questions

### Related actors

- **Google Maps Reviews Scraper** — Focused on extracting reviews in depth
- **Google Search Scraper** — Scrape Google SERP results
- **Yellow Pages Scraper** — Alternative business directory
- **Yelp Scraper** — Reviews and business data from Yelp

# Actor input Schema

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

List of search queries to find businesses on Google Maps. Examples: 'restaurants in New York', 'dentist near me Chicago', 'plumber Los Angeles CA'. Each query will be searched separately and results combined. For best results, include the location in the query.

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

Direct Google Maps URLs to scrape. Use this if you already have specific Google Maps search result URLs or individual place URLs. Supports both search URLs (google.com/maps/search/...) and place URLs (google.com/maps/place/...). Leave empty if using search queries above.

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

Maximum number of business listings to extract per search query. Google Maps typically shows up to 120 results per search. Set to 0 for unlimited (all available results). Higher values require more compute time.

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

Language code for Google Maps results. This affects the language of business names, addresses, and reviews. Use ISO 639-1 codes: en (English), es (Spanish), fr (French), de (German), ja (Japanese), ko (Korean), zh (Chinese), pt (Portuguese), it (Italian), etc.

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

Two-letter country code to target Google Maps for a specific country. This ensures results are localized correctly. Examples: US (United States), GB (United Kingdom), DE (Germany), FR (France), JP (Japan), KR (South Korea), BR (Brazil).

## `includeReviews` (type: `boolean`):

Extract individual reviews for each business. When enabled, the scraper will navigate to each business detail page and extract review text, author name, rating, and date. This significantly increases run time but provides valuable sentiment data.

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per business listing. Only applies when 'Include Reviews' is enabled. Set lower values for faster runs. Google shows most relevant reviews first.

## `reviewSort` (type: `string`):

How to sort reviews when extracting them. 'Most relevant' is Google's default ranking. 'Newest' gives most recent reviews. 'Highest rating' and 'Lowest rating' sort by star count.

## `includePhotos` (type: `boolean`):

Extract URLs of business photos from their Google Maps listing. Includes cover photos and gallery images. Useful for visual verification of business listings.

## `maxPhotos` (type: `integer`):

Maximum number of photo URLs to extract per business. Only applies when 'Include Photo URLs' is enabled.

## `includeOpeningHours` (type: `boolean`):

Extract detailed opening hours for each day of the week. Provides structured data with day name and time ranges. Useful for understanding business availability.

## `includePeopleAlsoSearch` (type: `boolean`):

Extract related businesses that Google suggests in the 'People also search for' section. Useful for competitive analysis and discovering similar businesses.

## `includeAdditionalInfo` (type: `boolean`):

Extract additional attributes like accessibility, amenities, dining options, payment methods, and other business-specific features that Google Maps displays.

## `filterByRating` (type: `number`):

Only include businesses with a rating equal to or above this value. Set to 0 to include all businesses regardless of rating. Useful for filtering out low-quality leads.

## `filterByMinReviews` (type: `integer`):

Only include businesses with at least this many reviews. Set to 0 to include all businesses. Higher values filter for more established businesses.

## `onlyWithPhone` (type: `boolean`):

When enabled, only include businesses that have a phone number listed. Essential for telemarketing and outreach campaigns where phone contact is required.

## `onlyWithWebsite` (type: `boolean`):

When enabled, only include businesses that have a website URL listed. Useful for digital marketing campaigns and web-based outreach.

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

Maximum number of pages to process in parallel. Higher values speed up the scrape but may increase the chance of being rate-limited. Recommended: 5-10 for most use cases.

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

Proxy settings for the scraper. Using Apify's residential proxies (RESIDENTIAL group) is recommended for Google Maps to avoid blocks. The scraper automatically rotates proxies between requests.

## Actor input object example

```json
{
  "searchQueries": [
    "restaurants in San Francisco"
  ],
  "maxResults": 50,
  "language": "en",
  "countryCode": "US",
  "includeReviews": false,
  "maxReviews": 5,
  "reviewSort": "mostRelevant",
  "includePhotos": false,
  "maxPhotos": 5,
  "includeOpeningHours": true,
  "includePeopleAlsoSearch": false,
  "includeAdditionalInfo": true,
  "filterByRating": 0,
  "filterByMinReviews": 0,
  "onlyWithPhone": false,
  "onlyWithWebsite": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "restaurants in San Francisco"
    ],
    "language": "en",
    "countryCode": "US",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lazymac/google-maps-business-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["restaurants in San Francisco"],
    "language": "en",
    "countryCode": "US",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lazymac/google-maps-business-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "restaurants in San Francisco"
  ],
  "language": "en",
  "countryCode": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call lazymac/google-maps-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Scraper - Leads & Reviews",
        "description": "Scrape Google Maps for business data: names, addresses, phones, websites, ratings, reviews, opening hours, and 20+ fields. Ideal for lead generation, sales prospecting, and market research.",
        "version": "1.0",
        "x-build-id": "JLqMyg5RiMAQCj71g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lazymac~google-maps-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lazymac-google-maps-business-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lazymac~google-maps-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lazymac-google-maps-business-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lazymac~google-maps-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lazymac-google-maps-business-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of search queries to find businesses on Google Maps. Examples: 'restaurants in New York', 'dentist near me Chicago', 'plumber Los Angeles CA'. Each query will be searched separately and results combined. For best results, include the location in the query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Google Maps URLs to scrape. Use this if you already have specific Google Maps search result URLs or individual place URLs. Supports both search URLs (google.com/maps/search/...) and place URLs (google.com/maps/place/...). Leave empty if using search queries above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Google Maps URL to scrape"
                                },
                                "method": {
                                    "title": "HTTP Method",
                                    "type": "string",
                                    "description": "HTTP method for the request"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of business listings to extract per search query. Google Maps typically shows up to 120 results per search. Set to 0 for unlimited (all available results). Higher values require more compute time.",
                        "default": 50
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for Google Maps results. This affects the language of business names, addresses, and reviews. Use ISO 639-1 codes: en (English), es (Spanish), fr (French), de (German), ja (Japanese), ko (Korean), zh (Chinese), pt (Portuguese), it (Italian), etc.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Two-letter country code to target Google Maps for a specific country. This ensures results are localized correctly. Examples: US (United States), GB (United Kingdom), DE (Germany), FR (France), JP (Japan), KR (South Korea), BR (Brazil).",
                        "default": "US"
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract individual reviews for each business. When enabled, the scraper will navigate to each business detail page and extract review text, author name, rating, and date. This significantly increases run time but provides valuable sentiment data.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Maximum Reviews Per Business",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business listing. Only applies when 'Include Reviews' is enabled. Set lower values for faster runs. Google shows most relevant reviews first.",
                        "default": 5
                    },
                    "reviewSort": {
                        "title": "Review Sort Order",
                        "enum": [
                            "mostRelevant",
                            "newest",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "How to sort reviews when extracting them. 'Most relevant' is Google's default ranking. 'Newest' gives most recent reviews. 'Highest rating' and 'Lowest rating' sort by star count.",
                        "default": "mostRelevant"
                    },
                    "includePhotos": {
                        "title": "Include Photo URLs",
                        "type": "boolean",
                        "description": "Extract URLs of business photos from their Google Maps listing. Includes cover photos and gallery images. Useful for visual verification of business listings.",
                        "default": false
                    },
                    "maxPhotos": {
                        "title": "Maximum Photos Per Business",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of photo URLs to extract per business. Only applies when 'Include Photo URLs' is enabled.",
                        "default": 5
                    },
                    "includeOpeningHours": {
                        "title": "Include Opening Hours",
                        "type": "boolean",
                        "description": "Extract detailed opening hours for each day of the week. Provides structured data with day name and time ranges. Useful for understanding business availability.",
                        "default": true
                    },
                    "includePeopleAlsoSearch": {
                        "title": "Include 'People Also Search For'",
                        "type": "boolean",
                        "description": "Extract related businesses that Google suggests in the 'People also search for' section. Useful for competitive analysis and discovering similar businesses.",
                        "default": false
                    },
                    "includeAdditionalInfo": {
                        "title": "Include Additional Business Info",
                        "type": "boolean",
                        "description": "Extract additional attributes like accessibility, amenities, dining options, payment methods, and other business-specific features that Google Maps displays.",
                        "default": true
                    },
                    "filterByRating": {
                        "title": "Minimum Rating Filter",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include businesses with a rating equal to or above this value. Set to 0 to include all businesses regardless of rating. Useful for filtering out low-quality leads.",
                        "default": 0
                    },
                    "filterByMinReviews": {
                        "title": "Minimum Reviews Count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include businesses with at least this many reviews. Set to 0 to include all businesses. Higher values filter for more established businesses.",
                        "default": 0
                    },
                    "onlyWithPhone": {
                        "title": "Only Businesses With Phone Number",
                        "type": "boolean",
                        "description": "When enabled, only include businesses that have a phone number listed. Essential for telemarketing and outreach campaigns where phone contact is required.",
                        "default": false
                    },
                    "onlyWithWebsite": {
                        "title": "Only Businesses With Website",
                        "type": "boolean",
                        "description": "When enabled, only include businesses that have a website URL listed. Useful for digital marketing campaigns and web-based outreach.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages to process in parallel. Higher values speed up the scrape but may increase the chance of being rate-limited. Recommended: 5-10 for most use cases.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Using Apify's residential proxies (RESIDENTIAL group) is recommended for Google Maps to avoid blocks. The scraper automatically rotates proxies between requests.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
