Como Raspagem de Resultados do Google com o Navegador Scrapeless: Resultados Orgânicos, PAA, Painéis de Conhecimento e Visão Geral de IA

Principais Conclusões:

• Uma CLI, todas as superfícies do Google. O fluxo de trabalho scrapeless-scraping-browser extrai resultados orgânicos do Google, Trechos Destacados, Perguntas Relacionadas, Painéis de Conhecimento, Pesquisas Relacionadas e Visão Geral de IA — tudo a partir do mesmo padrão de sessão. Verificado de ponta a ponta no Ubuntu, 2026-04-24 (138 contêineres orgânicos por página na consulta scrapeless).
• Estratégia de espera do Google. wait --load networkidle retorna em ~14 s porque os rastreadores do Google nunca se estabilizam; use um wait 5000 fixo em vez disso, e verifique a prontidão contando contêineres div[data-ved][data-hveid] (≥ 8 significa que o SERP foi renderizado).
• Descobrir → extrair com seletores de união. O Google roda o contêiner do trecho entre variantes A/B (div.VwiC3b, div[data-content-feature="1"], .lEBKkf, span.st). Consulte cada campo independentemente e junte por cartão — uma regra estrita de "deve ter h3 E âncora E trecho" perde 4/10 resultados para anúncios e cartões de vídeo.
• Trecho Destacado movido para fora de .kno-rdesc. Em consultas de altura/medida, o Google agora renderiza a resposta como um fragmento de Painel de Conhecimento por atributo (span.T286Pc). O padrão resiliente é uma cascata de seletores seguida por um fallback de regex de texto do corpo — mostrado no Passo 4.

Introdução: raspagem do Google Search

O Google Search é a superfície que suporta a carga para rastreamento de classificação SEO, inteligência competitiva, SOV de marca, pipelines de fundamentação de IA e conjuntos de dados de avaliação LLM. Raspá-lo de forma confiável em 2026 significa lidar com quatro partes móveis: roteamento de IP residencial além do limite de taxa /sorry/index, uma estratégia de espera fixa porque os rastreadores nunca vão totalmente inativos, seletores de união contra nomes de classe A/B rotativos, e um padrão de extração recurso por recurso (orgânico, Trecho Destacado, Perguntas Relacionadas, Painel de Conhecimento, Pesquisas Relacionadas, Visão Geral de IA).

O CAPTCHA /sorry/index do Google dispara em taxas variáveis — em qualquer lugar de ~1 em 10 em um dia calmo até quase cada solicitação de saída dos EUA durante grande carga — dependendo do pool de proxies, hora do dia e geo-alvo. Proxies DE/GB/JP/FR/CA geralmente têm uma taxa de aprovação mais alta do que os EUA especificamente para o Google (veja o Passo 1). O Scrapeless Scraping Browser lida com proxies residenciais, impressão digital anti-detecção e renderização JavaScript como preocupações em nível de sessão, de modo que o código do pipeline se concentra em seletores e esperas.

Este post é um guia centrado em CLI e fundamentado em verificação pelo navegador em nuvem scrapeless-scraping-browser. Cada seletor, limite de espera e padrão de falha abaixo é respaldado por uma execução de verificação no Ubuntu em 2026-04-24 — afirmações específicas do Google para extração orgânica, paginação, localização, supressão de SERP clássica, pesquisa da Visão Geral de IA, Painel de Conhecimento, PAA e Pesquisas Relacionadas.

O Que Você Pode Fazer Com Isso

• Rastreamento de classificação SERP no Google. Rastreie posições para um conjunto de palavras-chave, construa uma pontuação de visibilidade por domínio e fixe os melhores resultados por consulta por timestamp.
• Inteligência competitiva de palavras-chave. Extraia os 10 principais para as consultas-alvo de um concorrente, compare listas de host e identifique ganhos de SERP que seu próprio SEO não está capturando.
• Fundamentação de respostas de IA. Colete as citações da Visão Geral de IA do Google, atribuição de Trechos Destacados e pares de Perguntas Relacionadas para construir o conjunto exato de evidências que ferramentas de busca impulsionadas por LLM apresentam aos usuários finais.
• Extração de Painel de Conhecimento. Extraia folhas de fato de entidades via mapa de atributos data-attrid do Google — 20+ campos estruturados por entidade para a consulta de verificação de Albert Einstein — adequado para alimentar um grafo de conhecimento ou pipeline de enriquecimento de entidades.
• Monitoramento multilocal. Consulte a mesma palavra-chave de hl=de&gl=de, hl=en&gl=us e hl=ja&gl=jp através de proxies residenciais correspondentes a geo para capturar diferenças de SERP mercado a mercado.
• Conjuntos de dados de avaliação LLM. Construa conjuntos de dados de verdade determinística para avaliar sistemas de geração aumentada por recuperação ao fixar os melhores N por consulta por timestamp.

Por Que Escolher o Scrapeless Scraping Browser

O Scrapeless Scraping Browser é um navegador em nuvem personalizável, anti-detectação, projetado para rastejadores da web e Agentes de IA. Para a pesquisa do Google especificamente, ele oferece:

• Proxies residenciais em 195+ países (--proxy-country, --proxy-state, --proxy-city) — intervalos de IP de data center são filtrados agressivamente pela borda do Google; a saída residencial é o primitivo de suporte para raspagem sustentada.
• Solução CAPTCHA integrada.
• Impressão digital anti-detectação em cada sessão — as verificações do lado do cliente do SearchGuard do Google tratam o navegador como um Chrome real.
• Renderização JavaScript na nuvem — o SERP do Google é hidratado; HTML estático não é suficiente.
• Alinhamento de local por sessão via --timezone e --languages — automático com a geografia do proxy.
  Obtenha sua chave de API no plano gratuito em scrapeless.com. Produtos relacionados da Scrapeless: API Universal de Scraping, Soluções de Proxy e o Servidor MCP Scrapeless para integrações do Protocolo de Contexto do Modelo.

Se uma API de JSON estruturado se encaixa melhor em seu pipeline do que um navegador, consulte o guia Google Search Scraper API.

Pré-requisitos

• Node.js 18 ou mais recente.
• Uma conta Scrapeless e chave de API — inscreva-se em scrapeless.com.
• jq para análise de JSON (recomendado).
• Familiaridade básica com o terminal.

Instalação

As receitas abaixo funcionam no CLI scrapeless-scraping-browser. A configuração é feita em três etapas — tanto os usuários do CLI quanto os usuários do AI-agent precisam da #1 e da #2; usuários do AI-agent também fazem a #3.

1. Instale o pacote CLI

npm install -g scrapeless-scraping-browser

Isso fornece o binário scrapeless-scraping-browser que cada etapa deste post chama. A habilidade não traz seu próprio ambiente de execução — ela carrega padrões de comando em seu agente de IA, mas o CLI deve ser instalado primeiro.

2. Configure sua chave de API

Obtenha seu token em scrapeless.com, depois armazene-o onde o CLI possa lê-lo:

scrapeless-scraping-browser config set apiKey seu_token_api_aqui
scrapeless-scraping-browser config get apiKey   # verifique

Usando um agente de IA? As instruções da habilidade informam explicitamente ao seu agente que a autenticação é necessária antes de qualquer chamada de sessão. Se a chave de API não estiver configurada quando o agente tentar usar o CLI pela primeira vez, o agente solicitará que você a configure e executará o comando config set apiKey … para você — você pode configurá-la manualmente agora (comandos acima) ou colar seu token quando o agente perguntar.

O arquivo de configuração está em ~/.scrapeless/config.json, com acesso restrito ao usuário atual, tem prioridade sobre a variável de ambiente e é portátil entre agentes e executores de CI. Para pipelines de CI, prefira:

export SCRAPELESS_API_KEY=seu_token_api_aqui

3. Instale a habilidade Scrapeless em seu agente de IA

Este é um passo separado do passo 1 acima. O passo 1 instalou o binário do CLI — o ambiente de execução que seu agente invoca. A habilidade é o que ensina seu agente como invocá-lo corretamente (seletor, esperas, padrões de repetição, fluxo de descoberta→extração). São duas coisas diferentes, e você precisa de ambas.

A habilidade é uma pasta contendo SKILL.md + skill.json + references/. A fonte canônica é o repositório scrapeless-ai/scrapeless-agent-browser → skills/scraping-browser-skill no GitHub.

Para instalá-la no Claude Code, Cursor, VS Code + GitHub Copilot, CLI OpenAI Codex ou CLI Gemini, siga o guia de instalação da Scrapeless AI Agent — ele contém os comandos copiar e colar por agente (bash e Windows PowerShell). Recarregue seu agente após a instalação para que a habilidade se torne ativa.

Sem a habilidade instalada, seu agente não conhece o padrão de descoberta→extração, as esperas por motor específicas ou os seletores que realmente funcionam em 2026, e você teria que fornecer cada detalhe em cada prompt.

O que a habilidade carrega no contexto operacional do seu agente desde o início:

• Autenticação — verifica ~/.scrapeless/config.json ou SCRAPELESS_API_KEY e solicita que você defina se estiver faltando (veja o passo 2).
• Fluxo de Descoberta → Extração — o padrão de antifragilidade. O agente lê o DOM ao vivo com get html "<região>" primeiro, identifica âncoras estáveis (data-ved, data-attrid, aria-label, role, ids semânticos), e depois escreve seletores eval com base no que realmente está renderizado — em vez de adivinhar nomes de classes utilitárias que o Google rota entre variantes A/B a cada poucas semanas.
• Sintaxe de seletor — CSS (div[data-ved][data-hveid]) vs referências de acessibilidade (@e1 de snapshot -i).
• Estratégia de espera do Google — wait 5000 mais uma verificação de contagem div[data-ved][data-hveid] como sinal de prontidão. O agente escolhe essa configuração padrão em vez de confiar em wait --load networkidle, que nunca se estabiliza no Google.
• Trabalhadores CLI paralelos — encadeamento de && em um único shell, nomes de sessão exclusivos, ≤3 trabalhadores simultâneos por host. Apenas --session-id não é suficiente sob contenção de daemon.
• Armadilhas comuns — eval retorna valores com aspas JSON, open sai com código diferente de zero em navegação bem-sucedida, wait --load networkidle tem corrida em sessões frias, sessões terminam quando a conexão é fechada.
• Referência completa de comandos — cada flag para new-session, open, wait, eval, get, click, fill, snapshot, auth, profile, recording, stop, etc.

4. Verifique se a habilidade está configurada

Antes de seu primeiro scraping real do Google, teste a instalação com um prompt seguro:

"Usando a habilidade Scrapeless, abra https://example.com e me diga o título da página."

Seu agente deve criar uma sessão, abrir a página e responder com "Exemplo de Domínio". Se isso funcionar, você está pronto para raspar o Google.

Se falhar:

Como você realmente usa isso: converse com seu agente

Após a instalação, você raspa o Google conversando com seu agente — não copiando e colando bash. A habilidade carrega seletores de união, a estratégia de espera ajustada para o Google e o padrão de descobrir→extrair no contexto do agente, então um prompt de uma linha é suficiente para obter o JSON limpo do SERP de volta.

Prompts que você pode colar

Exemplo prático: raspe o Google por "airpods" em 3 páginas

Você digita:

"Raspe o Google por 'airpods' nas páginas 1–3, deduplicado por URL, salve como airpods-serp.json. Apenas resultados orgânicos — título, url, snippet."

O plano do agente (em inglês simples):

1. Crie três sessões de saída dos EUA, uma por página (estado limpo por página é melhor do que reutilizar uma sessão que se desvia).
2. Abra https://www.google.com/search?q=airpods&hl=en&gl=us&start={0,10,20}, depois wait 5000 (rastreadores do Google nunca ficam totalmente ociosos, então uma espera fixa é melhor que networkidle).
3. Confirme que a contagem de div[data-ved][data-hveid] ≥ 8 — o sinal carregado de que o SERP foi realmente renderizado.
4. eval o extrator de seletor de união (div.VwiC3b, div[data-content-feature="1"], .lEBKkf, span.st, .MUxGbd) — o Google rotaciona esses entre variantes A/B, consultar todos eles sobrevive à rotação.
5. Filtrar para título && url && snippet, deduplicar por URL, escrever o arquivo.

O que você recebe de volta (airpods-serp.json, abreviado):

[
  { "page": 1, "title": "AirPods", "url": "https://www.apple.com/airpods/",
    "snippet": "Os AirPods oferecem uma experiência incomparável de fones de ouvido sem fio..." },
  { "page": 1, "title": "Apple AirPods Fones de Ouvido Sem Fio, Fones Bluetooth ...",
    "url": "https://www.amazon.com/Apple-AirPods-Charging-Latest-Model/dp/B07PXGQC1Q",
    "snippet": "Os novos AirPods combinam design inteligente com tecnologia inovadora..." },
  { "page": 1, "title": "AirPods", "url": "https://en.wikipedia.org/wiki/AirPods",

"snippet": "AirPods são fones de ouvido Bluetooth sem fio projetados pela Apple..." },
{ "page": 2, "title": "Melhores AirPods para 2026: Testados e Avaliados por Especialistas",
"url": "https://www.cnet.com/tech/mobile/best-apple-airpods/",
"snippet": "Prós - Design leve, mais compacto e ajuste confortável..." },
{ "page": 3, "title": "O Que Esperar dos Próximos AirPods Pro, Lançamento em ...",
"url": "https://www.macrumors.com/2026/04/22/airpods-pro-cameras-2026/",
"snippet": "As câmeras infravermelhas podem reconhecer gestos das mãos..." }
O Google retorna 10 resultados orgânicos por SERP. O seletor ingênuo — "o container deve ter h3 E âncora E snippet" — produz apenas 6, pois 4 dos 10 são cartões não snippet (pré-visualizações de vídeo, anúncios de compras, blocos do Twitter). O padrão resiliente é consultar cada campo independentemente e combinar por container.

scrapeless-scraping-browser --session-id $SESSION eval '
(function(){
  const out = [];
  document.querySelectorAll("div[data-ved][data-hveid]").forEach((r, i) => {
    const h3 = r.querySelector("h3");
    const a  = r.querySelector("a[href^=\"http\"]");
    const sn = r.querySelector(
      "div.VwiC3b, div[data-content-feature=\"1\"], .lEBKkf, span.st, .MUxGbd"
    );
    const cite = r.querySelector("cite");

    // Ignorar containers que NÃO têm título e NENHUMA âncora (caixas decorativas)
    if (!h3 && !a) return;

    out.push({
      position:     i + 1,
      title:        h3?.textContent?.trim() || null,
      url:          a?.href || null,
      displayedUrl: cite?.textContent?.trim() || null,
      snippet:      sn?.textContent?.trim()?.slice(0, 300) || null,
    });
  });
  return JSON.stringify(out);
})()
' > google-organic.json

jq '. | length' google-organic.json                              # passagem bruta — espera-se muitos
jq 'map(select(.title and .url)) | length' google-organic.json   # subconjunto orgânico + recurso
jq 'map(select(.title and .url and .snippet))' google-organic.json  # apenas o orgânico canônico

Observações honestas da execução de verificação (consulta scrapeless, 2026-04-24 Ubuntu):

• A passagem bruta gerou 80 containers sob a combinação data-ved][data-hveid após o filtro "tem título ou url". O Google retorna muitos cartões/containers de recursos que compartilham este par de atributos.
• Aplicar title != null && url != null reduz para 16 itens — o conjunto de trabalho útil que inclui resultados orgânicos + entradas PAA + links do Painel de Conhecimento.
• Aplicar title && url && snippet reduz ainda mais para ~10 — o subconjunto orgânico canônico. Esta é a lista rígida de 10 por SERP.
• Escolha o filtro apropriado para seu caso de uso: os rastreadores de classificação geralmente querem os 10 canônicos; os pipelines de mineração de contexto geralmente querem o conjunto de trabalho de 16 itens.
• A contagem de cite foi 14 na mesma página — espere que cite corresponda ou exceda a contagem orgânica canônica, uma vez que alguns recursos (entradas PAA, anúncios) também renderizam um cite.

Passo 4 — Extrair recursos SERP (Snippet em Destaque, PAA, Painel de Conhecimento, Relacionados)

O Google sobrepõe vários tipos de recursos à lista orgânica. Cada um tem seu próprio padrão de extração.

4a — Snippet em Destaque (com fallback de regex no texto)

O Google tem se afastado progressivamente do texto clássico de resposta do container .kno-rdesc para fragmentos do Painel de Conhecimento por atributo (span.T286Pc para medições, por exemplo). O padrão resiliente é uma cascata de seletores mais uma fallback de regex no texto do corpo.

scrapeless-scraping-browser --session-id $SESSION open \
  "https://www.google.com/search?q=how+tall+is+the+eiffel+tower&hl=en&gl=us"
scrapeless-scraping-browser --session-id $SESSION wait 5000

scrapeless-scraping-browser --session-id $SESSION eval '
(function(){
  // Passo 1 — cascata de seletores (clássico → moderno)
  const selectors = [
    ".kno-rdesc",
    "[data-attrid=\"wa:/description\"]",
    ".IZ6rdc",
    ".hgKElc",
    "span.T286Pc",               // 2026 — fragmentos por atributo
    "[data-attrid] .LrzXr",      // fatos do Painel de Conhecimento
  ];
  for (const sel of selectors) {
    const el = document.querySelector(sel);
    if (el && el.textContent.trim().length > 10) {
      return JSON.stringify({ source: "selector", selector: sel, text: el.textContent.trim() });
    }
  }

  // Passo 2 — fallback de regex no texto do corpo para respostas numéricas
  const body = document.body.innerText;
  const m = body.match(/([0-9][0-9,\. ]*(metros|pés|metros|m|ft|km|milhas|°F|°C|%)[^\.]{0,40})/i);
  if (m) return JSON.stringify({ source: "regex", text: m[0].trim() });

  return JSON.stringify({ source: null, text: null });
})()
'

4b — As Pessoas Também Perguntam

scrapeless-scraping-browser --session-id $SESSION open \
  "https://www.google.com/search?q=best+running+shoes&hl=en&gl=us"
scrapeless-scraping-browser --session-id $SESSION wait 5000

scrapeless-scraping-browser --session-id $SESSION eval '
(function(){
  const out = [];
  document.querySelectorAll(".related-question-pair, div[jsname=\"N760b\"]").forEach(q => {
    const text = q.textContent.trim();
    if (text.length > 5) out.push({ question: text.slice(0, 200) });
  });
  return JSON.stringify(out);
})()
'

A contagem foi de 5 perguntas na consulta "melhores tênis de corrida" na execução de verificação. Para cada pergunta, clique para expandir e re-snapshot para extrair o corpo da resposta.

4c — Painel de Conhecimento via mapa data-attrid

Consultas de entidade (pessoas, lugares, empresas, marcos) geram um Painel de Conhecimento — um mapa de atributos estruturados que é uma das superfícies mais estáveis no Google em 2026.

scrapeless-scraping-browser --session-id $SESSION open \

"https://www.google.com/search?q=Albert+Einstein&hl=pt&gl=br"
scrapeless-scraping-browser --session-id $SESSION wait 5000

scrapeless-scraping-browser --session-id $SESSION eval '
(function(){
const attrs = {};
document.querySelectorAll("div[data-attrid]").forEach(el => {
const key = el.getAttribute("data-attrid");
const val = el.textContent.trim().replace(/\s+/g, " ").slice(0, 200);
if (key && val && !attrs[key]) attrs[key] = val;
});
return JSON.stringify({
title: document.querySelector("[data-attrid="title"]")?.textContent?.trim() || null,
attrCount: Object.keys(attrs).length,
attrs: attrs,
});
})()
'

4d — Pesquisas Relacionadas

scrapeless-scraping-browser --session-id $SESSION eval '
(function(){
  const out = [];
  document.querySelectorAll("#bres a, .brs_col a, .AJLUJb, [data-reltq]").forEach(a => {
    const t = a.textContent.trim();
    if (t.length > 1 && t.length < 80) out.push(t);
  });
  return JSON.stringify(out.slice(0, 10));
})()
'

10 consultas relacionadas retornadas sobre "Albert Einstein" — a faixa inferior da página é uma fonte confiável para expansão de consultas na mineração de tópicos.

Etapa 5 — Paginação, localização e a SERP clássica

5a — Paginação via start=N

O Google pagina com &start=0, &start=10, &start=20 … até &start=90 (profundidade prática de 10 páginas; o parâmetro &num= foi desativado em setembro de 2025 e cada página agora retorna exatamente 10 resultados orgânicos).

Crie uma nova sessão por página — a mecânica de histórico de rolagem do Google degrada a qualidade dos resultados dentro de uma única sessão em várias etapas de paginação.

for START in 0 10 20 30 40 50; do
  SID=$(scrapeless-scraping-browser new-session \
    --name "gs-page-$START" --ttl 300 --proxy-country DE --json \
    | jq -r '.data.taskId')

  scrapeless-scraping-browser --session-id $SID open \
    "https://www.google.com/search?q=scrapeless&hl=pt&gl=br&start=$START"
  scrapeless-scraping-browser --session-id $SID wait 5000

  scrapeless-scraping-browser --session-id $SID eval '
    JSON.stringify(Array.from(
      document.querySelectorAll("div[data-ved][data-hveid] a[href^=\"http\"]")
    ).slice(0, 10).map(a => a.href))
  ' > "google-page-$START.json"

  scrapeless-scraping-browser stop $SID >/dev/null 2>&1
  sleep 2
done

Na execução de verificação, a página 2 (start=10) retornou 10 URLs com zero sobreposição na página 1 — paginação limpa.

5b — Localização (hl, gl)

# Usuário alemão na Alemanha
DE_SID=$(scrapeless-scraping-browser new-session \
  --name "gs-de" --ttl 600 --proxy-country DE --json | jq -r '.data.taskId')

scrapeless-scraping-browser --session-id $DE_SID open \
  "https://www.google.com/search?q=wetter&hl=de&gl=de"
scrapeless-scraping-browser --session-id $DE_SID wait 5000

O país do proxy (DE) e os parâmetros da URL (hl=de&gl=de) devem corresponder. Combinações não correspondentes podem acionar a parede de consentimento em tráfego .eu (consent.google.com/*) — clique no botão Rejeitar/ aceitar via eval para dispensar antes da extração.

5c — Layout clássico via udm=14 (supressão de Visão Geral AI)

Anexar &udm=14 força a SERP "clássica" do Google — sem Visão Geral AI, apenas orgânica. Útil para reprodutibilidade e para pipelines que precisam de um layout estável de 10 orgânicos.

scrapeless-scraping-browser --session-id $SESSION open \
  "https://www.google.com/search?q=what+is+machine+learning&hl=pt&gl=br&udm=14"
scrapeless-scraping-browser --session-id $SESSION wait 5000

Verificado: udm=14 retornou 40 contêineres orgânicos e zero Visão Geral AI na consulta de teste — um layout clássico limpo.

Outros parâmetros úteis:

Etapa 6 — Extração de Visão Geral AI (SGE) — não determinística

A Visão Geral AI é renderizada para algumas consultas, mas não para outras, e a mesma consulta pode ou não retornar uma em repetições — a taxa de renderização varia por tópico, localidade, estado da conta e sessão. Projete o pipeline para aceitar ambos os resultados (present: true e present: false) como normais.

AI_SID=$(scrapeless-scraping-browser new-session \
  --name "gs-ai" --ttl 600 --proxy-country DE --json | jq -r '.data.taskId')
scrapeless-scraping-browser --session-id $AI_SID open \
  "https://www.google.com/search?q=qual+é+a+aprendizagem+de+máquina&hl=pt&gl=br"
scrapeless-scraping-browser --session-id $AI_SID wait 5000

# Poll up to 10 s — AI Overview renders asynchronously.
# IMPORTANTE: os seletores do container correspondem a um elemento de placeholder em consultas
# onde AI Overview NÃO foi servido. Sempre verifique se o comprimento do textContent > 100
# antes de declarar "present=true" — caso contrário, você obtém falsos positivos com
# text_len=0, cites=0.
for i in 1 2 3 4 5; do
  PRESENT=$(scrapeless-scraping-browser --session-id $AI_SID eval '
    (function(){
      const ai = document.querySelector(
        "[data-subtree=\"gw\"], .yp, .LT6XE, [aria-label*=\"AI Overview\"], [jsname=\"uIYcDb\"]"
      );
      if (!ai || ai.textContent.trim().length < 100) return "no";
      return "yes";
    })()
  ' | tail -1 | tr -d '"')
  [ "$PRESENT" = "yes" ] && break
  sleep 2
done

scrapeless-scraping-browser --session-id $AI_SID eval '
(function(){
  const ai = document.querySelector(
    "[data-subtree=\"gw\"], .yp, .LT6XE, [aria-label*=\"AI Overview\"], [jsname=\"uIYcDb\"]"
  );
  // Guarda de comprimento do conteúdo: os seletores do container geram falsos positivos em um
  // elemento placeholder quando AI Overview não é realmente renderizado.
  if (!ai || ai.textContent.trim().length < 100) {
    // Heurística de texto secundário antes de declarar a ausência
    const bodyHit = /AI Overview|Gerado com IA/i.test(document.body.innerText);
    return JSON.stringify({ present: false, body_heuristic: bodyHit });
  }
  const citations = Array.from(ai.querySelectorAll("a[href^=\"http\"]"))
    .slice(0, 8)
    .map(a => ({ url: a.href, text: a.textContent.trim().slice(0, 80) }));
  return JSON.stringify({
    present: true,
    text:    ai.textContent.trim().slice(0, 800),
    citations,
  });
})()
'

Em execuções de verificação, a abordagem ingênua do querySelector gerou falsos positivos na consulta qual é a aprendizagem de máquina — o elemento placeholder existe independentemente de o AI Overview ter sido realmente renderizado, retornando present: true, text_len: 0, cites: 0. A guarda do comprimento do conteúdo acima (textContent.length < 100 ⇒ tratar como ausente) é obrigatória, não opcional.

Os pipelines de produção devem:

1. Aceitar present: false como normal — não uma falha.
2. Opcionalmente realizar nova verificação em uma nova sessão após 60+ segundos — a presença do AI Overview varia em janelas de tempo curtas.
3. Usar &udm=14 para forçar SERP clássica quando o AI Overview é indesejado (Passo 5c).
4. Registrar os casos body_heuristic: true — estes são sinais úteis quando os seletores do container falham, mas o texto do corpo confirma que o AI Overview foi renderizado. Isso justifica uma passagem de descoberta de seletores no estilo do Passo 2 para capturar o novo container.

Passo 7 — Escalonamento: isolar o estado da CLI por trabalhador

Um problema importante detectado durante a verificação: a CLI do Scrapeless não isola o estado do daemon entre shells paralelos no mesmo host. Executar três shells que cada uma gera sua própria sessão via new-session e depois navegam simultaneamente colapsa para um único vencedor — as outras duas shells acabam consultando o mesmo contexto subjacente do navegador, e duas das três chamadas eval retornam 0 nós orgânicos.

Este é um problema de estado local a nível de CLI, não um problema de ID de sessão. Passar --session-id corretamente em cada chamada não é suficiente; o daemon compartilhado da CLI, arquivos PID/port e cache do pool de sessões no host local sobrepõem o --session-id sob carga paralela.

Os primitivas que realmente funcionam (verificado em 10+ agentes CLI paralelos em 2026-04-26):

1. Encadeamento de shell único && — encadeie cada chamada da CLI para um trabalho em uma única invocação atômica do shell; outros trabalhadores não podem intercalar entre seus passos. Este é o primitivo que suporta a carga.
2. Nomes de sessão únicos por trabalhador — a porta do daemon é hash da name; nomes únicos evitam colisões de porta.
3. Limitar a ~3 trabalhadores simultâneos por host — empiricamente além disso, erros transitórios chrome://new-tab-page/, ERR_TUNNEL_CONNECTION_FAILED, e "sessão encerrada" se acumulam.
4. USERPROFILE/HOME variáveis de env são documentadas na habilidade upstream, mas NÃO isolam o binário Rust v0.1.1 no Windows durante a verificação. Não dependa delas. Para mais distribuição, compartilhe entre hosts.

Padrões de fallback:

• Shard entre hosts. Uma vez que você exceda ~3 trabalhadores ativos por host, mova trabalhadores adicionais para máquinas separadas (cada host obtém seu próprio daemon). Isso ainda funciona porque o estado do daemon é por host, não por conta.
• Sequencial por host. Execute uma busca de SERP de cada vez por host; coloque o resto em fila. Simples, mais lento e suficiente para pequenos pipelines.

A concorrência sem encadeamento de shell único é aceitável para ≤ 1 solicitação ativa por vez. Não ultrapasse isso, a menos que toda a sequência de chamadas de cada trabalhador (new-session && open && wait && eval) viva em um único comando atômico do shell.

O que você recebe de volta

O esquema canônico para uma pesquisa da SERP do Google parece assim. Os valores organic[0] abaixo são a resposta ao vivo capturada para a consulta scrapeless em uma sessão DE-egress (verificação de 2026-04-27):

{
  "query": "scrapeless",
  "timestamp": "2026-04-27T15:42:00Z",
  "locale": { "hl": "en", "gl": "us" },
  "organic": [
    {
      "position": 1,
      "title": "Scrapeless: Conjunto de Ferramentas de Web Scraping Sem Esforço",
      "url": "https://www.scrapeless.com/",
      "displayedUrl": "https://www.scrapeless.com",
      "snippet": "Scrapeless oferece serviços de web scraping e automação robustos e escaláveis, alimentados por IA e confiáveis por grandes empresas. Nossas soluções de nível empresarial são..."
    }
  ],
  "organicCount":   10,
  "citeCount":      14,
  "featuredSnippet": null,
  "peopleAlsoAsk":   [],
  "knowledgePanel":  null,
  "relatedSearches": [],
  "aiOverview":     { "present": false },
  "errors":         []
}

Observações honestas:

• O organicCount frequentemente será 10, mas o total de "cards" na página pode ser 100+ — filtrar estritamente pela presença de h3 + anchor.
• featuredSnippet.source em pipelines de produção deve ser um dos seguintes: "selector-classic", "selector-attrid", "selector-T286Pc" ou "regex-body-text", para que os consumidores downstream saibam quanto confiar em cada campo.
• aiOverview.present: false é um estado válido, não um erro — a Visão Geral da IA é não determinística por consulta.

Precisa de JSON estruturado sem trabalho DOM? Use a API Scraper

A abordagem do Browser de Scraping acima oferece total flexibilidade — você controla os seletores, a estratégia de espera e a forma exata do JSON. Se você prefere pular completamente o DOM e receber JSON estruturado da SERP do Google diretamente, o Scrapeless oferece uma API de Scraping do Google Search:

Para pipelines que monitoram um pequeno conjunto de palavras-chave em uma programação constante, a API geralmente é mais barata e simples. Para trabalho com seletores personalizados, coleta da Visão Geral da IA e layouts não padronizados, o Browser de Scraping é o caminho flexível.

Conclusão

O scraping do Google Search em 2026 não é mais sobre coletar HTML estático. Exige um fluxo de trabalho que pode lidar com layouts de SERP rotativos, lógica de espera fixa, sessões sensíveis ao local e extração em nível de recurso entre resultados orgânicos, "As Pessoas Também Perguntam", Painéis de Conhecimento, Snippets em Destaque, Pesquisas Relacionadas e Visão Geral da IA.

O Scrapeless Scraping Browser oferece às equipes uma maneira prática de fazer isso em produção. Com proxies residenciais, impressão digital anti-detecção, renderização em JavaScript e controle geográfico em nível de sessão, reduz a carga de manutenção do scraping do Google ao mesmo tempo que mantém o pipeline flexível o suficiente para seletores personalizados e layouts não padronizados. Para equipes que desejam um caminho mais simples para dados estruturados, a API de Scraping do Google Search do Scrapeless é a opção mais rápida.

Pronto para Scrapar agora?

Junte-se à nossa comunidade vibrante para reivindicar um plano gratuito de $5-10 e conectar-se com outros inovadores:

Comunidade Oficial do Discord do Scrapeless
Comunidade Oficial do Telegram do Scrapeless

FAQ

P: Posso evitar proxies?
R: Não de forma confiável. Faixas de IP de datacenters são filtradas agressivamente pela borda do Google, e padrões de requisição de um único IP atraem limitação rapidamente. Proxies residenciais (--proxy-country DE para o Google, veja o Passo 1) são o primitivo que suporta o scraping sustentado.

P: Por que wait --load networkidle demora ~14 segundos no Google?
R: O Google emite contínuas chamadas XHR de anúncios/rastreadores — networkidle requer uma janela silenciosa de 500 ms antes de ativar, e as janelas silenciosas do Google são raras. Use o wait 5000 fixo do Passo 2 mais uma contagem de div[data-ved][data-hveid] em vez de confiar no networkidle.

P: Por que usar o Browser de Scraping do Scrapeless para scraping do Google em vez de uma configuração de navegador local?
Porque o Google Search é altamente dinâmico e possui forte proteção contra bots. O Scrapeless lida com roteamento de proxies, impressão digital e renderização na nuvem, o que torna o fluxo de trabalho de raspagem muito mais estável do que manter trabalhos locais do Playwright ou Puppeteer.

Q: O Scrapeless pode extrair AI Overview, Featured Snippets e People Also Ask?
Sim. O fluxo de trabalho do navegador é projetado para extração em nível de recurso, para que você possa extrair resultados orgânicos, Featured Snippets, PAA, Painéis de Conhecimento, Pesquisas Relacionadas e AI Overview do mesmo padrão de sessão.

Q: Quando devo usar a API do Google Search Scraper em vez disso?
Use a API quando você quiser JSON estruturado com menos trabalho de seletor e menor sobrecarga operacional. Use o Scraping Browser quando precisar de extração personalizada, resiliência de layout ou controle direto sobre como cada recurso SERP é lido.

Q: O Scrapeless suporta raspagem do Google em múltiplos locais?
Sim. Você pode alinhar a geografia do proxy, idioma e fuso horário por sessão, o que ajuda a manter os resultados consistentes em diferentes mercados e variações locais de SERP.