Best Google Maps APIs in 2026: We Benchmarked 5 Providers on 370+ Live Requests

The official Places API charges $17-$25 per 1,000 requests once the free credit runs out, gates fields behind SKU tiers, and its terms forbid storing what it returns.

So an entire market of scraping APIs exists to sell the same data cheaper. Every one of them claims the crown, and every comparison article ranking them is written by one of the vendors.

This one is different in a verifiable way: we ran five providers against identical Google Maps queries on the same day (2026-08-03), five passes per query, and counted a success only when the fields we needed actually came back. A 200 response with an empty payload is a failure. One provider found that out the hard way.

Provider	Search	Place details	Reviews	Avg response	Cost per 1K	Starting price	Free tier
Scrape.do	100%	100%	100%	8.5s	$1.16	$29/mo	1,000 credits/mo, no card
SerpApi	100%	100%	100%	0.5s	$25.00	$25/mo	250 searches/mo
ScrapingDog	100%	100%	100%	1.6s	$1.00	$40/mo	200-credit trial
Apify	100%	100%	66.7%	23s+	~$1.50/1K places	$29/mo + usage	$5 credit/mo
ScraperAPI	0%	no endpoint	no endpoint	n/a	n/a	$49/mo	1K credits

Yes, that last row says zero percent. On a documented, marketed endpoint. We tested it against ScraperAPI's own docs example to make sure the failure was theirs and not ours. More on that below.

How We Tested

Ten place searches with real commercial variety: coffee shops in Austin, dentists in Brooklyn, hotels in Berlin (gl=de), sushi in Tokyo (gl=jp), pubs in London (gl=gb), and five more. Each query was pinned to a city-center latitude/longitude so every provider answered for the same map viewport instead of whatever its exit IP happened to see.

On top of search: five place-details lookups and three review pulls against stable anchor places (Katz's Delicatessen, the Eiffel Tower, Griffith Observatory, Voodoo Doughnut, the Sydney Opera House), with IDs harvested fresh per provider the same day.

Five passes per query, sequential, 400 ms apart. Apify ran three passes instead of five because each of its calls is a full actor run measured in minutes, and we priced the runs accordingly.

Success was field-based, never status-based:

• A search passed with 5+ places where most carried a name, rating, and address or coordinates.
• A details lookup passed with name, address, and at least three of phone, website, hours, coordinates.
• A reviews pull passed with 3+ reviews each carrying text, author, and rating.

Two transparency notes. We made one harness correction mid-run (ScrapingDog nests reviews under reviews_results, not reviews) and re-ran that whole segment; the corrected 15/15 is what the table shows. And this was a single-day run, so the numbers are a same-conditions snapshot, not a longitudinal average.

The Three Google Maps IDs (and Why They Matter)

Before the rankings, the thing that breaks most Google Maps scraping projects: Google circulates three incompatible identifiers for the same place.

• place_id: the ChIJ... string most developers know from the official API
• data_id (also called fid): a 0xHEX:0xHEX pair
• data_cid: a plain numeric ID

Chaining search into place details into reviews means knowing which endpoint accepts which ID, and providers disagree:

Provider	Place details takes	Reviews take
Scrape.do	place_id or data_cid (not data_id)	data_id, paginated by next_page_token
SerpApi	same engine, type=place	separate reviews engine, keyed by data_id
ScrapingDog	place_id	data_id (first page fixed at 8 reviews)
Apify	no IDs at all; input is search strings	maxReviews on the same run

One reassuring cross-check: for identical queries, all three passing API providers returned identical place_ids. Everyone is parsing the same Google. What differs is how much of it they hand over, how fast, and at what price.

1. Scrape.do

• Trustpilot: 5.0 (68 reviews)
• Capterra: 5.0 (49 reviews)

Scrape.do's Google Maps Scraper API is three endpoints (maps/search, maps/place, maps/reviews) that went 90 for 90 in our benchmark: 100% on search, details, and reviews, field-verified.

The schema is deliberately SerpApi-compatible, which matters more than it sounds. Search items came back with 27 fields including data_cid, service options, and user review snippets; the place endpoint added menus, popular times, and image sets; reviews included owner responses and topic filtering. Teams migrating off SerpApi's pricing can keep most of their parsing code.

The pricing math is the headline. Every call costs 10 credits, so the $29 Hobby plan's 250K credits buy 25,000 calls: $1.16 per 1,000. Pro drops that to $0.79, Business to $0.71. The free tier is 1,000 credits monthly with no card, enough for 100 calls to test every endpoint compared here.

Where it wins:

• Perfect scores across all three surfaces at 1/22nd of SerpApi's price
• IDs chain cleanly: search output feeds the place endpoint feeds the reviews endpoint with no manual conversion
• Identical localization params (gl, hl, ll) across all three endpoints; Berlin and Tokyo queries came back correctly localized

Where it doesn't:

• Slowest of the three passing pure APIs: 8.5s average on search and 17.2s on reviews, with a 28.7s p90. Fine for pipelines, noticeable for interactive use.
• The place endpoint rejects data_id (it wants place_id or data_cid), which trips people coming from SerpApi's reviews flow. The docs also warn about occasional empty-result 502s; we saw none in 90 calls, but build the retry anyway.

2. SerpApi

• Trustpilot: 5.0 (~102 reviews)
• G2: 4.8 (28 reviews)
• Capterra: 5.0 (65 reviews)

SerpApi is the reference implementation everyone else copies, and the benchmark shows why: 100% everywhere, with response times an order of magnitude ahead of the field. Search averaged 460 milliseconds. Sub-second, consistently, helped by their caching layer (repeat searches hit cache and cost nothing).

The ecosystem depth is real. Beyond search, place, and reviews there are dedicated engines for photos, posts, directions, and autocomplete, plus every search item ships ready-made reviews_link and photos_link URLs. The docs are the best in this comparison, and the pagination is honestly documented (start offset, 20 per page).

Then the invoice arrives. The Starter plan is $25 for 1,000 searches: $25.00 per 1,000, roughly 22 times Scrape.do and 25 times ScrapingDog's entry rate. The Big Data tier still works out to $9.17 per 1K. For a price-monitoring pipeline doing 100K lookups a month, that is $2,500 versus $116 for the same Google truth.

Where it wins:

• Fastest responses we measured, by a wide margin
• Broadest engine catalog and the most polished developer experience
• 250 free searches a month, no card

Where it doesn't:

• The price, at any volume beyond hobby scale
• Small param gotcha: ll and location are mutually exclusive; sending both returns a 400

3. ScrapingDog

• Trustpilot: 4.7 (~585 reviews)
• G2: 3.0 (5 reviews, stale)

ScrapingDog's Google Maps API put up the best price/performance line of the run: 100% on all three surfaces, 1.6-second average responses, at the lowest per-call cost in this comparison.

Maps calls bill at 5 credits (half of what ScrapingDog charges for its own shopping endpoint, oddly). The $40 Lite plan's 200K credits translate to 40,000 calls: $1.00 per 1,000, and the $90 Standard tier drops it to $0.45. At volume, nothing else in this benchmark touches that number.

The response shape tracks SerpApi closely, and place, reviews, photos, and posts endpoints are all present.

Where it wins:

• Cheapest per call here, especially at Standard tier and up
• Second-fastest responses (1.3-2.1s averages across surfaces)
• Full endpoint set: search, place, reviews, photos, posts

Where it doesn't:

• The reviews first page is fixed at 8 items; the num parameter only works once you pass a pagination token. Budget an extra call per place if you need volume.
• No popular times in search items (they live on the place endpoint), search pagination requires ll and tops out around 100 results

4. Apify

• Trustpilot: 4.8
• G2: 4.7 (534 reviews)
• Capterra: 4.8 (534 reviews)

Apify's Google Maps Scraper is a different animal, and comparing it per-request undersells it. Every call is an actor run: a managed browser crawl that took 23 seconds on average for search and up to 107 seconds for reviews in our tests. It passed search and details at 100%. Reviews came in at 66.7% under our strict rule, because the actor surfaces text-less star ratings first on heavily-photographed tourist spots, and three reviews with text were not always in the first batch.

The pricing model is per place, not per request: $1.50 per 1,000 places plus small add-on events for details and reviews. That makes a single 10-place query cost around $0.015 (expensive as an API call) and a 1,000-place city crawl cost around $1.50 (absurdly cheap as a dataset). Apify also sidesteps Google's 120-results-per-search cap by subdividing the map area and searching each cell.

Where it wins:

• Bulk harvesting: POI datasets, lead lists, whole-city category crawls
• Richest single-item payloads of the run: popular-times histograms directly in search output, amenities, contact enrichment, social profiles
• Output lands as downloadable datasets (JSON, CSV, Excel) rather than one response at a time

Where it doesn't:

• Minutes-scale latency and run management make it wrong for request/response workloads
• No data_id in output, so it does not interoperate with the other providers' review flows

5. ScraperAPI

• Trustpilot: ~4.x (42 reviews)
• G2: 4.4 (16 reviews)
• Capterra: 4.6 (62 reviews)

ScraperAPI documents a Google Maps Search structured endpoint. We sent it 50 benchmark requests. All 50 came back as empty scaffolds: a JSON body with url, scraper_name, and next_page_url, and zero places in it.

Before writing that down as a finding, we ran their documentation's own example query (vegan restaurants at NYC coordinates, copied verbatim), twice, across a three-hour window. Same scaffold, zero places. The next_page_url it returns points at a raw tbm=map protobuf URL, which suggests the parsing chain behind the endpoint is broken. There is no place-details or reviews endpoint at all; search is the entire maps product, and as of our test date it does not return data.

Pricing is moot at 0%, but for the record: plans start at $49/month, and the maps endpoint's credit cost is not published (the general Google SERP rate is 25 credits, which would put it near $12.25 per 1K if it worked).

We are not framing this as vendor malice. Products break. But a documented, marketed endpoint returning empty payloads on its own docs example, for hours, is exactly the failure mode that field-verified benchmarking exists to catch. Test dated 2026-08-03; re-verify before ruling it out permanently.

Field Coverage: What Each API Actually Returns

Success rates say whether data came back. This matrix says which fields came back, measured across every search item each provider returned (30-60 items each), not copied from docs:

Field	Scrape.do	SerpApi	ScrapingDog	Apify
name	100%	100%	100%	100%
address	100%	100%	100%	100%
phone	85%	88%	85%	80%
website	98%	97%	97%	93%
hours	65%	65%	62%	63%
rating	100%	100%	100%	100%
review count	100%	100%	100%	100%
coordinates	100%	100%	100%	100%
place_id	100%	100%	100%	100%
data_id	100%	100%	100%	0%
photos	100%	100%	100%	100%
popular times	details only	details only	details only	100% in search

Read the imperfect rows carefully, because they are the trustworthy ones. Phone hovers at 80-88% and hours at 62-65% for every provider at once, which means those places genuinely lack the data on Google (landmarks without phone numbers, businesses without posted hours). Four independent parsers agreeing on the same gaps is the strongest evidence in this benchmark that all four are parsing the same reality.

The two real differences: Apify skips data_id entirely, and Apify alone puts popular-times histograms directly in search output where the pure APIs reserve them for the details call (where all three returned them, 12 of 12 matrix fields, in our samples).

Which One to Pick

For most teams the answer is Scrape.do: the only provider that combined perfect field-verified scores with a price that survives scale, at $1.16 per 1K on the entry plan and $0.71 at volume. The SerpApi-compatible schema also makes it the natural landing spot for teams priced out of SerpApi.

If response time is the product (autocomplete-adjacent features, interactive lookups) and the budget clears $25 per 1K, SerpApi is the best engineering in this comparison. It was flawless and fast, and its docs set the standard.

If the workload is high-volume and cost-dominated, ScrapingDog's Standard tier at $0.45 per 1K is the cheapest working Google Maps data in this benchmark, with the 8-review first page as the main operational wrinkle.

If the job is a dataset rather than an API (every restaurant in Chicago, every dentist in Texas), Apify's per-place pricing turns bulk harvesting into pocket change, as long as minutes-scale runs fit the workflow.

And ScraperAPI: re-test it before relying on it. As of 2026-08-03 its maps endpoint returned no data at all.

FAQ

Is there a cheaper alternative to the Google Places API?

Scraping APIs return the public Maps surface at $0.45-$1.16 per 1,000 requests versus $17-$25 per 1,000 for the official SKUs, with no field masks and no restriction on storing results. The trade-offs are unofficial status and higher latency (0.5-8.5 seconds versus the official API's consistent sub-second responses).

Can Google Maps reviews be scraped through an API?

Yes. Scrape.do, SerpApi, and ScrapingDog all returned complete review objects (text, author, rating, and owner responses) in our benchmark, keyed by the place's data_id and paginated by token at 8-20 reviews per page. Sorting by newest is supported on all three.

Why not use the official Google Maps API for this?

Cost at scale, per-field SKU pricing, quota ceilings, and terms that prohibit caching or storing results. The official API remains the right tool for rendering maps in consumer apps; the providers here exist for data pipelines the official terms rule out.

Is scraping Google Maps data legal?

The data involved is public business-listing information, and the providers in this comparison operate commercially on that basis. Reviews contain author names, so data-protection rules (GDPR and similar) apply to how you store and process them. For a specific use case, especially one involving personal data, get proper legal advice rather than a blog paragraph.

---

Three providers passed everything we threw at them; what separates them is a 22x price spread and an 18x latency spread, and now both are measured instead of claimed. The queries, IDs, and verification rules are documented above, so the whole run is reproducible the day you read this.

Get 1000 free credits and start scraping with Scrape.do