# Google Maps Reviews Monitor: New Review Alerts (`magnova/google-maps-reviews-monitor`) Actor

New Google Maps reviews for any place — your locations or competitors': rating, full text, reviewer name, date and owner response. Monitor mode delivers only reviews that are new since your last run. $0.01 per new review, no start fee, runs with no new reviews are free.

- **URL**: https://apify.com/magnova/google-maps-reviews-monitor.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Automation, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 new review fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Reviews Monitor: New Review Alerts

**Get every new Google Maps review for the places you care about — your own locations and your competitors' — as clean structured data, and pay only for the reviews that are actually new.**

You give this Actor a list of Google Maps place URLs. On every run it checks each place's newest reviews and delivers **only the reviews no earlier run has seen**: star rating, full review text, the reviewer's public display name, the review date, the owner's response when there is one, and the review language when Google provides it. Schedule it daily and it becomes a quiet new-review alert feed for one location or a whole chain — no more refreshing Google Maps by hand, and no paying for the same reviews twice.

### What it does

- **Monitors any Google Maps place** — restaurants, hotels, shops, clinics, dealerships, your competitors down the street. If it has a Google Maps page, it can be monitored.
- **Delta-only delivery.** With a monitor state store attached, each run delivers only genuinely new reviews. A day with no new reviews produces an empty result and costs nothing.
- **Complete review records.** Rating, full text (rating-only reviews are delivered too, without a text field), reviewer display name, exact timestamp when the feed carries one, owner responses with their dates, and language.
- **Per-place resilience.** If one place fails (a bad URL, a temporary Google block), that place produces one error record and the rest of the run continues. The final SUMMARY record tells you exactly what happened per category: places checked, fetched OK, empty, blocked and errored, reviews fetched, new reviews delivered, duplicates skipped.
- **Gentle by design.** One place at a time, paced requests, no login, no API key, no proxies.

### How monitoring works

1. **First run.** Without a store — or the first time a place is seen — the run delivers the place's current newest reviews as a *baseline batch* (charged normally), so you start with data, not an empty feed. Prefer to start silently? Turn on **Start monitoring silently** (`monitorOnlyNew`) and the first run only remembers the current reviews; delivery starts with the next new review.
2. **Attach a store.** Pick any of your Apify key-value stores in the **Monitor state store** input. The Actor keeps one small record in it: which review IDs it has already seen for each place.
3. **Schedule it.** Run it daily (or hourly for very busy places) with the same store. Every run fetches each place's newest reviews — the window size is yours to set — diffs them against the store, delivers only the new ones, and updates the store.
4. **Size the window to your schedule.** Only reviews inside the checked window can be detected as new. The default window of 40 newest reviews per place comfortably covers a daily check of a busy restaurant. For a weekly check of a very busy place, raise it (up to 200).

### Inputs

| Input | Type | Description |
| --- | --- | --- |
| `placeUrls` | array of strings (required) | The Google Maps places to monitor. Open each place on Google Maps and paste its URL — the full URL from the address bar, or its share link. Up to 50 places per run. |
| `reviewsPerPlacePerRun` | integer, 10–200 (default 40) | How many of each place's newest reviews are fetched and diffed per run. Checking is free; you pay only for new reviews delivered. |
| `monitorOnlyNew` | boolean (default false) | When true, the first run for a place silently remembers its current reviews instead of delivering a baseline batch. Only reviews posted afterwards are ever delivered. |
| `monitorStore` | key-value store (optional) | The store that remembers seen reviews across runs — this is what makes only-new delivery work. Without it, every run is a full baseline run. |

### Outputs

Every run writes three kinds of records to the dataset:

**`review` records — one per NEW review (the charged records):**

| Field | Meaning |
| --- | --- |
| `placeName` | The place's name as Google Maps shows it |
| `placeId` | The place's Google feature ID (`0x…:0x…`, from its Maps URL) |
| `placeIdChIJ` | The same place ID in ChIJ form (Places API form) |
| `placeUrl` | The place URL as supplied in the input |
| `reviewId` | The review's unique Google ID |
| `rating` | Star rating, 1–5 |
| `reviewText` | The full review text (omitted for rating-only reviews) |
| `reviewerName` | The reviewer's public display name, exactly as published with the review |
| `reviewDate` | ISO timestamp when the feed carries an exact time; otherwise Google's relative wording verbatim (e.g. "2 months ago") |
| `reviewTimestampMs` | Exact publish time in Unix milliseconds, when available |
| `ownerResponse` / `ownerResponseDate` | The owner's public response and its date, when the owner has responded |
| `language` | The review's language code (e.g. `en`), when Google states one |

**`error` records** — one per place that could not be checked (never charged), with the reason; `blocked: true` marks places Google rate-limited or refused, so you can tell a block apart from a place that simply had no new reviews.

**One `summary` record** at the end of every run (never charged): per-category counts (places checked / fetched OK / empty / blocked / errored, reviews fetched, new delivered, duplicates skipped, silently seeded), whether a state store was used, whether the run stopped at your maximum charge or the platform timeout, and notes about the run.

### Pricing

**$0.01 per new review delivered.** No start fee, no per-run fee, no charge for checking.

- Already-seen reviews: **free** (skipped as duplicates).
- A run where nothing is new: **free**.
- Error and SUMMARY records: **free**.
- Higher Apify pricing tiers pay less automatically: SILVER $0.0085, GOLD/PLATINUM/DIAMOND $0.007 per new review.

What that means in practice:

- **One restaurant, daily checks:** a typical independent restaurant gets ~5–20 new Google reviews a week → roughly **$0.20–$0.80 per month**.
- **A 25-location chain, daily checks:** suppose each location averages 2 new reviews a day. That's 25 × 2 × 30 = 1,500 new reviews a month → **$15/month** ($12.75 at SILVER, $10.50 at GOLD) for a complete, hands-off new-review feed across the whole estate.
- **Competitor watching:** add your five nearest competitors to the same run; you pay only for *their* new reviews too — typically a few dollars a month to never miss what customers are saying about them.

### Limits — the honest list

- **Google changes its internals.** This Actor reads the same public review feed that Google Search's local panel displays. Google reshapes that feed from time to time; when it does, places may temporarily return errors instead of reviews. Breakage is watched for in a weekly portfolio review and fixed as part of the Actor's maintenance — affected runs show per-place error records (never silently empty results), and you are never charged for them.
- **The window is a window.** Only the newest `reviewsPerPlacePerRun` reviews per place are diffed. If a place receives more new reviews than the window between two runs, the overflow ages out of the window undetected. Size the window to your schedule (see above).
- **Dates.** The feed normally carries an exact timestamp and `reviewDate` is then an ISO timestamp. If a payload ever lacks one, the field falls back to Google's relative wording ("a week ago") verbatim rather than inventing a date.
- **Place URLs.** The URL must identify one specific place (the URL of the place's own Maps page, or its share link). A search-results URL or a bare place name cannot be monitored — the run reports that place as an error record and continues with the rest.
- **Busy first runs.** A baseline run delivers the whole current window (default 40 reviews per place). That is a one-off cost of $0.40 per place at the default window — or use `monitorOnlyNew` to start from zero for free.

### Legal and data

- **Public, logged-out data only.** The Actor reads reviews that Google publishes to any logged-out visitor through its own search local panel. It uses no account, no login, no API key, and it does not solve CAPTCHAs or bypass any access control; if Google refuses a request, the place is reported as blocked and the run moves on.
- **Reviewer names as published.** A reviewer's display name is part of the public review as Google publishes it, and it is the only reviewer field this Actor emits. Reviewer profile URLs, profile photos, contributor IDs and every other piece of reviewer metadata present in the raw feed are deliberately never read into the output. No email addresses, phone numbers or contact details of any kind are collected — there is no profile enrichment, ever.
- **Legitimate interest.** Monitor places you have a legitimate interest in: your own business locations, your employer's, your clients', or competitors you lawfully track for market awareness. You are responsible for using the delivered data in line with the laws that apply to you (including privacy and platform terms), and for not using reviewer names to contact or profile individuals.
- This Actor is an independent tool and is not affiliated with or endorsed by Google.

### Tips

- **Start with the prefilled demo** (Googleplex, Katz's Delicatessen, the New York Marriott Marquis) to see real output immediately, then swap in your own places.
- **One store per monitoring setup.** Different place lists can share a store safely (state is kept per place), but keeping one store per business keeps things tidy.
- **Pair it with a schedule + webhook** (Apify supports both) to turn new reviews into alerts in Slack, email or your CRM the moment they land.

# Actor input Schema

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run for a place delivers its current newest reviews as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current reviews without delivering or charging anything, and only reviews posted afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which reviews it has already seen for each place — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers all checked reviews as a NEW baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes.

## `placeUrls` (type: `array`):

The Google Maps places to monitor — your own locations, competitors, or both. For each place: open it on Google Maps and paste its URL (the full URL from the address bar, or the share link). Every run checks the newest reviews of each place. Example: "https://www.google.com/maps/place/Katz's+Delicatessen/@40.7222378,-73.9875014,17z/data=!4m6!3m5!1s0x89c2598f7ff4aa09:0x313547e757cb8cea!8m2!3d40.7223289!4d-73.9873857". Up to 50 places per run.

## `reviewsPerPlacePerRun` (type: `integer`):

How many of each place's newest reviews are fetched and compared against the monitor store on every run (the diffing window). Only reviews inside this window can be detected as new, so size it above the most reviews a place could receive between two runs: 40 suits daily checks of busy places; raise it (up to 200) for weekly checks of very busy places. Checking itself is free — you only pay for new reviews actually delivered.

## Actor input object example

```json
{
  "monitorOnlyNew": false,
  "placeUrls": [
    "https://www.google.com/maps/place/Katz's+Delicatessen/@40.7222378,-73.9875014,17z/data=!4m6!3m5!1s0x89c2598f7ff4aa09:0x313547e757cb8cea!8m2!3d40.7223289!4d-73.9873857"
  ],
  "reviewsPerPlacePerRun": 40
}
```

# Actor output Schema

## `results` (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 = {
    "monitorOnlyNew": false,
    "placeUrls": [
        "https://www.google.com/maps/place/Googleplex/@37.4220656,-122.0840897,17z/data=!4m6!3m5!1s0x808fba02425dad8f:0x6c296c66619367e0!8m2!3d37.4219999!4d-122.0840575",
        "https://www.google.com/maps/place/Katz's+Delicatessen/@40.7222378,-73.9875014,17z/data=!4m6!3m5!1s0x89c2598f7ff4aa09:0x313547e757cb8cea!8m2!3d40.7223289!4d-73.9873857",
        "https://www.google.com/maps/place/New+York+Marriott+Marquis/@40.7585862,-73.9860565,17z/data=!4m6!3m5!1s0x89c2585500e85589:0x18f39d1f8ee2a312!8m2!3d40.7585862!4d-73.9860565"
    ],
    "reviewsPerPlacePerRun": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/google-maps-reviews-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 = {
    "monitorOnlyNew": False,
    "placeUrls": [
        "https://www.google.com/maps/place/Googleplex/@37.4220656,-122.0840897,17z/data=!4m6!3m5!1s0x808fba02425dad8f:0x6c296c66619367e0!8m2!3d37.4219999!4d-122.0840575",
        "https://www.google.com/maps/place/Katz's+Delicatessen/@40.7222378,-73.9875014,17z/data=!4m6!3m5!1s0x89c2598f7ff4aa09:0x313547e757cb8cea!8m2!3d40.7223289!4d-73.9873857",
        "https://www.google.com/maps/place/New+York+Marriott+Marquis/@40.7585862,-73.9860565,17z/data=!4m6!3m5!1s0x89c2585500e85589:0x18f39d1f8ee2a312!8m2!3d40.7585862!4d-73.9860565",
    ],
    "reviewsPerPlacePerRun": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/google-maps-reviews-monitor").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 '{
  "monitorOnlyNew": false,
  "placeUrls": [
    "https://www.google.com/maps/place/Googleplex/@37.4220656,-122.0840897,17z/data=!4m6!3m5!1s0x808fba02425dad8f:0x6c296c66619367e0!8m2!3d37.4219999!4d-122.0840575",
    "https://www.google.com/maps/place/Katz'\''s+Delicatessen/@40.7222378,-73.9875014,17z/data=!4m6!3m5!1s0x89c2598f7ff4aa09:0x313547e757cb8cea!8m2!3d40.7223289!4d-73.9873857",
    "https://www.google.com/maps/place/New+York+Marriott+Marquis/@40.7585862,-73.9860565,17z/data=!4m6!3m5!1s0x89c2585500e85589:0x18f39d1f8ee2a312!8m2!3d40.7585862!4d-73.9860565"
  ],
  "reviewsPerPlacePerRun": 40
}' |
apify call magnova/google-maps-reviews-monitor --silent --output-dataset

```

## MCP server setup

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

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/mxigK7mwbgHuHxg4c/builds/u8qF8pvCmJf9zb5Wm/openapi.json