# Google Maps Monitor: New Business & Fresh Local Leads (`obsidian937/google-maps-watchlist`) Actor

Track a location + niche and get only the NEW businesses since your last run. Fresh local leads with phone, website, guessed emails, rating and lead score. Delta monitor, CRM-ready JSON, pay per result.

- **URL**: https://apify.com/obsidian937/google-maps-watchlist.md
- **Developed by:** [Obsidian IT Consulting SRL](https://apify.com/obsidian937) (community)
- **Categories:** Lead generation, E-commerce, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 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 Monitor: New Business & Fresh Local Leads

Stop re-scraping the same businesses every week. This actor **watches a location and a niche for you and returns only what is new** since your last run: freshly listed businesses, ready to contact.

Point it at "plumbers in London" or "coffee shops in Austin", run it on a schedule, and each run hands you the businesses that appeared since last time, with phone, website, guessed emails, rating and a 0-100 lead score. CRM-ready JSON, pay per result.

### Why a monitor instead of a one-shot scraper

A normal Maps scraper dumps the same 200 businesses every time and leaves you to diff them by hand. A monitor keeps memory:

- **First run** = your baseline (every current match, so you start with a full list).
- **Every run after** = only the businesses that are genuinely new to your watchlist.

That means the moment a new competitor, supplier or prospect gets listed in your area, it lands in your next run. Newly listed businesses are prime outreach targets: they are setting up, still choosing vendors, and rarely locked into contracts.

### Who uses it

- **Agencies and freelancers** monitoring "new restaurants / clinics / gyms in {city}" to pitch websites, ads or SEO while the business is still ramping up.
- **B2B sales teams** tracking new entrants in a category to reach out first.
- **Suppliers and franchises** watching new openings that need equipment, POS, insurance or delivery.
- **Real estate and local media** keeping a live pulse on what is opening where.

### Output (one row per business)

| Field | Description |
|-------|-------------|
| `isNew` | `true` if first seen on this run |
| `firstSeen` | ISO timestamp the watchlist first saw this business |
| `leadScore` | 0-100 contactability + traction score |
| `name`, `category` | Business identity |
| `phone`, `website`, `guessedEmails` | Contact channels |
| `rating`, `reviewsCount` | Reputation signals |
| `address`, `latitude`, `longitude` | Location |
| `hours` | Opening hours (when available) |
| `placeUrl`, `searchQuery`, `scannedAt` | Provenance |

### Input

| Field | Description |
|-------|-------------|
| `searchQueries` | Location + niche to watch, e.g. `["plumbers in London"]`. Keep stable across runs. |
| `emit` | `new` (only new since last run, default) or `all` (full pull, each flagged new/known) |
| `maxResults` | Businesses scanned per query each run (default 20, up to 500) |
| `watchlistId` | Optional fixed name to preserve memory even if you tweak the queries |
| `minRating` / `requireWebsite` / `requirePhone` | Quality filters |
| `includeReviews` | Attach up to 5 recent reviews per place |
| `resetWatchlist` | Wipe memory and re-baseline |

#### Run it on a schedule

Use Apify Schedules to run the actor daily or weekly with `emit: "new"`. Each scheduled run delivers only the fresh leads. Keep `searchQueries` (or `watchlistId`) identical between runs so the monitor stays consistent.

### How memory works

Each unique combination of queries (or your `watchlistId`) has its own private memory, stored in your Apify account and persisted across runs. Your watchlists are yours; nothing is shared.

### Related actors

Building a local + business lead pipeline? Pair this with **Google Maps Scraper: B2B Leads & Scoring** for full one-shot pulls, and the **App Store / Google Play Reviews** scrapers for reputation intelligence.

### Notes

Public Google Maps data only. No login, no personal data beyond what a business publicly lists. Runs on Apify's proxy out of the box.

# Actor input Schema

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

Location + niche to monitor (e.g. 'plumbers in London', 'coffee shops in Austin'). Keep these stable across runs so the monitor can tell what is new.

## `emit` (type: `string`):

'Only new since last run' = monitor mode (fresh leads only). 'All matches' = full pull, each flagged as new or known.

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

How many businesses to scan per query each run (up to 500)

## `watchlistId` (type: `string`):

Give this watchlist a fixed name to keep its memory even if you tweak the queries. Leave blank to derive it automatically from the queries.

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

Language for results

## `minRating` (type: `number`):

Only return businesses with rating >= this value (0 = no filter)

## `requireWebsite` (type: `boolean`):

Skip businesses without a website

## `requirePhone` (type: `boolean`):

Skip businesses without a phone number

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

Scrape up to 5 most recent reviews per place (slower)

## `resetWatchlist` (type: `boolean`):

Wipe this watchlist's memory and treat every current match as new (re-baseline)

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

Proxy settings

## Actor input object example

```json
{
  "searchQueries": [
    "coffee shops in Austin"
  ],
  "emit": "new",
  "maxResults": 20,
  "language": "en",
  "minRating": 0,
  "requireWebsite": false,
  "requirePhone": false,
  "includeReviews": false,
  "resetWatchlist": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "coffee shops in Austin"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("obsidian937/google-maps-watchlist").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": ["coffee shops in Austin"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("obsidian937/google-maps-watchlist").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 '{
  "searchQueries": [
    "coffee shops in Austin"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call obsidian937/google-maps-watchlist --silent --output-dataset

```

## MCP server setup

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

```

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/qofP1Ec5hq9MARRbr/builds/Wc3JTestP9bCdqwpN/openapi.json