# Free Basic Google Maps Scraper (`automateitplease/free-basic-google-maps-scraper`) Actor

Extract business listings from Google Maps with ratings, reviews, addresses & categories. Fast, reliable scraper for market research and lead generation.

- **URL**: https://apify.com/automateitplease/free-basic-google-maps-scraper.md
- **Developed by:** [AutomateItPlease Workflow And Automaton Ops](https://apify.com/automateitplease) (community)
- **Categories:** Lead generation, Developer tools, Integrations
- **Stats:** 72 total users, 1 monthly users, 86.2% runs succeeded, 0 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

## Basic Google Maps Business Scraper

Extract business listings from Google Maps search results - fast, simple, and reliable.

### 🚀 Features

- **Universal Search**: Scrape any Google Maps search query (restaurants, hotels, shops, etc.)
- **Essential Data**: Get name, rating, reviews, address, category, and URL
- **Smart Extraction**: Robust rating/review extraction with multiple fallback methods
- **No Clicking Required**: Fast scraping from search results only
- **Configurable Limits**: Control how many businesses to scrape (1-500)
- **Null-Safe**: Handles missing data gracefully (sets to `null`)

### 💡 Use Cases

- **Market Research**: Gather competitor data in your area
- **Lead Generation**: Find businesses for B2B outreach
- **Location Analysis**: Compare ratings across neighborhoods
- **Data Enrichment**: Add Google Maps data to existing databases
- **Trend Analysis**: Track new businesses and ratings over time

### 📋 Input

```json
{
  "searchQuery": "pizza restaurants in New York",
  "maxResults": 100
}
````

#### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQuery` | string | Yes | - | Google Maps search query (e.g., "hotels in Paris") |
| `maxResults` | integer | No | 100 | Maximum number of businesses to scrape (1-500) |

### 📤 Output

Each business produces:

```json
{
  "businessName": "Joe's Pizza",
  "url": "https://www.google.com/maps/place/Joe%27s+Pizza/...",
  "rating": 4.5,
  "reviewCount": 1234,
  "address": "123 Main St, New York, NY 10001",
  "category": "Pizza restaurant"
}
```

#### Output Fields

- **businessName** (string): Name of the business
- **url** (string): Google Maps URL for the business
- **rating** (number | null): Star rating (0-5), `null` if not available
- **reviewCount** (integer | null): Number of reviews, `null` if not displayed
- **address** (string | null): Business address, `null` if not available
- **category** (string | null): Business category, `null` if not available

### 🎯 How It Works

1. **Navigate**: Opens Google Maps with your search query
2. **Scroll**: Automatically scrolls to load more businesses (lazy loading)
3. **Extract**: Pulls data from each business card
4. **Deduplicate**: Removes duplicate entries
5. **Store**: Saves to Apify dataset

### 🔧 Performance

- **Speed**: ~30-60 seconds for 100 businesses
- **Throughput**: Approximately 2-3 businesses per second
- **Reliability**: Handles missing data, scrolling detection, and rate limiting
- **Limits**: Stops at `maxResults` or when no more businesses are available

### 💻 Technology

- **Python 3.11**
- **Apify SDK**: Actor framework and storage
- **Selenium**: Browser automation for dynamic content
- **Chrome/Chromium**: Headless browser
- **Regex**: Smart rating/review extraction

### 📚 Examples

#### Example 1: Local Restaurant Research

```json
{
  "searchQuery": "italian restaurants in San Francisco",
  "maxResults": 50
}
```

Get 50 Italian restaurants with ratings and reviews.

#### Example 2: Hotel Comparison

```json
{
  "searchQuery": "hotels near Times Square",
  "maxResults": 20
}
```

Find 20 hotels near Times Square with ratings.

#### Example 3: Coffee Shop Discovery

```json
{
  "searchQuery": "coffee shops in Seattle",
  "maxResults": 100
}
```

Discover 100 coffee shops in Seattle.

### ⚡ Quick Start

#### Run Locally

```bash
cd free-basic-google-maps-scraper
apify run
```

#### Deploy to Apify

```bash
apify login
apify push
```

### ⚠️ Limitations

- **Search results only**: Does not click into individual businesses (fast but basic data)
- **No detailed info**: Does not extract phone numbers, hours, or full reviews
- **Review counts may be missing**: Google Maps doesn't always show review counts in search results
- **Geographic variation**: Results depend on your search query and Google's location detection
- **Rate limiting**: Google may temporarily block if scraping too aggressively

### 🔍 Data Availability Notes

**Rating**: Almost always available\
**Review Count**: Sometimes missing for businesses with few reviews\
**Address**: Usually available, sometimes shows city only\
**Category**: Usually available\
**Website/Phone**: Not available in search results (requires clicking into business)

### 🔒 Privacy & Compliance

- Works only with publicly accessible Google Maps data
- No authentication or private data access
- Users responsible for compliance with Google's Terms of Service
- Respects standard web scraping practices

### 🆘 Support

For issues or questions:

- Check the [Apify documentation](https://docs.apify.com)
- Review the [Selenium documentation](https://www.selenium.dev/documentation/)
- Open an issue in the Actor's repository
- Contact support through Apify Console

### 💡 Future Enhancements

Want more data? Consider:

- **Detailed scraper**: Click into each business for phone, website, hours, photos
- **Review extraction**: Scroll through reviews for detailed sentiment analysis
- **Photo URLs**: Extract business photos
- **Coordinates**: Parse lat/long from URLs

### 📄 License

This Actor is available for use on the Apify platform.

***

**Built for speed and reliability** 🚀

# Actor input Schema

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

What to search on Google Maps (e.g., 'pizza restaurants in New York')

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

Maximum number of businesses to scrape

## Actor input object example

```json
{
  "searchQuery": "coffee shops in Seattle",
  "maxResults": 100
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "coffee shops in Seattle"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automateitplease/free-basic-google-maps-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 = { "searchQuery": "coffee shops in Seattle" }

# Run the Actor and wait for it to finish
run = client.actor("automateitplease/free-basic-google-maps-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 '{
  "searchQuery": "coffee shops in Seattle"
}' |
apify call automateitplease/free-basic-google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Free Basic Google Maps Scraper",
        "description": "Extract business listings from Google Maps with ratings, reviews, addresses & categories. Fast, reliable scraper for market research and lead generation.",
        "version": "1.0",
        "x-build-id": "8GiCcmvLqikR97PVC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automateitplease~free-basic-google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automateitplease-free-basic-google-maps-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/automateitplease~free-basic-google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automateitplease-free-basic-google-maps-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/automateitplease~free-basic-google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automateitplease-free-basic-google-maps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "What to search on Google Maps (e.g., 'pizza restaurants in New York')",
                        "default": "coffee shops in Seattle"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of businesses to scrape",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```