ReviewForge — Google Maps Reviews & Reputation Monitor

ReviewForge is a monitoring-first Google Maps reviews actor. Instead of a one-shot bulk dump, it runs on a schedule and tells you what changed since your last run: new reviews, negative reviews, unanswered reviews, and rating drops — delivered as delta-tagged records, place snapshots, and an alerts feed.

Bulk extractors re-scrape everything every run and charge per review fetched. ReviewForge charges per review new since last run + per alert, so steady-state monitoring cost tracks monitoring value, not fetch volume. A weekly run on 10 places (~2 new reviews each) costs a fraction of re-fetching ~1,500 reviews the way a bulk scraper does.

What ReviewForge tracks

• New reviews posted since the last run (delta-tagged against your previous run)
• Negative reviews and sentiment shifts (English + Indonesian)
• Rating drops and changes (rating deltas)
• Unanswered reviews
• Place rating, review count, and rating delta over time (place snapshots)

Why monitor Google Maps reviews?

Google Maps has over 8 billion monthly active users and is one of the most influential platforms for local business reputation and discovery. Your reviews directly impact customer decisions, search rankings, and overall brand perception.

Here are just some of the ways monitoring Google Maps reviews could help your business or organization:

• Quickly respond to negative feedback before it damages your reputation
• Identify trending complaints or issues customers mention repeatedly
• Track competitor review activity and positioning
• Monitor rating trends to assess business health
• Automate alerts for urgent reputation management situations
• Build historical records of your online reputation
• Make data-driven decisions about service improvements

If you would like more inspiration on how scraping Google Maps data could help your business or organization, check out our industry pages.

How to monitor Google Maps reviews with ReviewForge

It's easy to monitor Google Maps with ReviewForge. Just follow these steps:

1. Click on Try for free.
2. Enter the Google Maps URL(s) for your business location(s) or provide search keywords to identify your business.
3. Configure your notification preferences and monitoring frequency.
4. Click on Run.
5. When ReviewForge finishes, review the change report in the Dataset tab showing new reviews, rating changes, and unanswered reviews.

The actor maintains state across runs in a named KeyValueStore (reviewforge-state), so it automatically detects what's new and different since your last execution. A failed target is skipped and its watermark is not advanced, so a retry re-sees its reviews; the run continues for the other targets.

How it works (per run)

1. Validate input → resolve startUrls / searchQueries to google_maps targets.
2. Load LAST_RUN_STATE from the named KeyValueStore (reviewforge-state). (The default KV store is purged every run, so state must live in a named store to persist across runs.)
3. For each target, dispatch through the source registry to the google_maps fetcher (Playwright + residential proxy): place snapshot + newest reviews.
4. Delta-tag each review (isNewSinceLastRun = reviewId ∉ seenSet); first run on a place ⇒ all reviews are "new".
5. Score sentiment (bilingual EN+ID keyword lexicon), compute place deltas, emit alerts (new / negative / rating-drop / unanswered).
6. Write REVIEWS (default dataset), PLACE-SNAPSHOTS, ALERTS.
7. On success only, atomically persist the new LAST_RUN_STATE.

Output — three datasets

• REVIEWS (default) — one row per fetched review, delta-tagged, with platform, sourceId, reviewId, rating, sentiment, tags, and isNewSinceLastRun.
• PLACE-SNAPSHOTS (named) — per place: rating, reviewCount, ratingDelta, newReviewCount.
• ALERTS (named) — the differentiator: new_review, negative_review, rating_drop, unanswered with severity. POSTed to notifications.webhookUrl if set.

Results

ReviewForge returns structured data about changes since the last run:

{
  "location": {
    "name": "Business Name",
    "address": "123 Main St, City, State",
    "placeId": "ChIJ1234567890",
    "url": "https://www.google.com/maps/place/..."
  },
  "currentRating": 4.5,
  "previousRating": 4.6,
  "ratingChange": -0.1,
  "totalReviews": 248,
  "newReviewsCount": 3,
  "newReviews": [
    {
      "author": "John D.",
      "rating": 5,
      "text": "Excellent service, highly recommend!",
      "date": "2024-01-15",
      "isNew": true
    }
  ],
  "negativeReviewsCount": 1,
  "unansweredReviewsCount": 2,
  "unansweredReviews": [
    {
      "author": "Jane S.",
      "rating": 3,
      "text": "Good but could be better",
      "date": "2024-01-10",
      "answered": false
    }
  ],
  "lastRun": "2024-01-15T10:30:00Z"
}

Pricing — PAY_PER_EVENT

ReviewForge uses Apify's PAY_PER_EVENT pricing model, meaning you only pay for actual changes detected (new reviews, rating updates, etc.) rather than for every run.

Apify gives you $5 in free usage credits every month on the Apify Free Plan. Depending on your review volume, you can monitor multiple locations completely free!

For regular monitoring of multiple business locations or higher review volumes, we recommend our $49/month Starter plan, which provides substantial event capacity.

For enterprise-level monitoring across many locations, the $499 Scale plan offers unlimited capacity with premium support.

Configured in the Apify Console at the monetization/publish step (the platform no longer reads PPE pricing from actor.json). The events charged in code (src/main.ts) and their ratified tiers (apifyMarginPercentage: 0.2):

Event	Charged on	FREE	BRONZE	SILVER	GOLD	PLATINUM	DIAMOND
apify-actor-start (synthetic, auto-charged by platform)	once per run	$0.00005	$0.00005	$0.00005	$0.00005	$0.00005	$0.00005
place-monitored	per distinct place processed	$0.004	$0.003	$0.002	$0.0015	$0.001	$0.0008
new-review	per review new since last run	$0.003	$0.002	$0.0015	$0.001	$0.0006	$0.0005
alert	per alert emitted	$0.005	$0.0035	$0.0025	$0.0018	$0.0012	$0.0008

Do not define apify-default-dataset-item — it would auto-charge every pushed review and destroy the "charge on new only" moat. Reviews already seen are pushed to the default dataset uncharged. apify-actor-start is synthetic and must never be charged in code.

Tips for monitoring Google Maps reviews

• Set up regular monitoring schedules (daily or weekly) to catch issues early before they escalate
• Configure alerts for rating drops to respond quickly to service issues
• Prioritize responding to unanswered reviews — this improves customer satisfaction and SEO
• Monitor competitor locations to benchmark your rating trends
• Export historical data to identify seasonal patterns or long-term trends
• Use negative review data to identify systemic service improvements needed

The source interface (Phase-2 drop-in)

Every platform fetcher implements one contract (src/sources/types.ts):

interface ReviewSource {
  readonly platform: 'google_maps' | 'yelp' | 'tripadvisor' | 'booking' | 'amazon';
  fetchEntity(target, ctx): Promise<EntitySnapshot>;
  fetchReviews(target, opts, ctx): AsyncGenerator<RawReview>;
  canonicalReviewId(raw: RawReview): string; // stable per-source delta key
}

The pipeline never special-cases a platform; it resolves a source from src/sources/registry.ts. Adding a Phase-2 platform = implement one module + one line in the registry — no pipeline, state-model, dataset, or pricing change.

Ethics & data

Reviews are public user-generated content. ReviewForge attributes each review to its original author, stores only public display data, and keeps personalData minimal — the delta key prefers the platform contributor id over any PII-derived hash. Respect each place's terms; use polite delays and residential proxies.

Verifying locally

No Apify account, proxy, or credits required:

npm test                            # 28 unit tests (delta, bilingual sentiment)
npx tsx scripts/local-dry-run.ts    # end-to-end on the 30 real captured reviews

Run locally

$apify run          # reads storage/key_value_stores/default/INPUT.json

Local storage (storage/) is not synced to the Apify Console — inspect it locally or deploy with apify push and run on the platform.

Project layout

.actor/                 # actor.json, input/output/dataset schemas
src/
  sources/              # source interface + google_maps reference impl + registry
  state.ts              # cross-run delta + atomic state (the pricing moat)
  sentiment.ts          # bilingual EN+ID keyword lexicon
  pipeline.ts           # platform-agnostic normalize → delta → sentiment → alerts
  orchestrator.ts       # the testable run core (per-target walk + watermark rules)
  main.ts               # Apify SDK shell: wires orchestrator to KV/datasets/charging
tests/                  # delta, sentiment, source contract, pipeline, orchestrator
spike/                  # S0 fetch-method spike (reference data + scripts)

main.ts is a thin SDK adapter; every decision (which targets advance their watermark, what's fatal vs recoverable) lives in orchestrator.ts behind injectable ports, so the delta invariants are unit-tested without the SDK.

Is it legal to scrape Google Maps?

Note that personal data is protected by GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

For business owners and reputation managers monitoring their own locations or locations they manage, this use case is generally legitimate. However, scraping competitors' reviews may have legal and ethical considerations depending on your jurisdiction.

We also recommend that you read our blog post: is web scraping legal?.