# Google Reviews Analysis - what customers say, and what's fake (`mentat-logic/mentat-reviews-analysis`) Actor

Paste a Google Maps link. See what customers actually say — recurring praise and complaints, by language, with real quotes — plus the bought or coordinated reviews most tools miss, with evidence attached. Silent star-ratings counted too. First check free; full audit $1.99 per 1,000 reviews.

- **URL**: https://apify.com/mentat-logic/mentat-reviews-analysis.md
- **Developed by:** [Mentat Logic](https://apify.com/mentat-logic) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.99 / 1,000 analyzed reviews

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/platform/actors/running/actors-in-store#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 Reviews Analysis — what customers say, and what's fake

**Paste a Google Maps link.** You get three answers: what your customers are actually saying, whether any of the recent reviews look manufactured, and what to do next. The first check is free.

### How do I know if my Google reviews are fake?

You usually cannot tell by reading them. A bought review is written to sound like a happy customer, and a review-bombing campaign is written to sound like an angry one. What gives them away is not the words in any single review — it is the pattern across all of them.

This tool checks five things against the business's own history, not against some universal threshold:

- Timing — reviews arriving far faster than this listing's normal rate.
- Rating shape — a burst that is overwhelmingly one-star, or overwhelmingly five-star, against what this listing usually receives.
- Repeated wording — the same distinctive phrasing appearing from accounts with no other connection to each other.
- Reviewer history — what share of a burst comes from accounts with almost no reviews to their name.
- How alike the reviews are — a campaign says one thing in one way; real customers say eight things in eight ways.

### What if the bad reviews are real?

This is the question most tools cannot answer, and it is the reason this one exists.

A rating drop with a wave of one-star reviews is what a review-bombing campaign looks like. **It is also exactly what a bad month looks like.** A tool that cannot tell the difference will tell an owner they are under attack when the food was simply cold — and that is worse than useless, because it sends them arguing with Google instead of fixing the kitchen.

So the analysis separates two things and only one of them sets the verdict. What happened to the rating — the volume spike, the one-sided ratings — is reported as context. Whether the reviews themselves look manufactured is what decides the answer. A rating drop on its own is never treated as evidence of a campaign.

When the reviews are genuine, the tool says so plainly, and then shows you what people are actually complaining about.

### What does the answer look like?

One verdict per location: NO COORDINATION FOUND, ISOLATED, SUBSTANTIAL, DOMINANT, or NOT ENOUGH DATA TO JUDGE — with the direction where there is one: review bombing or review buying. Every threshold used is printed in the report, so it can be argued with rather than taken on faith.

Then the themes: the terms that recur across the negative reviews, with counts and real quotes. Seven of the recent reviews mention the wait. Seven mention cold food. Six mention the wine list. No fixed complaint categories — the reviews supply the vocabulary, so a barber shop produces barber-shop themes and a garage produces garage themes from the same code.

### Where is my report?

When the run finishes, open it, go to **Storage** → **Key-value store**, and open **report.html** — you can preview it in the browser or download it. A comparison run adds **comparison.html** the same way.

Every location row in the dataset also carries the links directly: **report\_url**, the console page you just opened, and **report\_api\_url**, the raw API record for a machine to fetch (an API token is required for that one).

### Does it work for reviews in other languages?

Yes, and this is where most tools quietly fail.

Themes are reported **per language group and never merged** — "the Thai reviews complain about price, the English ones about service" is itself the finding. Where no stopword list exists for a language, the group is still reported and flagged as unfiltered rather than dropped.

Duplicate detection uses character sequences rather than words, in every script. Thai, Chinese, Japanese, Khmer and Lao do not put spaces between words, so a word-based tool returns "no duplicates found" on exactly the venues most at risk — silently, with no error. That failure mode is designed out here rather than documented around.

Nothing is translated. You get counts and real quotes, so you read your own reviews.

The analysis reads reviews in any language. The report itself is written in English; quotes and themes appear exactly as customers wrote them, in their original language — nothing is translated, so you read your customers' own words.

### Can you get fake reviews removed?

No — and neither can anyone else who is being honest with you. Only Google removes a review.

What the report gives you is the part that is actually in your control: which reviews the evidence covers, how the reporting route works, and a copy-paste evidence summary for the appeal — the window examined, the counts, the baseline the activity deviates from, and the method, written so it survives being forwarded to a platform or a lawyer.

### Can I compare several locations?

Yes. Give it more than one link — your place against the two competitors down the road, or the handful of branches you are worried about — and it adds a side-by-side table with the most concerning first. Each location still gets its own full report. Locations with nothing wrong are listed last, not omitted: a clean result is a result.

Up to 25 locations per run, a cap set by how the tool is actually used rather than by what the plumbing could survive.

### What does it cost?

| | |
|---|---|
| Free | one location, most recent 150 reviews |
| Full audit | $1.99 per 1,000 reviews analyzed, the full accessible history; most places land under $5 |
| Comparison | same per-1,000 rate, up to 25 locations per run |

The free window is deliberately honest about its limit: 150 reviews cannot establish a long baseline, so its verdict is less confident by construction. That is the reason the full audit exists.

Google caps accessible reviews at roughly 3,500–4,000 per place regardless of how many exist, so "full audit" means the full accessible history — and the report tells you which it got.

Measured on a real 2,300-review restaurant: the full history audit completed in about three minutes. The free first check covers the 150 most recent reviews.

### What this cannot do

- It cannot remove a review or file anything on your behalf.
- It cannot detect paid reviews written by real people using real, established accounts. Those are indistinguishable from genuine ones in this data. Any tool claiming otherwise is not being honest with you.
- It cannot see reviewer IP addresses. Google publishes them nowhere — not in the product, not through any scraper, not through the API. Reviewer history and review counts are what is actually available, and that is what is used.
- It cannot read meaning. It counts what recurs and shows you the quotes. Sarcasm and negation are invisible to it.
- It is not legal advice.

### What about personal data?

Reviewer details are requested for one purpose: counting how many reviews an account has in total, which is what separates a wave of one-review accounts from a wave of established locals. No reviewer name, profile link or identifier is stored, displayed, or written to the output. Findings appear as aggregates only — "41% of the recent reviews come from accounts with fewer than three reviews".

### How does it handle review dates?

Google publishes relative dates ("a month ago"). Recent activity resolves to days, which is where burst detection is meaningful — and a campaign worth catching is recent by definition. Older history resolves to months, so the baseline is expressed per month and no burst claim is made about older periods.

A tool claiming day-precise detection across three years of reviews is claiming something Google does not expose.

### For AI agents

One call replaces a pipeline: URL validation, scraper orchestration, field mapping, analysis, report. Inputs and outputs are schema-defined. Refusals are explicit — `status: refused` with a `reason` string, exiting cleanly rather than returning an empty success. Coverage is always reported, so a thin answer is distinguishable from a confident one. There is no LLM anywhere in the analysis: identical input produces identical output, every time.

# Actor input Schema

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

One Google Maps place URL or share link for a single business, or a few (up to 25) to compare side by side — your location against the competitors down the road, or the branches you are worried about. More than one adds a comparison table, and each location still gets its own full report. Leave empty to run the free demo on synthetic data: no scraper is invoked and nothing is charged.

## `fullAudit` (type: `boolean`):

Off by default. Off = the most recent 150 reviews per location, free, which cannot establish a long baseline so the verdict is less confident by construction. On = the full accessible review history per location, charged once per location. Google caps accessible reviews at roughly 3,500-4,000 per place regardless of how many exist, so a full audit means the full accessible history and the report states which it got.

## Actor input object example

```json
{
  "placeUrls": [],
  "fullAudit": false
}
```

# Actor output Schema

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

No description

## `report` (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 = {
    "placeUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("mentat-logic/mentat-reviews-analysis").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 = { "placeUrls": [] }

# Run the Actor and wait for it to finish
run = client.actor("mentat-logic/mentat-reviews-analysis").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 '{
  "placeUrls": []
}' |
apify call mentat-logic/mentat-reviews-analysis --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mentat-logic/mentat-reviews-analysis",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8kbkKPNHEtC0jnv2h/builds/BolPrb8B9WdMvA2tD/openapi.json