Google Maps Place Reviews Scraper

Export Google Maps reviews for any place you choose — restaurants, hotels, shops, clinics, attractions or your own business locations. Give it Google Maps place URLs, place IDs or a business name with a city, and get one clean row per review: review text, star rating, reviewer, exact date, owner response, review photos, per-aspect ratings (Food, Service, Atmosphere…), plus place context such as rating, total review count, address, category and coordinates.

It is a lightweight HTTP scraper: no browser, no Google login, no API key. A typical run exports 300 reviews per place in a few seconds.

What does Google Maps Place Reviews Scraper do?

For every place you give it, the Actor:

1. Resolves the place (full Maps URL, short maps.app.goo.gl link, ?cid= link, place_id: link, place ID, or "business name + city" search).
2. Reads the place header: name, address, average rating, total number of reviews, categories, website, phone and coordinates.
3. Pages through the place's public Google reviews in the order you choose (Newest, Most relevant, Highest rating, Lowest rating).
4. Applies your optional filters (start date, star ratings, keyword) and saves each matching review as a dataset row.

You can then download the dataset as JSON, CSV, Excel or HTML, or send it to Google Sheets, Slack, a database or your BI tool.

Who is it for?

• Reputation and customer-experience teams tracking new reviews and owner responses across locations every day or week.
• Multi-location brands and franchises comparing ratings, complaints and service aspects between branches.
• Agencies and local SEO consultants auditing client and competitor review profiles and review velocity.
• Market and competitor researchers collecting review text for sentiment analysis, topic modeling or LLM summarization.
• Hospitality, healthcare and retail analysts who need Food / Service / Atmosphere / Rooms aspect ratings and visit context (dine-in vs. takeout, price per person, wait time).
• Data scientists building labeled review datasets in many languages, with Google's translation alongside the original text.

Why use this scraper?

• Fast and cheap — plain HTTP requests to Google's public reviews feed, 50 reviews per request, 256 MB memory.
• Exact timestamps — publishedAtDate is Google's exact timestamp, not just "3 weeks ago".
• Original + translated text — the original review is always in text; when it's in another language you also get Google's translation into your chosen language.
• Owner responses included on the same row.
• Rich context — per-aspect ratings, visit details, review photos, likes, Local Guide status, reviewer review/photo counts.
• Monitoring-friendly — Newest sort plus a start date stops paging at the first older review, so daily runs read and pay only for new reviews plus the small per-place fee.
• GDPR switch — turn off personal data to drop reviewer names, IDs, profile links and avatars.
• Clear failures — places that don't exist are reported as "not found" instead of silently returning nothing.

What data can you extract from Google Maps reviews?

Field	Description
reviewId, reviewUrl	Stable Google review ID and direct link
stars	Star rating 1–5
text	Original review text (null for rating-only reviews)
textTranslated, originalLanguage, translatedLanguage	Google translation and language codes
publishedAtDate, publishAt	Exact ISO timestamp and the relative text Google shows
likesCount	"Helpful" likes
name, reviewerId, reviewerUrl, reviewerPhotoUrl	Reviewer identity (optional, see personal data)
reviewerNumberOfReviews, reviewerNumberOfPhotos, isLocalGuide	Reviewer profile signals
responseFromOwnerText, responseFromOwnerAgo	Owner reply and its relative time
reviewImageUrls	Photos attached to the review
reviewDetailedRating	Aspect ratings, e.g. {"Food": 5, "Service": 4}
reviewContext	Visit details, e.g. order type, meal type, price per person
title, address, categoryName, categories	Place name, address and categories
totalScore, reviewsCount	Place average rating and total review count
placeId, fid, cid, url, location, website, phone	Place identifiers, link, coordinates and contacts
searchString, language, scrapedAt	Which input produced the row, request language, collection time

How much does it cost to scrape Google Maps reviews?

This Actor uses pay-per-event pricing: a small fee per run (which includes the first place), a small fee for each additional place, and a fee per saved review. Reviews are charged only when they pass your filters and are saved to the dataset.

Event	Free plan	Bronze	Silver	Gold / Platinum / Diamond
Run start (once per run, includes the first place)	$0.0005	$0.0005	$0.0005	$0.0005
Additional place looked up	$0.00035372	$0.00030758	$0.00023992	$0.00018455
Review saved	$0.0003404	$0.000296	$0.00023088	$0.0001776

"Additional place" is charged once for each distinct place input after the first, whether or not any reviews match your filters, because the place is still looked up and its reviews are read. Inputs that Google can't find count as a place too. Exact repeats of the same input are looked up and charged only once.

Cost examples on the Bronze tier:

• 100 reviews of one place: $0.0005 + 100 × $0.000296 ≈ $0.030
• 1,000 reviews from 10 places (100 each): $0.0005 + 9 × $0.00030758 + 1,000 × $0.000296 ≈ $0.30
• Monitoring 50 locations daily, 5 new reviews each: $0.0005 + 49 × $0.00030758 + 250 × $0.000296 ≈ $0.089 per run
• 10,000 reviews: ≈ $2.96 plus the place fees

On the Apify Free plan's monthly credit you can export well over ten thousand reviews. Platform compute is included in these event prices.

How to scrape Google Maps reviews

1. Open the Actor in Apify Console and click Try for free.
2. Add places: paste Google Maps place URLs, add place IDs, or type "business name + city" into Search queries.
3. Set Max reviews per place (0 = all reviews Google lists).
4. Choose a sort order. Use Newest for monitoring.
5. Optionally set Only reviews published since, Star ratings or a Keyword filter.
6. Click Start and download results from the Output tab as JSON, CSV or Excel.

Input parameters

Parameter	Type	Description
startUrls	array	Google Maps place URLs: full /maps/place/... URLs, maps.app.goo.gl share links, ?cid= links, place_id: links. One place per URL.
placeIds	array	Google place IDs (ChIJ...) or feature IDs (0x...:0x...).
searchQueries	array	"Business name + city". Each query is resolved to the single best-matching place.
maxReviews	integer	Reviews saved per place after filters. Default 100; 0 = all.
reviewsSort	string	newest (default), mostRelevant, highestRanking, lowestRanking.
reviewsStartDate	string	YYYY-MM-DD or relative (30 days, 2 weeks, 6 months, 1 year).
reviewsFilterString	string	Keep reviews containing this phrase (case-insensitive, original or translated text).
starRatings	array	Keep reviews with these ratings, e.g. ["1","2"].
language	string	Interface/translation language, e.g. en, de, pt-BR. Default en.
personalData	boolean	Include reviewer name, ID, profile URL and photo. Default true.
proxyConfiguration	object	Apify Proxy (datacenter) by default. Residential and Google SERP proxy groups are not supported (the run stops at once with a clear error); your own proxy URLs work.

Example input:

{
    "startUrls": [
        { "url": "https://www.google.com/maps/place/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004" }
    ],
    "placeIds": ["ChIJCar0f49ZwokR6ozLV-dHNTE"],
    "searchQueries": ["Cafe Sacher Wien"],
    "maxReviews": 300,
    "reviewsSort": "newest"
}

Output example

One real row (reviewer identity replaced with placeholders, long texts shortened):

{
    "title": "Café Sacher",
    "address": "Philharmoniker Str. 4, 1010 Wien, Austria",
    "placeId": "ChIJI85wbpwHbUcR2nlviUzwg9s",
    "fid": "0x476d079c6e70ce23:0xdb83f04c896f79da",
    "cid": "15817750527769278938",
    "categoryName": "Cafe",
    "categories": ["Cafe"],
    "totalScore": 3.9,
    "reviewsCount": 20716,
    "location": { "lat": 48.2039459, "lng": 16.3698418 },
    "phone": "+43 1 514560",
    "url": "https://www.google.com/maps?cid=15817750527769278938",
    "reviewId": "ChdDSUhNMG9nS0VJQ0FnSUMtZ2NYYnhBRRAB",
    "stars": 1,
    "text": "La acomodadora, una señora rubia, nos atendió fatal, tuvimos que esperar…",
    "textTranslated": "The hostess, a blonde woman, treated us terribly. We had to wait…",
    "originalLanguage": "es",
    "translatedLanguage": "en",
    "publishAt": "Edited a day ago",
    "publishedAtDate": "2026-10-28T08:36:47.648Z",
    "likesCount": 0,
    "name": "Reviewer Name",
    "reviewerId": "1145235341000000000",
    "reviewerUrl": "https://www.google.com/maps/contrib/1145235341000000000/reviews?hl=en",
    "reviewerNumberOfReviews": 2,
    "reviewerNumberOfPhotos": 0,
    "isLocalGuide": false,
    "responseFromOwnerText": "Thank you very much for your review. I truly regret that your visit…",
    "responseFromOwnerAgo": "3 years ago",
    "reviewImageUrls": [],
    "reviewDetailedRating": { "Food": 2, "Service": 1, "Atmosphere": 2 },
    "reviewContext": { "Order type": "Dine in", "Meal type": "Other", "Price per person": "€10–20" },
    "reviewOrigin": "Google",
    "searchString": "Cafe Sacher Wien",
    "language": "en",
    "scrapedAt": "2026-10-30T07:33:25.311Z"
}

The dataset has three views: Reviews (main table), Reviewers and Place context.

Tips, limits and how failures are reported

• Monitoring: schedule the Actor daily with reviewsSort: "newest" and reviewsStartDate: "2 days". Deduplicate across runs by reviewId.
• Edited reviews: Google reports the time of the last edit; publishAt then starts with "Edited". The start-date filter uses that timestamp.
• Rating sorts: Google's Highest/Lowest rating lists show a limited number of reviews per star level, so use Newest or Most relevant to export a place's complete history.
• Filters are applied after download, with a read limit. Any filter (start date, keyword or stars) reads up to 300 reviews per place, then continues only while at least one review in 15 matches. Exceptions where the scraper stops exactly instead: a start date with Newest sort stops at the first older review, and a star filter with Highest/Lowest rating sort stops when the sorted list passes your ratings. So a start date with Most relevant, Highest or Lowest sort can miss older matching reviews deep in the list; use Newest sort for complete date windows. For 1–2 star reviews, combine the star filter with Lowest rating sort. The log shows how many reviews were read and saved per place.
• Search queries pick one best match. For chains ("Starbucks Seattle") this is Google's top-ranked branch; add the street to target a specific branch, or use its place URL. Category searches like "plumbers in Austin" are not expanded into many places; use place URLs for that.
• Not found: a place ID or URL that Google doesn't know, or a query with no matching reviewed place, is logged and counted as "not found" in the final status message; other places continue.
• Errors: rate-limit and network errors are retried with a fresh proxy session. If every place fails, the run fails with a clear message instead of finishing empty.
• Maximum cost per run: if you set one, the run stops when it is reached and keeps the reviews saved so far. The final status message says "Partial results" and how many place inputs were not processed.
• Proxy: the default Apify datacenter proxy works for Google reviews. Residential and Google SERP proxy groups are rejected with a clear error before any work starts and before the start fee, because they cost more per run than this Actor's prices cover.
• Rating-only reviews (no text) are included with text: null. Use the keyword filter or post-processing to drop them.

Integrations

• Google Sheets: send new reviews to a sheet with the Apify Google Sheets integration and build a reputation dashboard.
• Slack / email alerts: use a webhook on run success to post new 1–2 star reviews to a Slack channel for fast owner responses.
• Zapier, Make, n8n: trigger CRM tickets or support tasks for negative reviews.
• BI and warehouses: load the dataset into BigQuery, Snowflake or Postgres and track rating trends per location.
• LLM pipelines: feed text/textTranslated into an LLM to summarize complaints, extract topics or draft owner replies.

Use the API

cURL:

curl -X POST "https://api.apify.com/v2/acts/automation-lab~google-maps-place-reviews-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Katz'\''s Delicatessen New York"],"maxReviews":100,"reviewsSort":"newest"}'

JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/google-maps-place-reviews-scraper').call({
    placeIds: ['ChIJCar0f49ZwokR6ozLV-dHNTE'],
    maxReviews: 200,
    reviewsStartDate: '30 days',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].text);

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("automation-lab/google-maps-place-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.google.com/maps?cid=15817750527769278938"}],
    "maxReviews": 100,
    "starRatings": ["1", "2"],
    "reviewsSort": "lowestRanking",
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["stars"], review["text"])

Use with AI agents via MCP

Connect the Actor to Claude, Cursor or any MCP client through the Apify MCP server.

Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/google-maps-place-reviews-scraper"

Claude Desktop / Cursor / VS Code JSON configuration:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/google-maps-place-reviews-scraper"
        }
    }
}

Selecting this Actor also adds the run-status, dataset and key-value store helper tools. A safe recipe for agents:

1. Bound the run before starting it. Set maxReviews (for example 50) and a small number of places, so the run's row count is known in advance: at most places × maxReviews rows. Optionally set a maximum cost per run in the call options.
2. Start one run and keep its run ID. If the call returns before the run finishes, poll that same run with get-actor-run (backoff 2–10 s) until it is SUCCEEDED, FAILED, ABORTED or TIMED-OUT, with an overall deadline you choose (for example 5 minutes). Never start a duplicate run because a call timed out; if the deadline passes, report the run ID and its current status to the user instead.
3. Read results in pages, within a total budget. Use get-dataset-items with explicit limit (for example 20), offset and fields (for example title,stars,text,publishedAtDate,responseFromOwnerText). Stop when you reach your total row budget (for example 200 rows) or byte budget (for example 100 KB), and keep the rest in Apify storage.
4. Check the size of each page before it reaches the model. Row limits do not bound bytes: one review can be several KB, so 20 rows is usually under 20 KB but not always. If your MCP client or host can intercept tool responses, measure each page's serialized UTF-8 size before passing it to the model. When a page would exceed the remaining byte budget, either fetch fewer rows (smaller limit, or drop text/textTranslated from fields) or pass only the rows that fit and record the rest as omitted. A single row larger than the per-page budget should be summarized or skipped and reported as omitted, not passed in whole. Clients that cannot intercept tool responses cannot guarantee a hard byte ceiling; there, keep limit small and fields narrow.
5. Report what was read and what was not. Tell the user the dataset ID, the total row count (itemCount from get-dataset-info), the next unread offset (the dataset offset where you stopped, not the number of rows you passed on) and how many rows you omitted for size. Say "partial" whenever you stop before the end of the dataset.
6. Report partial runs honestly. The run's status message lists how many places were saved, not found and failed. If the run stopped at the maximum cost per run, the status message starts its last sentence with "Partial results" and says how many place inputs were not processed. If the run FAILED or TIMED-OUT, its dataset can still hold reviews saved before it stopped; say that the results are partial and which places are missing.
7. Large exports (thousands of reviews) should be downloaded by the user from the dataset (CSV/JSON/Excel) rather than read into the model context.

Example prompts:

• "Get the 50 newest Google reviews for Katz's Delicatessen in New York and summarize the main complaints."
• "Export all 1 and 2 star reviews from the last 3 months for these three hotel URLs and group them by topic."
• "Compare Food, Service and Atmosphere ratings for Café Sacher and Café Central in Vienna."

Is it legal to scrape Google Maps reviews?

This Actor collects publicly visible reviews that anyone can see without logging in. It does not log in, bypass paywalls or access private data. Reviews do contain personal data (reviewer names and profile links), so if you work under GDPR or similar laws, make sure you have a legitimate purpose, keep only what you need, or turn off Include reviewer personal data. Respect Google's terms and the reviewers' rights when you republish content. If unsure, consult your lawyer.

Error diagnostics and privacy

If a run or a place fails, the Actor sends a sanitized error report (error message, stack trace, Actor/run/build IDs and a scrubbed copy of the input with secrets, cookies, tokens and email-like values removed) to the operator's private GlitchTip instance. Reports are kept for 30 days and used only to fix bugs. Review texts and reviewer data are never included.

FAQ

How many reviews can I get per place? Set maxReviews to 0 to export all reviews Google lists with Newest or Most relevant sort. Large places (tens of thousands of reviews) take longer; for monitoring, use a start date.

Can I get reviews in a specific language? Original text is always kept. Set language (for example de) to receive Google's translation into that language in textTranslated for reviews written in other languages.

Why did a place return fewer reviews than its review count? Google's review count includes rating-only and hidden reviews, and rating sorts show a limited number of reviews per star level. Filters also reduce the number saved. The log shows how many reviews were read and saved per place.

My search query found the wrong branch. What should I do? Add the street or neighborhood, or paste the exact Google Maps place URL instead.

The run says "not found" for my input. Check that the URL opens a single place on Google Maps (not a search list) and that the place ID is complete. For search queries, use the exact business name and city.

Related scrapers

• Google Search Results Scraper — organic results, ads and local packs from Google Search.
• Bing Maps Places Scraper — business listings from Bing Maps.
• Booking.com Reviews Scraper — hotel guest reviews from Booking.com.
• Airbnb Reviews Scraper — guest reviews for Airbnb listings.
• Amazon Reviews Scraper — product reviews from Amazon.