Como fazer raspagem de dados no Google Maps com Python

Neste tutorial, você verá:

• A definição de um raspador de dados do Google Maps
• Quais dados você pode extrair com ele
• Como criar um script de raspagem de dados do Google Maps com Python

Vamos lá!

O que é um raspador de dados do Google Maps?

Um raspador de dados do Google Maps é uma ferramenta especializada para extrair dados do Google Maps. Ele automatiza o processo de coleta de dados do Maps, por exemplo, por meio de um script de raspagem de dados com Python. Os dados recuperados com esse raspador de dados são comumente usados para pesquisa de mercado, análise de concorrentes e muito mais.

Quais dados você pode recuperar do Google Maps

As informações que você pode extrair do Google Maps incluem:

• Nome da empresa: o nome da empresa ou local listado no Google Maps.
• Endereço: endereço físico da empresa ou local.
• Número de telefone: número de telefone de contato da empresa.
• Website: URL para o site da empresa.
• Horário comercial: horários de abertura e fechamento da empresa.
• Avaliações: avaliações de clientes, incluindo classificações e feedback detalhado.
• Classificações: classificação média por estrelas com base no feedback do usuário.
• Fotos: imagens enviadas pela empresa ou pelos clientes.

Instruções passo a passo para raspar o Google Maps com Python

Nesta seção guiada, você aprenderá a criar um script em Python para fazer raspagem de dados no Google Maps.

O objetivo final é recuperar os dados contidos nos itens do Google Maps na página “restaurantes italianos”:

Siga as etapas abaixo!

Etapa 1: configuração do projeto

Antes de começar, você precisa verificar se o Python 3 está instalado em sua máquina. Se não estiver, baixe, instale e siga o assistente de instalação.

Em seguida, use os seguintes comandos para criar uma pasta para o projeto, acessá-la e criar um ambiente virtual dentro dela:

mkdir google-maps-scraper
cd google-maps-scraper
python -m venv env

O diretório google-maps-scraper representa a pasta do projeto do raspador de dados com Python do Google Maps.

Carregue a pasta do projeto em seu IDE do Python favorito. O PyCharm Community Edition ou o Visual Studio Code com a extensão Python são suficientes.

Dentro da pasta do projeto, crie um arquivo scraper.py . Essa é a estrutura de arquivo que seu projeto deve ter no momento:

scraper.py agora é um script do Python em branco, mas em breve conterá a lógica de raspagem.

No terminal do IDE, ative o ambiente virtual. Para fazer isso, no Linux ou no macOS, execute este comando:

./env/bin/activate

Como alternativa, no Windows, execute:

env/Scripts/activate

Maravilhoso, agora você tem um ambiente Python para o seu raspador de dados!

Etapa 2: escolha a biblioteca de raspagem de dados

O Google Maps é uma plataforma altamente interativa e não faz sentido perder tempo determinando se é um site estático ou dinâmico. Em casos como esse, a melhor abordagem para raspagem de dados é usar uma ferramenta de automação do navegador.

Se você não está familiarizado com essa tecnologia, as ferramentas de automação de navegadores permitem renderizar e interagir com páginas da web em um ambiente de navegador controlável. Além disso, criar um URL de pesquisa válido no Google Maps não é fácil. A maneira mais simples de lidar com isso é realizando a pesquisa diretamente em um navegador.

Uma das melhores ferramentas de automação de navegador para Python é o Selenium, tornando-o a escolha ideal para raspar o Google Maps. Prepare-se para instalá-lo, pois será a principal biblioteca usada para esta tarefa!

Etapa 3: instalar e configurar a biblioteca de raspagem de dados

Instale o Selenium por meio do pacote selenium pip com este comando em um ambiente virtual Python ativado:

pip install selenium

Para mais detalhes sobre como usar essa ferramenta, siga nosso tutorial sobre raspagem de dados com o Selenium.

Importe o Selenium no scraper.py e crie um objeto WebDriver para controlar uma instância do Chrome em modo headless:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing

# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
    service=Service(),
    options=options
)

O trecho acima inicializa uma instância do Chrome WebDriver para controlar uma janela do navegador Chrome programaticamente. A flag --headless serve para iniciar o Chrome em modo headless, que é executado em segundo plano — sem carregar sua janela. Para depuração, você pode comentar esta linha para observar as ações do script em tempo real.

Como última linha do seu script de raspagem de dados do Google Maps, não se esqueça de fechar o web driver:

driver.quit()

Incrível! Agora você está totalmente configurado para começar a raspar as páginas do Google Maps.

Etapa 4: conectar à página desejada

Use o método get () para se conectar à página inicial do Google Maps:

driver.get("https://www.google.com/maps")

No momento, o  scraper.py conterá estas linhas:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing

# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
    service=Service(),
    options=options
)

# connect to the Google Maps home page
driver.get("https://www.google.com/maps")

# scraping logic...

# close the web browser
driver.quit()

Incrível, é hora de começar a raspar um site dinâmico como o Maps!

Etapa 5: lidar com a caixa de diálogo de cookies do GDPR

Observação: se você não estiver localizado na UE (União Europeia), você pode pular esta etapa.

Execute o script scraper.py no modo headed, adicionando um ponto de interrupção antes da última linha, se possível. Isso manterá a janela do navegador aberta, permitindo que você a observe sem que ela seja fechada imediatamente. Se você estiver na UE, deverá ver algo assim:

Observação: a mensagem “Chrome está sendo controlado por um software de teste automatizado.” confirma que o Selenium está controlando o Chrome com sucesso.

O Google precisa mostrar algumas opções de política de cookies para usuários da UE devido aos requisitos do GDPR. Se isso se aplicar a você, você precisará lidar com essa opção se quiser interagir com a página. Se esse não for o caso, você pode pular para a Etapa 6.

Dê uma olhada no URL na barra de endereço do navegador e você notará que ela não corresponde à página especificada em get(). O motivo é que o Google redirecionou você. Depois de clicar no botão “Aceitar tudo”, você será levado de volta à página de destino, que é a página inicial do Google Maps.

Para lidar com as opções do GDPR, abra a página inicial do Google Maps no modo de navegação anônima em seu navegador e aguarde o redirecionamento. Clique com o botão direito no botão “Aceitar Todos” e selecione a opção “Inspecionar”:

Como você deve ter notado, as classes CSS dos elementos HTML na página parecem ter sido geradas aleatoriamente. Isso significa que elas não são confiáveis para raspagem de dados na web, pois provavelmente são atualizadas a cada implantação. Portanto, você precisa se concentrar em direcionar atributos mais estáveis, como aria-label:

accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")

find_element() é um método no Selenium usado para localizar elementos HTML em uma página utilizando diversas estratégias. Nesse caso, usamos um seletor CSS. Se você quiser saber mais sobre os diferentes tipos de seletores, leia nosso XPath versus CSS selector.

Não se esqueça de importar By adicionando essa importação ao scraper.py:

from selenium.webdriver.common.by import By

A próxima instrução é clicar no botão:

accept_button.click()

Veja como tudo se encaixa para lidar com a página opcional de cookies do Google:

try:
     # select the "Accept all" button from the GDPR cookie option page
    accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")
    # click it
    accept_button.click()
except NoSuchElementException:
    print("No GDPR requirenments")

O comando click() pressiona o botão “Aceitar tudo”, permitindo que o Google o redirecione para a página inicial do Maps. Se você não estiver na UE, esse botão não estará na página, o que causará NoSuchElementException. O script detectará a exceção e prosseguirá, pois não é um erro crítico, apenas um cenário em potencial.

Certifique-se de importar NoSuchElementException:

from selenium.common import NoSuchElementException

Muito bem! Agora você está pronto para se concentrar na raspagem de dados do Google Maps.

Etapa 6: enviar o formulário de pesquisa

No momento, seu raspador de dados do Google Maps deve chegar a uma página como a abaixo:

Observe que a localização nos mapas depende da localização do seu IP. Neste exemplo, estamos localizados em Nova York.

Em seguida, você deve preencher o campo “Pesquisar no Google Maps” e enviar o formulário de pesquisa. Para localizar esse elemento, abra a página inicial do Google Maps no modo de navegação anônima em seu navegador. Clique com o botão direito no campo de entrada de pesquisa e escolha a opção “Inspecionar”:

search_input = WebDriverWait(driver, 5).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, "#searchboxinput"))
)

WebDriverWait é uma classe Selenium especializada que pausa o script até que uma condição especificada na página seja atendida. No exemplo acima, ele espera até 5 segundos para que o elemento HTML de entrada apareça. Essa espera garante que a página tenha sido totalmente carregada, o que é necessário se você seguiu a Etapa 5 (por causa do redirecionamento).

Para fazer as linhas acima funcionarem, adicione essas importações ao scraper.py:

from selenium.webdriver.support.ui import WebDriverWait 
from selenium.webdriver.support import expected_conditions as EC

Next, fill out the input with the `[send_keys()](https://www.selenium.dev/documentation/webdriver/actions_api/keyboard/#send-keys)` method:

search_query = "italian restaurants"
search_input.send_keys(search_query)

Nesse caso, “restaurantes italianos” é o termo de pesquisa, mas você pode pesquisar por qualquer outro termo.

Só resta enviar o formulário. Inspecione o botão de envio, que é uma lupa:

Selecione-o direcionando o atributo aria-label e clique nele:

search_button = driver.find_element(By.CSS_SELECTOR, "button[aria-label=\"Search\"]")
search_button.click()

Incrível! O navegador controlado agora carregará os dados para raspar.

Etapa 7: selecione os itens do Google Maps

É aqui que seu script deveria estar atualmente:

Os dados a serem raspados estão contidos nos itens do Google Maps à esquerda. Como se trata de uma lista, a melhor estrutura de dados para conter os dados extraídos é uma matriz. Inicialize um:

items = []

O objetivo agora é selecionar o item do Google Maps à esquerda. Inspecione um deles:

Mais uma vez, as classes CSS parecem ter sido geradas aleatoriamente, portanto, não são confiáveis para raspagem de dados. Em vez disso, você pode direcionar o atributo jsaction . Como partes do conteúdo desse atributo também parecem ser geradas aleatoriamente, concentre-se na string consistente dentro dele, especificamente, “mouseover:pane”.

O seletor XPath abaixo ajudará você a selecionar todos os elementos <div> dentro do elemento pai <div> onde role="feed", cujo atributo jsaction contém a string "mouseover:pane" :

maps_items = WebDriverWait(driver, 10).until(
    EC.presence_of_all_elements_located((By.XPATH, '//div[@role="feed"]//div[contains(@jsaction, "mouseover:pane")]'))
)

Novamente, WebDriverWait é necessário, pois o conteúdo à esquerda é carregado dinamicamente na página.

Repita em cada elemento e prepare seu raspador de dados do Google Maps para extrair alguns dados:

for maps_item in maps_items:
    # scraping logic...

Excelente! A próxima etapa é extrair dados desses elementos.

Etapa 8: faça raspagem de dados nos itens do Google Maps

Inspecione um único item do Google Maps e foque nos elementos dentro dele:

Aqui, você pode ver o que você pode raspar:

• O link do item do Maps do elemento a[jsaction][jslog] 
• O título do elemento div.fontHeadlineSmall 
• As estrelas e o número de avaliações de span[role="img"]

Você pode conseguir isso com a lógica abaixo:

link_element = maps_item.find_element(By.CSS_SELECTOR, "a[jsaction][jslog]")
url = link_element.get_attribute("href")

title_element = maps_item.find_element(By.CSS_SELECTOR, "div.fontHeadlineSmall")
title = title_element.text

reviews_element = maps_item.find_element(By.CSS_SELECTOR, "span[role=\"img\"]")
reviews_string = reviews_element.get_attribute("aria-label")

# define a regular expression pattern to extract the stars and reviews count
reviews_string_pattern = r"(\d+\.\d+) stars (\d+[,]*\d+) Reviews"

# use re.match to find the matching groups
reviews_string_match = re.match(reviews_string_pattern, reviews_string)

reviews_stars = None
reviews_count = None

# if a match is found, extract the data
if reviews_string_match:
    # convert stars to float
    reviews_stars = float(reviews_string_match.group(1))
    # convert reviews count to integer
    reviews_count = int(reviews_string_match.group(2).replace(",", ""))

A função get_attribute() retorna o conteúdo dentro do atributo HTML especificado, enquanto .text retorna o conteúdo da string dentro do nó.

Observe o uso de uma expressão regular para extrair os campos de dados específicos da string “X.Y estrelas em Z avaliações”. Saiba mais em nosso artigo sobre o uso de regex para raspagem de dados na web.

Não se esqueça de importar o pacote re da biblioteca padrão do Python:

import re

Continue inspecionando o item do Google Maps:

Dentro da classe <div> com a classe FondBodyMedium , você pode obter a maioria das informações de nós <span> sem atributos ou apenas do atributo style . Quanto ao elemento de preço opcional, você pode selecioná-lo segmentando o nó que contém “Preço” no atributo aria-label :

info_div = maps_item.find_element(By.CSS_SELECTOR, ".fontBodyMedium")

# scrape the price, if present
try:
    price_element = info_div.find_element(By.XPATH, ".//*[@aria-label[contains(., 'Price')]]")
    price = price_element.text
except NoSuchElementException:
    price = None

info = []
# select all <span> elements with no attributes or the @style attribute
# and descendant of a <span>
span_elements = info_div.find_elements(By.XPATH, ".//span[not(@*) or @style][not(descendant::span)]")
for span_element in span_elements:
  info.append(span_element.text.replace("⋅", "").strip())

# to remove any duplicate info and empty strings
info = list(filter(None, list(set(info))))

Como o elemento de preço é opcional, você deve envolver essa lógica com um bloco try ... except . Dessa forma, se o nó de preço não estiver na página, o script continuará sem falhas. Se você pular a Etapa 5, adicione a importação para NoSuchElementException:

from selenium.common import NoSuchElementException

Para evitar strings vazias e elementos de informação duplicados, observe o uso de filter() e set().

Agora, foque na imagem:

Você pode fazer a raspagem de dados com:

img_element = WebDriverWait(driver, 5).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, "img[decoding=\"async\"][aria-hidden=\"true\"]"))
)
image = img_element.get_attribute("src")

Lembre-se de que o WebDriverWait é necessário, pois as imagens são carregadas de forma assíncrona e podem levar algum tempo para aparecer.

A última etapa é raspar as tags no elemento na parte inferior:

Você pode recuperá-los todos dos nós <span> com o atributo style no último elemento .fontBodyMedium :

tags_div = maps_item.find_elements(By.CSS_SELECTOR, ".fontBodyMedium")[-1]
tags = []
tag_elements = tags_div.find_elements(By.CSS_SELECTOR, "span[style]")
for tag_element in tag_elements:
  tags.append(tag_element.text)

Ótimo! A lógica de raspagem de dados do Python no Google Maps está completa.

Etapa 9: colete os dados raspados

Agora você tem os dados raspados em várias variáveis. Crie um novo objeto item e preencha-o com esses dados:

item = {
  "url": url,
  "image": image,
  "title": title,
  "reviews": {
    "stars": reviews_stars,
    "count": reviews_count
  },
  "price": price,
  "info": info,
  "tags": tags
}

Em seguida, anexe-o à matriz items :

items.append(item)

No final do loop for nos nós de itens do Google Maps, items conterá todos os seus dados de coleta. Você só precisa exportar essas informações para um arquivo legível por humanos, como CSV.

Etapa 10: exportar para CSV

Importe o pacote csv da biblioteca padrão do Python:

import csv

Em seguida, use-o para preencher um arquivo CSV simples com seus dados do Google Maps:

# output CSV file path
output_file = "items.csv"

# flatten and export to CSV
with open(output_file, mode="w", newline="", encoding="utf-8") as csv_file:
    # define the CSV field names
    fieldnames = ["url", "image", "title", "reviews_stars", "reviews_count", "price", "info", "tags"]
    writer = csv.DictWriter(csv_file, fieldnames=fieldnames)

    # write the header
    writer.writeheader()

    # write each item, flattening info and tags
    for item in items:
        writer.writerow({
            "url": item["url"],
            "image": item["image"],
            "title": item["title"],
            "reviews_stars": item["reviews"]["stars"],
            "reviews_count": item["reviews"]["count"],
            "price": item["price"],
            "info": "; ".join(item["info"]),  
            "tags": "; ".join(item["tags"])
        })

O trecho acima exporta items para um arquivo CSV chamado items.csv. As principais funções usadas são:

• open(): abra o arquivo especificado no modo de escrita com codificação UTF-8 para lidar com a saída de texto.
• csv.DictWriter(): crie um objeto CSV writer usando os nomes de campo especificados, permitindo que as linhas sejam escritas como dicionários.
• writeheader(): escreva a linha de cabeçalho no arquivo CSV com base nos nomes dos campos.
• writer.writerow(): escreva cada item como uma linha no arquivo CSV.

Observe o uso da função de string join()  para transformar as matrizes em strings simples. Isso garante que o CSV de saída seja um arquivo limpo e de nível único.

Passo 11: coloque tudo junto

Aqui está o código final do raspador de dados do Google Maps em Python:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import re
import csv

# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing

# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
    service=Service(),
    options=options
)

# connect to the Google Maps home page
driver.get("https://www.google.com/maps")

# to deal with the option GDPR options
try:
     # select the "Accept all" button from the GDPR cookie option page
    accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")
    # click it
    accept_button.click()
except NoSuchElementException:
    print("No GDPR requirenments")

# select the search input and fill it in
search_input = WebDriverWait(driver, 5).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, "#searchboxinput"))
)
search_query = "italian restaurants"
search_input.send_keys(search_query)

# submit the search form
search_button = driver.find_element(By.CSS_SELECTOR, "button[aria-label=\"Search\"]")
search_button.click()

# where to store the scraped data
items = []

# select the Google Maps items
maps_items = WebDriverWait(driver, 10).until(
    EC.presence_of_all_elements_located((By.XPATH, '//div[@role="feed"]//div[contains(@jsaction, "mouseover:pane")]'))
)

# iterate over the Google Maps items and
# perform the scraping logic
for maps_item in maps_items:
    link_element = maps_item.find_element(By.CSS_SELECTOR, "a[jsaction][jslog]")
    url = link_element.get_attribute("href")

    title_element = maps_item.find_element(By.CSS_SELECTOR, "div.fontHeadlineSmall")
    title = title_element.text

    reviews_element = maps_item.find_element(By.CSS_SELECTOR, "span[role=\"img\"]")
    reviews_string = reviews_element.get_attribute("aria-label")

    # define a regular expression pattern to extract the stars and reviews count
    reviews_string_pattern = r"(\d+\.\d+) stars (\d+[,]*\d+) Reviews"

    # use re.match to find the matching groups
    reviews_string_match = re.match(reviews_string_pattern, reviews_string)

    reviews_stars = None
    reviews_count = None

    # if a match is found, extract the data
    if reviews_string_match:
        # convert stars to float
        reviews_stars = float(reviews_string_match.group(1))
        # convert reviews count to integer
        reviews_count = int(reviews_string_match.group(2).replace(",", ""))

    # select the Google Maps item <div> with most info
    # and extract data from it
    info_div = maps_item.find_element(By.CSS_SELECTOR, ".fontBodyMedium")

    # scrape the price, if present
    try:
        price_element = info_div.find_element(By.XPATH, ".//*[@aria-label[contains(., 'Price')]]")
        price = price_element.text
    except NoSuchElementException:
        price = None

    info = []
    # select all <span> elements with no attributes or the @style attribute
    # and descendant of a <span>
    span_elements = info_div.find_elements(By.XPATH, ".//span[not(@*) or @style][not(descendant::span)]")
    for span_element in span_elements:
      info.append(span_element.text.replace("⋅", "").strip())

    # to remove any duplicate info and empty strings
    info = list(filter(None, list(set(info))))

    img_element = WebDriverWait(driver, 5).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, "img[decoding=\"async\"][aria-hidden=\"true\"]"))
    )
    image = img_element.get_attribute("src")

    # select the tag <div> element and extract data from it
    tags_div = maps_item.find_elements(By.CSS_SELECTOR, ".fontBodyMedium")[-1]
    tags = []
    tag_elements = tags_div.find_elements(By.CSS_SELECTOR, "span[style]")
    for tag_element in tag_elements:
      tags.append(tag_element.text)

    # populate a new item with the scraped data
    item = {
      "url": url,
      "image": image,
      "title": title,
      "reviews": {
        "stars": reviews_stars,
        "count": reviews_count
      },
      "price": price,
      "info": info,
      "tags": tags
    }
    # add it to the list of scraped data
    items.append(item)

# output CSV file path
output_file = "items.csv"

# flatten and export to CSV
with open(output_file, mode="w", newline="", encoding="utf-8") as csv_file:
    # define the CSV field names
    fieldnames = ["url", "image", "title", "reviews_stars", "reviews_count", "price", "info", "tags"]
    writer = csv.DictWriter(csv_file, fieldnames=fieldnames)

    # write the header
    writer.writeheader()

    # write each item, flattening info and tags
    for item in items:
        writer.writerow({
            "url": item["url"],
            "image": item["image"],
            "title": item["title"],
            "reviews_stars": item["reviews"]["stars"],
            "reviews_count": item["reviews"]["count"],
            "price": item["price"],
            "info": "; ".join(item["info"]),
            "tags": "; ".join(item["tags"])
        })

# close the web browser
driver.quit()

Em cerca de 150 linhas de código, você acabou de criar um script de raspagem de dados do Google Maps!

Verifique se funciona iniciando o arquivo scraper.py . No Windows, execute o raspador com:

python scraper.py

De forma equivalente, no Linux ou macOS, execute:

python3 scraper.py

Aguarde até que o raspador de dados termine de ser executado e um arquivo items.csv aparecerá no diretório raiz do seu projeto. Abra o arquivo para visualizar os dados extraídos, que devem conter dados como estes:

Parabéns, missão cumprida!

Conclusão

Neste tutorial, você aprendeu o que é um raspador de dados do Google Maps e como criar um em Python. Como você viu, construir um script simples para recuperar dados automaticamente do Google Maps leva apenas algumas linhas de código em Python.

Embora a solução funcione para projetos pequenos, ela não é prática para raspagem em grande escala. O Google tem medidas anti-bots avançadas, como CAPTCHAs e bloqueios de IP, que podem bloquear você. Escalar o processo em várias páginas também aumentaria os custos de infraestrutura. Além disso, esse exemplo simples não leva em conta todas as interações complexas necessárias nas páginas do Google Maps.

Isso significa que fazer raspagem de dados no Google Maps de forma eficiente e confiável é impossível? De jeito nenhum! Você só precisa de uma solução avançada como a API de raspagem de dados do Google Maps da Bright Data.

A API de raspagem de dados do Google Maps oferece endpoints para recuperar dados do Google Maps, sem se preocupar com os principais desafios. Com chamadas de API simples, você pode obter os dados que você precisa no formato JSON ou HTML. Se você não gosta de chamadas de API, você também pode explorar nossos conjuntos de dados do Google Maps prontos para uso.

Crie uma conta gratuita da Bright Data hoje mesmo para testar nossas APIs de raspagem de dados ou explorar nossos conjuntos de dados!