Google Reviews Scraper

Extracts the full review history of any Google Maps place — review text (auto-expanded), star rating, dates, reviewer profile, owner responses, likes, photos — as structured JSON.

Billing is flat per place: $0.05 if you pull up to 50 reviews, $0.25 for anything from 51 to 5,000. There is no per-review meter and no per-run start fee. A run that returns zero reviews is never charged — that's enforced in code, not in a policy document.

Maintained by Godberry Studios. Questions, bugs, weird places that won't scrape: hello@godberrystudios.com.

The short version, for people who evaluate scrapers for a living

• You can verify everything below before spending a cent. The free Apify plan runs this actor capped at 10 reviews / 1 place — enough to confirm the output shape, field population, and date handling on a place you know.
• No data, no charge. The billing event fires once per place, after reviews are extracted. Failed runs and zero-review results cost $0. (If you ever see a charge on an empty dataset, send us the run ID — that's a refund and a P0 bug.)
• Our 30-day success rate is ~78%. The category leader publishes 99.5%. We explain the gap below instead of hiding it.
• The break-even against per-review pricing is ~417 reviews per place. Below that, a per-review competitor is cheaper on raw cost and we say so. Above it, the flat fee wins — up to 12× at the 5,000-review cap.
• Against Google's official Places API there is no contest on completeness: the API returns at most 5 truncated reviews per place, at any price. If you need more than 5 full-text reviews, the official route doesn't exist.

Quickstart (30 seconds)

1. Open Google Maps, click any business.
2. Copy the URL from the address bar.
3. Paste it into placeUrls and click Start.
4. Download the dataset as JSON, CSV, or Excel from the run page.

You can also pass short links (maps.app.goo.gl/...), Place IDs (ChIJ...), CIDs, or plain business names ("Lokys restaurant Vilnius") — the scraper resolves them the same way a human would. Multiple places per run is fine.

Input

{
  "placeUrls": [
    "https://www.google.com/maps/place/Katz's+Delicatessen/@40.7223234,-73.9873893",
    "Lokys restaurant Vilnius",
    "ChIJm77V--yUC0cRwEg_TQAef9Q"
  ],
  "maxReviewsPerPlace": 100,
  "sortBy": "newest",
  "onlyWithText": false,
  "language": "en"
}

Field	Default	Notes
placeUrls (required)	—	Maps URLs, short links, Place IDs, CIDs, or business-name queries
maxReviewsPerPlace	100	Max 5,000. Set to 50 or less to hard-pin every place to the $0.05 tier — see Pricing
sortBy	newest	relevant, newest, highest, lowest
onlyWithText	false	Skip star-only reviews
language	all	Locale code (en, de, fr, ...) — filters reviews and sets Google's UI locale
flattenForSpreadsheet	false	Joins the reviewImages array into one pipe-separated string so CSV/Excel exports cleanly

Output

One JSON row per review. Real output, not a mock:

{
  "placeUrl": "https://www.google.com/maps/place/Lokys/@54.6799344,25.2863904,17z/...?hl=en",
  "placeName": "Lokys",
  "placeAddress": "Stiklių g. 8, Vilnius, 01131 Vilniaus m. sav.",
  "placeOverallRating": 4.6,
  "placeTotalReviews": 14913,
  "reviewerName": "George Markopoulos",
  "reviewerUrl": "https://www.google.com/maps/contrib/103847265190284736512/reviews",
  "reviewerTotalReviews": 52,
  "reviewerIsLocalGuide": true,
  "reviewRating": 5,
  "reviewText": "Eating here is a reason by itself to visit Vilnius... believe me, the price is good for the quality of the taste.",
  "reviewDate": "2026-04-16T14:16:24.804Z",
  "reviewRelativeDate": "18 hours ago",
  "reviewLikes": 0,
  "ownerResponse": null,
  "ownerResponseDate": null,
  "reviewImages": ["https://lh3.googleusercontent.com/..."],
  "scrapedAt": "2026-04-17T08:16:24.804Z"
}

Field notes worth knowing before you build on this:

• reviewText is the full text — the scraper clicks "More" before extracting. Star-only reviews have empty text (filter them with onlyWithText).
• reviewDate is an ISO timestamp derived from Google's relative date ("2 months ago") and the scrape time, accurate to ±½ of the stated unit. Google does not render exact absolute dates in the DOM — no scraper can give you better than this, regardless of what their listing says. Relative dates are parsed across six locales (EN, DE, FR, ES, IT, PT); outside those, reviewDate is empty and you fall back to reviewRelativeDate, which is always present.
• ownerResponse is null when the owner never replied. That's data, not a bug.
• Download from the run page as JSON, JSONL, CSV, Excel, HTML, RSS, or XML — no code needed.

Pricing — the exact math

Two billable events, charged once per place, based on how many reviews you actually receive (not how many you requested):

Reviews extracted from a place	You pay	Effective per review
1–50	$0.05	$0.05 → $0.001
100	$0.25	$0.0025
417	$0.25	$0.0006 ← break-even vs per-review pricing
1,000	$0.25	$0.00025
5,000 (cap)	$0.25	$0.00005 — that's $0.05 per 1,000 reviews

No actor-start fee, no compute add-on surprises beyond Apify's standard platform usage. A place you ask 500 reviews from that only has 30 bills at $0.05, not $0.25.

Cost-control recipe: set maxReviewsPerPlace: 50 and every place in the run bills at exactly $0.05. For a 200-place run, your worst case is $10.00, known before you press Start.

Where we win, where we lose — with numbers

The biggest per-review competitor (compass/Google-Maps-Reviews-Scraper — 99.5% success, 4.79★ across 167 reviews; credit where due) charges from $0.0006 per review (declining to $0.00015 at high monthly volume) plus $0.00005 per start. Here is the honest head-to-head at their entry rate:

Job	This actor	Per-review @ $0.0006	Cheaper
1 place × 20 reviews	$0.05	~$0.012	them, 4×
200 places × 50 reviews	$10.00	~$6.01	them, 1.7×
1 place × 417 reviews	$0.25	~$0.25	tie — the break-even
1 place × 2,400 reviews	$0.25	~$1.44	us, 5.8×
10 places × 5,000 reviews	$2.50	~$30.00	us, 12×

Read that table before you buy. If your workload is many places × few reviews each — say, the newest 20 reviews across a thousand locations — a per-review actor is the cheaper tool and you should use one. This actor is priced for depth: complete review histories of specific places, where flat-fee pricing means a 5,000-review chain costs the same $0.25 as a 51-review café, and your bill is a function of place count, not whatever review counts Google happens to hold.

(At their high-volume floor of $0.00015/review the break-even moves to ~1,667 reviews per place — we still win 3× at the 5,000 cap.)

Versus the official Google Places API

Google's Place Details API returns at most 5 reviews per place, with truncated text, at roughly $17 per 1,000 requests — and requires an API key tied to a GCP billing account. There is no parameter, tier, or budget that gets you review #6. If your requirement is "all the reviews of this place," the official API is not a competitor; it's a different (and much smaller) product.

Free vs paid Apify plan

On Apify's free plan this actor is capped at 10 reviews / 1 place per run — deliberately, so you can verify the output shape, dates, and field population at $0 risk before committing. Full extraction (5,000 reviews/place, unlimited places) unlocks on any paid Apify subscription. The per-place prices above apply on every paid plan.

Use cases

• Reputation management — monitor what customers say about your locations.
• Competitor analysis — compare review sentiment and owner-response rates across rivals.
• Lead generation — find businesses with poor reviews that need your service.
• AI & sentiment pipelines — full review text is exactly what NLP models want; the truncated API previews are not.
• Market research & local SEO — track review velocity, ratings drift, and response behavior in any industry.

Success rate and failure modes — read this before complaining, or instead of it

Our published 30-day success rate is ~78%. The category leader shows 99.5%. Two reasons, neither of them hidden:

1. Strict failure semantics. When extraction yields zero reviews without strong evidence the place genuinely has none, we mark the run failed rather than returning an empty "success." Some scrapers report a green run with an empty dataset; we think that's worse than an honest red. Verified-empty places (positive evidence of 0 reviews) are recorded as uncharged successes.
2. Google's anti-bot rotation. Google periodically serves interstitial "sorry" pages to datacenter traffic. v0.3.4 added proxy rotation, which is improving the rate; the residual is the main driver of the gap.

The practical consequence for you: a green run means you got real data; a red run cost you $0. The charge event physically cannot fire before reviews are extracted (and if billing itself fails, we abort delivery rather than hand over data uncharged — you'll never get an inconsistent bill).

Failure mode	What happens	You pay	What to do
URL doesn't resolve to a specific place	Run fails with a clear message	$0	Open Maps, click the place, copy the URL from the panel
Landmark without a Reviews tab (Eiffel-Tower-type pages)	Extraction unreliable; run fails	$0	Scrape a specific business inside the landmark instead
Google anti-bot interstitial	Retried with rotated proxy; fails if persistent	$0	Retry after a few minutes; email us for high-volume configs
Place genuinely has 0 reviews	Recorded as a verified-empty success	$0	Nothing — that's the correct answer
Place has 100K+ reviews	Works, but takes several minutes (Google throttles its own virtualized list)	normal	Be patient or cap maxReviewsPerPlace
Review locale outside EN/DE/FR/ES/IT/PT	reviewDate empty	normal	Use reviewRelativeDate (always present)

Known limitations

• 5,000 reviews per place is Google's display ceiling, not ours. Places with 200K reviews expose ~5K through the Maps UI. Any actor claiming more is scraping the same wall.
• reviewDate is approximate (±½ unit, derived from relative dates) — see Output notes. Exact timestamps don't exist in the DOM.
• Review text comes in the locale Google renders. Pass language: "en" to get Google's English translations where available.
• Regression-tested against real Google Maps in 11 countries (US, UK, DE, FR, IT, ES, JP, AU, RU, CZ, LT) across Latin, Cyrillic, and Japanese scripts — typical run speed is ~100 reviews in ~30 seconds. Countries and place types outside that test matrix can still surface UI variants we haven't seen; that's what the support address is for.

FAQ

Is the fee per review or per place? Per place. 5,000 reviews from one place costs $0.25 total. The per-review numbers in the pricing table are arithmetic, not billing units.

What happens if a run fails? You pay nothing. The charge event fires only after reviews are extracted for a place. This is in the actor's source, not just this README.

Why is your success rate 78% when others show 99%+? Because we count differently: zero-data outcomes are failures here, not empty successes, and Google's anti-bot pages land as honest reds. See "Success rate and failure modes" above for the full accounting. We'd rather you know.

How do I guarantee the $0.05 price? Set maxReviewsPerPlace: 50. Every place then bills the small tier, hard cap, no exceptions.

Can I really get all 5,000 reviews of a big place? Yes — that's the standard $0.25 case. Above 5,000, Google itself stops serving reviews through Maps; nobody can scrape past that.

How fresh is the data? Every run scrapes Google Maps live at the moment you press Start — nothing is cached or pre-collected. With sortBy: "newest", the first row of your dataset is the newest review on the place, often minutes old.

Can I get only new reviews since my last run? There's no built-in incremental sync yet. The practical pattern: run with sortBy: "newest" and maxReviewsPerPlace: 50, then dedupe downstream on reviewerUrl + reviewRelativeDate or the review text. Because a ≤50-review pull is a flat $0.05, a daily "newest 50" check costs $0.05 per place per day — cheap enough to schedule. If incremental mode matters to you, email us; it's on the roadmap and customer demand sets the order.

Why not just use the official Places API? If 5 truncated reviews per place are enough for you, do — it's Google-sanctioned. If you need review #6 or the full text of review #1, the API has no option at any price.

How accurate are the dates? reviewDate is ±half of Google's stated unit ("2 months ago" → ±2 weeks), parsed across 6 locales. reviewRelativeDate is Google's raw string, always present. No scraper can do better; Google doesn't render exact dates.

Can I export to CSV or Excel? Yes — every Apify dataset exports to CSV/Excel/JSON/JSONL from the run page. Set flattenForSpreadsheet: true so the image-URL array becomes one delimited cell instead of a JSON blob.

What does the free Apify plan get me? 10 reviews from 1 place per run — enough to validate the output shape on a place you know before paying for an Apify subscription.

Is scraping reviews legal? What about GDPR? The actor reads publicly visible content. Reviews contain personal data (reviewer names, profile links); if you store or process them, you are the controller — ensure a lawful basis and honor deletion requests. Don't use this to automate writing or rating reviews; that violates Google's ToS and consumer-protection law in most jurisdictions. Provided as-is, MIT-licensed.

Related actors from Godberry Studios

• Google Play Reviews Scraper — same discipline, applied to app reviews on Google Play, at $0.10 per 1,000 reviews.
• Google Maps Leads Scraper — turn Maps searches into business lead lists (name, category, rating, address, hours) at $0.0015/lead.
• Yelp Scraper — business profiles, reviews, menus, and photos from Yelp's regional domains.

If this saved you a GCP billing setup

Leave a ⭐ rating on this page — Store ratings are how small, honest actors get found next to 42,000-user incumbents. If instead it failed on a place, don't rate it one star into the void: email the run ID to hello@godberrystudios.com first. Selector regressions get fixed fast, and we typically respond within 24 hours.

Support

Email hello@godberrystudios.com with: (1) the input you used, (2) the Apify run ID, (3) what you expected. Reproducible reports with run IDs go to the front of the queue.