# Google Maps Competitor Density Mapper (`seemuapps/google-maps-competitor-density-mapper`) Actor

Map competitor density for any business category across a city or neighborhood — grid-sampled counts, ratings, and top players per area.

- **URL**: https://apify.com/seemuapps/google-maps-competitor-density-mapper.md
- **Developed by:** [Andrew](https://apify.com/seemuapps) (community)
- **Categories:** E-commerce, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 grid cell results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Competitor Density Mapper

Grid-search any city, neighborhood, or trade area on Google Maps for a business category and get a competitor count for every cell — a point-in-time density snapshot you can pivot into a heatmap. See exactly where a category clusters, where it's thin, and who the top-rated players are in each pocket of the map.

### What you get

- **One row per grid cell** (not one row per place) — `cellRow`, `cellCol`, `cellLat`, `cellLng` so you can plot or pivot straight into a heatmap
- **`placeCount`** — number of matching businesses found in that cell (a density signal, sampled up to 40 per cell — not an exhaustive per-cell scrape)
- **`avgRating`** and **`avgReviewCount`** — how mature/competitive that pocket of the market is
- **`topPlaces`** — the top 5 businesses in the cell by review count (`name`, `rating`, `reviewCount`, `address`), so you can see who dominates each area
- **`category`** and **`searchedAt`** on every row for easy filtering across runs

### Use cases

- **Site selection** — find the gaps between existing locations before committing to a new address
- **Franchise expansion research** — rank candidate territories by how saturated or underserved they already are
- **Competitive market research** — map where a competitor category clusters across a city instead of guessing from a handful of manual searches
- **Sales-territory planning** — size and prioritize territories by competitor count and market maturity (ratings, review volume)

This is a **point-in-time snapshot**, not an ongoing monitoring tool — each run reflects the area as Google Maps shows it at that moment. Run it again later if you want a fresh read; the actor does not track changes between runs.

### How to use

1. Enter a **Business category** — e.g. `coffee shops`, `dentists`, `car washes`.
2. Set the search area either by typing a **Location** (e.g. `Chicago, IL`) or by entering **Center latitude**/**Center longitude** directly.
3. Set **Radius (km)** — how far the grid extends from the center in each direction (default 5).
4. Set **Grid size** — the grid is Grid size × Grid size cells (default 3 = 9 cells; max 7 = 49 cells).
5. Run — one row per grid cell streams into the **Dataset** tab. Export as CSV/Sheets and pivot `placeCount` by `cellRow`/`cellCol` to build a heatmap.

### Output format

Each dataset record is one grid cell:

```json
{
  "cellRow": 0,
  "cellCol": 1,
  "cellLat": 41.8533,
  "cellLng": -87.6324,
  "category": "coffee shops",
  "placeCount": 40,
  "avgRating": 4.39,
  "avgReviewCount": 195,
  "topPlaces": [
    {
      "name": "Cafe Jumping Bean",
      "rating": 4.7,
      "reviewCount": 1390,
      "address": "Cafe Jumping Bean, 1439 W 18th St, Chicago, IL 60608"
    }
  ],
  "searchedAt": "2026-08-18T02:56:32.612Z"
}
```

### Pricing

Pay per grid cell analyzed and saved to the dataset — a 3×3 run costs 9 events, a 5×5 run costs 25 events, and so on. No charge for cells that error out or get skipped.

### FAQ

**Is this a rank tracker or ongoing monitoring tool?** No. Each run is an independent snapshot of the area at run time. Run it again whenever you want a fresh read.

**What does `placeCount` mean exactly?** It's the number of matching businesses Google Maps returns for that cell, sampled up to 40 results (two pages) per cell. It's a density signal for comparing cells against each other, not a guaranteed exhaustive count of every business in that cell.

**Can I cover a whole metro area?** Yes — increase **Radius (km)** and **Grid size** together. Grid size is capped at 7×7 (49 cells) per run to keep run time and cost predictable; for a very large area, increase the radius per cell instead of only the grid size.

**Do I need a Google API key?** No.

# Actor input Schema

## `category` (type: `string`):

The type of business to search for on Google Maps in every grid cell, e.g. "coffee shops", "dentists", "car washes".

## `locationQuery` (type: `string`):

A place name, address, city, or neighborhood to center the search grid on, e.g. "Chicago, IL". Used to look up the center point when Center latitude/longitude are not set.

## `centerLat` (type: `number`):

Latitude of the grid center. Optional — provide this together with Center longitude to skip the location lookup, or leave both blank and set Location instead.

## `centerLng` (type: `number`):

Longitude of the grid center. Optional — provide this together with Center latitude to skip the location lookup, or leave both blank and set Location instead.

## `radiusKm` (type: `integer`):

How far from the center point the search grid extends in each direction, in kilometers.

## `gridSize` (type: `integer`):

Number of grid cells per side. A grid size of 3 searches a 3x3 grid (9 cells). Minimum 2, maximum 7 (49 cells) to keep runs bounded.

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

Language code for results, e.g. en, de, fr, es, pt-BR.

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

Two-letter country code that biases search results, e.g. us, gb, de, au.

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

Optional. By default the actor connects directly and automatically falls back to Apify datacenter → residential proxies only if Google starts blocking. Set a specific proxy here to force it for all requests.

## Actor input object example

```json
{
  "category": "coffee shops",
  "locationQuery": "Chicago, IL",
  "radiusKm": 5,
  "gridSize": 3,
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One grid cell per record: cellRow, cellCol, cellLat, cellLng, category, placeCount, avgRating, avgReviewCount, topPlaces (up to 5, sorted by review count), searchedAt. Pivot placeCount by cellRow/cellCol to build a heatmap.

# 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 = {
    "category": "coffee shops",
    "locationQuery": "Chicago, IL",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("seemuapps/google-maps-competitor-density-mapper").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 = {
    "category": "coffee shops",
    "locationQuery": "Chicago, IL",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("seemuapps/google-maps-competitor-density-mapper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "category": "coffee shops",
  "locationQuery": "Chicago, IL",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call seemuapps/google-maps-competitor-density-mapper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,seemuapps/google-maps-competitor-density-mapper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Jzbz8FbmQJzAtjgiP/builds/PHDGq8B1cA5trs9rD/openapi.json