How to scrape Google Maps places, reviews, and contact data

What data does the Google Maps scraper API return?

Every place in the dataset is a flat JSON record built from the Google Maps listing, not a raw HTML page. The core fields are title, category, address, phone, website, review_rating, review_count, status, description, and price_range. Location comes as latitude, longitude, plus_code, and an IANA timezone, and every row keeps a direct link back to the place on Google Maps plus Google's numeric cid identifier.

Two fields are lists rather than scalars. open_hours is keyed by weekday, and images holds up to 5 photo URLs per place. reviews is null unless you enable review scraping, in which case it carries the top 10 reviews for that listing.

Each record also stores search_query and an ISO scraped_at timestamp, so you can merge several runs into one table and still know which query produced which row and when. The dataset exports as JSON, CSV, or Excel, or you can read it item by item through the Apify API.

• Contact fields: phone, website, and full street address for lead lists
• Reputation fields: review_rating on a 1.0 to 5.0 scale plus total review_count
• Location fields: latitude, longitude, plus_code, and timezone for mapping
• Hours and status: open_hours per weekday and an Open / Closed / Temporarily closed status
• Media: up to 5 image URLs per place, plus the top 10 reviews when enabled
• Provenance: search_query and scraped_at on every row

How much does it cost to scrape Google Maps places?

Pricing is pay per result at a flat $0.003 per place, taken from the actor's live Apify billing as of August 2026. There are no volume tiers: the first place and the ten thousandth place cost the same. The only other event is an actor start charge of $0.00005 per run, which is small enough to ignore in any budget. You are billed only for places actually written to the dataset, and no Google Cloud account or API key is involved.

The math is easy to check. A quick 50-place test costs $0.15, a full single query of about 120 places costs $0.36, and 1,000 places cost $3.00. At 5,000 places the run costs $15.00, and 10,000 places cost $30.00, which is the same $0.003 per place at every scale.

The Apify Store lists the actor at $0.003 per place as its headline event price and shows 559 completed runs as of August 2026. The billing lists no separate per-review price; the input notes flag review scraping as slower, so budget extra run time rather than extra spend per place.

• Flat rate: $0.003 per place at any volume (live Apify billing, August 2026)
• Actor start event: $0.00005 per run, negligible in practice
• No volume tiers, so the per-place cost never changes with run size
• Worked examples: 1,000 places = $3.00, 5,000 = $15.00, 10,000 = $30.00
• You pay only for places delivered to the dataset, per the pay-per-result model

Why does one Google Maps search stop at about 120 places?

Google Maps itself renders only about 120 results for any one search no matter how far you scroll, and the actor's input notes flag the same ceiling. Setting maxResults to 500 on a single broad query like restaurants in New York will not return 500 places, it will return roughly 120 and stop. This is a property of Google Maps, not a quota on the actor.

The way around it is narrower queries. Split by neighborhood (restaurants in Williamsburg Brooklyn), by category (vegan restaurants in New York, pizza in New York), or by both, and run one query per slice. Ten neighborhood queries at up to 120 places each yield close to 1,000 places, with each run billed at the same flat $0.003 per place.

Deduplicate on the cid or link field when merging slices, because a business near a neighborhood boundary can appear in two searches. Concurrency defaults to 5 parallel place fetches and the input caps it at 10, the level where the actor's notes say Google rate limiting begins.

• Roughly 120 places per query is a Google Maps display limit, not an actor limit
• maxResults accepts 1 to 500, default 20, but a single query rarely exceeds about 120
• Split by neighborhood, district, postcode, or sub-category to multiply coverage
• Merge runs on the cid or link field to drop duplicates across overlapping areas
• Keep concurrency at the default 5; the input caps it at 10 to avoid rate limiting

How do you scrape Google Maps reviews with the actor?

Reviews are off by default because they add work per place. Set scrapeReviews to true and the actor opens each listing's review panel and captures the top 10 reviews, each with reviewer name, star rating, date, and review text. The input notes put the overhead at about 3 seconds per place, so 100 places with reviews add roughly 5 minutes to a run.

The reviews field is an array nested inside the place record, so a 20-place coffee shop query returns 20 rows and up to 200 review objects. There is no separate per-review charge in the actor's billing, the flat $0.003 place price covers them.

Ten reviews per place is enough to sample sentiment, catch recent complaints, or feed a summarization step in an agent pipeline. It is not a full review history, so for a business showing 843 reviews you get the 10 that Google surfaces first, not all 843.

• Enable with scrapeReviews: true in the input JSON
• Each review carries reviewer name, rating, date, and text
• Up to 10 reviews per place, nested in the reviews array
• Adds about 3 seconds per place, per the actor's input notes
• Pair with review_count and review_rating for a complete reputation snapshot

How do AI agents and scripts call the Google Maps scraper?

The actor is built to be called by code and by agents, not only from the Apify console. Over REST you POST the input JSON to the actor's run-sync-get-dataset-items endpoint with your Apify token and receive the place records in the same response, which fits a serverless function or a cron job. The Apify CLI and the JavaScript and Python client libraries wrap the same call.

For AI agents, the Apify MCP server exposes this actor as a tool. Point Claude, Cursor, or any MCP-compatible client at the MCP URL with openclawai/google-maps-scraper in the tools list, and the agent can read the input schema, run a query, and consume the dataset without custom glue code.

The input is small enough for an agent to construct reliably. query is the only required field, while maxResults (default 20, maximum 500), concurrency, scrapeReviews, and proxyConfiguration are optional. Residential proxies are prefilled in the default input because Google's bot detection is aggressive.

• REST: one POST to run-sync-get-dataset-items returns the full dataset
• MCP: https://mcp.apify.com/?tools=fetch-actor-details,openclawai/google-maps-scraper
• Only query is required; maxResults defaults to 20 and caps at 500
• concurrency defaults to 5 and the input caps it at 10, where rate limits start
• Residential proxy configuration is prefilled by default

Questions, answered

Keep reading