# Google Maps New Business Monitor (`davidbenittah/google-maps-new-business-monitor`) Actor

Monitor any Google Maps area on a schedule and get only the NEW businesses that appeared since the last run — name, address, phone, website.

- **URL**: https://apify.com/davidbenittah/google-maps-new-business-monitor.md
- **Developed by:** [David](https://apify.com/davidbenittah) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% 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

## Google Maps New Business Monitor

**Google Maps new business monitor** that watches any area on a schedule and returns **only the NEW businesses** that appeared since the last run — with name, address, phone, website, and Google Maps link. One-shot scrapers give you the same 500 places every week; this monitor gives you the diff, so you contact a new business before anyone else does.

### Features

- **Diff, not dump**: the first run saves a baseline of the area; every following run outputs only businesses that were not there before.
- **Any category, any area**: watch "restaurant" in Lyon, "dentist" in Brooklyn, "plumber" in Berlin — plain Google Maps search terms.
- **Full contact record** per new business: name, category, address, phone, website, rating, review count, coordinates, Google Maps URL.
- **Schedule-ready**: designed for weekly or daily scheduled runs; state is persisted between runs automatically.
- **No false positives on flaky results**: a business that temporarily drops out of Google Maps results is remembered and never re-flagged as "new".
- **Runs with defaults**: the prefilled input works without any configuration.

### Use cases

- **Local SEO & web agencies**: new businesses need a website, Google Business Profile setup, and reviews — reach them in week one.
- **B2B suppliers & wholesalers**: a new restaurant needs a food supplier, POS system, and insurance the day it opens.
- **Insurance & banking prospecting**: new commercial openings are the highest-intent moment for business services.
- **Market intelligence**: track how fast a competitor category grows in a target zone.

### Input / Output

Input (all defaults work out of the box):

```json
{
  "searchTerms": ["restaurant"],
  "location": "Lyon, France",
  "maxPlacesPerSearch": 100
}
````

Output — one dataset item per **new** business:

```json
{
  "placeId": "ChIJ...",
  "name": "Café Nouveau",
  "category": "Coffee shop",
  "address": "21 Rue Paul Bert, 69003 Lyon",
  "phone": "+33 4 78 00 00 09",
  "website": "https://cafenouveau.example",
  "googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJ...",
  "totalScore": 5.0,
  "reviewsCount": 4,
  "firstDetectedAt": "2026-07-06T12:00:00.000Z",
  "isNewSinceLastRun": true
}
```

The first run pushes the area baseline (items flagged `isBaseline: true`; disable with `includeBaselineInOutput: false`). Every later run pushes only new businesses. A `SUMMARY` record in the key-value store reports counts for each run.

### Pricing

Pay per event: you are charged a small fee per dataset item (new business detected), plus the underlying Google Maps scraping cost. Under the hood this Actor runs the standard Google Maps Scraper (`compass/crawler-google-places`, charged to your account at its own pay-per-event rate, ~$4 per 1,000 places scanned) and then computes the diff. A weekly monitor of 100 places costs roughly $0.40/run in scanning plus the per-result fee only when new businesses actually appear.

### FAQ

**How does it detect "new" businesses?**
Each run scans the area and compares Google `placeId`s against the saved baseline in a persistent key-value store. Anything not seen before is reported with `firstDetectedAt`.

**Does "new" mean newly opened?**
It means newly listed on Google Maps in that area's search results — for prospecting purposes this is the moment that matters: it is when the business becomes reachable.

**Why do I sometimes see an established business reported as new?**
If `maxPlacesPerSearch` is lower than the real number of places in the area, Google Maps returns a different sample each run. The built-in `maxReviewsForNew` filter (default 25 reviews) removes these false positives: a place with hundreds of reviews that "appears" is sampling noise, not a new opening. For exhaustive coverage, set `maxPlacesPerSearch` above the area's total place count.

**How do I reset a monitor?**
Set a new `monitorId` (or change search terms/location — each combination keeps its own baseline).

**Can I watch several areas?**
Yes — create one scheduled task per area, or one task with up to 10 search terms for the same area.

**Is scraping Google Maps data legal?**
The Actor only collects public business listing data (no personal data) via the standard Apify Google Maps Scraper. You are responsible for how you use the extracted data.

# Actor input Schema

## `searchTerms` (type: `array`):

What you would type in the Google Maps search bar, e.g. 'restaurant' or 'dentist'. Hard maximum: 10 terms per run.

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

Free-text location, e.g. 'Lyon, France' or 'Brooklyn, New York'. One area per monitor.

## `maxPlacesPerSearch` (type: `integer`):

Safety cap on places scanned per search term. Hard maximum: 500.

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

Language code for place details (e.g. 'en', 'fr').

## `includeBaselineInOutput` (type: `boolean`):

The very first run saves a baseline of the area. When enabled, that baseline is also pushed to the dataset (flagged isBaseline=true). Later runs always output only NEW businesses.

## `maxReviewsForNew` (type: `integer`):

A place that suddenly appears in results but already has many reviews is an established business surfacing due to Google Maps sampling, not a new opening. Places above this review count are not reported as new. Set 0 to disable the filter.

## `monitorId` (type: `string`):

Optional. Advanced: name this monitor to keep several baselines for the same area, or reset one by changing the ID.

## Actor input object example

```json
{
  "searchTerms": [
    "restaurant"
  ],
  "location": "Lyon, France",
  "maxPlacesPerSearch": 100,
  "language": "en",
  "includeBaselineInOutput": true,
  "maxReviewsForNew": 25
}
```

# 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 = {
    "searchTerms": [
        "restaurant"
    ],
    "location": "Lyon, France"
};

// Run the Actor and wait for it to finish
const run = await client.actor("davidbenittah/google-maps-new-business-monitor").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 = {
    "searchTerms": ["restaurant"],
    "location": "Lyon, France",
}

# Run the Actor and wait for it to finish
run = client.actor("davidbenittah/google-maps-new-business-monitor").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 '{
  "searchTerms": [
    "restaurant"
  ],
  "location": "Lyon, France"
}' |
apify call davidbenittah/google-maps-new-business-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps New Business Monitor",
        "description": "Monitor any Google Maps area on a schedule and get only the NEW businesses that appeared since the last run — name, address, phone, website.",
        "version": "1.0",
        "x-build-id": "cggX5RgFN4rgg3Nkf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/davidbenittah~google-maps-new-business-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-davidbenittah-google-maps-new-business-monitor",
                "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/davidbenittah~google-maps-new-business-monitor/runs": {
            "post": {
                "operationId": "runs-sync-davidbenittah-google-maps-new-business-monitor",
                "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/davidbenittah~google-maps-new-business-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-davidbenittah-google-maps-new-business-monitor",
                "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": [
                    "searchTerms",
                    "location"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Business categories to watch",
                        "type": "array",
                        "description": "What you would type in the Google Maps search bar, e.g. 'restaurant' or 'dentist'. Hard maximum: 10 terms per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Area to watch",
                        "type": "string",
                        "description": "Free-text location, e.g. 'Lyon, France' or 'Brooklyn, New York'. One area per monitor."
                    },
                    "maxPlacesPerSearch": {
                        "title": "Max places per search term",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety cap on places scanned per search term. Hard maximum: 500.",
                        "default": 100
                    },
                    "language": {
                        "title": "Results language",
                        "type": "string",
                        "description": "Language code for place details (e.g. 'en', 'fr').",
                        "default": "en"
                    },
                    "includeBaselineInOutput": {
                        "title": "Output the baseline on first run",
                        "type": "boolean",
                        "description": "The very first run saves a baseline of the area. When enabled, that baseline is also pushed to the dataset (flagged isBaseline=true). Later runs always output only NEW businesses.",
                        "default": true
                    },
                    "maxReviewsForNew": {
                        "title": "Max reviews for a 'new' business",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "A place that suddenly appears in results but already has many reviews is an established business surfacing due to Google Maps sampling, not a new opening. Places above this review count are not reported as new. Set 0 to disable the filter.",
                        "default": 25
                    },
                    "monitorId": {
                        "title": "Custom monitor ID",
                        "type": "string",
                        "description": "Optional. Advanced: name this monitor to keep several baselines for the same area, or reset one by changing the ID."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
