# Google Maps Scraper: Rating Trends, Leads, Reviews (`nokia2k/google-maps-scraper-rating-trends`) Actor

Google Maps scraper with rating trends: business name, phone number, website, address, hours, reviews and the rating of the last 3, 6 and 12 months. A whole city past the 120-result limit, or places by URL or place ID. Free no-website filter. Google Places API alternative, no API key. No emails.

- **URL**: https://apify.com/nokia2k/google-maps-scraper-rating-trends.md
- **Developed by:** [nokia2k](https://apify.com/nokia2k) (community)
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 places

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Google Maps Scraper** turns a Google Maps search into a spreadsheet you can open in Excel. Type a kind of business and a place, for example *dentist* in *Austin, Texas*, and get the businesses Google Maps lists there, each with its name, phone, website, address, rating, number of ratings and opening hours. It is made for anyone who needs a list of local businesses: shop owners looking at their competitors, sales teams, agencies, market researchers and developers. No Google API key, no browser extension, no code.

- 🆓 **Free to try.** Apify's free plan includes $5 of credit a month, enough for about 1,660 places. A first test of 50 places uses $0.15 of it. No credit card.
- 🗺️ **The whole area, not the first 120 results.** Google Maps ends its list after about 120 places. This tool keeps looking, one part of the map after another, and reports what it covered.
- 📈 **Rating trends: the rating of the last 3, 6 and 12 months.** See whether a business is getting better or worse, not only its all-time average.
- 🎯 **Free filters.** Rating, number of ratings, website, phone, unclaimed profiles, category, name. You pay for the places delivered, plus a start fee of $0.0002 per run.
- 📤 **Download as Excel or CSV**, or read the data as JSON through the API, Python, Make, Zapier, n8n or an AI assistant.
- ⚡ **Fast.** 1,086 places for `dentist` in Austin in 28 seconds. [Measured runs](#how-fast-is-this-google-maps-scraper).

Jump to [lead lists](#google-maps-lead-generation-and-other-uses), [reviews and rating trends](#google-maps-reviews-scraper-and-rating-trends), [a Google Places API alternative](#google-places-api-alternative) or [the API, Python and MCP](#google-maps-scraper-api-python-and-mcp).

New here? [Ten steps from this page to an Excel file](#how-to-extract-data-from-google-maps-step-by-step).

🇪🇸 ¿Prefieres leerlo en español? [Ve a la guía en español](#guia-en-espanol-como-extraer-datos-de-google-maps).

### What is Google Maps Scraper?

Google Maps Scraper by nokia2k copies the public business listings of Google Maps into a table: one row per business, each business once. A scraper is a program that copies public information from a website, so such a tool is also called a Google Maps scraping tool, a Google Maps data scraper or a Google Maps extractor. It runs on Apify, a website for running tools like this one: there is nothing to install. You fill in a short form in your browser, press **Start**, and download the result.

**What does it cost?** With this Google Maps scraper a place costs $0.003 on Apify's free plan ($3.00 per 1,000), and every run has a start fee of $0.0002. Reviews and recent ratings cost extra. [All prices](#how-much-does-it-cost-to-scrape-google-maps)

**Is it allowed?** Business names, addresses, phone numbers and ratings are public facts. What you may do with them depends on your country and your purpose: see [Is it legal to scrape Google Maps?](#is-it-legal-to-scrape-google-maps)

#### What data can you extract from Google Maps?

You can scrape the data that Google serves to any visitor of Google Maps who is not signed in. For each business this scraper extracts:

- **In every run:** name and categories; full address, also split into street, city, postal code, state and country; phone, also in international format; website, its domain and the kind of link it is (own website, social page, booking or directory page, none); rating and number of ratings; opening hours; open now, temporarily or permanently closed; whether the Google Business Profile has an owner; the Google Maps link.
- **When you switch it on:** the star breakdown, how many 1, 2, 3, 4 and 5 star ratings (same price); the rating of the last 3, 6 and 12 months with its trend (costs extra); reviews with exact date, text, photos, the owner's reply and ratings per aspect (cost extra); email addresses and social profiles published on the business's own website (no extra charge).
- **For programmers:** coordinates, time zone, Google's IDs (place ID, CID, feature ID, Knowledge Graph ID), attributes such as accessibility and payments, cover photo link, number of photos and position in the search results.

Every field is explained under [Google Maps data extractor: output fields](#google-maps-data-extractor-output-fields).

#### What does it not collect?

- **Emails that no website publishes.** Google Maps listings show no email. With **Emails and social profiles from the website** on, the scraper reads each business's own website; an address the website does not show is not found, and no address is guessed. See [Can I scrape emails from Google Maps?](#can-i-scrape-emails-from-google-maps)
- **Photo files.** You get the cover photo link and the number of photos.
- **Questions and answers, popular times, menus and booking links.** The `price` field is nearly always empty.
- **Reviewer names**, unless you switch them on. See [Are reviewer names included?](#are-reviewer-names-included)

#### Do I need a Google Maps API key?

No. An API key is an access code that Google gives to programmers. This scraper needs none, and no Google account, Google Cloud project or billing account either. It is an independent tool: not made by Google and not affiliated with Google. Coming from Google's Places API? See [Google Places API alternative](#google-places-api-alternative).

### How to scrape Google Maps

To scrape Google Maps without code, open this Google Maps scraper on Apify, type a search term such as `coffee shop` and an area such as `Santa Fe, New Mexico`, and press **Start**. It extracts the matching business listings into a table for Excel or CSV.

#### How to extract data from Google Maps, step by step

1. At the top of this page, press **Try for free** (the wording of the button can differ slightly).
2. Apify asks you to create an account: an email address and a password, or one of the sign-up buttons shown there. It is free and no credit card is asked for. If Apify emails you a link to confirm your address, press it; if it asks what you plan to do, answer or skip.
3. You now see a page whose title starts with **Google Maps Scraper**, and below it a form that begins with **Search terms** and **Area**. Only those two boxes matter. If you see another page, come back here and press **Try for free** again.
4. In **Search terms**, replace `coffee shop` with the kind of business you are looking for, the way you would type it into Google Maps. Example: `hardware store`.
5. In **Area**, replace `Santa Fe, New Mexico` with your town and your state or country. Example: `Toledo, Spain`. Outside English-speaking countries, also choose your language in **Language of the results**: the kind of business and the opening hours then arrive in it.
6. Leave **Places per search term** at `50` this first time. Fifty businesses cost $0.15, taken from the $5 that Apify gives you free every month.
7. At the bottom of the form, press **Start** (the button may say **Save & Start**). This starts a run, as one job of the tool is called. While it works, a line counts, for example `50 places found so far`.
8. Within a minute the status changes to **Succeeded**, and the tab **Output** holds a table: one business per line, with name, category, rating, phone, website and address. If the run failed instead, read the message next to the status: most often the area was not found on the map, and no places are charged. Return to the form by clicking the tool's name at the top of the run page, add the state or country to the area and press **Start** again.
9. Above the table press **Export**, choose **Excel** and press **Download**.
10. The file is saved where your browser keeps downloads, normally the folder **Downloads**. Double-click it and it opens in Excel. It has more columns than the table on screen: [what the columns mean](#how-to-export-google-maps-search-results-to-excel-or-csv).

Happy with the sample? Click the tool's name at the top of the run page to return to the form, which normally still holds what you typed. Empty the box **Places per search term** and press **Start** again to get every place the search finds in your town. A small town costs a few cents; a big city can use up the month's free $5, because 1,000 places cost $3.00. To be safe, type `500` in place of emptying the box.

#### After you press Start: what happens, and what if something goes wrong?

- **How long does it take?** 5 to 15 seconds for a sample of 50 places; from about ten seconds to several minutes for a whole city. Reviews and recent reputation make a run longer.
- **Can I stop a run?** Yes, with **Abort** on the run page. Places reach the table every few seconds while the run works; those found before you stop are kept, and you pay for those only.
- **What if I close the window?** Nothing is lost: the work is done on Apify's computers. Sign in again at console.apify.com, open your runs (**Runs** in the menu) and click the newest line.
- **Will I be charged if a run fails?** You pay for the places that reached your table, plus the $0.0002 start fee of every run. If the area you typed cannot be found on the map, the run stops at once and says so: no places are charged.
- **Where do I see what a run cost?** On the page of the run. Your use of the month's $5 is under **Billing** in Apify Console.
- **Excel shows strange letters, everything in one column, or postal codes without their first 0.** Export as **Excel**, not CSV.
- **How long are my results kept?** At least 7 days; how long depends on your Apify plan. Download the file to keep it.
- **Can I run it again next week?** Yes. Sign in at console.apify.com and open Google Maps Scraper from the tools you have used (**Actors** in the menu). To have it run by itself every week, see [Connect Make, Zapier and n8n, or run it on a schedule](#connect-make-zapier-and-n8n-or-run-it-on-a-schedule).
- **Does the business or Google find out who I am?** No. The tool reads public pages without signing in, from Apify's servers. Your own Google account is not involved.

#### What to type: good and bad search terms

| Write this | Not this | Why |
|---|---|---|
| `dentist` | `best cheap dentist near me open now` | Use the plain word for the kind of business. |
| `dentist`, with `Austin, Texas` in **Area** | `dentist in Austin`, with **Area** empty | Without an area a term is searched once, wherever Google places it: at most 120 places. |
| `coffee shop` and `cafe` on two lines | `coffee shop, cafe, bakery` on one line | One term per line. Each line searches the whole area again: more time, and places the other line missed. A place found twice is delivered once. |
| `restaurante` for Spain | `restaurant` for Spain | Use the word local customers type. |
| Area: `Springfield, Illinois` | Area: `Springfield` | Add the state or country when a name is common. |
| Area: `78701, Austin, Texas` | Area: `78701` | A postal or ZIP code needs its town or country. You get only places with that code. |
| Area: `Austin, Texas` | Area: `USA` | Start with a city to see the data and the cost. Cover a state or a country county by county. |

#### Which settings can I leave alone the first time?

All of them except **Search terms** and **Area**: filters and reviews are off, and the connection settings are tuned for speed. Three settings worth trying next are [**Recent reputation**](#recent-reputation-the-rating-of-the-last-3-6-and-12-months), the [**Website** filter](#how-to-find-businesses-without-a-website-on-google-maps) and [**Only places with a phone number**](#how-to-get-leads-from-google-maps). If you do not see a box that this page names, press its heading on the form, such as **🎯 Filters (all free)**, to open it. Every box has a help text: press the **?** next to its name.

#### How to export Google Maps search results to Excel or CSV

To export Google Maps search results to Excel or CSV, run the scraper, open the **Output** tab and press **Export**:

- **Excel or CSV:** choose the format and press **Download**. The file holds every column, whichever table is on screen, under technical names. For a short file, open **Select fields** in the Export window and pick the columns you want from its list, for example `title`, `categoryName`, `phone`, `website`, `address`, `totalScore`, `reviewsCount` and `url`.
- **Google Sheets:** download the **Excel** file as well and open it with *File > Import* in Google Sheets. Keep CSV for programs that ask for it: a spreadsheet that opens a CSV file can drop the 0 at the start of a postal code (`08001` becomes 8001).
- **Other formats:** JSON, JSONL, XML, HTML table and RSS.
- **Ready-made tables:** above the results, pick *Places*, *Leads*, *Recent reputation*, *Reviews (one per row)* or *All fields*. They change the columns on screen, not the file. For a file with one review per row, see [How do I get one review per row?](#how-do-i-get-one-review-per-row)

| In the file | Means |
|---|---|
| `title` | Name of the business |
| `categoryName` | Kind of business |
| `totalScore`, `reviewsCount` | Star rating (1 to 5), and the number of ratings |
| `phone`, `website` | Phone number, and the link on the Google Maps listing |
| `websiteType` | `website`: its own site. `social`: a Facebook or Instagram page. `platform`: a booking, delivery, directory or website-builder page. `none`: no link |
| `address`, `city` | Full address, and the town alone |
| `openingStatus` | Open or closed when the run was made |
| `permanentlyClosed` | TRUE when the business has closed for good |
| `url` | Opens the business on Google Maps |

An empty cell means that the listing does not have that detail. This exports the results of a search; for the places you saved in your own Google account, see Google's own export, Google Takeout.

### How many Google Maps results will I get?

As many as Google Maps lists for your search term in your area. A small town may have 20 coffee shops; a large city has thousands of restaurants. There is no fixed number.

#### Why does Google Maps stop at 120 results?

When you search on Google Maps, the list on the left ends after about 120 places, however many exist. A tool that only copies that list misses most of a city.

#### How this Google Maps scraper gets past the 120 limit

It zooms in. The area is searched as one map view. Where that view is crowded, it is cut into four smaller views, and each of those is searched again. This repeats until a closer look adds fewer than 3 new places (with **Coverage** set to **Deep**: until it adds none).

```text
Whole city           Split in four        Busy quarter split again
+---------------+    +-------+-------+    +---+---+-------+
|               |    |       |       |    |   |   |       |
|  120 results  | -> |  120  |  45   | -> +---+---+  45   |
|   (capped)    |    +-------+-------+    |   |   |       |
|               |    |  80   |  12   |    +---+---+-------+
+---------------+    +-------+-------+    |  80   |  12   |
                                          +-------+-------+
```

Google also returns places from outside your area, often many. They are dropped, using the outline of the city or region from OpenStreetMap (a rectangle around the area where it has no outline), and you do not pay for them.

In a test on 10 October 2026, `cafetería` in Toledo, Spain, was searched once with this scraper (standard setting) and once with the most used Google Maps scraper on Apify Store. Of the 171 cafés the two found together (places with *café*, *coffee* or *tetería* in the name or categories), this one found 168 (98%), the other one 151 (88%). Counting every place, with the restaurants and bars Google mixes in, each tool returned some that the other did not: 111 here, 88 there.

#### How do I see what a run covered?

When a run has finished, its status message sums it up (the same sentence stands at the end of the **Log** tab). For `coffee shop` in Santa Fe it read:

*98 places delivered in 7.0 s (98 unique in the area, 29 outside it dropped, 0 removed by your filters, 35 map views searched, 215 requests, 5.25 MB).*

The 7.0 seconds are the search alone; the whole run took 9 seconds. Programmers find these numbers and more in [the coverage record](#the-coverage-record).

#### Why did I get fewer places than I expected?

- The run stopped early: **Maximum cost per run** was reached, your Apify credit ran out, or the run came close to its time or memory limit. The places found up to then are in your table. When the run's own spending, time or memory limit stopped it, the status message says so. To get the rest, press **Resurrect** in the **Actions** menu of the run, open **Options** and raise the limit that stopped it: only the missing places are added and charged. A new run (**Re-run**, or **Re-run from start**) charges every place again.
- **Places per search term** has a number in it, and the status message says when a search stopped at it. Empty the box to get everything.
- **Area** was empty: a term without an area returns at most 120 places, and the status message says so.
- A **filter** is on. The status message of the finished run says how many places were *removed by your filters*.
- Your **search term** is narrower than you think. Google lists a business under the categories its owner chose. Try a second term on a new line, for example `cafe` next to `coffee shop`.
- The business lies just outside the official border of your town, for example in a retail park of the next municipality. Add the neighbouring town in **More areas**.
- You want every last place. Set **Coverage** to **Deep**: in a test it returned 23% more places (701 against 569) and took nearly twice as long.

#### Why are some results not what I searched for?

Google Maps pads its results: a search for coffee shops also returns bakeries, restaurants and sometimes a bookshop with a coffee corner. To keep one kind of business, enter every word that fits in **Only these categories**, one per line, for example `coffee` and `cafe`. A place is kept when one of its categories contains one of your words, so `coffee` alone drops a place whose only category is "Cafe", and a short word such as `bar` also keeps "Barber shop". The filter is free, and a place it removes is not charged.

### How much does it cost to scrape Google Maps?

This Google Maps scraper costs $3.00 per 1,000 places on Apify's free plan, which is $0.003 per place, and less on paid plans. You pay per place delivered, plus a start fee of $0.0002 per run. Server time, proxies and data transfer are included: there is no separate platform usage bill for this Actor ("Actor" is Apify's word for a tool).

#### Price per 1,000 places

| Price per 1,000 | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **Places**, with all details and all filters | $3.00 | $2.50 | $2.00 | $1.50 |
| **Recent reputation**: extra, per 1,000 places that have ratings | $2.00 | $1.50 | $1.20 | $1.00 |
| **Reviews**: per 1,000 reviews | $0.40 | $0.35 | $0.30 | $0.25 |

Every run also has a start fee, charged by Apify when the run starts: $0.0002 at the default memory of 4 GB ($0.00005 for each GB).

Free, Starter, Scale and Business are Apify's subscription plans; the higher the plan, the lower the price. Prices are in US dollars. On the free plan the price is paid from the $5 of monthly credit.

#### What you are never charged for

- Filters, however many you use.
- Places removed by a filter.
- Places outside your area.
- Duplicates within a run. A place found by three search terms is delivered and charged once.
- The star breakdown and the other details of a place.
- Recent reputation of a place that nobody has rated yet.
- Emails and social profiles from the website.
- The coverage record.
- Places, in a run that finds nothing or whose area could not be found. Such a run costs only the start fee of $0.0002.

One thing to know: the **Rating trend** filter needs recent reputation, so it brings that charge with it.

#### How fast is this Google Maps scraper?

Whole runs, from pressing Start to the finished table, measured on the morning of 10 October 2026 with 4 GB of memory and no place limit (searches in Spain with Spanish as the language of the results). Cost at the Free plan price, plus the $0.0002 start fee per run.

| Search | Places | Run time | Cost (Free plan) |
|---|---|---|---|
| `coffee shop` in Santa Fe, New Mexico | 98 | 9 seconds | $0.29 |
| `cafetería` in Toledo, Spain | 569 | 14 seconds | $1.71 |
| The same, with the star breakdown for every place | 570 | 25 seconds | $1.71 |
| The same, with recent reputation for every place | 570 | 58 seconds | $2.79 |
| `dentist` in Austin, Texas | 1,086 | 28 seconds | $3.26 |
| `dentist` in Austin, Round Rock and Cedar Park in one run | 1,410 | 39 seconds | $4.23 |
| `restaurante` in Madrid, Spain | 13,229 | 7 minutes 5 seconds | $39.69 |

The $2.79 are 570 places ($1.71) plus recent reputation for the 539 of them that have ratings ($1.08). Where a search was run several times, the table shows the middle value. Counts differ by a few places from run to run, because Google does not give exactly the same answer every time: three runs of the Austin search returned 1,086 to 1,102 places. They also move with the hour: the Toledo search returned 568 to 570 places in the morning and at midday (once 637) and 613 or 614 the same evening, when Google mixed in more restaurants and bars. It is quick because it asks Google's servers for the data directly, without opening a browser.

#### Is this Google Maps scraper free?

This Google Maps scraper is free up to a limit. Apify's free plan includes $5 of credit every month, without a credit card: about **1,660 places every month** at the Free plan price, or about 1,000 places with recent reputation. When the credit is used up, runs stop until the next $5 arrives; you are not billed. For more, Apify's paid plans have a monthly fee (see [Apify pricing](https://apify.com/pricing)) and a lower price per place.

#### How do I cap what a run can spend?

Before you press **Start**, open **Run options** on the form and type an amount in dollars into **Maximum cost per run**, for example `1`. The run stops when it reaches the limit and keeps the places delivered so far; you are never charged more ([how to get the rest later](#why-did-i-get-fewer-places-than-i-expected)). A second brake is **Places per search term**, which counts for each search term in each area: 2 terms in 3 cities with `200` can deliver up to 2 × 3 × 200 = 1,200 places, $3.60 at the Free plan price. For a large city, leave **Memory**, also under **Run options**, at 4 GB or more.

### Google Maps reviews scraper and rating trends

This Google Maps scraper is also a Google reviews scraper: it reads the reviews of each place, up to 2,400 per place, with exact dates. From them it works out how the place has been rated lately.

#### How to scrape Google Maps reviews

To scrape Google Maps reviews with this scraper, set **Reviews per place** to a number: each place of your search then comes with its newest reviews. For one business or a list of them, open each on Google Maps in your browser and paste the link from the address bar into **Google Maps links** (the short link of the Share button cannot be read), or paste place IDs into **Place IDs**. Empty **Search terms** and **Area** ([links and place IDs](#scrape-google-maps-by-url-or-by-place-id)). Then:

1. Set **Reviews per place**, for example to `20`.
2. Choose the order: newest, most relevant, highest or lowest rating.
3. If you like, set **Reviews newer than** to a date written year-month-day, such as `2026-05-03`, or a period such as `3 months`. Keep the order at newest: another order can bring fewer reviews than the place has since that date.
4. Press **Start**. Each review comes with its stars, exact date and time, text, Google's translation, the owner's reply, the photos and the ratings per aspect.

Reviews multiply quickly: 20 reviews for each of 1,000 places are 20,000 reviews, which is $8.00 for the reviews plus $3.00 for the places at the Free plan price. For a table or a file with **one review per row**, see [How do I get one review per row?](#how-do-i-get-one-review-per-row)

#### How to scrape Google reviews for free

With this scraper, Apify's free $5 a month pays for about 12,500 Google reviews, counting the reviews alone. The places are charged too: about 450 places with 20 reviews each fit into the $5. Set **Places per search term** and **Reviews per place** to stay inside it.

#### Recent reputation: the rating of the last 3, 6 and 12 months

The stars you see on Google Maps are an average over the whole life of a business. A restaurant that was excellent for eight years and changed owner last spring still shows 4.5. Turn on **Recent reputation** and each place also gets:

- the **average rating and the number of ratings of the last 3, 6 and 12 months**,
- a **trend**: `up`, `down` or `flat`, comparing the last 6 months with the 6 months before,
- the **owner's reply rate** over the last 12 months,
- the date of the newest review.

To see these figures, pick the table *Recent reputation* above the results: the first table, *Places*, does not show them. In the file they are columns such as `rating6Months` and `ratingTrend`.

A real example from Santa Fe: one coffee shop has 4.3 stars all-time. Its last 6 months average 4.55 from 22 ratings, 0.8 higher than the six months before. Trend: `up`. In the same search, a restaurant with 4.2 stars all-time averaged 2.31 over its last 3 months, from 13 ratings.

A trend needs at least 5 ratings in each of the two half-years. Places with fewer get `notEnoughData`. So does a place with more than 2,400 reviews in the last 12 months: its reviews cannot be read back a full year.

#### How to find businesses with falling Google ratings

With this Google Maps scraper, set **Rating trend** to **Going down**. You get only the places whose last 6 months are at least 0.3 stars below the 6 months before; the table *Recent reputation* shows by how much. Agencies can use this list to find businesses that need help with their reputation; buyers and franchise scouts can use it the other way round, with **Going up**. The filter needs recent reputation, which is charged for every rated place that is delivered.

#### Are reviewer names included?

Not by default. Reviews come without the reviewer's name, profile link and review link, because those are personal data. If you have a lawful reason to process them, switch on **Reviewer names**.

### Google Maps lead generation and other uses

Google Maps lead generation means turning map searches into contact lists: the plumbers, dentists or salons of a city, each with phone, website, rating and address. Used as a Google Maps lead scraper, this tool builds such a list, filters it for free and exports it to Excel or CSV for a dialer (a program that phones a list) or a CRM (a customer database).

#### How to get leads from Google Maps

With this Google Maps scraper, search for the kind of business you sell to, in the cities you cover, and turn on **Only places with a phone number**. Above the results, pick the table *Leads*: it shows name, category, phone as shown and in international format, website, rating, address and whether the business has closed for good (`permanentlyClosed`). Leave those rows out before you call. For email campaigns, turn on **Emails and social profiles from the website** as well: the table then shows the emails and the Facebook and Instagram pages each website publishes.

For a file with only these columns, use **Select fields** in the Export window. To get leads from Google Maps for free, stay inside Apify's free plan: about 1,660 businesses a month, and the phone filter costs nothing.

#### How to find businesses without a website on Google Maps

To find businesses without a website on Google Maps, search for a kind of business in your city with this Google Maps scraper and set its **Website** filter to **No real website**. You get the places with no link at all, and those whose link leads to a Facebook or Instagram page, a booking, delivery or directory page, or a free website-builder address such as `name.wixsite.com`. The `websiteType` column says which.

It is decided from the address of the link, using a list of known sites; the website is not opened, so check a link before you call it a lead. With a filter on, **Places per search term** counts the places that pass: `200` means up to 200 such businesses, at most $0.60 at the Free plan price.

#### How to see which Google Business Profiles are unclaimed

Turn on **Only unclaimed profiles** (`unclaimedOnly` in JSON), one of the free filters, to get only the places whose Google Business Profile shows no owner. It reads the `claimThisBusiness` value of each place: `true` when Google shows no owner for the profile, `false` when it shows one, empty when Google did not say. Only `true` is kept.

#### Research competitors and markets

Leave **Places per search term** empty and you have the businesses of one kind in a city: how many there are, where they are (coordinates are in the *Places* table), how they are rated and who has no website. Turn on **Recent reputation** to see who answers reviews. Add several areas to compare cities in one run.

#### Monitor competitor ratings and Google reviews

Save your input as a task and put it on a schedule, for example every Monday; the next section says how. To get the reviews written since the last run, set **Reviews per place** to, say, `50` and **Reviews newer than** to `8 days`. Place IDs normally stay the same from run to run, so the tables line up. To compare two runs, download the file of each: Apify keeps the results of a run for a limited time ([how long](#after-you-press-start-what-happens-and-what-if-something-goes-wrong)).

#### Connect Make, Zapier and n8n, or run it on a schedule

Apify has ready-made integrations for Make, Zapier, n8n, Google Drive, Slack and others, and webhooks for everything else. Google Sheets is reached through Make or Zapier. Examples: all places of a run go to Google Sheets; a Slack message, through Make or Zapier, for every competitor whose rating trend is `down`; a CRM that receives the week's list every Monday.

To run it every week by itself, save your input as a task (a saved copy of your settings; Apify Console offers this on the form). Then open **Schedules** in the Console menu, create a weekly schedule and add the task to it. Apify creates a schedule switched off: check that the schedule is switched on.

### Is it legal to scrape Google Maps?

It depends on the data and on what you do with it. Business listings (a shop's name, address, phone, opening hours and rating) are public facts shown on Google Maps, and collecting them is common practice in market research and sales. Personal data such as a reviewer's name is protected by laws like the GDPR, and Google's own terms forbid mass downloading.

There is no single answer for every country and every use. This is general information, not legal advice. For a large or sensitive project, ask a lawyer about your own case.

#### Does Google Maps allow scraping?

Not according to its terms. [Google's terms for Google Maps](https://www.google.com/help/terms_maps/) say that people using it may not mass download its content or create bulk feeds from it. This scraper is an independent tool, not affiliated with Google. You decide how you use it, and you are responsible for that use.

#### How this scraper reads Google Maps

- It reads only what Google serves to any visitor who is not signed in. It never logs in and never solves a CAPTCHA. When Google asks it to slow down, it waits or sends that request again over another address of Apify Proxy, a residential one if need be.
- Area names and outlines come from OpenStreetMap. © OpenStreetMap contributors, available under the Open Database License: [openstreetmap.org/copyright](https://www.openstreetmap.org/copyright). The answers of its map service are remembered in a small key-value store in your own Apify account, `google-maps-scraper-areas`, and looked up again after 30 days; you can delete that store at any time. A run started by a schedule looks up new area names 15 seconds apart.
- Review texts belong to their authors. Analysing them is one thing; republishing them is another. Check before you republish.

#### Google Maps scraping and the GDPR

The GDPR protects personal data of people in the EU, also when that data is public. A company's name, address and switchboard number are not personal data. A sole trader's name, mobile number or named email address (such as `maria.lopez@...`) can be, and so can a reviewer's name, a review text or a review ID. If you work with such data you need a legal basis (for B2B outreach, usually legitimate interest), and you must tell people where you got their data: within one month, or when you first contact them if that comes sooner.

#### Contacting the businesses on your list

Having a list and using it are two things. Many countries have their own rules for sales calls, text messages and marketing emails, such as do-not-call registers or consent for email. Check the rules of the country you call or write to before your first campaign.

### FAQ

#### Which Google Maps scraper is the best? How this one compares

It depends on what you need. This scraper has no photo files and no lookups of employees; others on Apify Store do. It is built for speed, coverage you can check and recent ratings. Here it is next to the most used Google Maps scraper on Apify Store: measured runs and published prices.

| Compared on 10 October 2026 | Google Maps Scraper by nokia2k (this page) | Google Maps Scraper by compass (`compass/crawler-google-places`) |
|---|---|---|
| `cafetería` in Toledo, Spain | 568 to 570 places in 12 to 16 seconds (four runs) | 547 places in 232 seconds (one run, default settings) |
| Cafés among them, of the 171 that the two tools found together | 168 | 151 |
| Rating of the last 3, 6 and 12 months | Yes, with trend | Not offered |
| Filters | Free | $0.001 per place for each filter, on the Free plan |
| Price per 1,000 places, Free plan and Starter | $3.00 and $2.50 | $4.00 and $3.00 |
| Price per 1,000 places, Scale and Business | $2.00 and $1.50 | The same |
| Price per 1,000 reviews, Free plan | $0.40 | $0.50 |
| Reviews per place | Up to 2,400 | No fixed limit |
| Areas per run | Several | One location query (several polygons possible) |
| Emails and social profiles from the website | Yes, no extra charge | Yes, charged per place |
| Photo files, employee lookups | No | Yes, as paid add-ons |

#### What is the best free Google Maps scraper?

Any scraper on Apify can be tried with the free plan's $5 a month, so the question is how far $5 goes: with this Google Maps scraper about 1,660 places, filters included. Before you compare with a free browser extension, check how many results it allows per day and per search.

#### Can I scrape emails from Google Maps?

Not from Google Maps itself: listings have a phone number and a website, but no email address. Turn on **Emails and social profiles from the website** (`scrapeContacts`) and this scraper reads each business's own website: its home page and, when that shows no address of the site's own, up to two of its contact, about or legal pages. When none of these shows an address, two pages where such sites usually keep it are tried, such as `/contact` and `/mentions-legales` in France or `/contatti` and `/note-legali` in Italy. A link to a page that no longer exists falls back to the home page, and a name that does not answer is tried with or without its `www`. You get the email addresses in `emails`, the site's own first, links to its Facebook, Instagram, LinkedIn, X, YouTube, TikTok and Pinterest profiles, the phone and WhatsApp numbers it links, and its contact form page. `emailDetails` says for each address whether it is the site's own domain or a personal mailbox such as Gmail, the page it was found on, and whether its domain can receive mail; addresses whose domain cannot receive mail, no-reply addresses and the privacy or webmaster addresses of whoever built the website are left out. Numbers written without a country code get the code of the place's country. `contactsStatus` says for each place whether something was found, the website showed nothing, it did not answer, or there was no website of its own.

Only what the website itself publishes is read. No address is guessed, no social network is opened and no one is looked up. Addresses written as `info [at] shop [dot] com` or hidden by Cloudflare are read; addresses that only appear after a page runs its scripts are not. It costs nothing extra; the run takes longer, because websites answer more slowly than Google.

#### Is there a Google Maps scraper Chrome extension?

Yes, there are Google Maps scraper extensions in the Chrome Web Store, but this tool is not one of them. Extensions run inside your own browser, on your computer and internet connection, and stop when you close the tab. This Google Maps scraper runs in the cloud: you can close the page, schedule runs for every night, and collect a whole city with your computer off.

#### Is this Apify Google Maps scraper legal to use?

The same answer applies as for any Google Maps scraper: business facts are public, personal data and Google's terms need your attention, and you are responsible for your use. See [Is it legal to scrape Google Maps?](#is-it-legal-to-scrape-google-maps)

#### Can I use an input from another Google Maps scraper?

Usually it starts as it is: the field names and values of the most used Google Maps scraper on Apify Store are accepted, except `maxCrawledPlacesPerSearch: 0` (leave the field out to get everything). The result is not always the same:

- Reviewer names are off unless `scrapeReviewsPersonalData` is `true`; there they are on by default.
- `categoryFilterWords` are matched as pieces of text, in the language of the results: `bar` also keeps "Barber shop".
- Reviews stop at 2,400 per place; `99999` is read as 2,400, with a note. `reviewsFilterString` and `reviewsOrigin` filter the reviews that were read; reviews further back are not searched.
- `scrapePlaceDetailPage` adds the star breakdown and nothing else.
- A search link returns one map view, up to 120 places. Short share links (`maps.app.goo.gl`, `goo.gl/maps`) are not read.
- `customGeolocation` takes no lines. With `locationQuery` filled as well, both areas are searched.
- `scrapeContacts` reads the website of each place, with the same output field names (`emails`, `facebooks`, `instagrams`, `linkedIns`, `twitters`, `youtubes`, `tiktoks`, `pinterests`), plus `emailDetails`, `websitePhones`, `whatsapps` and `contactFormUrl`. A website that refuses automated visits is not read (`contactsStatus` `websiteFailed`).
- Other add-ons (images, leads, social profile details, questions, web results, competitor analysis and the like) are ignored and listed under `notes` in the coverage record.

In the output the main fields keep their names, among them `title`, `categoryName`, `phone`, `phoneUnformatted`, `website`, `location`, `totalScore`, `reviewsCount`, `permanentlyClosed`, `placeId`, `cid`, `openingHours` and `reviews`. `url` is written differently (`.../maps/place/?q=place_id:...`), so match rows on `placeId`. Not delivered, for example: `plusCode`, `subTitle`, `isAdvertisement`, `menu`, `images`, `imageUrls`, `peopleAlsoSearch`, `reviewsTags`, popular times, and in reviews `reviewerId`, `reviewerPhotoUrl` and `likesCount`.

#### Does the order match what I see on Google Maps?

Roughly. Google has no single order: it changes with the viewer's location and country. This scraper asks for a view without those personal touches, so the same search gives nearly the same list from run to run. Searches in the United States are asked the way a visitor from outside the country sees them, which keeps the list stable; the order can therefore differ a little from what you see at home. With a place limit, rows come in Google's order for that view. `rank` is the position in the map view that first showed a place; positions repeat from view to view.

#### My run returned nothing or stopped. What went wrong?

The status message of the run says which case it is. In the first five, no places are charged.

- **"The area was not found on the map":** write the area the way a map would find it, for example `Springfield, Illinois`; a postal code needs its town or country. With several areas, the run stops only when none is found.
- **"The area could not be looked up right now":** the map service did not answer. Start the run again in a minute.
- **"'Reviews newer than' could not be read":** write a date as year-month-day, such as `2026-05-03`, or a number with days, weeks, months or years, such as `3 months`.
- **"The custom area could not be used":** give a `Polygon`, a `MultiPolygon` or a `Point` with `radiusKm`, not lines.
- **"Nothing to do":** add a search term, a place ID or a Google Maps link. An area alone is not enough. Short share links cannot be read: paste the long link from the address bar. The address of a text file of links must open the file itself, not a sharing or sign-in page.
- **No places:** is the search term something people type into Google Maps? Is a filter removing everything?
- **Fewer places than expected:** see [Why did I get fewer places than I expected?](#why-did-i-get-fewer-places-than-i-expected)

#### Why does a place have no rating or no opening hours?

Because its listing has none. New and small businesses often have no ratings yet, and many owners never enter their hours. The cell in your table is then empty. In rare cases only today's hours are known. A place for which Google returns a rating without the number of ratings is marked `limitedData: true`.

#### How do I get one review per row?

On screen, pick the table *Reviews (one per row)* above the results in Apify Console. The **Export** button does not follow that choice: its file has one row per place, with the reviews side by side, and Excel and CSV files stop at 2,000 columns.

For a file with one review per row:

1. Pick the table *Reviews (one per row)* and press **Preview in new tab**, next to the table names.
2. In the address bar of the new tab, change `format=html` to `format=xlsx` (or `format=csv`), delete `&limit=1000`, leave the rest as it is, and press Enter. The file downloads.

The address then looks like `https://api.apify.com/v2/datasets/DATASET_ID/items?format=xlsx&view=reviews&clean=true`. Each review comes with the name, place ID, rating and link of its place; with `unwind=reviews` in place of `view=reviews`, with every field of its place.

#### Where do I report a problem or ask for a feature?

Open the **Issues** tab of this Actor and describe what you ran and what you expected. I read every issue.

***

**The rest of this page is mostly for developers:** the comparison with the Google Places API, the API with Python and MCP, and every input and output field. If you only use the form, you can stop here, except for three how-tos: [several cities in one run](#scrape-several-cities-or-a-whole-region-in-one-run), [places by link or place ID](#scrape-google-maps-by-url-or-by-place-id) and [a radius or your own area](#search-a-radius-or-your-own-polygon). The [guide in Spanish](#guia-en-espanol-como-extraer-datos-de-google-maps) is at the end.

### Google Places API alternative

This Google Maps scraper is a Google Places API alternative for one job: getting the businesses of an area as a table. It needs no API key and no billing account, is not held to 60 results per search or 5 reviews per place, and costs $1.50 to $3.00 per 1,000 places. For other jobs Google's own Places API is the right choice.

#### Google Places API or this scraper: which one?

The Google Places API is Google's official interface for place data: a program sends a request with an API key and gets back up to 20 places per page. Figures are from Google's price list and documentation on 10 October 2026.

| | Google Places API (New) | Google Maps Scraper by nokia2k (this page) |
|---|---|---|
| What it is | Google's official, supported API, under Google's API terms | An independent tool that reads the public Google Maps website |
| What you need | A Google Cloud project, an API key and a billing account | An Apify account |
| Places per search | Up to 60 (Text Search, 20 per page). Nearby Search: up to 20 | No fixed limit: the area is split into smaller views |
| Reviews per place | Up to 5 | Up to 2,400 |
| Ratings over time | The all-time rating and up to 5 reviews | The rating of the last 3, 6 and 12 months, with trend |
| Keeping the data | Google's API terms limit what you may store: place IDs yes, most other content not | You download a file. Google's terms for Google Maps apply: see [Is it legal to scrape Google Maps?](#is-it-legal-to-scrape-google-maps) |

**Choose the Places API** when you are building an app that shows places to its users on a Google map, when you need autocomplete, or when you need a contract with Google behind the data. **Choose this scraper** for the businesses of an area as a table.

#### How much does the Google Places API cost?

Google Places API pricing is per request, not per place. A Text Search request that returns phone, website, rating and opening hours costs $35 per 1,000 requests, and $40 with reviews, for the first 100,000 requests a month; larger volumes cost less. One request returns up to 20 places, so the best case at that price is $1.75 per 1,000 places, when every request comes back full. Covering a whole city takes many overlapping requests, because each search stops at 60 places. This Google Maps scraper costs $1.50 to $3.00 per 1,000 places delivered, each place once.

#### Is the Google Places API free?

Partly. The Google Maps API (Google Maps Platform, which includes the Places API) is no longer free in the old way: since March 2025 Google gives no $200 monthly credit. Instead each kind of request has a free monthly allowance, the free tier of the Google Places API: 1,000 requests a month for the kind that returns phone, website, rating and opening hours. After that you pay per request.

#### Is there a free Google reviews API?

What people call the Google reviews API is part of Google's Places API, and it returns at most 5 reviews per place; 1,000 such requests a month are free. The Business Profile API, also called the Google My Business API, returns all reviews, but only for businesses you manage yourself. For the Google reviews of other businesses this Google Maps scraper works as a Google Maps reviews API: up to 2,400 reviews per place at $0.25 to $0.40 per 1,000 reviews, plus the price of each place they belong to.

### Google Maps scraper API, Python and MCP

Everything the form does can be done from code. Through the API there is no default limit of 50 places: set `maxCrawledPlacesPerSearch`, or a maximum cost for the run, in every call. Always send an area (`locationQuery`, `locations` or `customGeolocation`) with a search term: without one, a term is searched once and returns at most 120 places. An unknown field name such as `maxPlaces` is ignored and named under `notes` in the coverage record.

#### Use it as a Google Maps scraper API

This one call starts a run, waits for it and returns the places as JSON. Replace `YOUR_TOKEN` with your Apify API token, which you find in the settings of Apify Console, under API and integrations.

```bash
curl -X POST "https://api.apify.com/v2/actors/nokia2k~google-maps-scraper-rating-trends/run-sync-get-dataset-items?token=YOUR_TOKEN&maxTotalChargeUsd=1" \
  -H "Content-Type: application/json" \
  -d '{"searchStringsArray": ["dentist"], "locationQuery": "Austin, Texas", "maxCrawledPlacesPerSearch": 100}'
```

Add `&format=csv` or `&format=xlsx` to the address to receive a spreadsheet instead of JSON. This call waits up to 5 minutes; for larger jobs start the run and fetch the dataset when it has finished, as the Python example does.

#### How to scrape Google Maps with Python

This Google Maps scraper runs from Python through Apify's `apify-client` package: start a run, wait for it, then read the places from its dataset.

```python
## pip install apify-client   (version 3 or newer)
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("nokia2k/google-maps-scraper-rating-trends").call(
    run_input={
        "searchStringsArray": ["dentist"],
        "locationQuery": "Austin, Texas",
        "maxCrawledPlacesPerSearch": 100,
        "recentReputation": True,
    },
    max_total_charge_usd=1,
)
for place in client.dataset(run.default_dataset_id).iterate_items():
    print(place["title"], place["phoneUnformatted"], place["totalScore"], place["ratingTrend"])
```

Each place has a stable key, `placeId`. With a place limit, rows come in Google's order; without one, in the order they were finished. The same works in JavaScript with the `apify-client` package from npm.

A run ends as `FAILED` when it cannot start: nothing to search, no area found, no answer from the map service, a custom area it cannot use, an unreadable **Reviews newer than**, no usable proxy with `proxyOnly` on, or a table of the run it cannot read. No places are charged then, and the status message says what to change, or to start the run again. A run that fails later (rare: Apify's storage stopped taking places) keeps and charges the places in its table; **Resurrect** goes on from there. Every other run that the scraper finishes ends as `SUCCEEDED`, also when a single search or place failed on the way, and also when it stopped at its spending limit or close to its time or memory limit. So read the coverage record: `stoppedEarly` is an empty list when the run finished its work, and holds `spendingLimit`, `timeLimit` or `memoryLimit` when it did not. To get the rest from a program, resurrect the run with that limit raised: `POST https://api.apify.com/v2/actor-runs/RUN_ID/resurrect?token=YOUR_TOKEN&maxTotalChargeUsd=2` (or `timeout` in seconds, or `memory` in MB). Only the missing places are added and charged.

#### The coverage record

Every run saves a record called `COVERAGE` in its key-value store, where a run keeps its side files: the **Storage** tab of the run, or `https://api.apify.com/v2/key-value-stores/STORE_ID/records/COVERAGE?token=YOUR_TOKEN`, where `STORE_ID` is `defaultKeyValueStoreId` of the run (in Python `run.default_key_value_store_id`). The one-call example above returns only the places; the record of your latest run is at `https://api.apify.com/v2/actors/nokia2k~google-maps-scraper-rating-trends/runs/last/key-value-store/records/COVERAGE?token=YOUR_TOKEN`. The main numbers of a real run, `coffee shop` in Santa Fe:

```json
{
  "delivered": 98,
  "uniquePlaces": 98,
  "outOfAreaDropped": 29,
  "filteredOut": 0,
  "cells": 35,
  "cellsSplit": 10,
  "queriesCapped": 6,
  "newPlacesByDepth": {"0": 0, "2": 95, "3": 1, "4": 2},
  "requests": 215,
  "seconds": 7.0
}
```

35 map views were searched and 10 were split for a closer look. 6 searches hit Google's limit of 120. Two zoom steps in, 95 places were found; the next two steps added only 3 more, the sign that zooming further would bring little. `seconds` is the search alone. The record also has `areas` (what each area was resolved to), `errors` (empty when all went well), `notes` (settings that were ignored, or why the run stopped early), `stoppedEarly` (the same reason as a fixed word, for programs), `placesNotRead` (place IDs or links that could not be read), `placesAlreadyDelivered` (those whose place was already delivered, with its `placeId`), `storedBefore` (places stored before a restart), and, only when there is something to say, `areasSkipped`, `searchesAtPlaceLimit` and `inputFieldsIgnored`.

#### Google Maps MCP: use it from AI assistants

AI assistants that support MCP can run this scraper by themselves through the Apify MCP server.

1. Add the server address `https://mcp.apify.com/?tools=nokia2k/google-maps-scraper-rating-trends` to your assistant's MCP settings.
2. Sign in to Apify when asked.
3. Ask in plain words, for example: *"Find 50 dentists in Austin and tell me whose Google rating went down in the last six months."*

Tell the assistant how many places you want: without a number it may ask for all of them, and a large city may not finish inside one tool call. With this address it cannot set a maximum cost, so that number is your limit. If an assistant sends a list as one text, such as `["dentist","orthodontist"]` or one item per line, it is read as the list.

#### Does Google Maps have an MCP server?

Yes. Google offers its own MCP server for Maps, called Grounding Lite. Its tools let an AI assistant look up places, routes and weather. It needs a Google API key or a Google sign-in and is billed per request after a free monthly allowance. Getting the businesses of a kind in a whole city as a table, with their reviews and recent ratings, is the job of a scraper like this one.

### Input: every setting explained

This section gives the settings of the form for people who write the input as JSON.

#### Input example

The first run from the tutorial as JSON, with recent reputation, two reviews per place and the star breakdown switched on:

```json
{
  "searchStringsArray": ["coffee shop"],
  "locationQuery": "Santa Fe, New Mexico",
  "maxCrawledPlacesPerSearch": 50,
  "language": "en",
  "recentReputation": true,
  "maxReviews": 2,
  "scrapePlaceDetailPage": true
}
```

#### Scrape several cities or a whole region in one run

Put more areas in **More areas**, one per line: districts, cities, counties or larger regions, by a name that a map can find. Each place is delivered once, even where areas overlap. An area that is not found is skipped and named in the coverage record. The runs measured on this page are cities; for a state or a country, split the job into counties, provinces or districts, so that each run stays quick and inside its time and memory limits.

```json
{
  "searchStringsArray": ["dentist", "orthodontist"],
  "locationQuery": "Austin, Texas",
  "locations": ["Round Rock, Texas", "Cedar Park, Texas"]
}
```

Area names are looked up in OpenStreetMap. To check what a name resolves to, type it into the search box at openstreetmap.org.

#### Scrape Google Maps by URL or by place ID

Paste links from the address bar of Google Maps into **Google Maps links**, or place IDs into **Place IDs**, to refresh places you already have. A place ID starts with `ChIJ`: take it from the `placeId` column of an earlier run, from the Google Places API or from Google's Place ID Finder. Every ID and place link is read, whatever **Places per search term** says. A search link returns that one map view: at most 120 places, and no more than **Places per search term** (50 on the form). Short share links (`maps.app.goo.gl`) cannot be read. The box also takes a text file with one link per line; in JSON that is `{"requestsFromUrl": "https://..."}`. To read every place of an earlier run again, give that run's ID (or its dataset ID) in **Place IDs from earlier runs** instead of copying its `placeId` column: the tables are read by this Actor itself, and a place that is in several of them is read once. Each place read by ID or by a place link carries what you sent (`inputPlaceId` or `inputStartUrl`); places from a search link carry its search words in `searchString`. On the form, empty **Search terms** and **Area** first if you want only these places: its sample search would run, and be charged, as well.

```json
{
  "placeIds": ["ChIJm0hdIQ1QGIcRpDnU4qK8Q4M"],
  "startUrls": [{"url": "https://www.google.com/maps/search/dentist/@30.2672,-97.7431,14z"}]
}
```

#### Search a radius or your own polygon

Give **Custom area (GeoJSON)** a point and a radius in kilometres (5 km when left out), or a shape you drew yourself: a delivery zone, a sales territory, everything within 3 km of your shop. Draw it at geojson.io and paste what the site gives you: a `Polygon`, a `MultiPolygon`, or a `Feature` or `FeatureCollection` holding them. Lines are not accepted. Coordinates are longitude first, then latitude. A custom area is searched in addition to **Area**, so empty **Area** when you want only your own shape.

```json
{
  "searchStringsArray": ["pharmacy"],
  "customGeolocation": {"type": "Point", "coordinates": [-105.9378, 35.687], "radiusKm": 3}
}
```

#### All input fields

The table follows the sections of the form. "Default" is the value used when a field is left out.

| Box on the form | Name in JSON | Values |
|---|---|---|
| **📍 What and where** | | |
| Search terms | `searchStringsArray` | One term per line. A term written `place_id:ChIJ...` is read as a place ID. |
| Area | `locationQuery` | City, district, county or region to cover. A postal code next to its town or country (`78701, Austin, Texas` or `87501, USA`) delivers only places with that code; a code alone also needs `countryCode`. Coordinates (`30.2672, -97.7431`, latitude first) search 5 km around that point. |
| More areas | `locations` | Further areas for the same run. |
| Places per search term | `maxCrawledPlacesPerSearch` | Places to deliver for each term in each area and for each search link, counted after the filters. Left out: all. 50 on the form; no default through the API. |
| Language of the results | `language` | A code such as `en` (default), `es`, `de`, `pt-BR`. |
| Coverage | `coverage` | `standard` (default) or `deep`. |
| **🔗 Start from links or place IDs** | | |
| Google Maps links | `startUrls` | Place or search links from the address bar, each as `{"url": "..."}`, or a text file of links (at most 5,000) as `{"requestsFromUrl": "..."}`. Short share links are not read. |
| Place IDs from earlier runs | `placeIdsFromDatasets` | Dataset IDs or run IDs of earlier runs of this Actor (or links to them): every place in their tables is read again by its ID, without a search. For a fresh **Recent reputation** or **Emails and social profiles** over places you already have. |
| Places to skip | `skipPlaceIdsFromDatasets` | Dataset IDs or run IDs whose places are left out of Place IDs from earlier runs: continue a run that stopped at its spending limit. |
| Place IDs | `placeIds` | Google place IDs to read directly, also as `place_id:ChIJ...`, several in one line, or a link. A `cid` or `fid` is skipped with a note. |
| **⭐ Reviews and recent reputation** | | |
| Recent reputation (last 3, 6 and 12 months) | `recentReputation` | `true` adds the ratings of the last 3, 6 and 12 months and the trend. Default `false`. |
| Rating trend | `ratingTrendFilter` | `any` (default), `down`, `up` or `flat`. Every value but `any` turns recent reputation on. |
| Reviews per place | `maxReviews` | 0 (default) to 2,400. A larger number is read as 2,400. |
| Review order | `reviewsSort` | `newest` (default), `mostRelevant`, `highestRanking` or `lowestRanking`. |
| Reviews newer than | `reviewsStartDate` | A date as year-month-day (`2026-05-03`), a date and time (`2026-05-03T20:00:00`), or a number with minutes, hours, days, weeks, months or years (`3 months`, `2 weeks`). Anything else stops the run before anything is searched; no places are charged. Needs **Reviews per place** above 0. Keep `reviewsSort` at `newest`. |
| Reviewer names | `scrapeReviewsPersonalData` | `true` adds reviewer name, profile link and review link. Default `false`. |
| **🎯 Filters (all free)** | | |
| Website | `website` | `allPlaces` (default), `withWebsite`, `withoutWebsite`, `realWebsiteOnly` or `noRealWebsite`. |
| Only places with a phone number | `phoneRequired` | Default `false`. |
| Only unclaimed profiles | `unclaimedOnly` | `true` keeps only places whose profile shows no owner. Default `false`. `onlyUnclaimed` is accepted too. |
| Minimum rating | `placeMinimumStars` | `two`, `twoAndHalf`, `three`, `threeAndHalf`, `four` or `fourAndHalf`. Leaves out places without a rating. |
| Maximum rating | `placeMaximumStars` | The same values. Leaves out places without a rating. |
| Minimum number of ratings | `minReviewsCount` | A number. |
| Maximum number of ratings | `maxReviewsCount` | A number; `0` keeps only places that nobody has rated yet. |
| Only these categories | `categoryFilterWords` | Words. A place is kept when a category contains one of them; accents and capitals do not matter. With an area and no search term, the words are searched for. |
| Leave out these categories | `excludeCategories` | Words. A place is dropped when a category contains one of them. |
| Name must match the search term | `searchMatching` | `all` (default), `only_includes` (name contains the term) or `only_exact`. |
| Leave out names containing | `excludeNameWords` | Words. A place is dropped when its name contains one of them. |
| **➕ More data per place** | | |
| Star breakdown for every place | `scrapePlaceDetailPage` | `true` reads each place's own page for the star breakdown. Default `false`. |
| Emails and social profiles from the website | `scrapeContacts` | `true` reads each place's own website for email addresses and social profiles. No extra charge. Default `false`. |
| **🗺️ Other ways to give the area** | | |
| Custom area (GeoJSON) | `customGeolocation` | A `Polygon`, a `MultiPolygon` or a `Point` with `radiusKm`. Searched in addition to Area. |
| Country, State or region, County, City, Postal code | `countryCode`, `state`, `county`, `city`, `postalCode` | An area in separate boxes, used only when Area and More areas are empty (otherwise ignored, and the status message says so). `countryCode`, two letters, is also used for a postal code written alone in Area; on its own it searches the whole country. With `postalCode` (never alone: add `countryCode`), the part of the map where Google lists places with that code is searched, and only places with that postal code are delivered (a longer form of the same code, such as 87501-1234, counts). |
| **⚙️ Connection** | | |
| Proxy | `proxyConfiguration` | Leave as it is. |
| All requests to Google through the proxy | `proxyOnly` | Default `false`. If there is no proxy, or it cannot be set up, `true` stops the run at the start (no places charged); `false` goes on without it, with a note after a failed set-up. |
| Requests at the same time | `maxConcurrency` | 1 to 96, default 64. |
| Runs at once in your account | `maxRunsAtOnce` | Empty by default (start at once). With a number such as 3, the run waits while that many earlier runs of this Actor are working in your account: runs started together slow each other down and use more residential proxy. Nothing is searched or charged while waiting. |
| Residential proxy allowance (MB) | `maxResidentialMegabytes` | Empty by default (no limit). After that many megabytes of residential proxy the run goes on with the standard addresses only, more slowly, without dropping places. 300 suits a whole region. |

Not on the form, but applied through the API: `skipClosedPlaces` (`true` leaves out temporarily and permanently closed places; they are not charged) and `reviewsOrigin` (`google` keeps only reviews written on Google).

### Google Maps data extractor: output fields

This Google Maps data extractor returns one item per business: the place fields below, plus the recent reputation fields and the reviews when you switched those options on.

#### Output example

One place from the tutorial run (the input example above), shortened to two opening days and one review. The review text and its ID are replaced by placeholders here.

```json
{
  "title": "Betterday Coffee",
  "categoryName": "Coffee shop",
  "categories": ["Coffee shop"],
  "address": "905 W Alameda St, Santa Fe, NM 87501",
  "street": "905 W Alameda St",
  "neighborhood": null,
  "city": "Santa Fe",
  "postalCode": "87501",
  "state": "New Mexico",
  "countryCode": "US",
  "phone": "(505) 780-5638",
  "phoneUnformatted": "+15057805638",
  "website": "http://thebetterday.us/",
  "domain": "thebetterday.us",
  "websiteType": "website",
  "location": {"lat": 35.6894485, "lng": -105.9582093},
  "totalScore": 4.3,
  "reviewsCount": 388,
  "reviewsDistribution": {"oneStar": 23, "twoStar": 21, "threeStar": 26, "fourStar": 55, "fiveStar": 263},
  "price": null,
  "description": null,
  "highlight": "Brunch",
  "temporarilyClosed": false,
  "permanentlyClosed": false,
  "claimThisBusiness": false,
  "imagesCount": 114,
  "openingStatus": "Closed · Opens 7 AM",
  "openingHours": [
    {"day": "Saturday", "hours": "7 AM–5 PM"},
    {"day": "Sunday", "hours": "7 AM–5 PM"}
  ],
  "additionalInfo": {"Accessibility": [{"Wheelchair accessible entrance": true}]},
  "placeId": "ChIJm0hdIQ1QGIcRpDnU4qK8Q4M",
  "cid": "9458611050184456612",
  "fid": "0x8718500d215d489b:0x8343bca2e2d439a4",
  "kgmid": "/g/1hc66qfyx",
  "url": "https://www.google.com/maps/place/?q=place_id:ChIJm0hdIQ1QGIcRpDnU4qK8Q4M",
  "imageUrl": "https://lh3.googleusercontent.com/gps-cs-s/example=w114-h86-k-no",
  "timezone": "America/Denver",
  "searchString": "coffee shop",
  "rank": 20,
  "limitedData": false,
  "rating3Months": 4.5,
  "reviews3Months": 14,
  "rating6Months": 4.55,
  "reviews6Months": 22,
  "rating12Months": 4.07,
  "reviews12Months": 54,
  "ratingTrend": "up",
  "ratingChange": 0.8,
  "rating12MonthsVsAllTime": -0.23,
  "ownerReplyRate12Months": 0.28,
  "latestReviewDate": "2026-10-03T14:52:31.106Z",
  "recentReputationComplete": true,
  "reviews": [
    {
      "reviewId": "REVIEW_ID",
      "stars": 4,
      "publishedAtDate": "2026-10-03T14:52:31.106Z",
      "publishAt": "6 days ago",
      "text": "TEXT OF THE REVIEW",
      "textTranslated": null,
      "originalLanguage": "en",
      "responseFromOwnerText": null,
      "responseFromOwnerDate": null,
      "reviewDetailedRating": {"Food": 4, "Service": 4, "Atmosphere": 3},
      "reviewContext": {"Noise level": "Quiet, easy to talk"},
      "reviewImageUrls": [],
      "reviewOrigin": "Google"
    }
  ],
  "scrapedAt": "2026-10-10T06:37:07Z"
}
```

A value that the listing does not have is `null`; a list without entries is `[]`. In a spreadsheet both are an empty cell.

#### Place fields

| Field | Type | What it holds | Example |
|---|---|---|---|
| `title` | string or null | Name of the business as shown on Google Maps. | `Betterday Coffee` |
| `categoryName` | string or null | Main category, in the language you chose. | `Coffee shop` |
| `categories` | array | Every category of the listing, main one first. | `["Coffee shop"]` |
| `address` | string or null | Full address in one line. | `905 W Alameda St, Santa Fe, NM 87501` |
| `street` | string or null | Street and number. | `905 W Alameda St` |
| `neighborhood` | string or null | Neighborhood or district, when Google lists one. Empty for most places. | `Casco Histórico` |
| `city` | string or null | City or town. | `Santa Fe` |
| `postalCode` | string or null | Postal or ZIP code. | `87501` |
| `state` | string or null | State, province or region. | `New Mexico` |
| `countryCode` | string or null | Two-letter country code. | `US` |
| `location` | object | Coordinates of the pin: `lat` and `lng`. | `{"lat": 35.6894485, "lng": -105.9582093}` |
| `timezone` | string or null | Time zone of the place. | `America/Denver` |
| `phone` | string or null | Phone number as Google prints it; the spelling depends on the country. For dialing use `phoneUnformatted`. | `(505) 780-5638` |
| `phoneUnformatted` | string or null | The same number in international format, ready for a dialer or a CRM. | `+15057805638` |
| `website` | string or null | The link in the listing's website field. | `http://thebetterday.us/` |
| `domain` | string or null | Domain of that link, without www. | `thebetterday.us` |
| `websiteType` | string | `social` (Facebook, Instagram and the like) or `platform` (booking, delivery, menu, directory and link-in-bio pages, free website-builder addresses such as `name.wixsite.com`) when the registered domain of the link is on a list of known sites; `website` for any other link; `none` for no link. | `website` |
| `emails` | array or null | Email addresses published on the business's own website: its home page and up to two of its contact, about or legal pages. Addresses of the website's own domain come first. Only with `scrapeContacts` on. | `["hello@thebetterday.us"]` |
| `facebooks` | array or null | Facebook pages linked from the website (or the Facebook page the listing links instead of a website). Share buttons are left out. Only with `scrapeContacts` on. | `["https://www.facebook.com/thebetterdaycoffee"]` |
| `instagrams` | array or null | Instagram profiles linked from the website. Only with `scrapeContacts` on. | `["https://www.instagram.com/thebetterdaycoffee"]` |
| `linkedIns` | array or null | LinkedIn pages linked from the website. Only with `scrapeContacts` on. | `["https://www.linkedin.com/company/betterday-coffee"]` |
| `twitters` | array or null | X (Twitter) profiles linked from the website. Only with `scrapeContacts` on. | `["https://x.com/betterdaycoffee"]` |
| `youtubes` | array or null | YouTube channels linked from the website. Only with `scrapeContacts` on. | `["https://www.youtube.com/@betterdaycoffee"]` |
| `tiktoks` | array or null | TikTok profiles linked from the website. Only with `scrapeContacts` on. | `["https://www.tiktok.com/@betterdaycoffee"]` |
| `pinterests` | array or null | Pinterest profiles linked from the website. Only with `scrapeContacts` on. | `["https://www.pinterest.com/betterdaycoffee"]` |
| `emailDetails` | array or null | One entry per address in `emails`: `type` is `own` (the website's own domain), `free` (a personal mailbox such as Gmail or Hotmail) or `other`; `foundOn` is the page it was read on; `mailServer` is true when the domain can receive mail. Addresses whose domain cannot receive mail are left out. Only with `scrapeContacts` on. | `[{"email": "hello@thebetterday.us", "type": "own", "foundOn": "https://thebetterd...` |
| `websitePhones` | array or null | Phone numbers the website links (call links), up to three. A number written without its country code gets the code of the place's country. Only with `scrapeContacts` on. | `["+15059824040"]` |
| `whatsapps` | array or null | WhatsApp numbers the website links (wa.me and similar links), up to three. Only with `scrapeContacts` on. | `["+15059824040"]` |
| `contactFormUrl` | string or null | The website's page with a contact form (a message box), when one was found. Only with `scrapeContacts` on. | `https://thebetterday.us/contact` |
| `contactsStatus` | string or null | `found` (an address, a profile, a phone or a contact form was found), `nothingFound` (the website was read and shows none), `websiteFailed` (the website did not answer) or `noWebsite` (the listing has no website of its own). Only with `scrapeContacts` on. | `found` |
| `totalScore` | number or null | All-time average rating, 1 to 5. | `4.3` |
| `reviewsCount` | integer or null | All-time number of ratings. | `388` |
| `reviewsDistribution` | object or null | How many 1, 2, 3, 4 and 5 star ratings the place has. With `scrapePlaceDetailPage` on, present for every rated place in a test (602 of 602); without it, only for a few. | `{"oneStar": 23, "twoStar": 21, "threeStar": 26, "fourStar": 55, "fiveStar": 263}` |
| `price` | string or null | Price range, as Google shows it. Empty for nearly all places. | `10-60 €` |
| `description` | string or null | Short description of the business, when the listing has one. | `Laid-back cafe with house-roasted coffee and breakfast burritos.` |
| `highlight` | string or null | The one-line highlight Google prints under the name in search results. Empty for permanently closed places. | `Brunch` |
| `additionalInfo` | object | Attributes of the listing grouped by section (accessibility, payments, service options and so on), each marked true or false, named in the language you chose. | `{"Accessibility": [{"Wheelchair accessible entrance": true}]}` |
| `imageUrl` | string or null | Link to the listing's cover photo, small preview size. | `https://lh3.googleusercontent.com/gps-cs-s/example=w114-h86-k-no` |
| `imagesCount` | integer or null | Number of photos on the listing. | `114` |
| `temporarilyClosed` | boolean | True when Google marks the place as temporarily closed. | `false` |
| `permanentlyClosed` | boolean | True when Google marks the place as permanently closed. Such places still appear in searches by name. | `false` |
| `claimThisBusiness` | boolean or null | True when Google shows no owner for the Google Business Profile, false when it shows one. Empty when unknown. | `false` |
| `openingStatus` | string or null | Open or closed at the moment of the run, in Google's words. Text, not true or false. | `Closed · Opens 7 AM` |
| `openingHours` | array | Opening hours for each day of the week: `day` and `hours`, in the language you chose. An empty list when the listing has no hours. | `[{"day": "Monday", "hours": "7 AM–5 PM"}]` |
| `placeId` | string or null | Google place ID. The same ID the Google Places API uses. | `ChIJm0hdIQ1QGIcRpDnU4qK8Q4M` |
| `cid` | string or null | The number Google uses in `maps.google.com/?cid=` links. It is the second half of `fid` written as a decimal number. | `9458611050184456612` |
| `fid` | string or null | Google's internal ID of the place (feature ID), two hexadecimal numbers. | `0x8718500d215d489b:0x8343bca2e2d439a4` |
| `kgmid` | string or null | Google Knowledge Graph ID. | `/g/1hc66qfyx` |
| `url` | string or null | Link that opens the place on Google Maps. To match rows between runs use `placeId`. | `https://www.google.com/maps/place/?q=place_id:ChIJm0hdIQ1QGIcRpDnU4qK8Q4M` |
| `searchString` | string or null | The search term that first found this place (for a search link: its search words). `null` for places read by place ID or by a place link. | `coffee shop` |
| `rank` | integer or null | Position of the place in the Google Maps result list that first showed it. A large area is searched in many map views, so the same position can appear more than once. `null` for places read by place ID or by a place link. | `20` |
| `inputPlaceId` | string or null | Only on places read by place ID: the ID you sent, also when it came inside a link. Google sometimes answers with a newer `placeId`. | `ChIJm0hdIQ1QGIcRpDnU4qK8Q4M` |
| `inputStartUrl` | string or null | Only on places read by a place link that holds no place ID: the link you sent. Not on places found through a search link. | `https://www.google.com/maps/place/Betterday+Coffee/@35.6894485,-105.9582093,17z` |
| `limitedData` | boolean | True in the rare case that Google gave a rating but no number of ratings for the place. | `false` |
| `scrapedAt` | string | When the place was read (UTC). | `2026-10-10T06:37:07Z` |

#### Recent reputation fields

Present when **Recent reputation** is on (the `reviews` list when **Reviews per place** is above 0). If the reviews of a place could not be read, only `ratingTrend` (`notEnoughData`) and `recentReputationComplete` (`false`) are set, the problem is noted in the coverage record, and recent reputation is not charged for that place.

| Field | Type | What it holds | Example |
|---|---|---|---|
| `rating3Months` | number or null | Average rating of the last 3 months. | `4.5` |
| `reviews3Months` | integer or null | Number of ratings in the last 3 months. | `14` |
| `rating6Months` | number or null | Average rating of the last 6 months. | `4.55` |
| `reviews6Months` | integer or null | Number of ratings in the last 6 months. | `22` |
| `rating12Months` | number or null | Average rating of the last 12 months. | `4.07` |
| `reviews12Months` | integer or null | Number of ratings in the last 12 months. | `54` |
| `ratingTrend` | string | `up`, `down` or `flat`: the last 6 months compared with the 6 months before. `notEnoughData` when either half-year has fewer than 5 ratings, or when the reviews could not be read back a full 12 months. | `up` |
| `ratingChange` | number or null | Average of the last 6 months minus the average of the 6 months before. 0.3 or more counts as a trend. | `0.8` |
| `rating12MonthsVsAllTime` | number or null | Average of the last 12 months minus the all-time rating. Negative: the place is doing worse than its all-time rating suggests. | `-0.23` |
| `ownerReplyRate12Months` | number or null | Share of the last 12 months' reviews that the owner answered, from 0 (none) to 1 (all). | `0.28` |
| `latestReviewDate` | string or null | Date of the newest review. | `2026-10-03T14:52:31.106Z` |
| `recentReputationComplete` | boolean | False when the reviews could not be read back a full 12 months; the counts of the periods not read in full are then a minimum. | `true` |
| `reviews` | array | The reviews of the place when `maxReviews` is above 0, in the order you chose; an empty list when the place has none. Each one has the review fields. | see the review fields |

#### Review fields

| Field | Type | What it holds | Example |
|---|---|---|---|
| `reviewId` | string or null | Google's ID of the review. | `ChZDSUhNMG9nS0VJQ0FnSUN4eGM0` |
| `stars` | integer or null | Stars given, 1 to 5. | `4` |
| `publishedAtDate` | string or null | Exact date and time of the review (UTC). | `2026-10-03T14:52:31.106Z` |
| `publishAt` | string or null | The relative date Google shows, as text. For a real date use `publishedAtDate`. | `6 days ago` |
| `text` | string or null | Text of the review. Null when the reviewer left only stars. | `Go for the coffee` |
| `textTranslated` | string or null | Google's translation into the language you chose, when the review is in another language. | `Ve por el café` |
| `originalLanguage` | string or null | Language the review was written in. | `en` |
| `responseFromOwnerText` | string or null | The owner's reply, when there is one. | `Thank you for visiting us!` |
| `responseFromOwnerDate` | string or null | When the owner replied, as the relative text Google shows; not a date. | `5 days ago` |
| `reviewDetailedRating` | object | Ratings per aspect, such as food, service and atmosphere, named in the language you chose. | `{"Food": 4, "Service": 4, "Atmosphere": 3}` |
| `reviewContext` | object | Extra answers the reviewer gave, such as meal type, price per person or wait time. | `{"Meal type": "Breakfast", "Noise level": "Quiet, easy to talk"}` |
| `reviewImageUrls` | array | Links to the photos attached to the review. | `["https://lh3.googleusercontent.com/geougc-cs/example"]` |
| `reviewOrigin` | string | Where the review comes from. Google also shows reviews from a few partner sites. | `Google` |

With **Reviewer names** on, each review also has:

| Field | Type | What it holds | Example |
|---|---|---|---|
| `name` | string or null | Reviewer's display name. | `Alex R.` |
| `reviewerUrl` | string or null | Link to the reviewer's public profile. | `https://www.google.com/maps/contrib/100000000000000000000` |
| `reviewerNumberOfReviews` | integer or null | How many reviews the reviewer has written. | `27` |
| `isLocalGuide` | boolean | True when the reviewer is a Google Local Guide. | `true` |
| `reviewUrl` | string or null | Direct link to the review. | `https://www.google.com/maps/reviews/data=example` |

### Other scrapers by the same developer

nokia2k also publishes five YouTube tools on Apify Store: [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper), [YouTube Video to Text](https://apify.com/nokia2k/youtube-video-to-text), [YouTube Search Transcripts](https://apify.com/nokia2k/youtube-search-transcripts), [YouTube Channel Transcripts](https://apify.com/nokia2k/youtube-channel-transcripts) and [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper).

### Guía en español: cómo extraer datos de Google Maps

Para extraer datos de Google Maps sin código, abre este scraper de Google Maps en Apify, escribe un tipo de negocio y una zona y pulsa **Start** (empezar): recibes los negocios en una tabla que puedes descargar en Excel o CSV. La primera prueba, de 50 lugares, cuesta 0,15 $ (dólares de Estados Unidos), que salen de los 5 $ gratis que Apify da cada mes.

El formulario está en inglés. Esta guía da los nombres de las casillas y de los botones tal como aparecen en pantalla, con su traducción. Si el navegador te ofrece traducir la página, no lo aceptes: los nombres dejarían de coincidir.

#### ¿Qué es Google Maps Scraper? Un extractor de Google Maps sin código

Google Maps Scraper es un extractor de Google Maps: convierte una búsqueda de Google Maps en una hoja de cálculo que puedes abrir en Excel. Escribes un tipo de negocio y una zona, por ejemplo *dentista* en *Toledo, España*, y recibes los negocios locales que Google Maps muestra allí, cada uno con su nombre, teléfono, página web, dirección, puntuación, número de valoraciones y horario. Sirve para crear una base de datos de empresas de una ciudad, conseguir leads (clientes potenciales), estudiar a la competencia o seguir las reseñas de Google. Funciona en la nube, sin clave de API de Google, sin extensión del navegador y sin código.

Las fichas de Google Maps no muestran correos electrónicos (emails). Si activas **Emails and social profiles from the website** (correos y redes sociales de la web), lee la página web de cada negocio y entrega los correos, los perfiles de redes sociales, los teléfonos y WhatsApp que esa web publica y su página de contacto, sin coste extra. Los correos cuyo dominio no puede recibir mensajes se descartan. No descarga las fotos: da el enlace a la foto de portada. No recoge preguntas y respuestas, horas de más afluencia, menús ni enlaces de reserva.

#### Cómo extraer datos de Google Maps a Excel, paso a paso

1. Arriba, en esta página, pulsa **Try for free** (probar gratis; el texto puede variar algo).
2. Apify, la web donde funciona la herramienta, te pide que crees una cuenta: con tu correo y una contraseña, o con uno de los botones de registro. Es gratis y no pide tarjeta. Si Apify te envía un correo para confirmar tu dirección, pulsa el enlace que trae; si te pregunta para qué vas a usar Apify, responde o sáltate la pregunta.
3. Aparece una página cuyo título empieza por **Google Maps Scraper** y, debajo, un formulario que empieza por **Search terms** y **Area**. Para empezar solo importan esas dos casillas. Si ves otra página, vuelve aquí y pulsa **Try for free** otra vez.
4. En **Search terms** (qué buscar), cambia `coffee shop` por el tipo de negocio que buscas, como lo escribirías en Google Maps. Ejemplo: `ferretería`.
5. En **Area** (zona), cambia `Santa Fe, New Mexico` por tu ciudad y tu país. Ejemplo: `Toledo, España`. No dejes esta casilla vacía.
6. Deja **Places per search term** (lugares por búsqueda) en `50` esta primera vez. Cada lugar es un negocio. Cincuenta cuestan 0,15 $, que salen de los 5 $ de saldo gratis que Apify da cada mes.
7. Justo debajo, en **Language of the results** (idioma de los resultados), elige **Spanish** (español) o **Spanish (Latin America)** (español de América Latina). Si no lo cambias, las categorías y los horarios llegan en inglés.
8. Al final del formulario, pulsa **Start** (empezar); puede decir **Save & Start**. Empieza una ejecución: así se llama cada trabajo de la herramienta.
9. En menos de un minuto aparece la palabra **Succeeded** (terminado), y la pestaña **Output** (resultados) muestra una tabla: un negocio por fila.
10. Encima de la tabla pulsa **Export** (exportar), elige **Excel** y pulsa **Download** (descargar). El archivo se guarda normalmente en la carpeta **Descargas**: ábrelo con doble clic.

¿Te sirve la muestra? Vuelve al formulario: pulsa el nombre de la herramienta, en la parte de arriba de la página de la ejecución. El formulario suele conservar lo que escribiste. Vacía la casilla **Places per search term** y pulsa **Start** otra vez: recibes todos los lugares que la búsqueda encuentra en tu ciudad. Una ciudad grande puede gastar los 5 $ gratis del mes, porque 1.000 lugares cuestan 3,00 $. Para ir sobre seguro, escribe `500` en vez de vaciar la casilla.

Si no ves una casilla que cita esta guía, pulsa el título de su apartado para abrirlo. Los filtros están en **🎯 Filters (all free)** (filtros, todos gratis); las reseñas y la reputación reciente, en **⭐ Reviews and recent reputation**.

#### Después de pulsar Start: qué pasa y qué hacer si algo falla

- **¿Cuánto tarda?** Entre 5 y 15 segundos para una muestra de 50 lugares; entre unos diez segundos y varios minutos para una ciudad entera. Las reseñas y la reputación reciente alargan la ejecución.
- **¿Puedo parar?** Sí, con **Abort** (detener), en la página de la ejecución. Los lugares llegan a la tabla cada pocos segundos: los encontrados hasta ese momento se conservan, y solo pagas esos.
- **¿Y si cierro la ventana?** No se pierde nada. Entra otra vez en console.apify.com, pulsa **Runs** (ejecuciones) en el menú y abre la línea más reciente.
- **¿Pago si falla?** Pagas los lugares que llegan a tu tabla, más la tarifa de inicio de 0,0002 $ que tiene cada ejecución. Si la ejecución falla, la página muestra un mensaje que dice por qué. Está en inglés: si no lo entiendes, cópialo y pégalo en un traductor. Lo más frecuente es que la zona de **Area** no se encuentre en el mapa: entonces no se cobra ningún lugar (solo la tarifa de inicio de 0,0002 $). Vuelve al formulario (pulsa el nombre de la herramienta, en la parte de arriba de la página de la ejecución), escribe la zona con su provincia, su estado o su país y prueba otra vez.
- **¿Dónde veo cuánto costó una ejecución?** En la página de la ejecución, junto a la palabra **Succeeded**. Para ver cuánto llevas gastado de los 5 $ del mes, pulsa **Billing** (facturación) en el menú.
- **Excel muestra letras raras, todo en una sola columna o códigos postales sin el 0 inicial.** Exporta como **Excel**, no como CSV.
- **¿Cuánto tiempo se guardan los resultados?** Al menos 7 días; el plazo depende de tu plan de Apify. Descarga el archivo para conservarlo.

#### Cómo exportar los resultados de Google Maps a Excel o CSV

Para exportar los resultados de una búsqueda de Google Maps a Excel o CSV, abre la pestaña **Output**, pulsa **Export**, elige el formato y pulsa **Download**. Para Google Sheets, descarga también el archivo de Excel e impórtalo allí con *Archivo > Importar*: un CSV puede perder el 0 inicial de un código postal (`08001` pasa a ser 8001). El archivo trae todas las columnas, muchas más que la tabla de la pantalla y con nombres técnicos en inglés: su significado está en las preguntas frecuentes, al final de esta guía.

#### ¿Cuántos resultados de Google Maps voy a obtener?

Tantos como Google Maps tenga para tu búsqueda en tu zona. Google Maps corta su lista en unos 120 resultados, por muchos negocios que haya. Esta herramienta divide el mapa en vistas cada vez más pequeñas, hasta que mirar más de cerca casi no aporta lugares nuevos. Así se obtuvieron 569 lugares para `cafetería` en Toledo en 14 segundos y 13.229 para `restaurante` en Madrid en 7 minutos y 5 segundos. Los lugares de fuera de tu zona se descartan y no se cobran.

Google también mezcla negocios parecidos: al buscar cafeterías salen panaderías y restaurantes. Para quedarte con un solo tipo, usa **Only these categories** (solo estas categorías): escribe una palabra de la categoría, como `café`, en el idioma que elegiste en **Language of the results**.

¿Recibes menos lugares de los que esperabas? Sin zona en **Area**, la búsqueda se hace una sola vez, donde Google la sitúe, y da 120 lugares como máximo. Comprueba también que **Places per search term** está vacía y que no hay ningún filtro activo.

#### ¿Cuánto cuesta este scraper de Google Maps? ¿Es gratis?

Los precios están en dólares de Estados Unidos (USD). Se paga por lugar entregado: 3,00 $ por cada 1.000 lugares en el plan gratuito de Apify, es decir, 0,003 $ por lugar. En los planes de pago cuesta menos: 2,50 $, 2,00 $ y 1,50 $. El precio incluye el uso de la plataforma: no hay otra factura aparte. Cada ejecución tiene además una tarifa de inicio de 0,0002 $ con la memoria predeterminada de 4 GB (0,00005 $ por cada GB), que Apify cobra cuando la ejecución empieza.

El plan gratuito incluye 5 $ de saldo cada mes, sin tarjeta: unos 1.660 lugares al mes gratis. Cuando el saldo se acaba, las ejecuciones se detienen hasta que Apify da los 5 $ siguientes; no se te cobra nada.

Nunca se cobran los filtros, los lugares que un filtro elimina, los de fuera de la zona ni los duplicados. En el plan gratuito, la reputación reciente cuesta 2,00 $ más por cada 1.000 lugares con valoraciones. Las reseñas cuestan 0,40 $ por cada 1.000. Los correos y redes sociales de la web no tienen coste extra.

Para poner un tope de gasto, abre **Run options** (opciones de ejecución) en el formulario y escribe una cantidad en dólares, por ejemplo `1`, en **Maximum cost per run** (gasto máximo por ejecución). Otro freno es **Places per search term**, que cuenta por cada búsqueda y por cada zona: 2 búsquedas en 3 ciudades con `200` pueden entregar hasta 1.200 lugares, 3,60 $ en el plan gratuito.

#### Reputación reciente: la puntuación de los últimos 3, 6 y 12 meses

Las estrellas de Google Maps son la media de toda la historia del negocio. Un restaurante que fue excelente durante ocho años y cambió de dueño la primavera pasada sigue mostrando un 4,5. Activa **Recent reputation (last 3, 6 and 12 months)** (reputación reciente). Cada lugar recibe además la puntuación media y el número de valoraciones de los últimos 3, 6 y 12 meses, la proporción de reseñas que el propietario responde y la tendencia de los últimos 6 meses frente a los 6 anteriores: `up` (sube), `down` (baja) o `flat` (estable). Para ver estas cifras en pantalla, elige la tabla *Recent reputation* encima de los resultados: la tabla *Places*, la que se abre primero, no las muestra. La tendencia necesita al menos 5 valoraciones en cada semestre. Si no las hay, en vez de la tendencia aparece `notEnoughData` (datos insuficientes). Aparece lo mismo en un lugar con más de 2.400 reseñas en los últimos 12 meses, porque no se pueden leer todas las reseñas de ese año.

Para ver solo los negocios cuya puntuación está bajando, elige en **Rating trend** (tendencia), que está en el apartado **⭐ Reviews and recent reputation**, la opción que empieza por **Going down** (bajando). Ese filtro activa la reputación reciente, que se cobra por cada lugar entregado que tenga valoraciones.

#### Cómo extraer reseñas de Google Maps

Las reseñas son lo que mucha gente llama opiniones o comentarios de Google. En **Reviews per place** (reseñas por lugar) escribe cuántas quieres de cada lugar, hasta 2.400. Cada reseña entregada se cobra, además de su lugar, y la cuenta sube deprisa: 20 reseñas de cada uno de 1.000 lugares son 20.000 reseñas, es decir, 8,00 $ por las reseñas más 3,00 $ por los lugares en el plan gratuito. Cada reseña trae sus estrellas, la fecha exacta, el texto, la respuesta del propietario y las fotos. Para ver una reseña por fila, elige la tabla *Reviews (one per row)* encima de los resultados. El botón **Export** escribe siempre una fila por lugar: cómo descargar un archivo con una reseña por fila se explica, en inglés, en [How do I get one review per row?](#how-do-i-get-one-review-per-row).

Para recibir solo las recientes, escribe en **Reviews newer than** (reseñas posteriores a) una fecha en el orden año-mes-día, como `2026-05-03`, o un número seguido de `days` (días), `weeks` (semanas), `months` (meses) o `years` (años), como `3 months`. Cualquier otra cosa, por ejemplo `3 meses`, detiene la ejecución con un mensaje, sin cobrar ningún lugar.

Los nombres de los autores son datos personales y no se incluyen. Activa **Reviewer names** (nombres de los autores) solo si tienes una base legal para tratar esos datos.

#### Leads de Google Maps: cómo crear una base de datos de empresas

Para crear una base de datos de empresas con Google Maps, busca el tipo de negocio al que vendes y activa **Only places with a phone number** (solo lugares con teléfono). Encima de los resultados, elige la tabla *Leads*: muestra nombre, categoría, teléfono (también en formato internacional), página web, puntuación, dirección y si el negocio ha cerrado definitivamente (`permanentlyClosed`). Si activas también **Emails and social profiles from the website**, la tabla muestra los correos y las páginas de Facebook e Instagram que publica cada web.

Para buscar en varias ciudades a la vez, escribe las demás en **More areas** (más zonas), una por línea. Si una no se encuentra, se omite y el mensaje final lo indica. Para recibir solo los negocios cuyo perfil de Google no muestra propietario, activa **Only unclaimed profiles** (solo perfiles sin reclamar); el filtro es gratis.

#### Cómo encontrar negocios sin página web en Google Maps

En **Website** (página web), elige la opción que empieza por **No real website** (sin página web propia). Recibes los negocios sin ningún enlace y los que solo enlazan a Facebook o Instagram, a una página de reservas, de pedidos a domicilio o de directorio, o a una dirección gratuita de un creador de páginas web, como `name.wixsite.com`. La clasificación sale de una lista de sitios conocidos, sin abrir la página: comprueba el enlace antes de contactar.

#### Alternativa a la API de Google Places

La API de Google Places es la vía oficial y la opción adecuada para una aplicación que muestra lugares en un mapa de Google. Exige una clave de API y una cuenta de facturación, y devuelve como mucho 60 lugares por búsqueda y 5 reseñas por lugar. Esta herramienta no tiene esos dos límites. La comparación completa, en inglés, está en [Google Places API alternative](#google-places-api-alternative). Si programas, mira [los ejemplos de API y de Python](#google-maps-scraper-api-python-and-mcp).

#### ¿Es legal hacer scraping de Google Maps? Datos personales y RGPD

No hay una respuesta única para todos los países y usos. Los datos de un negocio (nombre, dirección, teléfono, horario, puntuación) son datos públicos que muestra Google Maps. Lo que la ley mira con más atención son los datos personales, los textos de las reseñas (pertenecen a sus autores) y lo que haces después con la información.

El Reglamento General de Protección de Datos (RGPD) de la Unión Europea protege los datos personales aunque sean públicos. El nombre o el teléfono móvil de quien trabaja por cuenta propia pueden ser datos personales, igual que el nombre de quien escribe una reseña y su texto. Si trabajas con esos datos, necesitas una base legal y debes decir a cada persona de dónde obtuviste sus datos: en el plazo de un mes, o la primera vez que contactes con ella si eso ocurre antes.

Tener una lista y usarla son dos cosas distintas. Muchos países tienen normas propias sobre llamadas comerciales, mensajes de texto y correos publicitarios, como los registros de quienes no quieren recibir llamadas o el consentimiento previo para el correo. Revisa las normas del país al que llamas o escribes antes de tu primera campaña.

Las condiciones de Google Maps dicen que sus usuarios no pueden descargar su contenido de forma masiva. Esta herramienta es independiente y no está afiliada a Google. Tú decides cómo la usas y eres responsable de ese uso. Esto es información general, no asesoramiento jurídico: si tu proyecto es grande o delicado, consulta a un abogado.

#### Preguntas frecuentes en español

- **¿Qué significan las columnas del Excel?** `title` es el nombre, `categoryName` la categoría, `totalScore` la puntuación, `reviewsCount` el número de valoraciones, `phone` el teléfono, `website` la página web, `address` la dirección y `url` el enlace a Google Maps. Hay muchas más: para un archivo corto, elige las que quieras en la lista de **Select fields** (elegir campos) antes de descargar. La lista completa, en inglés, está en [Google Maps data extractor: output fields](#google-maps-data-extractor-output-fields).
- **¿Dónde aviso de un problema?** En la pestaña **Issues** (incidencias) de esta página.

# Changelog

This Actor's version history is a separate document: https://apify.com/nokia2k/google-maps-scraper-rating-trends/changelog.md

# Actor input Schema

## `searchStringsArray` (type: `array`):

Enter what you would type into the Google Maps search bar, for example <b>dentist</b>, <b>coffee shop</b> or <b>plumber</b>. One term per line. Write the kind of business only and put the place in <b>Area</b>: a term such as <b>dentist in Austin</b> without an Area returns at most 120 places. Use the words a local customer would use. A place found by several terms is delivered, and charged, once. An area alone is not enough: add a term.

## `locationQuery` (type: `string`):

Enter a city, district, county or region, such as <b>Santa Fe, New Mexico</b> or <b>Toledo, Spain</b>. Add the region or country when the name is common. You get the places inside its border, not only the first 120 Google Maps shows. A postal code with its town or country (78701, USA) delivers only places with that code. Without an area, a term is searched once: at most 120 places. Area not found: the run stops, no places are charged.

## `locations` (type: `array`):

Add further areas here, one per line, to cover several cities or regions in one run. A postal code with its town or country (78702, Austin, Texas) works here as in <b>Area</b>. A place that lies in two of them is delivered once. An area that is not found is skipped and named in the coverage record; the run stops only when none of your areas is found.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Enter how many places to deliver for each search term in each area, counted after the filters. A search link is cut at this number too; place IDs and place links are not. You get the top places in Google's order. <b>Leave empty to get every place found in the area</b>, which can be thousands in one city. Start small (50) to see the data. Through the API there is no default limit: set this field, or a maximum cost for the run, in every call.

## `language` (type: `string`):

Choose the language for category names, opening hours and attribute labels. Review texts stay in the language they were written in.

## `coverage` (type: `string`):

Choose how far to zoom in. <code>standard</code> keeps zooming while a closer look adds at least 3 new places. <code>deep</code> keeps zooming until a closer look adds nothing. In a test, deep returned about a quarter more places and took nearly twice as long.

## `startUrls` (type: `array`):

Paste place links from the address bar of Google Maps, or a search link such as <code>https://www.google.com/maps/search/dentist/@30.2672,-97.7431,14z</code>, which returns one map view (up to 120 places). A short share link (maps.app.goo.gl) cannot be read: open it in your browser and paste the long one. A text file, one link per line, works too. In JSON: <code>\[{"url": "..."}]</code>, or <code>\[{"requestsFromUrl": "..."}]</code> for a file.

## `placeIds` (type: `array`):

Enter Google place IDs such as <code>ChIJm0hdIQ1QGIcRpDnU4qK8Q4M</code>, one per line, from the <code>placeId</code> column of an earlier run. Also read: an ID with <code>place_id:</code> in front, several IDs in one line, a Google Maps link. A CID number or a feature ID (the <code>cid</code> and <code>fid</code> columns) is skipped with a note. Every place ID is read, whatever Places per search term says. Same price as any other place.

## `placeIdsFromDatasets` (type: `array`):

Enter the dataset ID or the run ID of an earlier run of this Actor, one per line (a link to the run or its table works too). Every place in those tables is asked for again by its place ID, without searching the map: turn on <b>Recent reputation</b> or <b>Emails and social profiles</b> to add fresh data to places you already have, or run it as it is to see which places closed. Up to 60,000 place IDs; places that are in several tables are asked for once.

## `skipPlaceIdsFromDatasets` (type: `array`):

Enter the dataset ID or the run ID of runs whose places should not be asked for again, one per line: for example the run that stopped at its spending limit before it was through, so that this run takes up where it left off. Applies to the place IDs read from Place IDs from earlier runs.

## `recentReputation` (type: `boolean`):

Turn on to add the average rating and the number of ratings for the last 3, 6 and 12 months, the rating trend (<code>up</code>, <code>down</code>, <code>flat</code>) and the share of reviews the owner answered. Costs extra for each delivered place that has ratings (see Pricing). A place nobody has rated is not charged for it.

## `ratingTrendFilter` (type: `string`):

Keep only places whose rating is moving one way. <code>any</code>: no filter. <code>down</code>: the last 6 months average at least 0.3 stars below the 6 months before. <code>up</code>: at least 0.3 above. <code>flat</code>: in between. Left out: places with fewer than 5 ratings in either half-year or more than 2,400 reviews in 12 months. Free, but it turns recent reputation on, which is charged per place delivered, and the run takes longer.

## `maxReviews` (type: `integer`):

Enter how many reviews to attach to each place, up to 2,400; a larger number is read as 2,400. 0 attaches none. Each review comes with its stars, exact date, text, the owner's reply, photos and the ratings per aspect (food, service, atmosphere). Charged per review delivered.

## `reviewsSort` (type: `string`):

Choose which reviews come first when you attach reviews: <code>newest</code>, <code>mostRelevant</code>, <code>highestRanking</code> (highest rating first) or <code>lowestRanking</code> (lowest rating first). With <b>Reviews newer than</b>, keep <code>newest</code>: in any other order only the first reviews of that order are read and the older ones among them are dropped, so a place can come with fewer reviews than it has since that date.

## `reviewsStartDate` (type: `string`):

Enter a date as year-month-day (<code>2026-05-03</code>), a date and time such as <code>2026-05-03T20:00:00</code>, or a number with minutes, hours, days, weeks, months or years, such as <code>3 months</code>, to attach only reviews written after it. Anything else stops the run before anything is searched: no places are charged. <b>Reviews per place</b> must be above 0 and stays the upper limit. Keep <b>Review order</b> at Newest.

## `scrapeReviewsPersonalData` (type: `boolean`):

Off by default: reviews come without the reviewer's name, profile link and review link. Turn on only if you have a lawful reason to process personal data (in the EU and UK, a legal basis under the GDPR).

## `website` (type: `string`):

Choose which places to keep by the link in their website field. <code>withWebsite</code>: any link. <code>withoutWebsite</code>: no link at all. <code>realWebsiteOnly</code>: a link that is not a known social, booking, directory or website-builder page. <code>noRealWebsite</code>: no link, or only such a page. Every place also gets <code>websiteType</code>: <code>none</code>, <code>social</code>, <code>platform</code> or <code>website</code>.

## `phoneRequired` (type: `boolean`):

Turn on to leave out places that list no phone number.

## `unclaimedOnly` (type: `boolean`):

Turn on to keep only places whose Google Business Profile shows no owner (<code>claimThisBusiness</code> is true). Places where this is not known are left out.

## `placeMinimumStars` (type: `string`):

Keep only places rated at least this high: <code>two</code> (2 stars), <code>twoAndHalf</code> (2.5), <code>three</code> (3), <code>threeAndHalf</code> (3.5), <code>four</code> (4) or <code>fourAndHalf</code> (4.5). Leave empty for any rating (in JSON: leave the field out). Places without any rating are left out too.

## `placeMaximumStars` (type: `string`):

Keep only places rated at most this high: <code>two</code> (2 stars), <code>twoAndHalf</code> (2.5), <code>three</code> (3), <code>threeAndHalf</code> (3.5), <code>four</code> (4) or <code>fourAndHalf</code> (4.5). Leave empty for any rating (in JSON: leave the field out). Use it to find businesses with a weak rating. Places without any rating are left out too.

## `minReviewsCount` (type: `integer`):

Leave out places with fewer ratings than this number.

## `maxReviewsCount` (type: `integer`):

Leave out places with more ratings than this number. Handy for finding small or new businesses. 0 keeps only places that nobody has rated yet.

## `categoryFilterWords` (type: `array`):

Enter words, one per line. A place is kept only when one of its categories contains one of them as a piece of text: <b>dentist</b> keeps "Dentist" and "Pediatric dentist", and <b>bar</b> also keeps "Barber shop". Enter every word that fits: <b>coffee</b> alone leaves out a place whose only category is "Cafe". Use the language of the results; accents and capitals do not matter. With an area and no search term, the words are searched for.

## `excludeCategories` (type: `array`):

Enter words, one per line. A place is dropped when one of its categories contains one of them, for example <b>hotel</b>. Accents and capitals do not matter.

## `searchMatching` (type: `string`):

Choose this when you search for one brand or business name. <code>all</code>: keep every result. <code>only_includes</code>: the name contains the search term. <code>only_exact</code>: the name is the search term and nothing else. Capitals and accents do not matter. With several search terms, a place is compared with the term that found it.

## `excludeNameWords` (type: `array`):

Enter words, one per line. A place is dropped when its name contains one of them, for example the names of chains you do not want. Accents and capitals do not matter.

## `scrapePlaceDetailPage` (type: `boolean`):

Turn on to read each place's own page and get the number of 1, 2, 3, 4 and 5 star ratings (<code>reviewsDistribution</code>). In a test every rated place got it (602 of 602); without it only a few places have the breakdown. It adds nothing else. Same price per place; the run takes about twice as long (25 seconds against 14 in a test).

## `scrapeContacts` (type: `boolean`):

Turn on to read each place's own website (its home page and up to two of its contact, about or legal pages) and get the email addresses and social profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest) it publishes. Places without a website of their own are skipped. No extra charge. The run takes longer: websites answer more slowly than Google.

## `customGeolocation` (type: `object`):

Enter a GeoJSON Polygon or MultiPolygon to search inside your own shape, or a Point with <code>radiusKm</code> (5 if left out) to search around a spot. What geojson.io exports (a Feature or a FeatureCollection) is read too; lines are refused. Coordinates are \[longitude, latitude]. Leave <b>Area</b> empty when you use this: areas are added together. Example: <code>{"type":"Point","coordinates":\[-105.9378,35.687],"radiusKm":3}</code>

## `countryCode` (type: `string`):

Enter two letters, for example <b>us</b> or <b>es</b>, together with City, State, County or Postal code. Used when Area and More areas are empty, and for a postal code written alone in Area or More areas: it says which country the code is in. Next to any other area text it is ignored. On its own it searches the whole country, which is a very large run.

## `state` (type: `string`):

Enter a state, province or region, for example <b>Texas</b>. Used when Area and More areas are empty.

## `county` (type: `string`):

Enter a county, for example <b>Travis County</b>. Used when Area and More areas are empty.

## `city` (type: `string`):

Enter a city, for example <b>Austin</b>. Used when Area and More areas are empty.

## `postalCode` (type: `string`):

Enter one postal or ZIP code, for example <b>78701</b>, together with Country: a code alone exists in several countries and stops the run. Used only when Area and More areas are empty. The search covers the part of the map where Google lists that code, and only places with that postal code are delivered (a longer form of the same code, such as 78701-1234, counts). Places that show no address (many service-area businesses) are left out.

## `proxyConfiguration` (type: `object`):

Leave as it is. Proxy use is included in the price. If Google turns a request away, it is sent again over a residential address of Apify Proxy, so a run does not lose places. With proxy groups or your own proxies, the residential addresses are not used, and requests also leave from the server's own address unless you turn on <b>All requests to Google through the proxy</b>. Own proxies in JSON: <code>"proxyUrls": \["http://..."]</code>.

## `proxyOnly` (type: `boolean`):

Turn on only if every request to Google must leave through your proxy. Runs get slower. If <b>Proxy</b> holds no proxy, or the proxy cannot be set up, the run then stops at the start and no places are charged; with this box off it goes on from the server's own address, and a note says so when a proxy could not be set up. Area names are always looked up in OpenStreetMap directly.

## `maxConcurrency` (type: `integer`):

Lower it only if you want a slower, gentler run.

## `maxRunsAtOnce` (type: `integer`):

Leave empty to start straight away. With a number, this run first waits while that many earlier runs of this Actor are still working in your account, and starts when one of them ends. Google turns requests away by how many arrive at the same time, so several runs started together (by you, a schedule, an AI agent or another chat window) slow each other down and push traffic to the paid residential proxy. 3 is a good value for large jobs. Nothing is searched or charged while waiting; the wait is shown in the status message and in the COVERAGE record (waitedForSlotSeconds).

## `maxResidentialMegabytes` (type: `integer`):

Leave empty for no limit. When Google turns away the standard addresses, a request is sent again through the residential proxy, which Apify bills per megabyte. With a number, the run stops using the residential proxy after that many megabytes and goes on with the standard addresses only: more slowly, waiting longer between tries, without dropping places on purpose. 300 is a good value for a whole region. The COVERAGE record shows residentialMegabytes and residentialCapReached.

## Actor input object example

```json
{
  "searchStringsArray": [
    "dentist",
    "orthodontist"
  ],
  "locationQuery": "Austin, Texas",
  "locations": [
    "Austin, Texas",
    "Round Rock, Texas"
  ],
  "maxCrawledPlacesPerSearch": 200,
  "language": "en",
  "coverage": "standard",
  "placeIds": [
    "ChIJm0hdIQ1QGIcRpDnU4qK8Q4M"
  ],
  "placeIdsFromDatasets": [
    "aXz4CRVa3KYLBMBVf"
  ],
  "skipPlaceIdsFromDatasets": [],
  "recentReputation": false,
  "ratingTrendFilter": "any",
  "maxReviews": 0,
  "reviewsSort": "newest",
  "reviewsStartDate": "3 months",
  "scrapeReviewsPersonalData": false,
  "website": "allPlaces",
  "phoneRequired": false,
  "unclaimedOnly": false,
  "placeMinimumStars": "",
  "placeMaximumStars": "",
  "categoryFilterWords": [
    "dentist"
  ],
  "searchMatching": "all",
  "excludeNameWords": [
    "ATM"
  ],
  "scrapePlaceDetailPage": false,
  "scrapeContacts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "proxyOnly": false,
  "maxConcurrency": 64
}
```

# Actor output Schema

## `places` (type: `string`):

Core columns of every place: name, category, rating, number of ratings, phone, website, what kind of link the website is, address, city, opening status, unclaimed profile, place ID, coordinates and the Google Maps link. Add \&format=csv or \&format=xlsx to download a spreadsheet. Every other field is in the output "All fields".

## `leads` (type: `string`):

The same places as a lead list: name, category, phone as shown and in international format, website and what kind of link it is (none, social, platform or website), rating, number of ratings, unclaimed profile, permanently closed, address, city and the Google Maps link.

## `reputation` (type: `string`):

Average rating and number of ratings for the last 3, 6 and 12 months next to the all-time rating, the rating trend and the owner's reply rate. Filled when recent reputation is switched on.

## `reviews` (type: `string`):

Each review on its own row with the place it belongs to: place name, place ID, stars, exact date, text, the owner's reply and the other review fields. Add \&format=csv or \&format=xlsx to download a spreadsheet with one review per row. Filled when reviews per place is above 0.

## `allFields` (type: `string`):

Every place with every field: all categories, address parts, coordinates, opening hours, attributes, IDs, closed status, and the recent reputation figures and reviews when they were asked for. JSON; add \&format=csv or \&format=xlsx for a spreadsheet.

## `coverage` (type: `string`):

What the run did: the area that was used, map views searched and split, places found, places dropped outside the area, places removed by filters, requests, megabytes and seconds. Its notes say which settings or field names were ignored or read differently, which links were skipped and when Places per search term stopped a search; its errors list the problems met.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchStringsArray": [
        "coffee shop"
    ],
    "locationQuery": "Santa Fe, New Mexico",
    "maxCrawledPlacesPerSearch": 50,
    "placeIdsFromDatasets": [],
    "skipPlaceIdsFromDatasets": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nokia2k/google-maps-scraper-rating-trends").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchStringsArray": ["coffee shop"],
    "locationQuery": "Santa Fe, New Mexico",
    "maxCrawledPlacesPerSearch": 50,
    "placeIdsFromDatasets": [],
    "skipPlaceIdsFromDatasets": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nokia2k/google-maps-scraper-rating-trends").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchStringsArray": [
    "coffee shop"
  ],
  "locationQuery": "Santa Fe, New Mexico",
  "maxCrawledPlacesPerSearch": 50,
  "placeIdsFromDatasets": [],
  "skipPlaceIdsFromDatasets": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nokia2k/google-maps-scraper-rating-trends --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nokia2k/google-maps-scraper-rating-trends"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DfkSN1JtFpKRnl06i/builds/2REQwLWHkfQ69txQd/openapi.json