Como os Proxies Ajudam a Raspar Dados de Avaliações em Várias Plataformas

Aviso: Este guia aborda apenas acesso a dados públicos. Respeite os Termos de Serviço de cada plataforma, o robots.txt e leis aplicáveis como a CFAA nos EUA e a GDPR na UE. Não colete informações pessoais identificáveis (PII) nem contorne logins. Quando existir uma API oficial, considere usá-la primeiro.

Equipes de pesquisa de mercado e monitoramento de marca precisam de datasets de avaliações consistentes e multiplataforma. Mas páginas de reviews são agressivamente rate-limited, geo-personalizadas e protegidas por anti-bot. É exatamente aqui que entra o tema central deste artigo: como os proxies ajudam a raspar dados de avaliações do Trustpilot, G2 e Google Business sem ser bloqueado.

Por que proxies são essenciais para raspar dados de avaliações

Páginas de avaliações são diferentes de páginas estáticas comuns. Plataformas como Trustpilot, G2 e Google Business expõem conteúdo dinâmico, localizado e sensível a abuso. Três fatores tornam um IP único insuficiente:

• Rate limiting agressivo: Trustpilot e G2 limitam requisições por IP em segundos, não minutos. Estudos de comunidades como a documentação do Google Maps mostram que o Google impõe cotas estritas para endpoints de lugares e reviews; o mesmo princípio se aplica ao scraping direto.
• Geo-personalização: O Google Business retorna subconjuntos de avaliações diferentes conforme hl (idioma) e gl (país) do solicitante. Um IP alemão pode ver avaliações em alemão que um IP brasileiro nunca verá.
• Anti-bot heurístico: G2 usa proteções como Cloudflare e fingerprints de TLS/JA3. IPs de datacenter com assinaturas automáticas costumam receber challenge pages em vez de HTML real.

Proxies residenciais rotativos resolvem os três problemas: distribuem requisições por milhares de IPs de ISPs reais, permitem geo-segmentação consistente e reduzem a taxa de detecção. Em testes práticos, equipes de scraping relatam saltos de taxa de sucesso de 30–40% para 95%+ ao trocar de datacenter para residenciais em plataformas com anti-bot moderado.

Comparação: tipos de proxy para raspar avaliações

Para revisões em escala, proxies residenciais oferecem o melhor equilíbrio custo-benefício. Veja opções em nossos planos de proxies e localizações disponíveis.

Trustpilot: paginando e parseando __NEXT_DATA__

O Trustpilot renderiza perfis de empresas com Next.js. Em vez de parsear HTML frágil, extraia o JSON embutido em <script id="__NEXT_DATA__">, que contém todas as avaliações da página em estrutura estável. Use o parâmetro ?page=N para paginação e rotacione o IP a cada página via gate.proxyhat.com:8080.

Snippet Python — Trustpilot com rotação por página

import requests
import json
import time
import random
from bs4 import BeautifulSoup

GATE = "http://gate.proxyhat.com:8080"
USER = "user"
PASS = "pass"

def fetch_trustpilot_reviews(company_slug, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        # Rotaciona IP a cada página (sem session flag)
        proxy_url = f"http://{USER}:{PASS}@gate.proxyhat.com:8080"
        proxies = {"http": proxy_url, "https": proxy_url}
        url = f"https://www.trustpilot.com/review/{company_slug}?page={page}"
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
            "Accept-Language": "en-US,en;q=0.9",
        }
        try:
            r = requests.get(url, proxies=proxies, headers=headers, timeout=30)
            soup = BeautifulSoup(r.text, "html.parser")
            script = soup.find("script", id="__NEXT_DATA__")
            if not script:
                print(f"Página {page}: sem __NEXT_DATA__, parando.")
                break
            data = json.loads(script.string)
            reviews = (
                data.get("props", {})
                .get("pageProps", {})
                .get("reviews", [])
            )
            if not reviews:
                break
            for rv in reviews:
                all_reviews.append({
                    "id": rv.get("id"),
                    "stars": rv.get("rating"),
                    "title": rv.get("title"),
                    "text": rv.get("text"),
                    "date": rv.get("dates", {}).get("publishedDate"),
                })
            print(f"Página {page}: {len(reviews)} avaliações coletadas.")
            time.sleep(random.uniform(2, 5))
        except Exception as e:
            print(f"Erro na página {page}: {e}")
    return all_reviews

reviews = fetch_trustpilot_reviews("example.com", max_pages=20)
print(f"Total: {len(reviews)} avaliações")

Esse padrão evita dependência de classes CSS voláteis e reduz a manutenção. A rotação por requisição distribui o risco de throttling, mas se você precisar de continuidade de sessão (por exemplo, para carregar todas as páginas de um perfil sem revalidação), use sessões sticky.

Snippet Python — sessão sticky para perfis multipágina

import requests
import json
from bs4 import BeautifulSoup

def fetch_with_sticky_session(company_slug, max_pages=10, session_id="abc123"):
    # Sessão sticky mantém o mesmo IP durante a vida da sessão
    proxy_url = f"http://user-session-{session_id}:pass@gate.proxyhat.com:8080"
    proxies = {"http": proxy_url, "https": proxy_url}
    session = requests.Session()
    session.proxies = proxies
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Accept-Language": "en-US,en;q=0.9",
    })
    all_reviews = []
    for page in range(1, max_pages + 1):
        url = f"https://www.trustpilot.com/review/{company_slug}?page={page}"
        r = session.get(url, timeout=30)
        soup = BeautifulSoup(r.text, "html.parser")
        script = soup.find("script", id="__NEXT_DATA__")
        if not script:
            break
        data = json.loads(script.string)
        reviews = data.get("props", {}).get("pageProps", {}).get("reviews", [])
        if not reviews:
            break
        all_reviews.extend(reviews)
    return all_reviews

data = fetch_with_sticky_session("example.com", max_pages=15, session_id="tp-profile-001")
print(f"Coletadas: {len(data)} avaliações com sessão sticky")

Sessões sticky são úteis quando a plataforma associa preferências de paginação ao IP. Consulte a documentação do ProxyHat para detalhes de parâmetros de sessão.

G2: lidando com anti-bot mais pesado

O G2 tem postura anti-bot mais agressiva que o Trustpilot. Cloudflare e fingerprints de TLS/JA3 tornam proxies de datacenter quase inúteis. Para raspar avaliações do G2 com proxy, combine três elementos:

1. Proxies residenciais com rotação por requisição.
2. Headers realistas incluindo sec-ch-ua, accept e referer.
3. Delays aleatórios entre 3 e 7 segundos para parecer humano.

As páginas de produto do G2 costumam incluir a distribuição de estrelas em um bloco div[class*="stars"] e avaliações em containers div[itemprop="review"]. Embora menos estável que o __NEXT_DATA__ do Trustpilot, ainda é parseável com BeautifulSoup se você usar seletores baseados em atributos itemprop.

import requests
import time
import random
from bs4 import BeautifulSoup

def fetch_g2_reviews(product_slug, max_pages=5):
    proxy_url = "http://user:pass@gate.proxyhat.com:8080"
    proxies = {"http": proxy_url, "https": proxy_url}
    headers = {
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
        "sec-ch-ua-mobile": "?0",
        "sec-ch-ua-platform": '"macOS"',
    }
    all_reviews = []
    for page in range(1, max_pages + 1):
        url = f"https://www.g2.com/products/{product_slug}/reviews?page={page}"
        r = requests.get(url, proxies=proxies, headers=headers, timeout=30)
        if r.status_code == 403:
            print(f"Página {page}: bloqueado (403). Aumente o delay.")
            break
        soup = BeautifulSoup(r.text, "html.parser")
        for review in soup.select("div[itemprop='review']"):
            all_reviews.append({
                "author": review.select_one("span[itemprop='author']").get_text(strip=True) if review.select_one("span[itemprop='author']") else None,
                "rating": review.select_one("meta[itemprop='ratingValue']").get("content") if review.select_one("meta[itemprop='ratingValue']") else None,
                "text": review.select_one("div[itemprop='reviewBody']").get_text(strip=True) if review.select_one("div[itemprop='reviewBody']") else None,
            })
        time.sleep(random.uniform(3, 7))
    return all_reviews

reviews = fetch_g2_reviews("salesforce", max_pages=5)
print(f"G2: {len(reviews)} avaliações")

Se você encontrar muitos 403, reduza a concorrência para 1–2 sessões simultâneas e considere proxies mobile para os casos mais difíceis.

Google Business/Maps reviews: hl, gl e geo-segmentação

O Google Business retorna avaliações diferentes conforme o país e o idioma do solicitante. Dois parâmetros controlam isso:

• hl: idioma da interface (ex.: hl=pt-BR).
• gl: país do solicitante (ex.: gl=US).

Se o IP não corresponder ao gl, o Google pode mostrar um subconjunto diferente de avaliações ou redirecionar. Por isso, ao raspar avaliações do Google Business, use proxies residenciais geo-segmentados com a flag -country-US (ou outro país) para garantir consistência entre IP e parâmetros hl/gl.

import requests
import json
import time
import random

def fetch_google_business_reviews(place_id, country="US", hl="en", max_reviews=50):
    # Geo-segmentação: IP residencial dos EUA
    proxy_user = f"user-country-{country}"
    proxy_url = f"http://{proxy_user}:pass@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/120.0 Safari/537.36",
        "Accept-Language": f"{hl},{hl.split('-')[0]};q=0.9",
    }
    url = f"https://www.google.com/maps/place/?q=place_id:{place_id}&hl={hl}&gl={country}"
    r = requests.get(url, proxies=proxies, headers=headers, timeout=30)
    # O Google Business retorna HTML pesado; extraia dados via selectors ou APIs de terceiros
    # Aqui simplificado: em produção, combine com parsers específicos ou Places API oficial
    print(f"Status: {r.status_code}, tamanho: {len(r.text)} bytes")
    return r.text

html = fetch_google_business_reviews("ChIJN1t_tDeuEmsRUsoJgCq5pK0", country="US", hl="en")

Nota: Para volumes altos de reviews do Google Business, considere a Places API do Google, que retorna reviews estruturadas com rate limits documentados. Para datasets amplos e multiplataforma, scraping com proxies residenciais costuma ser mais econômico.

Snippet Node.js — rotação de IPs em páginas de avaliações

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const GATE = 'http://user:pass@gate.proxyhat.com:8080';

async function fetchReviews(companySlug, maxPages = 10) {
  const agent = new HttpsProxyAgent(GATE);
  const results = [];
  for (let page = 1; page <= maxPages; page++) {
    const url = `https://www.trustpilot.com/review/${companySlug}?page=${page}`;
    try {
      const res = await axios.get(url, {
        httpsAgent: agent,
        headers: {
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
          'Accept-Language': 'en-US,en;q=0.9',
        },
        timeout: 30000,
      });
      const match = res.data.match(/<script id="__NEXT_DATA__" type="application\/json">([\s\S]*?)<\/script>/);
      if (!match) { console.log(`Página ${page}: sem dados.`); break; }
      const data = JSON.parse(match[1]);
      const reviews = data.props?.pageProps?.reviews || [];
      if (reviews.length === 0) break;
      results.push(...reviews.map(r => ({
        id: r.id, stars: r.rating, title: r.title, text: r.text,
      })));
      console.log(`Página ${page}: ${reviews.length} avaliações`);
      await new Promise(r => setTimeout(r, 2000 + Math.random() * 3000));
    } catch (e) {
      console.error(`Erro página ${page}: ${e.message}`);
    }
  }
  return results;
}

(async () => {
  const reviews = await fetchReviews('example.com', 10);
  console.log(`Total: ${reviews.length} avaliações`);
})();

Erros comuns e casos de borda

• IP único para todo o perfil: Sessões longas sem rotação aumentam a chance de throttling após 20–30 páginas. Rotacione a cada 5–10 páginas se não precisar de continuidade.
• Headers genéricos: Usar apenas User-Agent sem sec-ch-ua e Accept-Language é um sinal de bot. Complete o header set.
• Ignorar robots.txt: Verifique sempre /robots.txt da plataforma antes de raspar. Algumas proíbem paths específicos de reviews.
• Concorrência alta: 50+ requisições simultâneas de um único pool de IPs dispara rate limits. Mantenha 5–10 sessões simultâneas por perfil.
• hl/gl incompatíveis com o IP: Pedir gl=US de um IP brasileiro pode retornar resultados inconsistentes. Alinhe geo do proxy com os parâmetros.
• Parsear HTML em vez de JSON embutido: No Trustpilot, seletores de CSS quebram a cada release. Prefira __NEXT_DATA__.

Configuração no ProxyHat e links úteis

Todos os exemplos usam o gateway gate.proxyhat.com:8080 (HTTP) ou :1080 (SOCKS5). Parâmetros de geo e sessão vão no username:

• user-country-US — IP residencial dos EUA.
• user-country-DE-city-berlin — geo-segmentação até cidade.
• user-session-abc123 — sessão sticky para perfis multipágina.

Recursos relacionados:

• Caso de uso: web scraping
• Caso de uso: rastreamento de SERP
• Planos e preços de proxies
• Localizações de proxies
• Documentação oficial do ProxyHat

Quando usar APIs oficiais em vez de scraping

Antes de raspar, verifique se a plataforma oferece uma API. O Google Places API retorna reviews estruturadas com cotas claras; o G2 e o Trustpilot têm parâmetros de parceria para dados em escala. APIs oficiais eliminam risco legal, custos de infraestrutura anti-bot e manutenção de parsers. Use scraping quando:

• A API não cobrir os campos ou filtros que você precisa.
• O custo da API for proibitivo para o volume desejado.
• Você precisar de cobertura multiplataforma padronizada.

Em todos os casos, mantenha boas práticas: respeite robots.txt, limite concorrência, evite PII e documente a origem de cada dataset.

Pontos-chave

• Proxies residenciais rotativos são essenciais para contornar rate limits e geo-personalização em Trustpilot, G2 e Google Business.
• No Trustpilot, parse o JSON __NEXT_DATA__ em vez de HTML; rotacione IPs por página via gate.proxyhat.com:8080.
• No G2, use proxies residenciais com headers realistas e delays de 3–7 segundos; IPs de datacenter costumam receber 403.
• No Google Business, alinhe hl/gl com a geo do proxy (-country-US) para evitar subconjuntos localizados inconsistentes.
• Sessões sticky (-session-abc123) mantêm continuidade em perfis multipágina; rotação por requisição é melhor para varreduras amplas.
• Compliance primeiro: só raspe dados públicos, respeite ToS e robots.txt e considere APIs oficiais quando disponíveis.

Conclusão

Raspar dados de avaliações em escala exige mais do que um bom parser: exige infraestrutura de IPs que pareça humana e seja geo-consistente. Com proxies residenciais do ProxyHat, você pode distribuir requisições por milhares de IPs de ISPs reais, geo-segmentar por país e cidade e manter sessões sticky quando necessário. Comece com os snippets acima, ajuste delays e concorrência conforme a plataforma e valide seu dataset contra amostras manuais antes de publicar análises. Para volumes maiores, consulte nossos planos e a documentação para configurar pools dedicados.