🕵️ Google Review Fraud & Fake Review Detector

Scores every Google Maps review on a business for fake/paid-review risk — not by guessing from the text, but from the one thing a fake review can't fake: the reviewer's own account history, which Google renders on the page for every single review.

Keywords: fake review detector, google review checker, review fraud detection, local guide review analysis, google maps review scraper, fake reviews, paid reviews, review bombing detection, local business reputation.

🌟 Why this one

• Reads the signal Google itself exposes, not sentiment — every review on Google Maps shows the reviewer's full history right next to it, e.g. "Local Guide · 82 reviews · 12 photos" or just "2 reviews" for a brand-new account — confirmed by direct inspection of real review blocks. A brand-new account's first-ever review being an extreme 1★ or 5★ with no real text is the single strongest, most reproducible fake-review signal there is — far more reliable than trying to judge review text.
• Transparent scoring, not a black box — every suspicion score comes with the exact reasons behind it (thin_account, extreme_rating_from_thin_account, extreme_rating_with_little_or_no_text, reviewer_has_never_reviewed_anything_else). Nothing is hidden behind an unexplained "fraud probability."
• Catches review bursts — flags clusters of 3+ reviews all posted in the same relative time window (a classic sign of a bought review batch).
• No login, no API key, no paid review-monitoring subscription.

⚙️ How it works

1. Opens the business on Google Maps and switches to its Reviews tab.
2. Scrolls Google's own lazy-loaded review list to pull as many recent reviews as requested.
3. For each review, extracts the reviewer's name, Local Guide status, total lifetime review/photo count, star rating, relative post date, full review text, and a link to the reviewer's own profile.
4. Scores each review with a transparent rule set weighted toward reviewer account history, and rolls everything up into a per-business fraud-risk summary.

🚀 Quick start

{ "businessQueries": ["Dominos Pizza Times Square New York"], "maxReviewsPerBusiness": 30 }

Or via the API, once published:

curl "https://api.apify.com/v2/acts/google-review-fraud-detector/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"businessQueries": ["Starbucks Times Square New York"], "maxReviewsPerBusiness": 25}'

📥 Input

Field	Type	Default	Description
businessQueries	array	["Dominos Pizza Times Square New York"]	Business name + city, as you'd type it into Google Maps search — one per line
maxReviewsPerBusiness	integer	30	How many recent reviews to fetch and score per business (5–150)

📤 Output

Two record types in the same dataset, one per review plus one per business:

record_type: "review"

Field	Description
reviewer_name, reviewer_profile_url	Who posted it, and a link to their own reviewer profile
reviewer_is_local_guide, reviewer_total_reviews, reviewer_total_photos	The reviewer's own account history — the core fraud signal
rating, relative_date, review_text	The review itself
suspicion_score	0–100, higher = more suspicious
suspicion_flags	The exact, named reasons behind the score — never unexplained

record_type: "business_summary"

Field	Description
reviews_analyzed, average_rating	What was analyzed
suspicious_review_count, suspicious_review_pct	How many reviews scored ≥40
thin_account_review_count	Reviews from accounts with ≤3 lifetime reviews, not a Local Guide
burst_periods	Relative-date windows where 3+ reviews landed at once
fraud_risk_level	low / medium / high, based on the suspicious-review ratio

{
  "record_type": "review",
  "place_name": "Domino's Pizza",
  "reviewer_name": "Lydia Lugo",
  "reviewer_is_local_guide": false,
  "reviewer_total_reviews": 2,
  "rating": 1,
  "relative_date": "5 months ago",
  "review_text": "Worst service ever",
  "suspicion_score": 70,
  "suspicion_flags": ["thin_account (only 2 review(s) ever, not a Local Guide)", "extreme_rating_from_thin_account"]
}

A business that can't be matched or fails outright produces one record_type: "error" row with a real error message — never a silent gap.

🎯 Use cases

• Reputation management — spot a wave of suspicious reviews (real or competitor-driven) as soon as it starts
• Due diligence — sanity-check a business's rating before trusting it (franchise buyers, local SEO agencies, review-monitoring services)
• Competitor monitoring — check whether a rival's glowing reviews hold up to account-history scrutiny

🔌 Integration examples

Python (apify-client):

from apify_client import ApifyClient
client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("google-review-fraud-detector").call(
    run_input={"businessQueries": ["Dominos Pizza Times Square New York"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["record_type"] == "business_summary":
        print(item["place_name"], item["fraud_risk_level"])

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('google-review-fraud-detector').call({
    businessQueries: ['Starbucks Times Square New York'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

📊 Performance & reliability

Metric	Value
Proxy required	No — confirmed by direct testing with a free, open stealth browser
CAPTCHA-solving service required	No
Login / API key required	No
Data source	Google Maps' own rendered review panel — the same data any visitor sees
Challenge handling	Up to 4 automatic retries per business, each with a fresh browser session; if a chain search's top result lands on a location with no usable tab strip, the next few results are tried before retrying; a sustained failure surfaces as one clear error row, never a silent gap
Cost per business (real cloud runs)	~$0.015–0.035/business for 20 reviews, depending on retries needed

❓ FAQ

Is this a certainty that a review is fake? No — it's a transparent, rule-based risk signal from the reviewer's own account history, not proof. Always spot-check flagged reviews (every output row includes a direct link to the reviewer's profile) before taking any action against a business or reviewer.

Does this need a Google account or API key? No — it reads the same public review panel any visitor sees on google.com/maps.

Why "Local Guide" status specifically? Local Guide status is Google's own badge for an established, verified reviewer — the single cheapest, most reliable signal to tell a real long-time contributor apart from a disposable throwaway account.

⚖️ Notes

Reads only Google Maps' own public, already-posted review data — no login, no private account data, no scraping of anything behind a sign-in wall.