Google Reviews Scraper

Pull the full review history of any Google Maps place as structured JSON — a flat fee per place, no Google API key, and failed runs cost $0.

This Actor extracts every review the Google Maps UI exposes for a business — full review text (auto-expanded past the "More" cut-off), star rating, dates, reviewer profile, owner responses, likes, and photos — and returns it as clean JSON, CSV, or Excel. No GCP project, no Places API key, no per-review meter.

Maintained by Godberry Studios. Bugs, weird places that won't scrape, or feature requests: hello@godberrystudios.com — reproducible reports with a run ID typically get a reply within 24 hours.

---

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

• You can verify everything below before spending a cent. On Apify's free plan this Actor runs capped at 10 reviews / 1 place — enough to confirm the output shape, field population, and date handling on a place you already know.
• No URL hunting, no Place ID, no Google API key. Paste a plain business name — "Katz's Delicatessen, New York" — and press Start. (Maps URLs, short links, Place IDs, and CIDs all work too.)
• 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 the run ID — that's a refund and a P0 bug.)
• A green run means complete, real data — never a half-empty dataset dressed up as "success." We mark partial or anti-bot-blocked extractions as honest $0 failures, which is exactly why our published 30-day success rate (~78%) reads lower than competitors who score empty runs as wins. The trade you get: when a run is green, the data is actually there. (Full accounting below.)
• 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 review #6 or the full text of review #1, the official route doesn't exist.

Quickstart (30 seconds)

1. Open Google Maps and click any business.
2. Copy the URL from the address bar.
3. Paste it into placeUrls and press 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 a plain business name ("Lokys restaurant Vilnius") — the scraper resolves them the same way a human would. Multiple places per run is fine.

What does this Actor do?

Give it a Google Maps URL, a short link, a Place ID, a CID, or a business name, and it opens the place on Google Maps live, sorts the reviews the way you asked, clicks "More" on each one to capture the complete text, and writes one structured row per review to your dataset. It runs against real Google Maps at the moment you press Start — nothing is cached or pre-collected — so with sortBy: "newest" the first row is often a review only minutes old.

The official Google Places API returns at most 5 truncated reviews per place, at any price. This Actor is the route to review #6 and beyond.

What you get

Every row maps to a real field the scraper populates — no invented columns:

Field	Type	What it is
placeUrl	string	Canonical Google Maps URL of the place
placeName	string	Business name
placeAddress	string	Full street address
placeOverallRating	number	The place's aggregate star rating
placeTotalReviews	number	Total review count Google reports for the place
reviewerName	string	Display name of the reviewer
reviewerUrl	string	Link to the reviewer's Google Maps contributions
reviewerTotalReviews	number	How many reviews that reviewer has written
reviewerIsLocalGuide	boolean	Whether the reviewer is a Google Local Guide
reviewRating	number	Star rating of this individual review (1–5)
reviewText	string	Full review text, auto-expanded (empty for star-only reviews)
reviewDate	string	ISO 8601 timestamp derived from Google's relative date (±½ unit; see notes)
reviewRelativeDate	string	Google's raw relative string ("2 months ago") — always present
reviewLikes	number	Like count on the review
ownerResponse	string | null	The owner's reply text, or null if they never replied
ownerResponseDate	string | null	When the owner replied, or null
reviewImages	string[]	URLs of photos attached to the review
scrapedAt	string	ISO 8601 timestamp of when the row was scraped

Export from the run page as JSON, JSONL, CSV, Excel, HTML, RSS, or XML — no code required.

Use cases

• Reputation monitoring — pull the newest reviews across all your locations on a schedule and route negatives to your team before they spread.
• Competitor analysis — compare review sentiment, rating drift, and owner-response rates across rival businesses in your market.
• Lead generation — find businesses with weak or unanswered reviews that need exactly the service you sell.
• AI & sentiment pipelines — full review text is what NLP and LLM workflows actually need; the truncated API previews aren't enough to summarize or score against.
• Local SEO & market research — track review velocity, response behavior, and ratings trends across an entire industry or geography.

Input

Paste anything that points at a place — a Maps URL is easiest, but Place IDs, CIDs, short links, and business-name searches all resolve the same way a human would.

{
  "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",
  "flattenForSpreadsheet": false
}

Field	Default	Notes
placeUrls (required)	—	One per line. Maps URLs, short links (maps.app.goo.gl/...), Place IDs (ChIJ...), CIDs, or business-name searches. Landmarks like the Eiffel Tower have no Reviews tab — use business pages (restaurants, hotels, shops).
maxReviewsPerPlace	100	1–5,000. Set to 50 or less to pin every place to the $0.05 tier — see Pricing.
sortBy	newest	relevant, newest, highest, or lowest.
onlyWithText	false	Skip star-only reviews that have no text.
language	(all)	Locale code (en, de, lt, …) to filter reviews and set Google's UI locale. Empty = all languages.
flattenForSpreadsheet	false	Joins the reviewImages array into one |-separated string so CSV/Excel exports stay in one cell. Leave off for raw JSON.
proxyConfiguration	Apify datacenter pool	Routes each request through Apify Proxy for fresh IPs — the single biggest reliability lever against Google's rate limiting. Switch to Residential here for the hardest places.

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: true.
• 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 do better, regardless of what a listing claims. 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 / ownerResponseDate are null when the owner never replied. That's data, not a bug.

How it works

1. Resolve — each placeUrls entry (URL, short link, Place ID, CID, or name) is resolved to a specific Google Maps place.
2. Open & sort — the place opens live on Google Maps and reviews are sorted by your sortBy choice.
3. Expand & extract — every review is auto-expanded past the "More" cut-off and parsed into the structured fields above.
4. Bill, then deliver — the per-place charge fires only after reviews are extracted, then the rows are written to your dataset. If billing itself fails, the place is aborted rather than handed over uncharged — so you don't get an inconsistent bill.

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 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 — you pay for what you receive.

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

Where we win, where we lose — with numbers

The biggest per-review competitor charges from ~$0.0006 per review (declining at high monthly volume) plus a small per-start fee. 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 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 totals Google happens to hold.

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 (up to 5,000 reviews/place, unlimited places) unlocks on any paid Apify subscription, where the per-place prices above apply.

Reliability & success rate (the honest version)

The deal here: a green run means you actually got the data. We refuse to mark partial extractions or anti-bot-blocked runs as "success" with a half-empty dataset — those land as honest $0 failures. That's why our published 30-day success rate (~78%) reads lower than category leaders at 99%+: we count honestly, and most of the gap is a deliberate design choice you benefit from:

1. Strict failure semantics. When extraction yields zero reviews without strong evidence the place genuinely has none, we mark that place failed rather than returning an empty "success" — and if no place in the run delivered anything, the whole run fails. Some scrapers report a green run with an empty dataset; we think an honest red is better. Places with positive evidence of 0 reviews are recorded as uncharged successes, not failures.
2. Google's anti-bot rotation. Google periodically serves interstitial "sorry" pages to datacenter traffic. Proxy rotation (added in v0.3.4) is meant to soften this; the residual blocks are the rest of the gap.

The practical consequence for you: a green run means you got real data; a red run cost you $0. The per-place charge fires only after reviews are extracted — it's ordered that way in the Actor's source.

Situation	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 page)	Extraction unreliable; run fails	$0	Scrape a specific business inside the landmark instead
Google anti-bot interstitial	Retried on a rotated proxy session (deeper retry budget for blocks); the place fails if every rotation stays blocked	$0	Retry in 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
Some places fail in a multi-place run	Successful places are delivered; the run finishes green with a status note naming how many failed and why	only the delivered places	Re-run just the failed URLs
Every place fails (all blocked/unresolvable)	Run fails honestly — no empty dataset dressed as success	$0	Check the status message for per-reason counts
Place has 100K+ reviews	Works, but takes several minutes (Google throttles its own 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. A place with 200K reviews exposes ~5K through the Maps UI. Any actor claiming more is scraping the same wall.
• reviewDate is approximate (±½ unit, derived from relative dates). 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 across 11 countries (US, UK, DE, FR, IT, ES, JP, AU, RU, CZ, LT) and Latin, Cyrillic, and Japanese scripts; typical speed is ~100 reviews in ~30 seconds. Place types outside that matrix can surface UI variants we haven't seen yet — that's what the support address is for.

FAQ

Do I need a Google API key? No. This Actor reads Google Maps directly — no GCP project, no Places API key, no billing-account setup. That's the whole point versus the official API.

Is the fee per review or per place? Per place. 5,000 reviews from one place cost $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 enforced by the ordering in the Actor's source, not just promised here.

Why is your success rate ~78% when others show 99%+? Because we count honestly. A run that hit Google's anti-bot wall, or that couldn't return complete data, lands as a red $0 failure here — not a green run with a half-empty dataset. You never get handed a partial result labeled "done," and you never pay for one. See Reliability & success rate above for the full accounting.

How do I get the $0.05 price? Set maxReviewsPerPlace: 50. Every place then bills the small tier, because the $0.05 band covers 1–50 reviews.

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 the moment you press Start — nothing is cached. With sortBy: "newest", the first row is the newest review Google is currently showing for the place, often minutes old.

Can I get only new reviews since my last run? No built-in incremental sync yet. The practical pattern: run sortBy: "newest" with maxReviewsPerPlace: 50 and dedupe downstream on reviewerUrl + reviewRelativeDate or the text. A ≤50-review pull is a flat $0.05, so a daily "newest 50" check costs $0.05 per place per day — cheap enough to schedule. Want native incremental mode? Email us; customer demand sets the roadmap order.

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

Maintenance & changelog

Actively maintained. A smoke test runs known-good places to catch Google selector regressions early, and fixes ship fast when Google changes its DOM.

• v0.3.4 — proxy rotation on retry (mitigates Google's anti-bot interstitials).
• v0.3.3 — stripped a reviewText UI-metadata leak on star-only reviews; added the first unit-test suite.
• v0.3.1 — six-locale relative-date parser (EN/DE/FR/ES/IT/PT); fixed the reviewerUrl regression after Google's <a> → <button> migration; hardened production billing so data is never delivered uncharged.

Found a place that won't scrape? Send the run ID — selector regressions get priority.

Other Actors from Godberry Studios

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

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 — we typically respond within 24 hours.

If this Actor saved you a GCP billing setup, a ⭐ rating on the listing is how small, honest Actors get found next to the big incumbents. If it failed on a place, email the run ID first — we'll fix it faster than a one-star review will.