How to Scrape Google Maps Reviews Using Python in 2026 — Complete Guide

If you've ever tried to manually copy-paste reviews from Google Maps, you know the pain. Click a business, scroll through reviews, copy each one... do that for 50 businesses and you've lost an entire afternoon. I've been there.

That's why scraping Google Maps reviews with Python makes so much sense. You write the code once, and it does all the tedious work for you — pulling reviewer names, star ratings, the full review text, dates, everything. Whether you're tracking your own brand's reputation, keeping tabs on competitors, or building a dataset for some research project, automation is the way to go.

In this guide, I'll walk you through two different ways to do it: one using Playwright and one using Selenium. Both work. I'll also show you how to dodge Google's anti-bot systems (because yes, they will try to block you), and if you'd rather skip all the code entirely, I'll point you to a no-code tool that handles the whole thing.

You don't need to be a Python expert to follow along. If you can install a library and run a script, you're good.

What Are Google Maps Reviews and Why Scrape Them?

You already know what Google Maps reviews are — those star ratings and comments people leave on businesses. Every pizza shop, dentist office, hotel, and plumber on Google Maps has them. What you might not realize is just how much useful data is sitting in those reviews.

What Data Can You Extract?

Here's what you can pull from each review:

• Reviewer name — who wrote it
• Star rating — the 1-to-5 star score
• Review text — the actual comment they left
• Review date — when they posted it
• Owner response — if the business replied, you get that too
• Reviewer profile link — their Google profile URL
• Review photos — any images they attached

So What Do People Actually Do With This Data?

Quite a lot, actually:

• Brand monitoring — keeping an eye on what people say about your business across different locations
• Competitor research — figuring out where competitors are falling short (or doing well) based on their reviews
• Sentiment analysis — running reviews through NLP tools to spot patterns in how customers feel
• Lead generation — finding businesses with terrible reviews who might need your product or service
• Market research — looking at review trends across an entire industry
• Academic work — building research datasets around consumer behavior

Google's Official API vs. Web Scraping — What's the Difference?

Before we get into any code, there's something you should know. Google does have an official API for this — the Places API — but honestly, it's pretty limited for what most people need.

Google Places API (The Official Way)

Here's the deal with the API:

• It only gives you 5 reviews per business. Five. That's the cap.
• It costs money — about $17 per 1,000 requests for Place Details
• You don't get the full review history at all
• Google picks which 5 reviews to show you (their algorithm decides, not you)
• On the bright side, the data comes back as clean JSON, so parsing is easy

Web Scraping (What We're Going to Do)

Scraping, on the other hand:

• Gets you every single review a business has — not just 5
• It's free (well, your time isn't free, but the tools are)
• You get the complete review history with actual dates
• It takes more effort to set up, no question about that
• And you'll need to update your code now and then when Google changes their page layout

So if 5 reviews is enough for you, go with the API. But if you need the full picture — hundreds or thousands of reviews — you'll need to scrape, or use a tool like Livescraper that does it for you.

Prerequisites — What You Need Before Starting

Let's get your machine set up. None of this is complicated, but you do need a few things installed first.

1. Python 3.9 or Higher

Open your terminal (or Command Prompt on Windows) and check your version:

python --version
# You want Python 3.9 or newer. 3.12 or 3.13 is ideal in 2026.

Don't have Python yet? Grab it from python.org. If you're on a Mac, brew install python works too.

2. Create a Virtual Environment

This keeps your project dependencies separate from everything else on your system. Trust me, it saves headaches later:

# Make a project folder and jump in
mkdir google-reviews-scraper
cd google-reviews-scraper

# Create the virtual environment
python -m venv venv

# Activate it
# Mac/Linux:
source venv/bin/activate
# Windows:
venv\\Scripts\\activate

3. Install the Libraries

We'll cover two methods below. Install whichever one you plan to use (or both if you want to try them out):

# For Playwright (this is the one I'd recommend)
pip install playwright pandas
playwright install chromium

# For Selenium
pip install selenium webdriver-manager pandas beautifulsoup4

Don't worry about what each library does just yet — I'll explain as we go.

Method 1: Scraping Reviews with Playwright (Recommended)

Playwright is a browser automation tool made by Microsoft. I prefer it over Selenium for this kind of work because it handles dynamic pages better, it's faster, and you end up writing less boilerplate code. It came out a few years after Selenium and it shows — a lot of the rough edges are smoothed out.

Why Playwright Over Selenium?

Here's the short version:

• It waits for you automatically. Playwright knows when an element is ready before trying to click it. With Selenium, you're constantly sprinkling time.sleep() everywhere and hoping for the best.
• It's genuinely faster. The way it talks to the browser under the hood is more efficient.
• Selectors are more flexible. CSS, XPath, text matching, ARIA roles — all built in.
• Easier to make stealthy. It's simpler to configure so websites don't immediately flag you as a bot.
• Works with multiple browsers. Chromium, Firefox, and WebKit (Safari's engine) all supported.

Step 1: The Basic Setup

Alright, let's write some code. Create a file called scraper.py and start with the browser setup:

from playwright.sync_api import sync_playwright
import pandas as pd
import time
import random
import re

def create_browser():
    """Launch a browser that looks like a real user."""
    p = sync_playwright().start()
    browser = p.chromium.launch(
        headless=False,  # Set True for production
        args=[
            '--disable-blink-features=AutomationControlled',
            '--no-sandbox',
        ]
    )
    context = browser.new_context(
        viewport={'width': 1366, 'height': 768},
        user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                   'AppleWebKit/537.36 (KHTML, like Gecko) '
                   'Chrome/124.0.0.0 Safari/537.36',
        locale='en-US',
    )
    return p, browser, context

Let me break down what's going on here. We're launching a Chromium browser with settings that make it look like a normal person browsing the web — not a script. The headless=False part means the browser window actually pops up on your screen, which is great for debugging because you can see exactly what's happening. The user agent string tells Google which browser we're supposedly using, and that disable-blink-features flag removes the telltale sign that says "hey, this browser is being controlled by automation software."

Step 2: Navigate to the Business and Open the Reviews Tab

Now we need to actually go to a Google Maps business page and click on the reviews section. This part's straightforward:

def open_reviews_panel(page, place_url):
    """Navigate to a Google Maps place and open the reviews tab."""
    page.goto(place_url, wait_until='networkidle')

    # Accept cookies if prompted
    try:
        page.click('button:has-text("Accept all")', timeout=3000)
    except:
        pass

    # Wait for the page to fully load
    page.wait_for_selector('button[data-tab-index="1"]', timeout=10000)

    # Click on the "Reviews" tab
    page.click('button[data-tab-index="1"]')
    time.sleep(2)  # Let reviews load

    print("Reviews panel opened successfully")

Pretty simple, right? We go to the URL, wait for it to fully load, handle that annoying cookie consent popup (if you're in Europe, you know what I'm talking about), and then click the "Reviews" tab. The data-tab-index="1" selector points to the reviews tab — at least as of early 2026. If Google changes their layout, this selector might need updating.

Step 3: Scroll Down to Load More Reviews

Here's where it gets interesting. Google Maps doesn't load all reviews at once — it shows you maybe 10 and then loads more as you scroll down. So we have to keep scrolling and waiting, scrolling and waiting, until we've got everything (or hit our target number):

def scroll_reviews(page, max_reviews=100):
    """Scroll the reviews panel to load more reviews."""
    scrollable = page.query_selector('div.m6QErb.DxyBCb.kA9KIf.dS8AEf')
    if not scrollable:
        print("Could not find scrollable reviews container")
        return

    last_count = 0
    scroll_attempts = 0
    max_attempts = 50

    while scroll_attempts < max_attempts:
        # Scroll down inside the reviews panel
        scrollable.evaluate('el => el.scrollTop = el.scrollHeight')

        # Wait for new reviews to load
        time.sleep(random.uniform(1.5, 3.0))

        # Count current reviews
        reviews = page.query_selector_all('div.jftiEf.fontBodyMedium')
        current_count = len(reviews)

        print(f"Loaded {current_count} reviews...")

        # Stop if we've reached our target
        if current_count >= max_reviews:
            print(f"Reached target of {max_reviews} reviews")
            break

        # Stop if no new reviews loaded (we've reached the end)
        if current_count == last_count:
            scroll_attempts += 1
            if scroll_attempts >= 3:
                print(f"No more reviews to load. Total: {current_count}")
                break
        else:
            scroll_attempts = 0

        last_count = current_count

The tricky part here is finding the right scrollable container — it's not the main page that scrolls, it's a specific div inside the reviews panel. We scroll it to the bottom with JavaScript, then pause for a random amount of time (between 1.5 and 3 seconds) to look more human. The script keeps going until we either hit our target number of reviews or no new ones show up after a few attempts.

Step 4: Pull Out the Review Data

Now that all the reviews are loaded on the page, we need to actually grab the data from each one. This function loops through every review element and pulls out the name, rating, text, date, and any owner response:

def extract_reviews(page):
    """Extract all review data from the loaded reviews."""
    reviews_data = []
    review_elements = page.query_selector_all('div.jftiEf.fontBodyMedium')

    for element in review_elements:
        try:
            # Reviewer name
            name_el = element.query_selector('.d4r55')
            name = name_el.inner_text() if name_el else 'Anonymous'

            # Star rating
            rating_el = element.query_selector('.kvMYJc')
            rating = 0
            if rating_el:
                aria = rating_el.get_attribute('aria-label')
                match = re.search(r'(\\d+)', aria or '')
                rating = int(match.group(1)) if match else 0

            # Review text (click "More" to expand if needed)
            more_btn = element.query_selector('button.w8nwRe.kyuRq')
            if more_btn:
                try:
                    more_btn.click()
                    time.sleep(0.3)
                except:
                    pass

            text_el = element.query_selector('.wiI7pd')
            text = text_el.inner_text() if text_el else ''

            # Review date
            date_el = element.query_selector('.rsqaWe')
            date = date_el.inner_text() if date_el else ''

            # Owner response
            response_el = element.query_selector('.CDe7pd')
            owner_response = response_el.inner_text() if response_el else ''

            reviews_data.append({
                'reviewer_name': name,
                'rating': rating,
                'review_text': text,
                'review_date': date,
                'owner_response': owner_response,
            })

        except Exception as e:
            print(f"Error extracting review: {e}")
            continue

    return reviews_data

One thing to note: some reviews have a "More" button that hides the full text. We try to click that button to expand the review before grabbing the text. It doesn't always work perfectly, but it catches most of them.

Step 5: Wire It All Up

Alright, now let's connect all those functions into one script you can actually run:

def scrape_google_reviews(place_url, max_reviews=100):
    """Main function to scrape Google Maps reviews."""
    p, browser, context = create_browser()
    page = context.new_page()

    try:
        # Step 1: Open the reviews panel
        open_reviews_panel(page, place_url)

        # Step 2: Scroll to load reviews
        scroll_reviews(page, max_reviews)

        # Step 3: Extract review data
        reviews = extract_reviews(page)

        # Step 4: Save to CSV
        df = pd.DataFrame(reviews)
        filename = 'google_reviews.csv'
        df.to_csv(filename, index=False, encoding='utf-8')
        print(f"\\nSaved {len(reviews)} reviews to {filename}")
        print(f"Average rating: {df['rating'].mean():.1f} stars")

        return reviews

    finally:
        browser.close()
        p.stop()


# Run the scraper
if __name__ == '__main__':
    url = 'https://www.google.com/maps/place/YOUR_BUSINESS_URL'
    reviews = scrape_google_reviews(url, max_reviews=200)
    print(f"\\nDone! Scraped {len(reviews)} reviews")

Just swap out YOUR_BUSINESS_URL with an actual Google Maps link. Go to Google Maps, search for any business, and copy the URL from your browser's address bar. That's what goes in there.

Method 2: Scraping Reviews with Selenium

Maybe you've used Selenium before and you're comfortable with it. Or maybe your work environment doesn't support Playwright for some reason. Fair enough — Selenium can absolutely get the job done too. The code is a bit more verbose, but the logic is the same.

Selenium Setup

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from bs4 import BeautifulSoup
import pandas as pd
import time
import random

def create_selenium_driver():
    """Create a Selenium Chrome driver with stealth settings."""
    options = webdriver.ChromeOptions()
    options.add_argument('--disable-blink-features=AutomationControlled')
    options.add_argument('--window-size=1366,768')
    options.add_argument('--lang=en-US')
    options.add_experimental_option('excludeSwitches', ['enable-automation'])
    options.add_experimental_option('useAutomationExtension', False)

    service = Service(ChromeDriverManager().install())
    driver = webdriver.Chrome(service=service, options=options)

    # Remove the webdriver flag
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': '''
            Object.defineProperty(navigator, 'webdriver', {get: () => undefined})
        '''
    })

    return driver

Selenium Review Scraper

def scrape_with_selenium(place_url, max_reviews=100):
    """Scrape Google Maps reviews using Selenium."""
    driver = create_selenium_driver()

    try:
        driver.get(place_url)
        time.sleep(3)

        # Accept cookies
        try:
            cookie_btn = WebDriverWait(driver, 5).until(
                EC.element_to_be_clickable((By.XPATH,
                    '//button[contains(text(), "Accept all")]'))
            )
            cookie_btn.click()
        except:
            pass

        # Click Reviews tab
        reviews_tab = WebDriverWait(driver, 10).until(
            EC.element_to_be_clickable((By.CSS_SELECTOR,
                'button[data-tab-index="1"]'))
        )
        reviews_tab.click()
        time.sleep(2)

        # Scroll to load reviews
        scrollable = driver.find_element(By.CSS_SELECTOR,
            'div.m6QErb.DxyBCb.kA9KIf.dS8AEf')

        last_count = 0
        for _ in range(50):
            driver.execute_script(
                'arguments[0].scrollTop = arguments[0].scrollHeight',
                scrollable
            )
            time.sleep(random.uniform(1.5, 3.0))

            reviews = driver.find_elements(By.CSS_SELECTOR,
                'div.jftiEf.fontBodyMedium')
            if len(reviews) >= max_reviews or len(reviews) == last_count:
                break
            last_count = len(reviews)

        # Parse with BeautifulSoup for easier extraction
        soup = BeautifulSoup(driver.page_source, 'html.parser')
        review_elements = soup.select('div.jftiEf.fontBodyMedium')

        reviews_data = []
        for el in review_elements:
            name = el.select_one('.d4r55')
            rating = el.select_one('.kvMYJc')
            text = el.select_one('.wiI7pd')
            date = el.select_one('.rsqaWe')

            rating_val = 0
            if rating and rating.get('aria-label'):
                import re
                m = re.search(r'(\\d+)', rating['aria-label'])
                rating_val = int(m.group(1)) if m else 0

            reviews_data.append({
                'reviewer_name': name.text if name else 'Anonymous',
                'rating': rating_val,
                'review_text': text.text if text else '',
                'review_date': date.text if date else '',
            })

        # Save to CSV
        df = pd.DataFrame(reviews_data)
        df.to_csv('reviews_selenium.csv', index=False)
        print(f"Saved {len(reviews_data)} reviews")
        return reviews_data

    finally:
        driver.quit()

Playwright vs. Selenium — Which One Should You Pick?

I get asked this a lot. Here's how they stack up side by side:

Feature	Playwright	Selenium
Speed	Faster (async support)	Slower
Auto-waiting	Built-in	Manual (WebDriverWait)
Ease of setup	Very easy	Requires driver management
Anti-detection	Better stealth options	Needs undetected-chromedriver
Community	Growing fast	Largest community
Learning curve	Moderate	Gentle

My honest take? If you're starting from scratch, go with Playwright. You'll write less code and run into fewer headaches. But if you already have Selenium code running somewhere, there's no strong reason to rewrite it.

How to Avoid Getting Blocked by Google

This is the part most tutorials gloss over, but it's probably the most important. Google is really good at detecting bots. If you just fire up a headless browser and start hammering their servers, you'll get blocked within minutes. Here's how to stay under the radar.

1. Add Random Pauses Between Actions

Nobody clicks a button and then instantly clicks another one 50 milliseconds later. Real people hesitate, read things, get distracted. Your scraper should do the same:

import random

def human_delay(min_sec=1.0, max_sec=3.0):
    """Wait a random amount of time to mimic human behavior."""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

2. Switch Up Your User Agent

If every single request comes from the exact same browser fingerprint, that's a dead giveaway. Mix it up:

USER_AGENTS = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Firefox/125.0',
]

user_agent = random.choice(USER_AGENTS)

3. Use Proxies (Especially for Larger Jobs)

Once you're scraping more than a handful of businesses, you'll want to rotate your IP address. Otherwise Google sees hundreds of requests coming from one place and shuts you down:

def create_browser_with_proxy(proxy_url):
    """Launch browser through a proxy server."""
    p = sync_playwright().start()
    browser = p.chromium.launch(
        proxy={'server': proxy_url},
        headless=True,
    )
    return p, browser

4. Don't Be Greedy With Speed

I know it's tempting to scrape as fast as possible, but patience pays off here. Some rough guidelines that have worked for me:

• Stick to around 10-20 businesses per hour from one IP address
• Wait 3-5 seconds between loading different business pages
• Pause 1-3 seconds between scroll actions within the reviews panel
• Every 10-15 businesses, take a longer break — like 30-60 seconds. Go grab a coffee or something.

Common Problems (and How to Fix Them)

You will run into issues. Everyone does. Here are the ones I see come up most often:

"The reviews aren't loading at all"

This usually means Google caught on that you're a bot, or they changed something in their page layout. First thing to try: set headless=False so you can actually see the browser window. Is there a CAPTCHA? A cookie banner blocking everything? Sometimes the fix is as simple as clicking "Accept" on a popup you didn't account for. Other times, Google changed their CSS classes and you'll need to update your selectors.

"I'm only getting 10 reviews even though there are hundreds"

The scrolling isn't working right. Double-check that you're scrolling inside the correct container — it's a specific div within the reviews panel, not the main page. Add a print(scrollable) to make sure it's not None. Also try increasing the delay between scrolls — sometimes Google's servers are slow to send the next batch of reviews.

"It works for 3-4 businesses and then I get blocked"

You're going too fast. Slow down, add longer pauses between businesses, and seriously consider using proxies if you haven't already. Ten to twenty businesses per session from one IP is a reasonable target.

"The selectors aren't finding anything"

Google changes their CSS class names more often than you'd think. When this happens, open Google Maps in your own browser, right-click on a review, click "Inspect Element," and look at the current class names. Then update your code to match. It's annoying but it's part of the deal with web scraping.

Or Just Skip the Code — Use Livescraper Instead

Look, I just spent a good chunk of this article teaching you how to build a scraper from scratch. And everything above works. But I'd be lying if I said it was zero-maintenance. Google changes their page layout, your selectors break. They roll out new anti-bot measures, your proxies stop working. You fix one thing and something else breaks. It's a cycle.

If you just want the data without dealing with all of that, that's exactly what Livescraper's Reviews Scraper is for.

Why Would You Use Livescraper Instead of Building Your Own?

Feature	DIY Python Scraper	Livescraper
Setup time	Hours to days	2 minutes
Maintenance	Constant (selectors break)	Zero — we handle it
Anti-detection	You manage proxies & delays	Built-in proxy rotation
Scale	Limited by your machine	Cloud-based, unlimited
Output format	CSV (manual export)	CSV, JSON, Excel
Coding required	Yes (Python)	No
Cost	Free + your time	Free tier available

How It Works (Seriously, It's 3 Steps)

1. Make an account — head to app.livescraper.com and sign up. It's free to start.
2. Tell it what to scrape — paste the Google Maps URL or just type the business name. Pick "Reviews Scraper" as the task type.
3. Grab your file — hit "Start Scraping" and download the results as CSV or JSON when it's done.

No Python environment to set up, no proxies to buy, no selectors to fix when they break. You just get the data. I know that sounds like a sales pitch, but when you've spent hours debugging a scraper at 2am because Google changed a CSS class... you start to appreciate the simplicity.

What Else Can You Do With Livescraper?

Reviews aren't the only thing. If you're already pulling review data, chances are you need other business data too:

• Google Maps Scraper — grab business names, addresses, phone numbers, websites, ratings from any Maps search
• Email Scraper — pull email addresses from business websites (great for outreach)
• Google Search Scraper — extract URLs, titles, and snippets from Google search results
• B2B Lead Database — a pre-built database of business leads with verified contact info, no scraping needed

A Quick Word on Legality

I'm not a lawyer, so this isn't legal advice. But here's what's generally understood about scraping publicly available data like Google reviews.

You're Probably Fine If You're...

• Scraping public review data for your own research or analysis
• Pulling your own business's reviews in bulk
• Doing academic research with properly anonymized data
• Running competitive analysis for internal business decisions

Be Careful If You're...

• Copying reviews and republishing them on your own website
• Scraping so aggressively that you're basically DDoS-ing Google's servers
• Storing personal info about reviewers without thinking about GDPR or privacy laws
• Using the data to target or harass specific reviewers (obviously don't do this)

General Good Habits

• Take a look at robots.txt before you start — it tells you what the site owner prefers
• Keep your request rate reasonable
• Don't hold onto personal data longer than you actually need it
• Stick to legitimate business uses
• If compliance is a concern, a service like Livescraper handles a lot of that for you

Wrapping Up

That was a lot of ground to cover, but you should now have a pretty solid understanding of how to scrape Google Maps reviews with Python. We went through the full Playwright approach (which I'd pick for any new project), the Selenium approach (perfectly fine if that's what you know), anti-detection tricks, and troubleshooting for the most common headaches.

The reality is, building a scraper is the easy part. Keeping it running reliably over time — dealing with Google's constant changes, managing proxies, fixing broken selectors — that's where the real time investment is. So depending on your needs, it might make sense to just use a tool that handles all of that behind the scenes.

If that sounds appealing, give Livescraper a try. There's a free tier so you can test it out without any commitment. And if you prefer the DIY route, the code above has everything you need to get going. Good luck with your project!