Come i Proxy Aiutano a Raccogliere Dati di Recensioni: Guida Pratica

Come i proxy aiutano a raccogliere dati di recensioni: introduzione pratica

Raccogliere dati di recensioni pubbliche da piattaforme come Trustpilot, G2 e Google Business è essenziale per il monitoraggio del brand, la ricerca di mercato e l'analisi competitiva. Ma ogni piattaforma implementa sistemi anti-bot aggressivi, rate limiting rigorosi e personalizzazione geo-locale che rendono lo scraping da un singolo IP rapidamente impraticabile. Ecco come i proxy aiutano a raccogliere dati di recensioni in modo affidabile e scalabile.

Avviso di conformità: Questo articolo riguarda esclusivamente l'accesso a dati di recensioni pubblicamente disponibili, senza login. Rispetta sempre i Termini di Servizio di ogni piattaforma, il file robots.txt e le leggi applicabili — inclusi il CFAA negli Stati Uniti e il GDPR nell'Unione Europea. Non raccogliere dati personali (PII) oltre il minimo necessario e interrompi lo scraping se il provider lo richiede.

Perché le pagine di recensioni sono rate-limited e geo-personalizzate

Le piattaforme di recensioni proteggono i loro dati con strati multipli di difesa. Il primo problema è il rate limiting: Trustpilot, G2 e Google applicano limiti di richieste che possono variare da 20 a 80 richieste al minuto per indirizzo IP. Superare questa soglia genera risposte HTTP 429 (Too Many Requests) o redirect a pagine CAPTCHA.

Il secondo problema è la personalizzazione geo-locale. Google Business, in particolare, utilizza i parametri hl (lingua) e gl (geografia) per determinare quali recensioni mostrare. Un utente con IP tedesco potrebbe vedere un sottoinsieme diverso di recensioni rispetto a un utente con IP statunitense, anche per la stessa attività commerciale. Questo significa che un singolo IP non solo viene throttled, ma potrebbe anche mostrare un sottoinsieme localizzato e non rappresentativo delle recensioni totali.

G2 aggiunge un ulteriore livello di difficoltà con un'infrastruttura anti-bot più pesante, che include fingerprinting del browser e challenge JavaScript. Un datacenter IP che fa 50 richieste al minuto a G2 verrà quasi certamente bloccato entro i primi 3-5 minuti.

I proxy residenziali risolvono entrambi i problemi: distribuiscono le richieste su migliaia di IP reali (evitando il rate limiting per singolo IP) e permettono il geo-targeting per paese o città (garantendo coerenza locale). Puoi esplorare le località disponibili su ProxyHat per capire la copertura geografica.

Scrapeare recensioni Trustpilot: parsing di __NEXT_DATA__

Trustpilot costruisce le sue pagine con Next.js, che include un oggetto JSON serializzato in un tag <script id="__NEXT_DATA__">. Questo JSON contiene tutte le recensioni della pagina in formato strutturato, rendendo il parsing molto più robusto rispetto all'estrazione da HTML frammentato.

La strategia ottimale è:

• Paginare con il parametro ?page=N (1, 2, 3, ...).
• Estrarre il JSON da __NEXT_DATA__ con una regex.
• Rotare l'IP residenziale ad ogni pagina per evitare pattern detection.

import requests
import json
import re
import random
import time

def get_rotating_proxy():
    """ProxyHat residential proxy with per-request rotation."""
    return {
        "http": "http://user:pass@gate.proxyhat.com:8080",
        "https": "http://user:pass@gate.proxyhat.com:8080",
    }

def scrape_trustpilot(domain, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        url = f"https://www.trustpilot.com/review/{domain}?page={page}"
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                         "AppleWebKit/537.36 (KHTML, like Gecko) "
                         "Chrome/120.0.0.0 Safari/537.36",
            "Accept": "text/html,application/xhtml+xml",
            "Accept-Language": "en-GB,en;q=0.9",
        }
        proxies = get_rotating_proxy()
        resp = requests.get(url, headers=headers, proxies=proxies, timeout=30)
        if resp.status_code != 200:
            print(f"Page {page}: HTTP {resp.status_code} — stopping")
            break

        match = re.search(
            r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
            resp.text
        )
        if not match:
            print(f"Page {page}: __NEXT_DATA__ not found")
            break

        data = json.loads(match.group(1))
        business = data.get("props", {}).get("pageProps", {}).get("businessUnit", {})
        page_reviews = business.get("reviews", [])

        for r in page_reviews:
            all_reviews.append({
                "id": r.get("id"),
                "rating": r.get("rating"),
                "title": r.get("title"),
                "text": r.get("text"),
                "date": r.get("dates", {}).get("publishedDate"),
                "author": r.get("consumer", {}).get("displayName"),
            })

        print(f"Page {page}: {len(page_reviews)} reviews extracted")
        time.sleep(random.uniform(2, 4))

    return all_reviews

reviews = scrape_trustpilot("example.com", max_pages=10)
print(f"Total reviews collected: {len(reviews)}")

La rotazione automatica degli IP avviene ad ogni chiamata a get_rotating_proxy(), poiché il gateway ProxyHat assegna un nuovo IP residenziale a ogni richiesta quando non viene specificata una sessione sticky.

Scrapeare recensioni G2: anti-bot più aggressivo

G2 implementa una difesa anti-bot più pesante rispetto a Trustpilot. Oltre al rate limiting, G2 utilizza fingerprinting del browser e, in alcuni casi, challenge JavaScript. Per raccogliere recensioni pubbliche da G2 è necessario combinare proxy residenziali con header HTTP realistici e delay più lunghi tra le richieste.

import requests
from bs4 import BeautifulSoup
import time
import random

def get_proxy(country="US"):
    return {
        "http": f"http://user-country-{country}:pass@gate.proxyhat.com:8080",
        "https": f"http://user-country-{country}:pass@gate.proxyhat.com:8080",
    }

def scrape_g2_product(product_slug, max_pages=5):
    all_reviews = []
    for page in range(1, max_pages + 1):
        url = f"https://www.g2.com/products/{product_slug}/reviews"
        if page > 1:
            url += f"?page={page}"

        headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                         "AppleWebKit/537.36 (KHTML, like Gecko) "
                         "Chrome/120.0.0.0 Safari/537.36",
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
            "Upgrade-Insecure-Requests": "1",
        }

        proxy = get_proxy("US")
        resp = requests.get(url, headers=headers, proxies=proxy, timeout=30)

        if resp.status_code == 200:
            soup = BeautifulSoup(resp.text, "html.parser")
            review_items = soup.select("[itemprop='review']")
            for item in review_items:
                rating_elem = item.select_one("[itemprop='ratingValue']")
                body_elem = item.select_one("[itemprop='reviewBody']")
                all_reviews.append({
                    "rating": rating_elem.get("content") if rating_elem else None,
                    "text": body_elem.get_text(strip=True) if body_elem else None,
                })
            print(f"G2 page {page}: {len(review_items)} reviews")
        else:
            print(f"G2 page {page}: HTTP {resp.status_code}")

        time.sleep(random.uniform(3, 6))

    return all_reviews

reviews = scrape_g2_product("slack", max_pages=3)
print(f"Total G2 reviews: {len(reviews)}")

La latenza tipica con proxy residenziali su G2 si aggira tra 200ms e 800ms per richiesta, rispetto ai 50ms di un datacenter IP — ma il trade-off è necessario: i datacenter IP vengono bloccati da G2 entro poche richieste.

Scrapeare recensioni Google Business: geo-targeting e coerenza locale

Google Business/Maps è la piattaforma più complessa per lo scraping di recensioni. Il parametro hl controlla la lingua dell'interfaccia, mentre gl controlla la geografia. Un IP statunitense con hl=en&gl=US mostrerà un insieme di recensioni potenzialmente diverso rispetto a un IP tedesco con hl=de&gl=DE per la stessa attività.

Per ottenere un dataset coerente, usa sessioni geo-targeted con ProxyHat specificando il paese nel username:

import requests
import json
import re

def scrape_google_business(place_id, country="US", hl="en"):
    """Scrape Google Business reviews with country-targeted residential IP."""
    proxy = {
        "http": f"http://user-country-{country}:pass@gate.proxyhat.com:8080",
        "https": f"http://user-country-{country}:pass@gate.proxyhat.com:8080",
    }

    url = f"https://www.google.com/maps/place/?q=place_id:{place_id}&hl={hl}"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                     "AppleWebKit/537.36 (KHTML, like Gecko) "
                     "Chrome/120.0.0.0 Safari/537.36",
        "Accept-Language": f"{hl},{country.lower()};q=0.9",
    }

    resp = requests.get(url, headers=headers, proxies=proxy, timeout=30)
    print(f"Status: {resp.status_code}, Locale: {hl}-{country}")
    return resp.text

def scrape_trustpilot_sticky(domain, session_id="tp-review-001"):
    """Multi-page scraping with a sticky session for IP consistency."""
    proxy = {
        "http": f"http://user-session-{session_id}:pass@gate.proxyhat.com:8080",
        "https": f"http://user-session-{session_id}:pass@gate.proxyhat.com:8080",
    }

    all_reviews = []
    for page in range(1, 6):
        url = f"https://www.trustpilot.com/review/{domain}?page={page}"
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                         "AppleWebKit/537.36",
            "Accept-Language": "en-GB,en;q=0.9",
        }
        resp = requests.get(url, headers=headers, proxies=proxy, timeout=30)
        if resp.status_code != 200:
            print(f"Page {page}: HTTP {resp.status_code}")
            break

        match = re.search(
            r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
            resp.text
        )
        if match:
            data = json.loads(match.group(1))
            reviews = data.get("props", {}).get("pageProps", {}).get("businessUnit", {}).get("reviews", [])
            all_reviews.extend(reviews)
            print(f"Page {page} via session {session_id}: {len(reviews)} reviews")

    return all_reviews

# Country-targeted Google Business scrape
html = scrape_google_business("ChIJN1t_tDeuEmsRUsoxG2fCKAI", country="US", hl="en")

# Sticky session for multi-page Trustpilot profile
reviews = scrape_trustpilot_sticky("example.com", session_id="brand-monitor-001")
print(f"Total: {len(reviews)}")

La sessione sticky (-session-abc123) mantiene lo stesso IP per tutta la durata della sessione, il che è cruciale quando devi paginare un profilo multipagina senza che l'IP cambi a metà della raccolta.

Esempio Node.js: Trustpilot con sessione sticky

Per i team che lavorano in JavaScript/TypeScript, ecco un esempio equivalente usando axios e cheerio con una sessione sticky ProxyHat:

const axios = require('axios');
const cheerio = require('cheerio');

async function scrapeTrustpilot(domain, maxPages = 5) {
  const sessionId = 'tp-review-001';
  const allReviews = [];

  for (let page = 1; page <= maxPages; page++) {
    const url = `https://www.trustpilot.com/review/${domain}?page=${page}`;

    try {
      const resp = await axios.get(url, {
        proxy: {
          host: 'gate.proxyhat.com',
          port: 8080,
          auth: {
            username: `user-session-${sessionId}`,
            password: 'pass',
          },
        },
        headers: {
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
          'Accept-Language': 'en-GB,en;q=0.9',
        },
        timeout: 30000,
      });

      const $ = cheerio.load(resp.data);
      const nextDataScript = $('#__NEXT_DATA__').text();

      if (nextDataScript) {
        const data = JSON.parse(nextDataScript);
        const reviews = data.props?.pageProps?.businessUnit?.reviews || [];

        reviews.forEach(r => {
          allReviews.push({
            id: r.id,
            rating: r.rating,
            title: r.title,
            text: r.text,
            date: r.dates?.publishedDate,
          });
        });

        console.log(`Page ${page}: ${reviews.length} reviews`);
      }
    } catch (err) {
      console.error(`Page ${page} error: ${err.message}`);
    }
  }

  return allReviews;
}

scrapeTrustpilot('example.com', 5)
  .then(r => console.log(`Total: ${r.length} reviews`));

Errori comuni e edge case

• Non rispettare il rate limiting: anche con proxy rotanti, inviare 100 richieste concorrenti verso la stessa piattaforma può generare pattern detection. Mantieni 2-5 secondi di delay tra le richieste.
• Usare datacenter IP per G2: G2 blocca la maggior parte degli IP datacenter noti. I proxy residenziali sono praticamente obbligatori per G2.
• Ignorare la geo-personalizzazione su Google: se raccogli recensioni Google Business senza geo-targeting, otterrai un mix incoerente di lingue e sottoinsiemi di recensioni. Specifica sempre -country-XX.
• Parsing HTML fragile su Trustpilot: non estrarre recensioni dai <div> di Trustpilot — la struttura HTML cambia frequentemente. Usa sempre __NEXT_DATA__.
• Non gestire HTTP 429: implementa retry con backoff esponenziale. Se ricevi un 429, attendi 30-60 secondi prima di riprovare con un nuovo IP.

Scraping etico e quando usare API ufficiali

Lo scraping di recensioni pubbliche è una pratica comune per la ricerca di mercato, ma ci sono linee guida etiche da seguire:

• Rispetta robots.txt: controlla sempre il file robots.txt della piattaforma prima di iniziare. Se una sezione è disallow, non scraperarla.
• Non raccogliere PII: i nomi visualizzati degli utenti sono spesso pseudonimi. Non arricchire i dati con informazioni personali aggiuntive.
• Considera API ufficiali: Google offre le Places API che includono recensioni. Se hai budget, le API ufficiali sono più affidabili e legalmente sicure. Tuttavia, le API ufficiali spesso hanno limiti di quota (es. 5 recensioni per posto) che lo scraping può superare.
• GDPR e CCPA: se operi nell'UE o raccogli dati di utenti europei, considera che le recensioni contengono dati personali. Anonimizza i dati dove possibile e non conservare informazioni identificative non necessarie.

Per approfondire le best practice di scraping, consulta la nostra guida al web scraping e la guida al SERP tracking. La documentazione ProxyHat contiene tutti i dettagli sulla configurazione del gateway.

Punti chiave

Riepilogo pratico:

• Le piattaforme di recensioni applicano rate limiting (20-80 req/min) e personalizzazione geo-locale — un singolo IP viene throttled o mostra dati non rappresentativi.
• Trustpilot: usa __NEXT_DATA__ JSON per parsing robusto; ruota IP residenziali ad ogni pagina.
• G2: richiede proxy residenziali + header realistici + delay di 3-6 secondi tra richieste.
• Google Business: usa geo-targeting (-country-XX) per coerenza locale; combina con parametri hl/gl.
• Sessioni sticky (-session-abc123) per profili multipagina; rotazione automatica per raccolta su larga scala.
• Rispetta sempre ToS, robots.txt, GDPR e CFAA. Usa API ufficiali quando disponibili e appropriate.

Pronto a iniziare? Esplora i piani ProxyHat e configura il tuo primo proxy residenziale in pochi minuti. Con il gateway gate.proxyhat.com:8080 e proxy residenziali in oltre 190 paesi, puoi costruire dataset di recensioni affidabili e scalabili.