SERP e SEO 9 min de leitura

Como Fazer Scraping de Resultados de Busca do Google com Proxies

Saiba como raspar o Google SERPs usando proxies residenciais. Exemplos completos de códigos em Python, Node.js e Go para extrair resultados orgânicos, destaque de trechos, e Dados do People Also Ask.

ProxyHat Team
Como Fazer Scraping de Resultados de Busca do Google com Proxies

Por que raspar resultados da pesquisa do Google?

O Google processa mais de 8,5 bilhões de pesquisas por dia, tornando suas páginas de resultados de mecanismos de busca (SERPs) a fonte mais valiosa de inteligência competitiva na web. Raspar os resultados da pesquisa do Google lhe dá acesso a rankings orgânicos, trechos apresentados, pessoas também perguntar caixas, pacotes locais e anúncios pagos – tudo em tempo real.

Se você está construindo um Oleoduto de monitoramento SERP ou realizando uma pesquisa de palavras-chave única, o acesso programático aos resultados do Google permite automatizar fluxos de trabalho que levariam horas para completar manualmente. Os casos comuns de utilização incluem:

  • Rastreando seus próprios rankings de palavras-chave em mercados
  • Monitoramento da visibilidade do concorrente para consultas-alvo
  • Analisando a distribuição de recursos SERP (snippets, imagens, vídeos)
  • Construindo conjuntos de dados para pesquisa de SEO e estratégia de conteúdo

Compreendendo a estrutura do Google SERP

Antes de escrever um raspador, você precisa entender a anatomia de uma página de resultados do Google. Um SERP moderno pode conter mais de uma dúzia de tipos de resultados distintos:

Compreendendo a estrutura do Google SERP
Tipo de ResultadoCSS / Marcador de DadosDesignação das mercadorias
Resultados orgânicosdiv#search .gResultados padrão do link azul com título, URL e trecho
Excerto em destaquediv.xpdopenCaixa de resposta mostrada acima dos resultados orgânicos
As pessoas também perguntamdiv.related-question-pairPerguntas expansíveis no estilo FAQ
Embalagem localdiv.VkpGBbMapa com 3 listas de negócios locais
Painel de conhecimentosdiv.kp-wholepageBarra lateral de informações da entidade
Resultados dos anúnciosdiv.uEierdAnúncios de pesquisa pagos em cima e em baixo
O Google muda os nomes das classes frequentemente. Construa seu analisador com seletores de retorno e teste regularmente para manter a extração confiável.

Configurar seu ambiente de raspagem

Para raspar o Google de forma confiável, você precisa de três componentes: um cliente HTTP, uma conexão proxy e um analisador HTML. Abaixo estão exemplos completos em Python, Node.js e Go usando ProxyHat proxies.

Exemplo Python

Instale as dependências primeiro. A ProxyHat Python SDK simplifica a configuração do 'proxy'.

pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup
proxy_url = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}
headers = {
    "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",
    "Accept-Language": "en-US,en;q=0.9",
}
def scrape_google(query, num_results=10):
    params = {
        "q": query,
        "num": num_results,
        "hl": "en",
        "gl": "us",
    }
    response = requests.get(
        "https://www.google.com/search",
        params=params,
        headers=headers,
        proxies=proxies,
        timeout=15,
    )
    response.raise_for_status()
    soup = BeautifulSoup(response.text, "html.parser")
    results = []
    for g in soup.select("div#search .g"):
        title_el = g.select_one("h3")
        link_el = g.select_one("a")
        snippet_el = g.select_one(".VwiC3b")
        if title_el and link_el:
            results.append({
                "title": title_el.get_text(),
                "url": link_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
            })
    return results
results = scrape_google("best residential proxies 2026")
for i, r in enumerate(results, 1):
    print(f"{i}. {r['title']}\n   {r['url']}\n")

Exemplo Node.js

Utilizar Nó do ProxyHat SDK e Cheerio para análise:

npm install axios cheerio https-proxy-agent
const axios = require('axios');
const cheerio = require('cheerio');
const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
async function scrapeGoogle(query) {
  const { data } = await axios.get('https://www.google.com/search', {
    params: { q: query, num: 10, hl: 'en', gl: 'us' },
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Accept-Language': 'en-US,en;q=0.9',
    },
    httpsAgent: agent,
    timeout: 15000,
  });
  const $ = cheerio.load(data);
  const results = [];
  $('div#search .g').each((i, el) => {
    const title = $(el).find('h3').text();
    const url = $(el).find('a').attr('href');
    const snippet = $(el).find('.VwiC3b').text();
    if (title && url) {
      results.push({ position: i + 1, title, url, snippet });
    }
  });
  return results;
}
scrapeGoogle('best residential proxies 2026').then(console.log);

Exemplo de Ir

Utilizar ProxyHat Ir para SDK e goquery:

package main
import (
    "fmt"
    "log"
    "net/http"
    "net/url"
    "github.com/PuerkitoBio/goquery"
)
func main() {
    proxyURL, _ := url.Parse("http://USERNAME:PASSWORD@gate.proxyhat.com:8080")
    client := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    }
    req, _ := http.NewRequest("GET", "https://www.google.com/search?q=best+residential+proxies&num=10&hl=en&gl=us", nil)
    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
    req.Header.Set("Accept-Language", "en-US,en;q=0.9")
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    doc, _ := goquery.NewDocumentFromReader(resp.Body)
    doc.Find("div#search .g").Each(func(i int, s *goquery.Selection) {
        title := s.Find("h3").Text()
        link, _ := s.Find("a").Attr("href")
        fmt.Printf("%d. %s\n   %s\n\n", i+1, title, link)
    })
}

Analisando diferentes recursos SERP

Um raspador completo deve lidar com mais do que apenas resultados orgânicos. Aqui estão os padrões de análise para os recursos SERP mais valiosos.

Excertos em Destaque

# Python: Extract featured snippet
snippet_box = soup.select_one("div.xpdopen")
if snippet_box:
    featured = {
        "type": "featured_snippet",
        "text": snippet_box.get_text(strip=True),
        "source_url": snippet_box.select_one("a")["href"] if snippet_box.select_one("a") else None,
    }

As pessoas também perguntam

# Python: Extract PAA questions
paa_questions = []
for q in soup.select("div.related-question-pair"):
    question_text = q.select_one("span")
    if question_text:
        paa_questions.append(question_text.get_text(strip=True))

Resultados do Pacote Local

# Python: Extract local pack
local_results = []
for item in soup.select("div.VkpGBb"):
    name = item.select_one(".dbg0pd")
    rating = item.select_one(".yi40Hd")
    local_results.append({
        "name": name.get_text() if name else "",
        "rating": rating.get_text() if rating else "",
    })

Manuseando blocos do Google e CAPTCHAs

Google defende ativamente contra raspagem automatizada. Sem infraestrutura proxy adequada, você encontrará blocos dentro de dezenas de pedidos. Os principais mecanismos de defesa incluem:

  • Limitação da taxa: Muitos pedidos de um IP desencadeiam um código de status 429
  • Desafios CAPTCHA: Google serve reCAPTCHA quando suspeita de automação
  • Reputação IP: Intervalos IP do Datacenter recebem mais escrutínio do que IPs residenciais
  • Impressão digital do navegador: Cabeçalhos ausentes ou inconsistentes levantam bandeiras

Para estratégias antidetecção detalhadas, consulte nosso guia sobre raspagem sem bloqueio e como sistemas anti-bots detectam proxies.

Estratégia de Proxy recomendada

Proxies residenciais são essenciais para a remoção sustentada do Google. ProxyHat proxies residenciais fornecer acesso a milhões de IPs 190+ locais, permitindo que você gire IPs automaticamente e geo- direcionar suas solicitações. Dicas de configuração das chaves:

  • Rodar IPs em cada solicitação — nunca reutilize o mesmo IP para consultas consecutivas do Google
  • Adicionar atrasos aleatórios entre 2-5 segundos entre pedidos
  • Coincidir seu Agente de Usuário com uma versão de navegador real
  • Definir hl e gl parâmetros consistentes com a localização do seu proxy

Consultar Documentação do ProxyHat para configuração de autenticação e gerenciamento de sessão.

Construindo um raspador de produção

Mudar de um script para um pipeline de produção requer lógica de repetição, saída estruturada e monitoramento. Aqui está uma versão endurecida do raspador Python:

import requests
import time
import random
import json
from bs4 import BeautifulSoup
from datetime import datetime
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
]
def scrape_serp(query, location="us", retries=3):
    for attempt in range(retries):
        try:
            headers = {
                "User-Agent": random.choice(USER_AGENTS),
                "Accept-Language": "en-US,en;q=0.9",
                "Accept": "text/html,application/xhtml+xml",
            }
            response = requests.get(
                "https://www.google.com/search",
                params={"q": query, "num": 10, "hl": "en", "gl": location},
                proxies={"http": PROXY_URL, "https": PROXY_URL},
                headers=headers,
                timeout=15,
            )
            if response.status_code == 429:
                wait = (attempt + 1) * 10
                print(f"Rate limited. Waiting {wait}s...")
                time.sleep(wait)
                continue
            response.raise_for_status()
            soup = BeautifulSoup(response.text, "html.parser")
            # Check for CAPTCHA
            if "captcha" in response.text.lower() or soup.select_one("#captcha-form"):
                print(f"CAPTCHA detected. Retrying with new IP...")
                time.sleep(random.uniform(5, 10))
                continue
            return parse_serp(soup, query)
        except requests.RequestException as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            time.sleep(random.uniform(2, 5))
    return None
def parse_serp(soup, query):
    results = {
        "query": query,
        "timestamp": datetime.utcnow().isoformat(),
        "organic": [],
        "featured_snippet": None,
        "paa": [],
    }
    # Organic results
    for i, g in enumerate(soup.select("div#search .g")):
        title_el = g.select_one("h3")
        link_el = g.select_one("a")
        snippet_el = g.select_one(".VwiC3b")
        if title_el and link_el:
            results["organic"].append({
                "position": i + 1,
                "title": title_el.get_text(),
                "url": link_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
            })
    # Featured snippet
    snippet_box = soup.select_one("div.xpdopen")
    if snippet_box:
        results["featured_snippet"] = snippet_box.get_text(strip=True)[:500]
    # People Also Ask
    for q in soup.select("div.related-question-pair span"):
        results["paa"].append(q.get_text(strip=True))
    return results
# Usage: scrape a list of keywords
keywords = ["best residential proxies", "proxy for web scraping", "serp tracking tools"]
all_results = []
for kw in keywords:
    result = scrape_serp(kw)
    if result:
        all_results.append(result)
    time.sleep(random.uniform(3, 7))  # Delay between keywords
# Save to JSON
with open("serp_results.json", "w") as f:
    json.dump(all_results, f, indent=2)

Escalar seu raspador SERP

Ao monitorar centenas ou milhares de palavras-chave, a raspagem de fio único é muito lenta. Considere estas abordagens de escala:

  • Pedidos simultâneos: Use assyncio (Python), worker threads (Node.js), ou goroutes (Go) para enviar várias solicitações em paralelo
  • Arquitetura baseada na fila: Empurre palavras-chave para uma fila (Redis, RabbitMQ) e processá-las com vários trabalhadores
  • Gestão de grupos de proxy: O ProxyHat lida automaticamente com a rotação, mas configura a rigidez da sessão com base nas suas necessidades
  • Cache de resultado: Dados de cache SERP para evitar pedidos redundantes para a mesma consulta dentro de uma janela de tempo

Para uma orientação abrangente sobre sistemas de raspagem escaláveis, leia guia completo para web raspando proxies.

Considerações Legal e Ética

Os Termos de Serviço do Google restringem o acesso automatizado. Ao raspar o Google SERPs, siga estas diretrizes:

  • Respeite limites de taxa e evite sobrecarregar servidores do Google
  • Utilizar os dados para fins comerciais legítimos (monitoramento SEO, pesquisa de mercado)
  • Não redistribuir dados SERP brutos comercialmente sem compreender as leis aplicáveis
  • Considere usar APIs oficiais do Google onde atendem às suas necessidades
Verifique sempre as suas leis locais sobre raspagem da web e coleta de dados antes de implantar um raspador SERP em escala.

Pronto para começar?

Acesse mais de 50M de IPs residenciais em mais de 148 países com filtragem por IA.

Ver preçosProxies residenciais
← Voltar ao Blog