Como extrair comentários do Google Maps: Um Guia Prático em Python

Se já tentou descobrir como extrair avaliações do Google Maps em volume significativo, já conhece os pontos críticos: a API oficial do Places devolve, no máximo, um punhado de avaliações por local, o JavaScript renderiza a maior parte da listagem e os ganchos de classe CSS rodam com frequência suficiente para danificar um scraper entre sexta-feira e segunda-feira. A boa notícia é que os dados estão acessíveis, basta escolher a ferramenta certa para o trabalho.

Este guia foi escrito para programadores Python, analistas de dados e equipas de crescimento que pretendem obter avaliações de empresas do Google Maps para análise de sentimentos, pesquisa da concorrência, inteligência de localização ou geração de leads. Abordaremos três métodos em paralelo: Selenium mais um proxy para controlo total, uma API de extração com instruções de renderização para uma abordagem com menos código e uma API JSON por avaliação quando necessitar de campos limpos e estruturados, como review_id, iso_date_of_last_edite respostas do proprietário.

Vais sair daqui com código funcional, uma tabela comparativa para justificar a abordagem que escolheres e um pequeno pipeline para limpar e analisar o que recolheres. Nos casos em que se sabe que os seletores ou quotas subjacentes podem variar, o artigo destaca isso para que possas planear em conformidade, em vez de teres de depurar o código às 2 da manhã.

As avaliações são um dos conjuntos de dados mais reveladores na web pública. Um feed de avaliações do Maps limpo permite-lhe comparar a experiência do cliente de um concorrente, monitorizar a reputação em diferentes locais, criar listas de leads com base na localização, calcular um índice de sentimento regional ou treinar um modelo de recomendação com comentários reais de pessoas. Nada disso funciona se tiver apenas médias de estrelas, que é exatamente onde a maioria dos scrapers de listagens genéricos se detém.

Na prática, os campos que pode extrair do Google Maps dividem-se em duas camadas. Na camada de listagem, obtém o nome do local, endereço, classificação geral, número de avaliações, categoria, horário de funcionamento, telefone e opções de serviço, como refeições no local ou entrega. Na camada de cada avaliação, obtém-se o texto da avaliação (o excerto), o nome do avaliador, o link do perfil, a classificação por estrelas, a data da avaliação ou da última edição, URLs de fotos, uma resposta do proprietário, quando presente, e tags de tópicos, como Serviço ou Ambiente. Saber esta divisão antecipadamente permite-lhe decidir se a extração ao nível da listagem é suficiente ou se precisa de aprofundar as avaliações individuais. Os casos de utilização de pesquisa de mercado e monitorização de avaliações quase sempre necessitam da segunda camada.

Quando se pesquisa como extrair avaliações do Google Maps, surgem três caminhos. Escolher o caminho errado é a razão mais comum pela qual as equipas desistem a meio do caminho, por isso dedique alguns minutos a esta etapa antes de escrever código.

A API oficial do Google Places é a mais segura do ponto de vista legal, mas foi concebida para integrações de aplicações, não para análise. De acordo com a documentação do Google, os pedidos de detalhes de locais devolvem apenas um pequeno subconjunto limitado das avaliações apresentadas na interface do Maps, o que a torna inadequada para a pontuação de sentimentos em qualquer escala. Um scraper Selenium DIY (faça você mesmo) juntamente com um proxy residencial dá-lhe controlo total e a mesma visualização que um utilizador sem sessão veria, ao custo de ter de executar um navegador e acompanhar as alterações de CSS. Uma API de scraping no meio absorve a rotação de proxies, o tratamento de CAPTCHA e a renderização headless, e uma API JSON por avaliação, além disso, absorve também a análise.

Utilize a tabela abaixo como uma matriz de decisão fundamentada.

O Maps é mais difícil de rastrear do que um site de comércio eletrónico típico, e não pelas razões que as pessoas esperam. A primeira coisa com que se depara é a barreira de consentimento de cookies, que bloqueia a renderização do painel de resultados de pesquisa até ser ignorada. A segunda é que o Maps é uma experiência exclusivamente em JavaScript, pelo que um requests.get retorna uma estrutura quase vazia. A terceira, e a que mais frequentemente bloqueia os scrapers, é que o painel de listagem utiliza carregamento baseado em rolagem em vez de URLs paginadas. Não há ?page=2 que possa ser acedido.

Além disso, o Google ofusca e alterna os nomes das classes CSS. Ganchos como hfpxzc, MW4etd, UY7F9e Nv2PK eram válidos no momento da redação, mas devem ser verificados novamente antes da publicação ou execução, pois mudam frequentemente. Padrões de pedidos agressivos a partir de um único IP também acionam limites de taxa e, ocasionalmente, o reCAPTCHA, razão pela qual um conjunto de proxies residenciais e tempos de espera aleatórios não são opcionais assim que se ultrapassa um número reduzido de consultas.

Vais precisar do Python 3.10 ou mais recente e de uma instalação recente do Chrome. A vertente Selenium também necessita de alguns pacotes. Instala-os com o pip:

pip install selenium selenium-wire webdriver-manager beautifulsoup4 lxml requests

Cada um faz a sua parte. O Selenium controla o navegador. O Selenium Wire é uma extensão leve que expõe as solicitações HTTP subjacentes para que possa ligar um proxy autenticado sem ter de mexer nas configurações do Chrome. O Webdriver Manager gere o binário do ChromeDriver para que não tenha de fixar uma versão específica em cada computador portátil. O BeautifulSoup com o backend lxml analisa o HTML renderizado, e o requests é suficiente para as faixas de API.

Para os Métodos 2 e 3, crie uma conta na API SERP antes de começar. Normalmente, pode obter um crédito gratuito para testar e, em seguida, inserir a chave nos blocos de código abaixo.

A resposta clássica para saber como extrair comentários do Google Maps é um navegador real mais um proxy residencial rotativo. Este é o caminho com maior abrangência e maior controlo. Executa uma instância do Chrome, encaminha o tráfego através do proxy, percorre o painel até que sejam carregadas listagens suficientes e analisa o código-fonte da página com o BeautifulSoup. É a escolha certa quando precisa de flexibilidade (fluxos de cliques personalizados, captura de ecrãs, perfis empresariais protegidos por login) ou quando a sua escala é suficientemente pequena para gerir seletores. As cinco subsecções abaixo orientam-no em cada passo do início ao fim, com código que pode colar diretamente num script.

O truque para extrair avaliações do Google Maps com o Selenium é enviar todos os pedidos através de um proxy residencial rotativo. O Selenium simples não consegue passar credenciais de autenticação HTTP básica de forma limpa, e é aí que o Selenium Wire entra. Ele expõe o bloco de proxy em seleniumwire_options e trata do handshake de autenticação nos bastidores. O padrão de URL de proxy que a maioria dos fornecedores espera tem o seguinte formato http://<username>:<password>@<host>:<port>, com parâmetros adicionais como render ou country_code anexados ao nome de utilizador. Confirme o formato exato com base na documentação atual do seu fornecedor antes de executar isto em produção, pois as convenções de URL variam.

from seleniumwire import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

API_KEY = "YOUR_API_KEY"
PROXY = (
    f"http://scrape.render=true.country_code=us:{API_KEY}"
    "@proxy-server.example.com:8001"
)

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")

sw_options = {"proxy": {"http": PROXY, "https": PROXY, "no_proxy": "localhost,127.0.0.1"}}

driver = webdriver.Chrome(
    service=Service(ChromeDriverManager().install()),
    seleniumwire_options=sw_options,
    options=options,
)
driver.implicitly_wait(30)

O modo headless mantém o uso de memória mais baixo nos servidores, e a espera implícita de 30 segundos dá tempo ao Maps para renderizar antes que qualquer pesquisa de seletor seja disparada. Se quiser uma introdução mais aprofundada ao Selenium, a documentação de ligações de linguagem explica cada opção em detalhe.

Assim que o driver estiver configurado, aponte-o para um URL de pesquisa como https://www.google.com/maps/search/pizza+in+new+york. O Maps geralmente exibe uma caixa de diálogo de consentimento de cookies na primeira vez que uma sessão é carregada, e o layout não permite que você role os resultados até que a feche. Envolva o clique num try/except, pois o tráfego renderizado por proxy em algumas regiões ignora completamente a caixa de diálogo.

from selenium.webdriver.common.by import By

driver.get("https://www.google.com/maps/search/pizza+in+new+york")

try:
    accept_btn = driver.find_element(
        By.XPATH, "//button[.//span[contains(text(), 'Accept all')]]"
    )
    accept_btn.click()
except Exception:
    print("Cookie consent not shown for this session.")

Registe sempre a falha em vez de deixar a exceção propagar-se. Pretende que a execução continue quando a caixa de diálogo estiver ausente, não que seja abortada. Se a sua localização apresentar um rótulo de botão diferente, troque o texto XPath ou recorra a uma aria-label correspondência no banner de consentimento.

O Maps não pagina. À medida que percorre o painel do lado esquerdo, ele transmite mais listagens para o DOM e, eventualmente, atinge um marcador de fim. Para extrair avaliações do Google Maps em qualquer escala razoável, tem de controlar essa rolagem você mesmo. Dois padrões funcionam bem. O primeiro usa teclas através de ActionChains, o que se assemelha a um utilizador real. O segundo utiliza um executor de JavaScript, que é mais rápido mas mais fácil de identificar.

import time
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys

def scroll_panel_down(driver, panel_xpath, presses=5, pause_time=1):
    panel = driver.find_element(By.XPATH, panel_xpath)
    actions = ActionChains(driver)
    actions.move_to_element(panel).click().perform()
    for _ in range(presses):
        actions.send_keys(Keys.PAGE_DOWN).perform()
        time.sleep(pause_time)

# Cleaner JS-executor alternative
def scroll_panel_js(driver, panel_xpath, rounds=8, pause=1.2):
    panel = driver.find_element(By.XPATH, panel_xpath)
    for _ in range(rounds):
        driver.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", panel)
        time.sleep(pause)

Ajuste presses e pause_time em função da sua consulta alvo. Cinco movimentos para baixo com uma pausa de um segundo são um ponto de partida razoável, mas uma consulta sobre uma cidade densa pode precisar de 15 ou mais rondas antes de o painel reportar 'You've reached the end of the list'. Observe o HTML renderizado e pare quando deixarem de aparecer novos resultados.

Assim que o painel tiver carregado listagens suficientes, passe o código-fonte da página para o BeautifulSoup e extraia os campos. Os ganchos de classe abaixo eram válidos no momento da redação, mas o Maps altera-os de acordo com o seu próprio calendário, por isso execute sempre uma verificação DOM atualizada antes de uma execução em produção.

from bs4 import BeautifulSoup

soup = BeautifulSoup(driver.page_source, "lxml")

# These class names rotate. Re-verify before each run.
titles = soup.find_all("a", class_="hfpxzc")        # listing anchors
ratings = soup.find_all("span", class_="MW4etd")      # numeric rating
counts = soup.find_all("span", class_="UY7F9")        # review count

places = []
for i, t in enumerate(titles):
    place = {
        "name": t.get("aria-label") or t.get_text(strip=True),
        "url": t.get("href"),
        "rating": ratings[i].get_text(strip=True) if i < len(ratings) else "N/A",
        "review_count": counts[i].get_text(strip=True) if i < len(counts) else "N/A",
    }
    places.append(place)

Há dois hábitos de resiliência importantes aqui. Primeiro, dê preferência ao aria-label atributo em vez do texto visível, porque o rótulo é mais estável perante ajustes na interface do utilizador. Segundo, use pesquisas seguras para o índice, para que uma classificação em falta não faça o loop falhar. Se quiser uma introdução mais aprofundada ao BeautifulSoup, um guia interno sobre padrões de análise é uma leitura complementar útil para estratégias de seleção mais avançadas.

O último passo do Método 1 é gravar as suas listagens analisadas no disco. O CSV é adequado para tarefas pontuais, e mudar para Parquet ou uma base de dados é uma alteração de uma linha a fazer mais tarde.

import csv

with open("maps_pizza_places.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "rating", "review_count", "url"])
    for p in places:
        writer.writerow([
            p.get("name") or "N/A",
            f"{p['rating']}/5" if p["rating"] != "N/A" else "N/A",
            p.get("review_count") or "N/A",
            p.get("url") or "N/A",
        ])

driver.quit()

Defina sempre os campos em falta como um valor de sentinela, como N/A em vez de uma célula vazia. Células vazias são ambíguas em pipelines a jusante (o campo estava em falta ou a extração falhou?) e dificultam as verificações de qualidade dos dados. Chamar driver.quit() no final libera o processo do Chrome e quaisquer ligações de proxy que ele mantivesse.

O Método 1 é adequado para protótipos, mas é pesado. A resposta de produção mais limpa para como extrair avaliações do Google Maps em escala é delegar a renderização e a rotação de proxy a uma API de extração e enviar um conjunto de instruções JSON que diz a um navegador headless hospedado o que fazer na página. Obtém-se o mesmo HTML final, sem a sobrecarga do navegador local, e o fornecedor absorve as tentativas de repetição e a rotação de proxy que, de outra forma, seriam da sua responsabilidade.

A maioria dos fornecedores, incluindo a nossa API WebScrapingAPI SERP, aceita um conjunto de instruções JSON nos cabeçalhos de pedido que descreve deslocamentos, cliques e tempos de espera. O exemplo abaixo ignora o banner de cookies, desloca o painel de resultados algumas vezes e devolve o HTML final num único pedido. Confirme os nomes exatos dos cabeçalhos e o esquema de instruções nos documentos atuais do fornecedor, uma vez que estes detalhes variam.

import json, requests
from bs4 import BeautifulSoup

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://www.google.com/maps/search/pizza+in+new+york"

instructions = [
    {"type": "click", "selector": "button[aria-label='Accept all']", "optional": True},
    {"type": "scroll", "selector": "div[role='feed']", "repeat": 8, "delay": 1500},
    {"type": "wait", "value": 2000},
]

headers = {
    "x-api-key": API_KEY,
    "x-render-js": "true",
    "x-instruction-set": json.dumps(instructions),
}

resp = requests.get("https://api.example-scraper.com/v1",
                    params={"url": TARGET_URL}, headers=headers, timeout=120)

soup = BeautifulSoup(resp.text, "lxml")
listings = soup.find_all("div", class_="Nv2PK")  # re-verify class before each run
print(f"Got {len(listings)} listings.")

Três coisas fazem com que valha a pena mudar para este padrão. Primeiro, já não está a executar e a atualizar o Chrome em cada worker. Segundo, o fornecedor roda proxies e repete as solicitações falhadas por si, o que elimina a maior parte do trabalho operacional dos dias maus. Terceiro, todo o pipeline pode ficar num cron job ou numa função sem servidor, sem dependência do navegador.

A extração ao nível do anúncio indica-lhe quais os locais que importam, mas o valor comercial reside uma camada mais abaixo, no texto real da avaliação. A resposta mais curta à questão de como extrair avaliações do Google Maps ao nível de cada avaliação é ignorar completamente a análise e utilizar uma API estruturada do Maps Reviews. Pesquise um local data_id uma vez e, em seguida, chama o endpoint de avaliações com os parâmetros de que necessita.

A estrutura é intuitiva. engine seleciona o motor de Avaliações do Maps. data_id identifica o local. sort_by controla a ordenação: qualityScore (padrão, mais relevante), newestFirst, ratingHighou ratingLow. topic_id filtra por um tema específico, por exemplo, um ID de tópico de Amenidades extraído da resposta estruturada (o resumo indicou um ID de amostra de /m/0f3yyn para verificação). Campos opcionais como Snippet, Responsee Response.iso_date são indexados a partir de zero, com a primeira avaliação no índice 0.

import requests

params = {
    "engine": "google_maps_reviews",
    "data_id": "0x80dcd1f0c5cb6f53:0xd2c4f5c30e2b7c5a",
    "sort_by": "newestFirst",
    "api_key": "YOUR_API_KEY",
}

r = requests.get("https://api.example-reviews.com/search", params=params, timeout=60).json()

for rev in r.get("reviews", []):
    print({
        "user": rev.get("user", {}).get("name"),
        "rating": rev.get("rating"),
        "date": rev.get("iso_date_of_last_edit"),
        "text": rev.get("snippet", "No review text, rating only"),
        "owner_response": rev.get("response", {}).get("snippet", "No response from owner"),
    })

Considere sempre os campos em falta como padrão. Os avaliadores deixam frequentemente uma classificação por estrelas sem texto, e a maioria dos proprietários nunca responde, pelo que o JSON terá lacunas.

Tanto a API como as faixas DIY limitam o primeiro lote a um número reduzido. De acordo com a documentação dos fornecedores, uma API de Avaliações do Maps típica devolve cerca de 10 avaliações por pedido e expõe um next_page_token (ou cursor equivalente) na resposta. O ciclo de paginação tem a mesma forma que usaria para qualquer API baseada em token: continue a chamar até que o campo do token esteja em falta.

all_reviews, token = [], None
while True:
    p = dict(params, **({"next_page_token": token} if token else {}))
    r = requests.get(URL, params=p, timeout=60).json()
    all_reviews.extend(r.get("reviews", []))
    token = r.get("serpapi_pagination", {}).get("next_page_token")
    if not token:
        break

No lado do Selenium, a paginação consiste simplesmente em continuar a percorrer a página dentro do separador de avaliações do cartão do local. Esteja atento ao marcador «Chegou ao fim da lista» e pare quando a contagem de avaliações apresentadas deixar de aumentar ao longo de duas passagens consecutivas.

Depois de compreender como extrair avaliações do Google Maps de forma automática, o desafio a longo prazo é permanecer desbloqueado. Volume e discrição são um compromisso, não uma configuração fixa. A alavanca mais importante é o seu conjunto de proxies. Os IPs de centros de dados são sinalizados nas consultas do Maps muito mais rapidamente do que os residenciais; por isso, assim que ultrapassar algumas dezenas de pedidos por hora, planeie alternar entre IPs residenciais com segmentação ao nível do país. Incorpore esperas aleatórias entre ações (300 a 1500 ms é um intervalo razoável), recue exponencialmente em 429s e limite sempre as tentativas, para que um alvo indesejado não consuma todo o seu orçamento.

O desvio do seletor é o segundo modo de falha. Trate os ganchos como hfpxzc, MW4etde Nv2PK como voláteis. Crie uma etapa simples de monitorização do DOM que avise claramente quando um seletor deixar de corresponder a qualquer coisa, dê preferência a aria-label e seletores estruturais em vez de nomes de classe sempre que possível, e mantenha pelo menos um plano de contingência por campo crítico. Vale a pena marcar como favorito uma breve lista de dicas sobre sinais de bloqueio comuns e como contorná-los, e o guia mais detalhado da nossa equipa sobre como evitar bloqueios de IP aprofunda a rotação de cabeçalhos e a identificação digital (uma leitura complementar útil quando um script outrora estável de repente começa a devolver erros 403).

O objetivo de tudo isto é obter dados prontos para a tomada de decisões, não um CSV gigante. Um pequeno pipeline de pós-processamento transforma as avaliações em bruto em algo sobre o qual uma equipa de produto ou de marketing pode agir.

import pandas as pd
from textblob import TextBlob

df = pd.DataFrame(all_reviews)
df = df.drop_duplicates(subset=["review_id"])  # dedupe
df["rating"] = df["rating"].astype(float).clip(0, 5)  # normalize
df["text"] = df["snippet"].fillna("").str.replace(r"[\u200b-\u200f]", "", regex=True)
df["sentiment"] = df["text"].apply(lambda t: TextBlob(t).sentiment.polarity if t else 0.0)

Quatro passos fazem a maior parte do trabalho: deduplicação por review_id, ajustar as classificações para uma escala de 0 a 5, remover caracteres de largura zero e ruído de emojis do texto e marcar a polaridade do sentimento por linha com uma biblioteca leve de NLP. A partir daí, é um passo direto de Pandas para SQL ou de Pandas para o data warehouse. Essa saída é o que alimenta um painel de monitorização de avaliações ou uma comparação de sentimentos dos concorrentes, o que fecha o ciclo de volta aos casos de uso com que começámos.

• A API oficial do Google Places é conveniente para incorporar algumas avaliações num produto, mas os seus limites por local tornam-na a ferramenta errada para análise ou pesquisa da concorrência.
• Uma combinação de Selenium e proxies residenciais oferece-lhe o máximo controlo. Planeie para banners de cookies, carregamento acionado por rolagem e ganchos de classes CSS rotativos como hfpxzc e Nv2PK.
• Uma API de scraping com um conjunto de instruções de renderização JSON elimina totalmente o navegador local e é o caminho mais simples para tarefas agendadas e repetíveis.
• Uma API estruturada do Maps Reviews é o caminho mais rápido para campos limpos por avaliação. Use sort_by, topic_ide next_page_token para controlar a profundidade e a segmentação.
• Trate o pipeline como um pipeline. Desduplique por review_id, normalize as classificações, elimine ruído e identifique o sentimento para que o resultado esteja pronto para a tomada de decisões, e não apenas armazenado.

Os dados de avaliações públicas são geralmente aceites como passíveis de extração em muitas jurisdições quando utilizados para análise ou investigação, mas os Termos de Serviço do Google restringem o acesso automatizado aos seus produtos, e a jurisprudência dos EUA sobre a extração de dados públicos continua a evoluir. Verifique sempre os termos do Maps, respeite robots.txt, evite extrair dados pessoais para além do que é visível publicamente e consulte um advogado antes de qualquer utilização comercial.

A API do Places tem um limite de taxa, requer um projeto Google Cloud faturável e devolve apenas um pequeno subconjunto das avaliações apresentadas na interface do Maps. Isso torna-a adequada para incorporar algumas avaliações num produto, mas impraticável para análise de sentimentos, comparação com a concorrência ou qualquer caso de utilização que necessite de uma amostra representativa.

Não de forma fiável com dados brutos requests, porque o Maps é uma SPA com muito JavaScript. As alternativas realistas são uma API de scraping que executa um navegador headless hospedado por si, ou uma API de Avaliações estruturada que devolve JSON analisado sem renderizar nada no lado do cliente.

Com frequência suficiente para que não deva assumir que qualquer gancho de classe é permanente. Proteja-se contra desvios com aria-label seletores, fallbacks estruturais de XPath, uma pequena tarefa de monitorização do DOM que falha de forma evidente quando um seletor retorna zero correspondências e um alerta que o notifica antes da próxima execução agendada.

Uma API de Avaliações do Maps típica retorna cerca de 10 avaliações por solicitação e um next_page_token cursor para o lote seguinte. Não há um limite total fixo, mas as avaliações muito antigas tornam-se mais difíceis de recuperar. Percorra os tokens até que nenhum seja devolvido e, no Selenium, continue a percorrer a secção de avaliações até que a contagem pare de aumentar.

Não existe uma resposta única e correta sobre como extrair avaliações do Google Maps. A resposta certa depende da quantidade de dados de que necessita, da frequência com que precisa deles e do esforço operacional que consegue suportar. Para uma auditoria pontual às localizações de um concorrente, o Selenium e um proxy residencial são suficientes. Para um pipeline de análise de sentimentos recorrente que tem de continuar a funcionar enquanto o Google altera nomes de classes e reforça a sua defesa anti-bot, uma API de extração gerida ou uma API estruturada do Maps Reviews é o caminho que não o vai tirar do sono.

Seja qual for o método que escolher, trate o resultado como dados e não como HTML. Desduplique por ID de avaliação, normalize classificações, elimine ruído, avalie o sentimento e carregue-o num local pesquisável para que o trabalho valha a pena num painel ou modelo, em vez de um CSV desatualizado.

Se preferir não gerir e manter uma frota de Chrome apenas para acompanhar as alterações na interface do Maps, a nossa API Scraper SERP na WebScrapingAPI trata da rotação de proxies, renderização headless e resolução de CAPTCHA por trás de um único endpoint, para que possa manter o código Python deste guia e apenas trocar a camada de recolha. Crie uma chave API, aponte-a para um URL do Maps e comece a recolher dados de avaliações limpos numa tarde.