Como Raspar People Also Ask e Autocomplete do Google para Pesquisa de Palavras-chave (Guia Python)

Pesquisa de palavras-chave costuma custar caro em ferramentas SaaS — mas o Google oferece três minas de ouro gratuitas que você pode raspar programaticamente: Autocomplete, People Also Ask (PAA) e Related Searches. Este guia mostra como raspar People Also Ask e construir um expansor de palavras-chave em Python que transforma uma seed em centenas de variações longtail, usando proxies residenciais da ProxyHat para evitar bloqueios e garantir sugestões localizadas.

Por que raspar People Also Ask e Autocomplete do Google para pesquisa de palavras-chave

Cada uma das três fontes mapeia para um estágio diferente da intenção de busca:

Fonte	Intenção predominante	Volume típico por seed	Dificuldade de raspagem
Autocomplete (suggestqueries.google.com)	Exploratória / informacional	10 sugestões por consulta, expansível com prefixos a–z	Baixa — endpoint JSON público
People Also Ask	Informacional / investigativa	4 perguntas iniciais, expansível recursivamente	Média — requer renderização JS e cliques em accordions
Related Searches	Transacional / comparativa	8–10 termos por SERP	Média — parsing HTML da SERP

O endpoint de Autocomplete do Google (suggestqueries.google.com/complete/search?client=chrome&q=) retorna JSON puro com sugestões em tempo real. PAA, por sua vez, revela perguntas reais que usuários fazem, exibidas em accordions que se expandem em cascata — cada pergunta aberta gera novas perguntas relacionadas, permitindo expansão recursiva.

Segundo a documentação oficial do Google Search Central, sugestões de busca são geradas com base em tendências reais de consulta. Isso torna esses dados extremamente valiosos para planejamento de conteúdo e FAQ. Para entender o comportamento do algoritmo de sugestão, a página da Wikipedia sobre Google Suggest oferece um bom panorama histórico.

Contexto técnico: por que esses dados existem e por que o Google limita raspagem

O Autocomplete foi lançado em 2004 como recurso de UX para reduzir digitação. O endpoint client=chrome retorna um array JSON simples:

["semente",["semente a","semente b","semente c",...],{...}]

O segundo elemento do array contém as sugestões. O problema é que o Google aplica limites de taxa por IP: tipicamente, após ~100 requisições rápidas no mesmo IP, você recebe erros 429 ou sugestões vazias. Além disso, as sugestões são localizadas por IP — se seu servidor está em Frankfurt, você recebe sugestões alemãs mesmo consultando em português.

É aqui que proxies residenciais com geo-targeting se tornam essenciais. Com a ProxyHat, você pode forçar saída de IPs brasileiros, portugueses ou de qualquer país/cidade, obtendo sugestões autênticas daquele mercado.

Construindo um expansor de palavras-chave seed-to-longtail

A estratégia é simples: para cada seed, combinamos com prefixos a até z e modificadores comuns como "como", "melhor", "preço", "review". Cada combinação gera até 10 sugestões, multiplicando uma seed em centenas de variações.

Exemplo 1: Raspagem básica de Autocomplete com httpx e ProxyHat

import httpx
import json
import time
import logging
from urllib.parse import quote_plus

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)

# ProxyHat HTTP proxy com geo-targeting para Brasil
PROXY_URL = "http://user-country-BR:PASSWORD@gate.proxyhat.com:8080"

def fetch_autocomplete(keyword: str, retries: int = 3) -> list[str]:
    """Raspa sugestões do Autocomplete do Google via endpoint Chrome."""
    url = f"https://suggestqueries.google.com/complete/search?client=chrome&q={quote_plus(keyword)}"
    
    for attempt in range(retries):
        try:
            with httpx.Client(proxy=PROXY_URL, timeout=10.0) as client:
                resp = client.get(url)
                resp.raise_for_status()
                data = json.loads(resp.text)
                suggestions = data[1] if len(data) > 1 else []
                logger.info(f"'{keyword}' -> {len(suggestions)} sugestões")
                return suggestions
        except (httpx.HTTPError, json.JSONDecodeError) as e:
            logger.warning(f"Tentativa {attempt+1} falhou para '{keyword}': {e}")
            time.sleep(2 ** attempt)  # backoff exponencial
    return []

def expand_seed(seed: str) -> list[str]:
    """Expande uma seed com prefixos a-z e modificadores."""
    all_suggestions = set()
    
    # Prefixos alfabéticos
    alpha_prefixes = [seed + " " + chr(c) for c in range(ord("a"), ord("z") + 1)]
    
    # Modificadores comuns em português
    modifiers = [
        f"como {seed}", f"melhor {seed}", f"{seed} preço",
        f"{seed} review", f"{seed} vs", f"{seed} o que é",
        f"{seed} funciona", f"{seed} 2025", f"{seed} dicas",
    ]
    
    queries = [seed] + alpha_prefixes + modifiers
    
    for q in queries:
        suggestions = fetch_autocomplete(q)
        all_suggestions.update(suggestions)
        time.sleep(0.5)  # throttle educado
    
    return sorted(all_suggestions)

# Uso
if __name__ == "__main__":
    resultados = expand_seed("hosting")
    print(f"Total de sugestões: {len(resultados)}")
    for r in resultados[:20]:
        print(f"  - {r}")

Uma única seed como "hosting" com 26 prefixos alfabéticos + 9 modificadores = 36 consultas, gerando até 360 sugestões únicas. Com 10 seeds, você chega a milhares de variações longtail.

Por que chamadas rápidas disparam limites de taxa e viés de localidade

O Google monitora padrões de requisição por IP. Uma rajada de 200 consultas de Autocomplete em 10 segundos a partir de um IP de datacenter é trivialmente detectável. Os sintomas incluem:

• HTTP 429 — rate limit explícito.
• Array de sugestões vazio — o Google retorna ["query",[],{}] sem erro, silenciosamente.
• Captcha interstitial — redirecionamento para google.com/sorry.
• Sugestões não localizadas — resultados genéricos em vez de locais.

Proxies residenciais resolvem ambos os problemas: IPs de ISPs reais não são sinalizados como datacenter, e o geo-targeting garante sugestões do mercado-alvo. Veja as localizações disponíveis da ProxyHat para cobrir mais de 190 países.

Exemplo 2: Raspagem concorrente com async httpx e rotação de proxies

import asyncio
import httpx
import json
from urllib.parse import quote_plus
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

BASE_PROXY = "http://user-country-BR-session-{sid}:PASSWORD@gate.proxyhat.com:8080"
AUTOCOMPLETE_URL = "https://suggestqueries.google.com/complete/search?client=chrome&q={q}"

async def fetch_one(client: httpx.AsyncClient, keyword: str) -> list[str]:
    url = AUTOCOMPLETE_URL.format(q=quote_plus(keyword))
    try:
        resp = await client.get(url, timeout=10.0)
        resp.raise_for_status()
        data = json.loads(resp.text)
        return data[1] if len(data) > 1 else []
    except Exception as e:
        logger.warning(f"Erro em '{keyword}': {e}")
        return []

async def batch_autocomplete(keywords: list[str], concurrency: int = 20) -> dict[str, list[str]]:
    """Raspa múltiplas seeds concorrentemente com sessões rotativas."""
    semaphore = asyncio.Semaphore(concurrency)
    results: dict[str, list[str]] = {}
    
    async def worker(kw: str, session_id: str):
        async with semaphore:
            proxy_url = BASE_PROXY.format(sid=session_id)
            async with httpx.AsyncClient(proxy=proxy_url) as client:
                suggestions = await fetch_one(client, kw)
                results[kw] = suggestions
    
    tasks = []
    for i, kw in enumerate(keywords):
        # Cada keyword usa uma sessão diferente para rotacionar IP
        sid = f"kw{i:04d}"
        tasks.append(worker(kw, sid))
    
    await asyncio.gather(*tasks)
    return results

# Uso
if __name__ == "__main__":
    seeds = ["hosting", "vpn", "proxy", "cloud server", "dominio"]
    expanded = []
    for s in seeds:
        for c in range(ord("a"), ord("z") + 1):
            expanded.append(f"{s} {chr(c)}")
    
    print(f"Total de queries: {len(expanded)}")
    resultados = asyncio.run(batch_autocomplete(expanded, concurrency=20))
    total = sum(len(v) for v in resultados.values())
    print(f"Total de sugestões coletadas: {total}")

Com 20 conexões concorrentes e rotação de sessão por keyword, você pode coletar ~1.300 sugestões em menos de 60 segundos, mantendo uma taxa de sucesso acima de 95% com IPs residenciais.

Raspando People Also Ask com Playwright

PAA é mais complexo porque os accordions precisam ser clicados para revelar perguntas aninhadas. O Playwright resolve isso automatizando o navegador real. Veja mais sobre rastreamento de SERP na ProxyHat.

Exemplo 3: Extraindo perguntas PAA recursivamente com Playwright

from playwright.async_api import async_playwright
import asyncio
import json
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# ProxyHat SOCKS5 para Playwright
PROXY_CONFIG = {
    "server": "socks5://gate.proxyhat.com:1080",
    "username": "user-country-BR",
    "password": "PASSWORD",
}

async def scrape_paa(keyword: str, max_depth: int = 3) -> dict:
    """Raspa perguntas PAA e suas fontes citadas recursivamente."""
    async with async_playwright() as p:
        browser = await p.chromium.launch(proxy=PROXY_CONFIG, headless=True)
        page = await browser.new_page()
        
        url = f"https://www.google.com/search?q={keyword}&hl=pt-BR&gl=br"
        await page.goto(url, wait_until="domcontentloaded", timeout=30000)
        await page.wait_for_timeout(2000)  # aguardar renderização
        
        paa_questions = []
        seen = set()
        
        async def extract_paa_block(depth: int):
            if depth > max_depth:
                return
            
            # Selecionar elementos PAA
            paa_elements = await page.query_selector_all("div[role='heading'] + div >> text=/./")
            # Alternativa: buscar por texto "Perguntas relacionadas"
            paa_section = await page.query_selector("div.related-question-pair, div[jsname='Cpkphb']")
            
            if not paa_section:
                logger.info(f"Nenhum bloco PAA encontrado para '{keyword}'")
                return
            
            # Extrair perguntas visíveis
            questions = await page.eval_on_selector_all(
                "div[jsname='Cpkphb'] .related-question-pair, div.iDjcJe",
                "els => els.map(e => e.textContent.trim())"
            )
            
            for q_text in questions:
                if q_text and q_text not in seen:
                    seen.add(q_text)
                    paa_questions.append({
                        "question": q_text,
                        "depth": depth,
                        "source": keyword,
                    })
                    logger.info(f"PAA d{depth}: {q_text[:80]}")
            
            # Clicar no primeiro accordion para expandir mais perguntas
            try:
                first_paa = await page.query_selector("div[jsname='Cpkphb']")
                if first_paa:
                    await first_paa.click()
                    await page.wait_for_timeout(1500)
                    await extract_paa_block(depth + 1)
            except Exception as e:
                logger.warning(f"Erro ao expandir accordion: {e}")
        
        await extract_paa_block(0)
        
        # Extrair Related Searches
        related = await page.eval_on_selector_all(
            "div[data-async-context='related-searches'] a, .BNeawe.s3v9rd.Q7Bff",
            "els => els.map(e => e.textContent.trim())"
        )
        
        await browser.close()
        
        return {
            "keyword": keyword,
            "paa_questions": paa_questions,
            "related_searches": related,
        }

# Uso
if __name__ == "__main__":
    resultado = asyncio.run(scrape_paa("melhor hosting brasileiro", max_depth=4))
    print(json.dumps(resultado, indent=2, ensure_ascii=False))

Cada nível de profundidade do PAA revela aproximadamente 3–4 novas perguntas. Com profundidade 4, você pode extrair 12–16 perguntas por seed, cada uma sendo uma oportunidade de conteúdo ou FAQ.

Exemplo 4: Pipeline completo combinando Autocomplete + PAA

import httpx
import asyncio
import json
import csv
import re
from urllib.parse import quote_plus
from collections import defaultdict
from playwright.async_api import async_playwright
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

PROXY_HTTP = "http://user-country-BR:PASSWORD@gate.proxyhat.com:8080"
PROXY_SOCKS = {
    "server": "socks5://gate.proxyhat.com:1080",
    "username": "user-country-BR",
    "password": "PASSWORD",
}

class KeywordResearchScraper:
    def __init__(self, country: str = "BR"):
        self.country = country
        self.autocomplete_results = set()
        self.paa_results = []
        self.related_results = set()
    
    async def fetch_autocomplete(self, keyword: str) -> list[str]:
        url = f"https://suggestqueries.google.com/complete/search?client=chrome&q={quote_plus(keyword)}"
        proxy = f"http://user-country-{self.country}:PASSWORD@gate.proxyhat.com:8080"
        async with httpx.AsyncClient(proxy=proxy, timeout=10.0) as client:
            try:
                resp = await client.get(url)
                resp.raise_for_status()
                data = json.loads(resp.text)
                return data[1] if len(data) > 1 else []
            except Exception as e:
                logger.warning(f"Autocomplete erro '{keyword}': {e}")
                return []
    
    async def expand_keyword(self, seed: str) -> set[str]:
        queries = {seed}
        for c in range(ord("a"), ord("z") + 1):
            queries.add(f"{seed} {chr(c)}")
        modifiers = ["como", "melhor", "preço", "review", "vs", "o que é", "funciona", "2025"]
        for m in modifiers:
            queries.add(f"{m} {seed}")
        
        tasks = [self.fetch_autocomplete(q) for q in queries]
        results = await asyncio.gather(*tasks)
        
        for suggestions in results:
            self.autocomplete_results.update(suggestions)
        
        return self.autocomplete_results
    
    async def scrape_paa_batch(self, keywords: list[str]):
        async with async_playwright() as p:
            browser = await p.chromium.launch(proxy=PROXY_SOCKS, headless=True)
            
            for kw in keywords[:10]:  # limitar para evitar rate limits
                page = await browser.new_page()
                url = f"https://www.google.com/search?q={quote_plus(kw)}&hl=pt-BR&gl=br"
                try:
                    await page.goto(url, wait_until="domcontentloaded", timeout=30000)
                    await page.wait_for_timeout(2000)
                    
                    # Extrair PAA
                    questions = await page.eval_on_selector_all(
                        "div[jsname='Cpkphb'] .related-question-pair, div.iDjcJe",
                        "els => els.map(e => e.textContent.trim())"
                    )
                    for q in questions:
                        if q and len(q) > 10:
                            self.paa_results.append({"keyword": kw, "question": q})
                    
                    # Extrair Related Searches
                    related = await page.eval_on_selector_all(
                        ".BNeawe.s3v9rd.Q7Bff, div[data-async-context='related-searches'] a",
                        "els => els.map(e => e.textContent.trim())"
                    )
                    self.related_results.update(related)
                    
                    logger.info(f"PAA para '{kw}': {len(questions)} perguntas")
                except Exception as e:
                    logger.warning(f"Erro PAA '{kw}': {e}")
                finally:
                    await page.close()
                    await asyncio.sleep(2)  # throttle
            
            await browser.close()
    
    def cluster_by_intent(self) -> dict[str, list[str]]:
        """Agrupa sugestões por intenção detectada."""
        clusters = defaultdict(list)
        intent_patterns = {
            "informacional": [r"^como", r"^o que é", r"^por que", r"^qual", r"^quando"],
            "transacional": [r"preço", r"comprar", r"melhor", r"barato", r"desconto"],
            "comparativo": [r"vs", r"ou", r"alternativa", r"compar"],
            "navegacional": [r"site:", r"login", r"cadastro"],
        }
        
        all_keywords = list(self.autocomplete_results | self.related_results)
        for kw in all_keywords:
            matched = False
            for intent, patterns in intent_patterns.items():
                for pat in patterns:
                    if re.search(pat, kw, re.IGNORECASE):
                        clusters[intent].append(kw)
                        matched = True
                        break
                if matched:
                    break
            if not matched:
                clusters["outros"].append(kw)
        
        return dict(clusters)
    
    def export_csv(self, filename: str = "keyword_research.csv"):
        """Exporta todos os dados para CSV para planejamento de conteúdo."""
        clusters = self.cluster_by_intent()
        
        with open(filename, "w", newline="", encoding="utf-8") as f:
            writer = csv.writer(f)
            writer.writerow(["keyword", "source", "intent", "length"])
            
            for kw in self.autocomplete_results:
                intent = "autocomplete"
                length = len(kw.split())
                writer.writerow([kw, "autocomplete", intent, length])
            
            for item in self.paa_results:
                writer.writerow([item["question"], "paa", "question", len(item["question"].split())])
            
            for kw in self.related_results:
                writer.writerow([kw, "related", "related", len(kw.split())])
        
        logger.info(f"Exportado {filename} com sucesso")

# Uso completo
async def main():
    scraper = KeywordResearchScraper(country="BR")
    
    # 1. Expandir via Autocomplete
    await scraper.expand_keyword("hosting")
    logger.info(f"Autocomplete: {len(scraper.autocomplete_results)} sugestões")
    
    # 2. Raspar PAA das top sugestões
    top_keywords = sorted(scraper.autocomplete_results)[:10]
    await scraper.scrape_paa_batch(top_keywords)
    logger.info(f"PAA: {len(scraper.paa_results)} perguntas")
    logger.info(f"Related: {len(scraper.related_results)} termos")
    
    # 3. Clusterizar e exportar
    clusters = scraper.cluster_by_intent()
    for intent, kws in clusters.items():
        logger.info(f"Cluster '{intent}': {len(kws)} keywords")
    
    scraper.export_csv()

if __name__ == "__main__":
    asyncio.run(main())

Deduplicação, clusterização por intenção e exportação

Após coletar sugestões de múltiplas seeds, você terá duplicatas significativas. A estratégia de deduplicação deve considerar:

• Normalização: lowercase, remoção de acentos e espaços extras.
• Dedup por similaridade: agrupar variações como "melhor hosting" e "melhor hosting 2025" como relacionadas.
• Clusterização por intenção: classificar cada keyword como informacional, transacional, comparativa ou navegacional usando padrões regex.
• Filtragem por comprimento: keywords longtail (4+ palavras) tendem a ter menor concorrência e maior conversão.

O código acima já implementa clusterização básica e exportação CSV. O arquivo resultante pode ser importado diretamente em ferramentas de planejamento de conteúdo ou planilhas.

Exemplo 5: Deduplicação avançada com normalização

import unicodedata
import re
from collections import defaultdict

def normalize_keyword(kw: str) -> str:
    """Normaliza keyword para deduplicação: lowercase, sem acentos, sem espaços extras."""
    kw = kw.lower().strip()
    kw = unicodedata.normalize("NFKD", kw)
    kw = "".join(c for c in kw if not unicodedata.combining(c))
    kw = re.sub(r"\s+", " ", kw)
    return kw

def deduplicate_keywords(keywords: list[str]) -> list[str]:
    """Remove duplicatas normalizadas mantendo a versão original mais legível."""
    seen: dict[str, str] = {}
    for kw in keywords:
        norm = normalize_keyword(kw)
        if norm not in seen or len(kw) > len(seen[norm]):
            seen[norm] = kw
    return sorted(seen.values())

def filter_longtail(keywords: list[str], min_words: int = 4) -> list[str]:
    """Filtra apenas keywords longtail com pelo menos N palavras."""
    return [kw for kw in keywords if len(kw.split()) >= min_words]

# Uso
if __name__ == "__main__":
    raw = [
        "Melhor Hosting", "melhor hosting", "melhor hosting 2025",
        "como funciona hosting", "hosting barato", "Hosting Barato",
        "melhor hosting brasileiro", "hosting vs vps",
    ]
    deduped = deduplicate_keywords(raw)
    longtail = filter_longtail(deduped, min_words=3)
    print(f"Antes: {len(raw)} -> Depois dedup: {len(deduped)} -> Longtail: {len(longtail)}")
    for kw in longtail:
        print(f"  {kw}")

Erros comuns e casos de borda

• Sugestões vazias sem erro: o Google retorna 200 OK com array vazio quando detecta automação. Solução: monitorar tamanho do array e rotacionar IP se vazio.
• Viés de localidade: sugestões em alemão mesmo consultando em português porque o IP de saída está na Alemanha. Solução: usar user-country-PT ou user-country-BR na ProxyHat.
• PAA não aparece: nem toda SERP tem bloco PAA. Verificar existência antes de tentar expandir.
• Timeout do Playwright: páginas pesadas com muitos anúncios podem demorar >30s. Usar wait_until="domcontentloaded" em vez de networkidle.
• Encoding de caracteres: o Autocomplete retorna UTF-8, mas alguns caracteres podem vir escapados. Sempre usar json.loads() em vez de regex parsing.

Configuração específica da ProxyHat

Para configurar seus proxies da ProxyHat para raspagem de Autocomplete e PAA:

1. Crie sua conta em proxyhat.com/pricing.
2. Obtenha suas credenciais de usuário e senha no dashboard.
3. Use gate.proxyhat.com:8080 para HTTP ou gate.proxyhat.com:1080 para SOCKS5.
4. Para geo-targeting, adicione flags no username: user-country-BR, user-country-DE-city-berlin.
5. Para sessões sticky (IP fixo por sessão): user-session-abc123.

Consulte a documentação oficial da ProxyHat para detalhes completos de configuração. Para casos de uso de web scraping em geral, veja nosso guia de web scraping.

Ética e considerações legais

Os dados de sugestão do Google são públicos — qualquer usuário vê as mesmas sugestões ao digitar na barra de pesquisa. No entanto, raspagem em escala deve seguir boas práticas:

• Throttle educado: mantenha 0.3–1 segundo entre requisições por IP.
• Respeite robots.txt: verifique https://www.google.com/robots.txt antes de raspagem em escala.
• Preferir APIs oficiais: o Google oferece a Custom Search JSON API para busca programática. Para volume de keywords moderado, considere a Google Keyword Planner (requere conta Google Ads).
• GDPR/CCPA: sugestões de autocomplete não contêm dados pessoais identificáveis, mas evite combinar dados de forma que possa identificar indivíduos.
• Termos de serviço: leia os ToS do Google. Raspagem automatizada pode violar termos; use por sua conta e risco.

Principais conclusões

As três minas de ouro gratuitas do Google — Autocomplete, PAA e Related Searches — fornecem dados de intenção de busca que ferramentas SaaS cobram centenas de reais por mês. Com Python, httpx e Playwright, você pode construir um pipeline completo de pesquisa de palavras-chave em um dia.

• Autocomplete via suggestqueries.google.com é a fonte mais fácil: JSON puro, ~10 sugestões por consulta, expansível com prefixos a–z para centenas de variações.
• PAA requer Playwright para clicar em accordions, mas revela perguntas reais dos usuários — ideal para planejamento de FAQ e conteúdo.
• Proxies residenciais com geo-targeting são obrigatórios para evitar rate limits e garantir sugestões localizadas autênticas.
• Deduplicação e clusterização por intenção transformam dados brutos em insights acionáveis para SEO e conteúdo.
• Throttle educado (0.3–1s entre requisições) e respeito a robots.txt são essenciais para raspagem sustentável.
• Para escala muito alta, considere APIs oficiais do Google para reduzir risco de bloqueios.

FAQ

O que é raspar People Also Ask e Autocomplete do Google para pesquisa de palavras-chave?

É a prática de coletar programaticamente as sugestões que o Google exibe no Autocomplete (barra de pesquisa), as perguntas do bloco People Also Ask (SERP) e os termos de Related Searches. Esses dados refletem intenção de busca real dos usuários e são gratuitos, tornando-se uma alternativa ou complemento a ferramentas SaaS pagas de keyword research. Com Python, httpx e Playwright, você pode automatizar essa coleta em escala usando proxies residenciais para evitar bloqueios.

Por que raspar People Also Ask e Autocomplete importa para usuários de proxy?

O Google aplica limites de taxa por IP e localiza sugestões com base no IP de saída. Sem proxies, raspagem em escala recebe erros 429, sugestões vazias ou captchas. Proxies residenciais com geo-targeting (ex.: country-BR, city-sao-paulo) permitem coletar sugestões autênticas do mercado-alvo sem ser sinalizado como datacenter. Isso é crítico porque sugestões localizadas diferem significativamente entre países — "melhor hosting" no Brasil retorna sugestões diferentes das do Portugal.

Qual tipo de proxy funciona melhor para raspar People Also Ask e Autocomplete?

Proxies residenciais são os mais adequados porque usam IPs de ISPs reais, não sinalizados como datacenter pelo Google. Para Autocomplete (endpoint JSON leve), HTTP proxies com rotação por sessão funcionam bem. Para PAA (que requer renderização JavaScript via Playwright), SOCKS5 proxies oferecem melhor compatibilidade com navegadores headless. A ProxyHat suporta ambos os protocolos em gate.proxyhat.com:8080 (HTTP) e :1080 (SOCKS5) com geo-targeting por país e cidade.

Como evitar bloqueios ao raspar People Also Ask e Autocomplete?

Use quatro estratégias combinadas: (1) proxies residenciais com rotação de IP por sessão para distribuir requisições; (2) throttle educado de 0.3–1 segundo entre requisições por IP; (3) backoff exponencial ao receber erros 429 ou sugestões vazias; (4) geo-targeting correto (country/city) para evitar viés de localidade. Para PAA com Playwright, use headless mode com user-agent real e aguarde 2 segundos após carregamento da página antes de interagir com accordions.

É legal raspar sugestões de autocomplete e PAA do Google?

As sugestões são dados públicos visíveis a qualquer usuário. No entanto, raspagem automatizada pode violar os Termos de Serviço do Google. A prática existe numa área cinzenta: os dados são públicos, mas o método de coleta em escala pode ser contestado. Recomenda-se throttle educado, respeito a robots.txt e preferência por APIs oficiais (Custom Search API, Keyword Planner) em escala comercial. Consulte sempre um advogado para seu caso específico.