How to Scrape Google Maps: Code and No-Code Approach

import asyncio
import json

from playwright.async_api import Playwright, async_playwright
from playwright.async_api import TimeoutError as PlaywrightTimeoutError


async def extract_details(page):
    """
    Extracts the results information from the page

    Args:
        page: Playwright page object

    Returns:
        A list containing details of results as dictionary. The dictionary has
        title, review count, rating, address of various results
    """

    # defining selectors
    result_container_selector = 'div[role="article"]'
    title_selector = '.fontHeadlineSmall span'
    review_text_selector = '.ZkP5Je span'
    address_selector = 'div.W4Efsd div.W4Efsd:nth-of-type(1) span[jsinstance' \
                       '="*1"] span:not([aria-hidden="true"]):not([style' \
                       '*="none"])'
    phone_selector = 'div.W4Efsd div.W4Efsd:nth-of-type(2) span[jsins' \
                     'tance="*1"] span:not([aria-hidden="true"]):not([sty' \
                     'le*="none"])'

    results_parsed = []

    results = page.locator(result_container_selector)
    # iterating through all the displayed results
    for result_idx in range(await results.count()):
        # extracting individual results
        result_elem = results.nth(result_idx)
        # extracting the title
        title = await result_elem.locator(title_selector).inner_text()

        # extracting and cleaning review details
        review_raw = await result_elem.locator(
            review_text_selector).all_inner_texts()
        rating = float(review_raw[0])
        review_count = review_raw[1].replace('(', '').replace(')', '')

        # extracting address
        try:
            address = await result_elem.locator(address_selector).inner_text()
        except PlaywrightTimeoutError:
            # address may not be available
            address = None
        # extracting phone
        try:
            phone = await result_elem.locator(phone_selector).inner_text()
        except PlaywrightTimeoutError:
            # phone may not be available
            phone = None

        data = {
            'title': title,
            'review_count': review_count,
            'rating': rating,
            'address': address,
            'phone': phone
        }
        results_parsed.append(data)

    return results_parsed


async def run(playwright: Playwright) -> None:
    """
    Main function which launches browser instance and performs browser
    interactions

    Args:
        playwright: Playwright instance
    """
    browser = await playwright.chromium.launch(
        headless=False,
        proxy={'server': 'proxy url here'}
    )
    context = await browser.new_context()

    # overriding timeout
    context.set_default_timeout(100000)

    search_term = "dentist in New York City, NY, USA"

    # Open new page
    page = await context.new_page()

    # Go to https://www.google.com/maps/
    await page.goto("https://www.google.com/maps/")

    # Click [aria-label="Search Google Maps"]
    await page.locator("[aria-label=\"Search Google Maps\"]").click()

    # Fill input[name="q"]
    await page.locator("input[name=\"q\"]").fill(search_term)

    # click search button
    await page.locator("button[id=\"searchbox-searchbutton\"]").click()

    # waiting for results to be displayed on the page
    await page.wait_for_selector('div[role="article"]')

    results = await extract_details(page)

    # saving the data
    with open('restaurant_data.json', 'w') as f:
        json.dump(results, f, indent=2)

    # ---------------------
    await context.close()
    await browser.close()


async def main() -> None:
    async with async_playwright() as playwright:
        await run(playwright)


asyncio.run(main())

// importing required modules
import fs from 'fs';
// initializing the required browser
import playwright from 'playwright';

/**
 * Open browser, goto given url and collect data
 */
async function run() {
  const browser = await playwright.chromium.launch({
    headless: false
  });
  const context = await browser.newContext({
    proxy: { server: 'http://ProxyIP:Port' }
  });
  // Open new page
  const page = await context.newPage();
  // Go to https://www.google.com/maps
  await page.goto('https://www.google.com/maps', { waitUntil: 'load' });
  // Click on search tab
  await page.locator('[aria-label="Search Google Maps"]').click();
  // Enter the search query
  await page.locator('[aria-label="Search Google Maps"]').type('restaurants near New York, NY, USA', { 'delay': 500 });
  // Press Enter after entering the query
  await page.locator('[aria-label="Search Google Maps"]').press('Enter');
  let ListingPageData = await extractDetails(page);
  // Save data as JSON
  const jsonData = JSON.stringify(ListingPageData);
  saveJSONFile(jsonData);
  // Closing browser context after use
  await context.close();
  await browser.close();
};

/**
 * Extract data from HTML content
 * @param page -  Page object
 * @returns {JSON} - Return collected data in JSON format
 */
async function extractDetails(page) {
  // Wait for results
  let listedProductSelector = 'div[role="article"]';
  await page.waitForSelector(listedProductSelector);
  let results = page.locator(listedProductSelector);
  // Now we need to collect details from HTML content.
  let ListingPageData = [];
  let resultCount = await results.count();
  // All the selectors used to collect data
  let reviewTextSelector = '.ZkP5Je span';
  let addressSelector = 'div.W4Efsd div.W4Efsd:nth-of-type(1) span[jsinstance="*1"] span:not([aria-hidden="true"]):not([style*="none"])';
  let phoneSelector = 'div.W4Efsd div.W4Efsd:nth-of-type(2) span[jsinstance="*1"] span:not([aria-hidden="true"]):not([style*="none"])';
  let titleSelector = `.fontHeadlineSmall span`;
  // Iterate through each search result and save data to a list variable
  for (let i = 0; i < resultCount; i++) {
    let resultElem = results.nth(i);
    let title = await resultElem.locator(titleSelector).innerText();
    let reviewRaw = await resultElem.locator(reviewTextSelector).allInnerTexts();
    let rating = reviewRaw[0];
    let reviewCount = reviewRaw[1].replace('(', '').replace(')', '');
    let address = null;
    let phone = null;
    try {
      address = await resultElem.locator(addressSelector).innerText();
    }
    catch (err) {
      console.log("Address was not found!");
    };
    try {
      phone = await resultElem.locator(phoneSelector).innerText();
    }
    catch (err) {
      console.log("Phone number was not found!");
    };
    let productData = {
      title: title,
      reviewCount: reviewCount,
      rating: rating,
      address: address,
      phone: phone
    };
    console.log(productData);
    ListingPageData.push(productData);
  };
  return ListingPageData;
};

/**
 * Save JSON data to .json file
 * @param jsonData -  Extracted data in JSON format
 */
async function saveJSONFile(jsonData) {
  fs.writeFile("data.json", jsonData, 'utf8', function (err) {
    if (err) {
      console.log("An error occured while writing JSON Object to File.");
      return console.log(err);
    };

    console.log("JSON file has been saved.");
  });
};

run();