# How to scrape Google Maps with Python? [2024 Edition]

> Scrape Google Maps with Python at scale. With a stable piece of code and all local places. Collect all you need with our comprehensive API.

- **Author**: Sasha Bouloudnine
- **Published**: 2024-02-28 (28 Feb 2024)
- **Reading time**: 13 min
- **Canonical**: https://www.lobstr.io/blog/google-maps-scraper-python

---

Google Maps is an incredible source of data, with [+200 million establishments](https://cloud.google.com/blog/products/maps-platform/how-google-maps-platform-enabled-businesses-and-organizations-provide-critical-information-and-services-during-pandemic#:~:text=Google%20Maps%20Platform%20provides%20developers,and%20places%20around%20the%20world.) recorded, all over the world. And in 1000+ categories of establishments.

In this tutorial, we will see **how to retrieve this data with Python, requests, and the Google Maps API from lobstr**.

## What is a Google Maps Python Scraper?

**A Google Maps Python Scraper is a robot which will move on Google Maps and automatically retrieve the information present**.

![google maps search export lobstr product page - image23.png](https://d37gzvgyugjozl.cloudfront.net/google_maps_search_export_lobstr_product_page_image23_e9d0a96fab.png "width=1999;height=960")

[Scrape Google Maps at scale for free](https://www.lobstr.io/store/google-maps-search-export)

As its name suggests, **the web scraping bot is developed with the Python programming language**.

Recovering data by hand is time-consuming and expensive.

The development of a Python scraper therefore has 3 advantages:

* Time saving
* Money saving
* Data robustness

This will allow you to collect data quickly and inexpensively.

## What are the differences between a scraper and using the Google Maps API?

Google Maps provides [an official API](https://developers.google.com/maps/documentation): the Places API.

![google places api product page - image12.png](https://d37gzvgyugjozl.cloudfront.net/google_places_api_product_page_image12_f2cc16895f.png "width=1999;height=641")

You can directly retrieve data from Google Maps, with clear code examples and comprehensive documentation.

All with the blessing of Google themselves.

What's the difference with a homemade scraper?

When you use a homemade scraper, you will create a robot that will move around Google Maps, like a human, and retrieve the data.

**If you use the Google Maps API, Google Maps immediately gives you access to its internal database**.

![differences between google places api calls and google maps scraper - image5.png](https://d37gzvgyugjozl.cloudfront.net/differences_between_google_places_api_calls_and_google_maps_scraper_image5_55df6cc786.png "width=1586;height=1144")

In other words:

* Retrieving from official API: 1 step
* Homemade scraper: 2 steps

Why bother using a homemade scraper?

## Why not use the official Google Maps API?

The Google Maps API seems to have only advantages: quality of documentation, blessing from Google, number of steps to access the data.

**Why not use the official API then?**

These are the main reasons:

* Documentation complex
* Limited data access
* Crazy price

### Documentation complex

**First, the documentation is really really complex**.

Here for example, the documentation gives us access to (we counted) **49 different sublinks**.

![all google maps platform products - image19.png](https://d37gzvgyugjozl.cloudfront.net/all_google_maps_platform_products_image19_9fa492fbdc.png "width=1999;height=789")

Especially, once you get your hands on the right API — here [to the Places API](https://developers.google.com/maps/documentation/places/web-service) — there are still 2 documentations that coexist (!)

* Places API
* Places API (New)

And once we head towards Places API (New), lovers of progress that we are, there are still 5 distinct routes.

![five routes in google places api complex - image22.png](https://d37gzvgyugjozl.cloudfront.net/five_routes_in_google_places_api_complex_image22_d330eeca03.png "width=1272;height=790")


A real maze.

As is often the case with Google, the speed of iteration ends up rhyming with complexity and [certain difficulty in readability](https://x.com/ThomasOrTK/status/1760327638558642503?s=20).

![google complex products naming updates - image10.png](https://d37gzvgyugjozl.cloudfront.net/google_complex_products_naming_updates_image10_b61598085f.png "width=948;height=878")

### Limited data access

On Google Maps, when you search for a business in a given area, the search results show you up to 200 businesses.

On the Google Maps API, it’s simple, it’s 10 times less.

**Max 20 establishments** **by location and type of business**.
Terrible.

![max results count google places api - image2.png](https://d37gzvgyugjozl.cloudfront.net/max_results_count_google_places_api_image2_e4d623fd2f.png "width=1660;height=230")

### Crazy price

**Finally, the price is particularly high**.

With lobstr.io for example, for **550 USD**, you will be able to fetch approx. 1 million establishments. From 10 places per minute.

The Google Maps Places API equivalent is:

* Nearby Search 
* Advanced — to have all attributes
* 50K requests
* 20 businesses per request

This gives us a total price of **1750 USD**. 

![price differences between google places api and lobstr io google maps api - image14.png](https://d37gzvgyugjozl.cloudfront.net/price_differences_between_google_places_api_and_lobstr_io_google_maps_api_image14_f2982b4981.png "width=1999;height=1554")

**It is** **more than 3 times more expensive**.

For current prices, I compared the Places API with 8 scraper APIs in my [Google Maps scraper API benchmark](https://www.lobstr.io/blog/google-maps-scraper-api).

## Why not use a homemade requests data scraper?

[requests](https://pypi.org/project/requests/) is the most used Python library. It allows you to make HTTP requests, and therefore to browse the Internet with Python. 

**Only problem, you will have to go find these requests**.

Let me explain: when you browse the Internet, your browser “exchanges” with the target site, and requests are made without you being aware of it.

If you build a scraper, you will have to find the query that allows you to access the data.

![schema of requests exchanged between browser and website - image7.png](https://d37gzvgyugjozl.cloudfront.net/schema_of_requests_exchanged_between_browser_and_website_image7_1803eb6dbf.png "width=1366;height=1258")

**And** **in the case of Google Maps, the structure of this query is horribly complicated**.

First, we will open our inspection tool, and go to the tabulation _Network_. This will allow us to observe the requests exchanged between the site and the browser.

We then use the search tool, and we look for the origin of the data _Corner Restaurant_.

**We can find the URL. But it's incomprehensible.**

![complex url to call to scrape with requests and python - image4.png](https://d37gzvgyugjozl.cloudfront.net/complex_url_to_call_to_scrape_with_requests_and_python_image4_b2dad4afd6.png "width=1999;height=986")

And on the response side, it’s the same, **the data structure is unreadable**. 

![response from google maps complex url requests - image18.png](https://d37gzvgyugjozl.cloudfront.net/response_from_google_maps_complex_url_requests_image18_57a163d1e4.png "width=1562;height=584")

For a quick scraper, maybe we'll pass.

## Why not use a homemade selenium scraper?

OK, fetching the original requests with requests is work beyond the scope of this quick tutorial.

**But why not use [selenium](https://pypi.org/project/selenium/)?**

**Indeed, selenium allows you to control a Chrome browser remotely**.

No more searching for silent requests exchanged between the browser and the target site. Just let the browser do the work, and then parse the data.

An easy-to-deploy and visual-based automation.
It is this method that use the very serious tutorial of [GeeksForGeeks](https://www.geeksforgeeks.org/how-to-scrape-data-from-google-maps-using-python/).

![geeksforgeeks tutorial scraping google maps using selenium - image16.png](https://d37gzvgyugjozl.cloudfront.net/geeksforgeeks_tutorial_scraping_google_maps_using_selenium_image16_00f2e6ca39.png "width=1862;height=696")

But if everyone uses this tool, what's the problem?

Selenium is slow, that’s a fact.
**But above all, selenium is incredibly unstable**.

OK it's very visual, and therefore still useful for a quick tutorial, where volume and speed requirements are limited.

But if you have to look for more than a dozen establishments it becomes hell.

[Reddit rarely gets it wrong](https://www.reddit.com/r/QualityAssurance/comments/10bxumz/anyone_else_not_like_selenium/). And there is absolutely no mistake here.

![selenium is bad according to reddit - image3.png](https://d37gzvgyugjozl.cloudfront.net/selenium_is_bad_according_to_reddit_image3_a8b942aebe.png "width=1650;height=740")

## How do I scrape Google Maps at scale with the Lobstr Google Maps Search Export API?


### Step-by-step Tutorial

The official API is too expensive and expensive. `requests` is (almost) impossible to reverse-engineer. `selenium` is horrible to use.

We will therefore use **the Lobstr Google Maps Search Export API**, which has all the following advantages:

* Simple to use
* Very competitive price
* Easy-to-read documentation
* Comprehensive data

> If you want to consult the complete documentation, it is accessible [here](https://lobstrio.docs.apiary.io/) directly.

And we're going to do this in 5 steps:

1. Retrieve the API key
2. Create a Cluster
3. Add tasks
4. Start the run
5. Retrieve results

Let's go.

### Prerequisites

Before getting started, we will simply install the library [requests](https://requests.readthedocs.io/en/latest/). 

```bash
$ pip3 install requests
```

It is quite simply the most used library on Python, with 51K+ stars on Github. It allows to **browse the Internet quietly with Python**.

![requests python library home page - image17.png](https://d37gzvgyugjozl.cloudfront.net/requests_python_library_home_page_image17_f3babd3816.png "width=1999;height=1191")

### Retrieve the API key

To use a third-party API, you must always use an API key. We're going to go get it!

First of all, **[create an account on lobstr.io](https://app.lobstr.io/auth/sign-up)**: 

![sign up lobstr io - image15.png](https://d37gzvgyugjozl.cloudfront.net/sign_up_lobstr_io_image15_2bec013852.png "width=1999;height=986")

Once on the _Dashboard_, click on the 3 points at the top right, then on the part _Profile_.
Finally, in the part _API key details_, click on the icon _Copier_.

![copy api key from dashboard lobstr - image11.png](https://d37gzvgyugjozl.cloudfront.net/copy_api_key_from_dashboard_lobstr_image11_a7d4f5a2d6.png "width=1999;height=856")

And there you go!
Keep this value carefully, we will need it for the future.

To pass the requests, it will now be enough to add this token in the `headers` at the `Authorization` key.

**In the rest of this tutorial, it will be marked as `$TOKEN`.**

### Create a Cluster

First, we will create a _Cluster_. 

But what is a _Cluster_?

It’s a place where we are going to:

* Add all URLs or _Tasks_ that we want to scrape
* Specify the settings of our scraper e.g. the language
* Specify launch frequency

![cluster and tasks differences in lobstr api - image1.png](https://d37gzvgyugjozl.cloudfront.net/cluster_and_tasks_differences_in_lobstr_api_image1_6bef7d03be.png "width=1228;height=1130")

In other words, the _Cluster_ is the bag that contains what we’re going to get.

#### Code

```python
import requests

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token $TOKEN'
}

json_data = {
    'crawler': '4734d096159ef05210e0e1677e8be823',
}

response = requests.post('https://api.lobstr.io/v1/clusters/save', headers=headers, json=json_data)
print(response.json())
```

> The value `4734d096159ef05210e0e1677e8be823` after `crawler` corresponds to **the unique identifier of the crawler used**, here _Google Maps Search Export_. To list all existing crawlers, you can see [the List Crawlers route](https://lobstrio.docs.apiary.io/#reference/0/schedules/list-crawlers).

#### Output

```json
{
   "id":"0b8e606cda1442789d84e3e7f4809506",
   "account":[
      
   ],
   "concurrency":1,
   "crawler":"4734d096159ef05210e0e1677e8be823",
   "created_at":"2024-02-28T16:48:12Z",
   "is_active":true,
   "name":"Google Maps Search Export (1)",
   "params":{
      
   },
   "schedule":"None",
   "to_complete":false
}
```

We will keep the unique ID of our crawler, here `0b8e606cda1442789d84e3e7f4809506`, we will need it for the rest.

### Specify Cluster Settings

In this second part, we will specify the Cluster parameters:

* Export of unique results
* Line break
* Collection of contacts on websites
* Language
* Maximum results to retrieve by URL
* Notifications 

Visually this is what we find here and there:

![settings cluster lobstr - image9.jpg](https://d37gzvgyugjozl.cloudfront.net/settings_cluster_lobstr_image9_d313c64212.jpg "width=1338;height=1999")

#### Code

```python
import requests

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token $TOKEN',
}

json_data = {
    'name': 'Google Maps Search Export (1)',
    'concurrency': 1,
    'export_unique_results': True,
    'no_line_breaks': True,
    'to_complete': False,
    'params': {
        'language': 'in',
        'max_results': 200,
        'collect_contacts': True,
    },
    'accounts': None,
    'run_notify': 'on_success',
}

response = requests.post('https://api.lobstr.io/v1/clusters/0b8e606cda1442789d84e3e7f4809506', headers=headers, json=json_data)
print(response.json())
```

#### Output

```json
{
   "name":"Google Maps Search Export (8)",
   "no_line_breaks":true,
   "params":{
      "language":"in",
      "max_results":200,
      "collect_contacts":true
   },
   "to_complete":false,
   "accounts":"None",
   "run_notify":"on_success",
   "export_unique_results":true,
   "id":"0b8e606cda1442789d84e3e7f4809506"
}
```

### Add Tasks

Now it's time to go add tasks!
The _Task_ is the target from which the scraper will scrape the data.

Each task is a Google Maps search URL.

To fetch a task:

* Go on [Google Maps](https://www.google.com/maps)
* Do a search
* Get URL from browser

![copy url from google maps - image13.png](https://d37gzvgyugjozl.cloudfront.net/copy_url_from_google_maps_image13_fd5add4e76.png "width=1999;height=1482")

> If you want to quickly generate URLs for an entire country, you can do it manually or use our generator [here](https://www.lobstr.io/tools/google-maps-search-urls-generator).

As part of this example, we will retrieve restaurants from Austin, and from New York.

Here are our two search URLs, or _Tasks_: 

```bash
https://www.google.com/maps/search/restaurants+austin/@30.2685323,-97.7377576,15z
https://www.google.com/maps/search/restaurants+new+york/@40.7345699,-74.0168744,14z
```

We will now add _Tasks_ to our _Cluster_.

#### Code

```python
import requests

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token $TOKEN'
}

json_data = {
    'tasks': [
        {
            'url': 'https://www.google.com/maps/search/restaurants+austin/@30.2685323,-97.7377576,15z?entry=ttu',
        },
        {
            'url': 'https://www.google.com/maps/search/restaurants+new+york/@40.7345699,-74.0168744,14z/data=!3m1!4b1?entry=ttu'
        }
    ],
    'cluster': '0b8e606cda1442789d84e3e7f4809506',
}

response = requests.post('https://api.lobstr.io/v1/tasks', headers=headers, json=json_data)
print(response.json())
```

#### Output

```json
{
   "duplicated_count":0,
   "tasks":[
      {
         "id":"51d62eee574a4c0f8f4d57a8733903da",
         "created_at":"2024-02-28T17:01:59.419166",
         "is_active":true,
         "params":{
            "url":"https://www.google.com/maps/search/restaurants+austin/@30.2685323,-97.7377576,15z?entry=ttu"
         },
         "object":"task"
      },
      {
         "id":"b9f90d14135fa3d9b27595dfdb4969e3",
         "created_at":"2024-02-28T17:01:59.419281",
         "is_active":true,
         "params":{
            "url":"https://www.google.com/maps/search/restaurants+new+york/@40.7345699,-74.0168744,14z/data=!3m1!4b1?entry=ttu"
         },
         "object":"task"
      }
   ]
}
```

And there you have it, our tasks are added!
Let's move on to the collection phase.

### Start the run

It's time to start collecting!
The route this time is very simple, it’s [the /runs route](https://lobstrio.docs.apiary.io/#reference/0/runs/launch-run).

#### Code

```python
import requests

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token $TOKEN',
}

json_data = {
    'cluster': '0b8e606cda1442789d84e3e7f4809506',
}

response = requests.post('https://api.lobstr.io/v1/runs', headers=headers, json=json_data)
print(response.json())
```

#### Output

```json
{
   "id":"d0c0d2548b8c4ad6ae0201b69ef0f787",
   "object":"run",
   "cluster":"0b8e606cda1442789d84e3e7f4809506",
   "is_done":false,
   "started_at":"2024-02-28T17:19:46Z",
   "total_results":0,
   "total_unique_results":0,
   "next_launch_at":"None",
   "ended_at":"None",
   "duration":0.0,
   "credit_used":0.0,
   "origin":"user",
   "status":"pending",
   "export_done":"None",
   "export_count":0,
   "export_time":"None",
   "email_done":"None",
   "email_time":"None",
   "created_at":"2024-02-28T17:19:46Z",
   "done_reason":"None",
   "done_reason_desc":"None"
}
```

Great, the run is on!

The run ID is `d0c0d2548b8c4ad6ae0201b69ef0f787`. 

We will keep it carefully, we will need it for the future.

### Retrieve results

And this is the last step, it’s time to collect our precious results!

> Do you want to know the status of the current run? You can do it quickly with the route [Get Run](https://lobstrio.docs.apiary.io/#reference/0/runs/get-run). Then look at the `status` field.

The last route is: [List Results](https://lobstrio.docs.apiary.io/#reference/0/results/list-results).

Please note, by calling this route, we will display the last 100 results in JSON format. Now with 2 tasks, we can hope for approx. 400 results.

We will therefore set up **a fast paging system** with a _for loop_.

Finally, to easily visualize these results, **we will insert the results into a CSV file**.

#### Code

```python
import requests
import csv
import time

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token $TOKEN'
}

fieldnames = None

data = []
csv_file = "lobstr_google_maps_search_export_api.csv"

for i in range(1, 5, 1): 
    print('going page %s' % i)
    params = {
        'run': 'd0c0d2548b8c4ad6ae0201b69ef0f787',
          'page': '%i'%i,
          'page_size': '100',
    }

    response = requests.get('https://api.lobstr.io/v1/results', params=params, headers=headers)
    assert response.ok
    time.sleep(1)
    items = response.json()["data"]
    for item in items: 
        if not fieldnames: 
            fieldnames = list(item.keys())
        data.append(item)

with open(csv_file, 'In') as f: 
    writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter='\t')
    writer.writeheader()
    for row in data: 
        writer.writerow(row)

print('success :°')
```

#### Output

```bash
going page 1
going page 2
going page 3
going page 4
success :°
```

And if we open the `lobstr_google_maps_search_export_api.csv` file, this is what appears: **400 rows of data extracted from Google Maps**, with 36 attributes for each.

Include name, address, country and zip code, website, phone number, email…

![csv with all google places collected from lobstr google maps api - image20.png](https://d37gzvgyugjozl.cloudfront.net/csv_with_all_google_places_collected_from_lobstr_google_maps_api_image20_61b5f4c3f0.png "width=1890;height=1504")

## Complete Code

And here is **the complete code snippet, to directly extract local businesses from Google Maps**, using the lobstr.io Google Maps Search Export API.

Google Maps data scraping with one straightforward Python script.

```python
import requests
import time
import csv

token = '$TOKEN'  # <-- pick your API key from lobstr.io!

print('creating cluster')

headers = {
    'Accept': 'application/json',
    'Authorization': 'Token %s' % token 
}

json_data = {
    'crawler': '4734d096159ef05210e0e1677e8be823',
}

response = requests.post('https://api.lobstr.io/v1/clusters/save', headers=headers, json=json_data)
time.sleep(1)
assert response.ok

cluster_id = response.json()["id"]
assert cluster_id
print('cluster_id: %s' % cluster_id)

print('setting cluster up')

json_data = {
    'concurrency': 1,
    'export_unique_results': True,
    'no_line_breaks': True,
    'to_complete': False,
    'params': {
        'language': 'in',
        'max_results': 200,
        'collect_contacts': True,
    },
    'accounts': None,
    'run_notify': 'on_success',
}

response = requests.post('https://api.lobstr.io/v1/clusters/%s' % cluster_id, headers=headers, json=json_data)
time.sleep(1)
assert response.ok

print('add tasks')

json_data = {
    'tasks': [
        {
            'url': 'https://www.google.com/maps/search/restaurants+austin/@30.2685323,-97.7377576,15z?entry=ttu',
        },
        {
            'url': 'https://www.google.com/maps/search/restaurants+new+york/@40.7345699,-74.0168744,14z/data=!3m1!4b1?entry=ttu'
        }
    ],
    'cluster': '%s' % cluster_id,
}

response = requests.post('https://api.lobstr.io/v1/tasks', headers=headers, json=json_data)
time.sleep(1)
assert response.ok

print('launch run')

json_data = {
    'cluster': '%s' % cluster_id,
}

response = requests.post('https://api.lobstr.io/v1/runs', headers=headers, json=json_data)
time.sleep(1)
assert response.ok

run_id = response.json()["id"]
assert run_id
print('run_id: %s' % run_id)

print('waiting for the run to complete')
for _ in range(10): 
    print('waiting for the run 10s')
    time.sleep(10)

print('collecting results')
fieldnames = None

data = []
csv_file = "lobstr_google_maps_search_export_api.csv"

for i in range(1, 5, 1): 
    print('going page %s' % i)
    params = {
          'run': '%s' % run_id,
          'page': '%i'%i,
          'page_size': '100',
    }

    response = requests.get('https://api.lobstr.io/v1/results', params=params, headers=headers)
    assert response.ok
    time.sleep(1)
    items = response.json()["data"]
    for item in items: 
        if not fieldnames: 
            fieldnames = list(item.keys())
        data.append(item)

with open(csv_file, 'In') as f: 
    writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter='\t')
    writer.writeheader()
    for row in data: 
        writer.writerow(row)

print('success :°')
```

## FAQ

### Is it legal to scrape data from Google Maps?

Yes, absolutely!

**Google Maps data is public data, so it is completely legal to scrape it**.
This is not a violation of the Computer Fraud and Abuse Act, or CFAA.

Our full article on this subject is available [here](https://www.lobstr.io/blog/is-scraping-google-maps-legal).

### Can I be banned while scraping Google Maps with Python?

**Yes, completely**. Google Maps also specifies this in its terms of use. To avoid an IP ban or account deletion, use our API. We take care of everything.

Or use a third-party proxies provider, such as the excellent [ScrapingBee](https://www.scrapingbee.com/).

### How much does the Google Maps Search Export API from lobstr.io cost?

There is a free plan, with up to 150 local businesses per day, or 4,500 establishments per month.

Beyond that, it goes like this:

* 50 EUR / month with 50K establishments
* 250 EUR / month with 400K establishments
* 500 EUR / month with 1M establishments (!!)

![pricing plans lobstr - image8.png](https://d37gzvgyugjozl.cloudfront.net/pricing_plans_lobstr_image8_4b59e41253.png "width=1999;height=1139")

### Is there a no-code Google Maps scraper?

Yes, and ours is the best!

![google maps search export lobstr product page - image23.png](https://d37gzvgyugjozl.cloudfront.net/google_maps_search_export_lobstr_product_page_image23_e9d0a96fab.png "width=1999;height=960")

[Scrape Google Maps at scale for free](https://www.lobstr.io/store/google-maps-search-export)

And if you search for the best no-code scraper?
Well it’s still ours.

We took a look at the best no-code Google Maps scrapers. Everything is documented [here](https://www.lobstr.io/blog/best-google-maps-scraper), and this is our [Google Maps Search Export](https://www.lobstr.io/store/google-maps-search-export) who wins the prize again.

### Is it possible to scrape reviews from Google Maps?

Yes, it’s absolutely possible!

Check our dedicated [Google Maps Reviews Scraper](https://www.lobstr.io/store/google-maps-reviews-scraper).

![google maps reviews scraper lobstr product page - image6.png](https://d37gzvgyugjozl.cloudfront.net/google_maps_reviews_scraper_lobstr_product_page_image6_07f7a4f717.png "width=1999;height=1028")

[Scrape reviews from Google Maps at scale for free](https://www.lobstr.io/store/google-maps-reviews-scraper)

### Can I use ChatGPT to build my Google Maps Python scraper?

**Yes, you can ask ChatGPT to provide support with a Python scraper.**
**But it will not work**.

We tested for you. It started conveniently, with a proper text and [cordial talk](https://chat.openai.com/share/cd6f5249-6b34-4047-82c0-027f306c7a53). The AI suggests to use a homemade scraper that retrieves HTML data and parsing is done with `beautifulsoup`.

But endly, **the piece of code does not return anything**.

![gpt google maps requests scraper return no result - image21.png](https://d37gzvgyugjozl.cloudfront.net/gpt_google_maps_requests_scraper_return_no_result_image21_c6493c9167.png "width=1999;height=966")

[AGI](https://en.wikipedia.org/wiki/Artificial_general_intelligence) is coming soon but it's not for tomorrow.

---

## Scrapers in this article

- [Google Maps Leads Scraper](https://www.lobstr.io/store/google-maps-leads-scraper): Scrape all local businesses data from a Google Maps Search URL and export into a Google Sheet. Emails included. (1 credit per result)
- [Google Maps Reviews Scraper](https://www.lobstr.io/store/google-maps-reviews-scraper): Scrape all reviews from a Google Maps Local Business. Extremely fast. For free. (0.2 credits per result)

## Related articles

- [Google Maps Email Extractor: Free, No Code, Proven (214,361 Listings)](https://www.lobstr.io/blog/google-maps-email-extractor)
- [How to Scrape Google Maps for Leads With Verified Emails [No-Code]](https://www.lobstr.io/blog/scrape-google-maps-no-code)

Tags: Google Maps, Tutorials, Code, Python, Web Scraping

_Canonical HTML: https://www.lobstr.io/blog/google-maps-scraper-python_

More for agents: https://www.lobstr.io/llms.txt, pricing in Markdown: https://www.lobstr.io/pricing.md