5 Best Google Maps Scraper APIs: Tested & Ranked

To find the best Google Maps scraper, we benchmarked five web scraping providers, Apify, SerpApi, Oxylabs, Zyte and Nimble, by requesting the same 1,000 businesses from each. The businesses span 10 categories across 10 US cities, for 5,000 requests in total.

Google Maps scraping benchmark results

Since all providers exceeded 90% success, we compared completion time:

Available metadata fields by Google Maps scraper

Only SerpApi and Apify returned structured JSON, so those are the two we counted fields on. Apify returned 71 fields per place on average and SerpApi 30. The remaining providers returned rendered HTML, which has no field count to report, so we validated their responses with CSS selectors instead.

29 of those fields carry the same data in both, sometimes under different names: totalScore and rating, reviewsCount and reviews, placeId and place_id. The table below lists only what one returns and the other does not.

Google Maps scrapers free trial

Best Google Maps scrapers

Bright Data splits its Google Maps coverage across six scrapers. Four of them return full business information and differ only in how you address a place. The other two cover a single part of a listing.

Business information

• Collect by URL: You supply a Google Maps place URL and get that business back.
• Discover by place ID: Takes Google’s own place identifier instead of a URL, which is useful when your records already carry place IDs and you do not want to build URLs for them.
• Discover by CID: The same idea with the customer ID, the numeric identifier behind a Maps listing.
• Discover by location: Runs a location search and returns the businesses it finds, so you can collect places you have not identified in advance.

Reviews and images

Images, collect by URL: Returns the photos attached to a listing.

Reviews, collect by URL: Returns the reviews for a place rather than the business record. It takes a days_limitsetting, so you can ask for recent reviews only, such as the past 9 or 18 days, instead of pulling the full history.

The first four are the ones to compare against each other: they return the same record and differ only in the input they accept. Which one fits depends on what your existing data looks like. If you hold URLs, collect by URL is the direct route. If you hold place IDs or CIDs, the matching discover scraper saves you a URL building step. If you hold neither and want to build a list from scratch, discover by location is the only one of the four that finds places rather than fetching ones you already name.

Requests run in either synchronous or asynchronous mode. In synchronous mode the browser stays open and the data comes back as soon as the task finishes.

Oxylabs offers two routes to Google Maps, and which one you can use depends on what you are starting from.

The dedicated google_maps source takes a search query rather than a URL. It will not accept a url parameter, and it does not support parsed output: asking for either returns an error saying the source is not available with that parameter. So it fits discovery work, where you are searching for places rather than fetching ones you already hold.

The general google source accepts any Google URL, place pages included. This is the route to use when you already have Maps URLs. Setting render to html runs the JavaScript, and geo_location pins the exit country, which matters on Google properties because a European exit can return a consent interstitial instead of the page.

SerpApi splits Google Maps into seven APIs. Two of them share the google_maps engine and differ by input, and the rest are separate engines keyed on an identifier that the first two hand you.

The google_maps engine

• Local Results: type=search with a query and ll coordinates. Returns the businesses matching a search, 20 at a time.
• Place Results: The same engine with place_id or data_cid instead of a query. Returns one business record, no search step involved.

Dedicated engines

• Reviews: google_maps_reviews, keyed on data_id or place_id. This one has the most controls: sorting by qualityScore, newestFirst, ratingHigh or ratingLow, filtering by keyword or topic_id, and pagination through num and next_page_token.
• Photos: google_maps_photos, keyed on data_id. Returns full-size images and thumbnails with the user who posted them.
• Posts: google_maps_posts, keyed on data_id. Returns the business’s own posts.
• Contributor Reviews: google_maps_contributor_reviews, keyed on a contributor_id taken from a reviewer’s profile URL. Returns everything one person has reviewed, which is the reverse of the Reviews API: it starts from the reviewer rather than the place.
• Autocomplete: google_maps_autocomplete, keyed on a query. Returns the suggestions Google would show as you type.
• Directions: google_maps_directions, taking a start and an end point as addresses, coordinates or data IDs. Returns routes with distances, durations and turn-by-turn steps.

The identifiers are what tie these together. A search returns place_id, data_id and data_cid for every business, and those are the keys the reviews, photos and posts engines expect, so the first call decides which of the others you can make.

In our benchmark we used Place Results: engine=google_maps with the place_id of each of the 1,000 businesses in the dataset, and no_cache=true so that a cached answer could not be returned.

Apify is a marketplace, so you pick an actor rather than an endpoint. The one we used for Google Maps is compass/crawler-google-places, published as Google Maps Scraper. It is billed per event.

It takes either a search term with a location, or start URLs when you already know the places you want. The rest of the input is optional toggles, and several cost extra: category and star rating filters, skipping closed places, opening the place detail page, and pulling reservation providers, order online widgets or web results.

Runs are asynchronous. You start a run, poll until it finishes, then read the results from its dataset.

In our Google Maps benchmark we used this actor with startUrls set to each place URL and maxCrawledPlacesPerSearch at 1, so it returned only the business we asked for. Reviews, images, web results and people-also-search were turned off.

Zyte has no Google Maps specific product. You call the general Zyte API at /v1/extract with the place URL and ask for browserHtml, which runs a full browser and returns the rendered page. There is no parsed Maps schema behind it, so what you get back is HTML to parse yourself.

One parameter matters more than the docs suggest: geolocation. Left unset, our requests exited in Europe and came back with Google’s consent interstitial, a real page with a 200 status and no place data on it. Pinning it to US returned the place. Beyond that no extra instructions were needed, the panel was already painted when the response arrived.

Nimble offers two routes. The Web API takes a URL with render enabled and returns the rendered page, the same shape as Zyte. Its SERP API also lists Google Maps among the engines it supports, taking a query rather than a URL, which fits discovery rather than fetching a place you already hold.

Parsed responses come back grouped by entity type rather than as one list, with the organic results, pagination and search information in separate buckets. The same response also carries the raw HTML alongside the parsed data, so you get both in one call.

Octoparse is a template you run inside its app or cloud rather than an endpoint you call.

What it takes as input

• Keywords with locations: up to 100,000 keyword and location combinations, with location given as a city, region or country.
• Place URLs: up to 5,000 of them, when you already know the businesses you want.
• Language: English, French, Spanish, Italian, Korean, Japanese or Traditional Chinese.

What it returns

Title, address broken into country, city and state, plus code, latitude and longitude, phone, website, category, opening hours, current status, price range, rating and review count, review content and reviewer information, popular times, images, description, delivery, page URL, and both the Google ID and the place ID.

Google Maps scraper benchmark methodology

We benchmarked 5 data providers (Apify, SerpApi, Oxylabs, Zyte, Nimble) on their ability to return Google Maps business data. Each provider was asked for the same 1,000 businesses, one request per business, for 5,000 requests in total.

Dataset

We built the dataset in advance rather than searching at run time, so every provider was asked for the same places in the same order.

• Places: 1,000 businesses, each with its own Google Maps URL and place ID.
• Cities (10): New York, Los Angeles, Chicago, Houston, Phoenix, Philadelphia, San Antonio, San Diego, Dallas and Austin, 100 businesses from each.
• Categories (10): coffee shop, restaurant, gym, pharmacy, hotel, hospital, bank, supermarket, gas station and hair salon.
• Addressing: five providers received the Google Maps URL. SerpApi received the place ID, because its Google Maps product takes an identifier rather than a URL.

Test parameters

• Runs: one request per business, no repetitions.
• Execution: sequential, one request at a time, with a pause between them. No parallel requests.
• Timeouts: 300 seconds to submit, 600 seconds to complete.
• Rate limits: on HTTP 429 the request was retried up to 3 times.

Provider implementations

• Apify: the compass/crawler-google-places Actor, asynchronous. The place URL went in as startUrls with maxCrawledPlacesPerSearch set to 1, so the Actor returned that business rather than crawling outward. Reviews, images, web results and people-also-search were turned off.
• SerpApi: the google_maps engine with place_id and no_cache=true. Caching was disabled because a cached search is free, is not counted against the quota, and would make the timing meaningless.
• Oxylabs: the Realtime Scraper API with source: google, the place URL, render: html and geo_location: United States, plus browser_instructions to wait, scroll and wait again. Without them the response came back as the shell, with the business name in the page title and no place panel in the DOM.
• Zyte: Zyte API /v1/extract with browserHtml and geolocation: US. Left unset, requests exited in Europe and returned Google’s consent interstitial, a real page with a 200 status and no place data on it.
• Nimble: the Web API with the place URL, rendering enabled and country set to US.

Success

The HTTP status is checked first. Responses between 200 and 399, and 404, go on to be validated. Any other status fails without reaching the data. A 404 passes on the status alone, since correctly reporting a page that no longer exists is a correct answer and there is no data to check.

For providers returning JSON, at least one of four fields had to be present and of the right type:

• Name: a non-empty string.
• Address: if present, a non-empty string and not “N/A”.
• Phone number: if present, at least 5 digits.
• Reviews count: if present, a non-negative number. Zero counts, since a business with no reviews is a real answer.

For providers returning rendered HTML, at least one of the place selectors had to match and return a value. The selectors are attribute based rather than class based, because Google’s class names on this page are build hashes that change on deploy.

We recorded which rule passed each request, so that a selector going stale reads differently in the data from a provider returning nothing.

Time

Times are calculated over successful requests only, since a timeout or an instant error does not tell you how long it takes to get data.

Available metadata

We counted the fields in the record each provider returned. This is reported only for the providers that return structured JSON. The three that return a rendered page are left blank rather than scored as zero: what we could pull out of a page is a count of the selectors we wrote, not of what the provider offers.

Don’t miss our benchmarks and data-driven insights. The button opens Google; selecting AIMultiple confirms that you wish to see AIMultiple more often in Google search results.

Add as preferred source

FAQs

Cite this benchmark

Pick the format that matches where you're publishing. Pasting the link version into your CMS preserves the backlink.

@misc{sipi2026,
  author = {Şipi, Nazlı},
  title  = {{5 Best Google Maps Scraper APIs: Tested & Ranked}},
  year   = {2026},
  month  = sep,
  howpublished    = {\url{https://aimultiple.com/google-maps-scraper}},
  note   = {AIMultiple. Retrieved September 29, 2026}
}

Changelog

4 updates

20262025

1. Jan 30

   Removed the "How to scrape Google Maps with Python" section.

Nazlı Şipi

AI Researcher

Follow On

Nazlı is a data analyst at AIMultiple. She has prior experience in data analysis across various industries, where she worked on transforming complex datasets into actionable insights.

View Full Profile

Be the first to comment

Your email address will not be published. All fields are required. Comments are left in their original language.

Name

Email Address

Comment

0/450

Post Comment