Come Scrapearere Recensioni Aziendali e Salari da Glassdoor nel 2026: BFF GraphQL, DataDome e Proxy Residenziali

Avviso legale: questo articolo riguarda esclusivamente l'accesso a dati pubblici su Glassdoor. Prima di qualsiasi attività di scraping, consulta i Termini di Servizio della piattaforma. Negli Stati Uniti, il Computer Fraud and Abuse Act (CFAA) può applicarsi ad accessi non autorizzati; nell'UE, il GDPR disciplina il trattamento di dati personali, inclusi quelli relativi a dipendenti. Se l'uso è commerciale o su larga scala, valuta una licenza dati ufficiale.

Se lavori nell'HR analytics o nell'analisi del mercato del lavoro, sapere come scrapearere recensioni aziendali e salari da Glassdoor nel 2026 è una competenza tecnica sempre più richiesta. Glassdoor ospita milioni di recensioni anonime di dipendenti, valutazioni e interviste, ma protegge i suoi dati con uno stack anti-bot tra i più aggressivi del web: DataDome, Cloudflare Bot Management, fingerprinting TLS e challenge JavaScript. Questa guida ti mostra cosa è effettivamente raggiungibile senza login, quali endpoint GraphQL nascosti restituiscono JSON strutturato, e come i proxy residenziali rotanti di ProxyHat ti permettono di mantenere tassi di successo elevati.

Come scrapearere recensioni aziendali e salari da Glassdoor nel 2026: panoramica tecnica

Glassdoor combina rendering server-side per le pagine pubbliche (SEO) con un'architettura BFF (Backend-for-Frontend) basata su GraphQL per le interazioni lato client. Questo significa che ci sono due vie di accesso ai dati:

• Pagine HTML pubbliche — le URL /Reviews/<company>-Reviews-E<id>.htm sono indicizzate dai motori di ricerca e contengono recensioni troncate (prime 2–3 righe di pro/contro), valutazioni aggregate e dati aziendali di base.
• Endpoint GraphQL BFF — /graph e /bff/ restituiscono JSON strutturato con campi come ratingOverall, pros, cons, jobTitle, ma richiedono header specifici e superamento delle challenge anti-bot.

I dati salariali completi (breakdown per ruolo, località, anni di esperienza) sono dietro un wall di autenticazione. Non li tratteremo in questa guida: scrapearere dietro login viola quasi certamente i ToS di Glassdoor e può esporti a responsabilità legali. Ci concentreremo su recensioni e valutazioni pubbliche.

Cosa è pubblico vs. cosa è dietro login

Tipo di dato	Accessibilità	URL / Endpoint
Panoramica aziendale	Pubblico (no login)	/Overview/<company>-EI_IE<id>.htm
Recensioni troncate	Pubblico (no login)	/Reviews/<company>-Reviews-E<id>.htm
Valutazioni aggregate	Pubblico (no login)	Pagina Overview / Reviews
Recensioni complete (testo integrale)	Parzialmente pubblico (troncato)	GraphQL BFF per caricamento dinamico
Stipendi dettagliati per ruolo	Dietro login	Non trattato in questa guida
Interviste complete	Dietro login	Non trattato in questa guida

Lo stack anti-bot di Glassdoor: DataDome + Cloudflare

Glassdoor utilizza DataDome come soluzione primaria anti-bot e Cloudflare Bot Management come livello aggiuntivo. Combinati, questi sistemi applicano:

• JavaScript challenge — il browser deve eseguire un payload JS che valuta l'ambiente (WebGL, canvas, navigator properties) prima di emettere un cookie di sessione.
• TLS fingerprinting (JA3/JA4) — la signature TLS del client viene confrontata con un database di client noti. requests con Python usa una signature OpenSSL che non corrisponde a nessun browser reale.
• IP reputation scoring — DataDome classifica gli IP in tempo reale: datacenter = alto rischio, residenziali = basso rischio, mobile = rischio medio-basso.
• Behavioral analysis — pattern di navigazione troppo regolari (stesso intervallo tra richieste, nessuna interazione mouse) aumentano il punteggio di rischio.

Per questo motivo, l'approccio classico con requests + proxy datacenter fallisce quasi immediatamente. La combinazione vincente è:

1. curl_cffi — una libreria Python che usa curl-impersonate per replicare la signature TLS di Chrome. Questo risolve il problema del fingerprinting TLS a livello di libreria, senza bisogno di un browser headless completo.
2. Proxy residenziali rotanti — IP reali ISP che DataDome classifica come traffico legittimo.
3. Session management intelligente — cookie DataDome riutilizzati entro una finestra temporale, con rotazione IP quando necessario.

Secondo la documentazione ufficiale di DataDome, il sistema analizza oltre 50 parametri per richiesta, inclusi header HTTP, fingerprint del browser e segnali comportamentali. Un singolo parametro fuori posto può far bloccare l'intera richiesta.

Gli endpoint GraphQL BFF di Glassdoor

Glassdoor usa un'architettura BFF con endpoint GraphQL che restituiscono JSON strutturato. I due endpoint principali sono:

• https://www.glassdoor.com/graph — endpoint GraphQL principale
• https://www.glassdoor.com/bff/ — endpoint BFF che incapsula query GraphQL con header aggiuntivi

Per chiamare questi endpoint servono:

• Header gd-csrf-token — un token CSRF estratto dalla pagina HTML iniziale (presente in un meta tag o in un oggetto JavaScript inline).
• Cookie di sessione DataDome — ottenuti superando la challenge JS al primo caricamento.
• Header del browser realistici — User-Agent, Accept, Accept-Language, sec-ch-ua, ecc.
• Body GraphQL — un oggetto JSON con query (la query GraphQL) e variables (parametri come employerId, cursor di paginazione, ecc.).

Un esempio di query per ottenere recensioni:

query EmployerReviews($employerId: Long!, $cursor: String) {
  employer(id: $employerId) {
    reviews(cursor: $cursor, limit: 10) {
      nodes {
        id
        ratingOverall
        pros
        cons
        jobTitle { name }
        date
      }
      pageInfo { nextCursor hasNextPage }
    }
  }
}

I nomi esatti dei campi possono cambiare tra versioni del BFF. Il modo più affidabile per scoprire la query attuale è ispezionare il traffico di rete con DevTools mentre si naviga la pagina recensioni di un'azienda.

Perché i proxy residenziali battono il IP scoring di DataDome

DataDome assegna un punteggio di rischio a ogni IP. Gli IP datacenter (AWS, GCP, DigitalOcean) hanno punteggi alti perché il traffico bot è statisticamente prevalente da quei range. Gli IP residenziali, invece, appartengono a ISP reali (Comcast, AT&T, Vodafone) e sono usati da navigatori umani reali.

Con proxy residenziali ProxyHat, ogni richiesta può uscire da un IP residenziale diverso, rendendo il IP scoring di DataDome inefficace. La rotazione per-request è ideale per distribuire il carico, mentre le sessioni sticky mantengono lo stesso IP per un numero configurabile di minuti — utile per riutilizzare i cookie DataDome.

Confronto dei tipi di proxy per scraping Glassdoor:

Tipo proxy	Success rate stimato	Latenza tipica	Costo relativo	Idoneità
Datacenter	10–30%	50–100ms	Basso	Non consigliato
Residenziale rotante	85–95%	200–800ms	Medio	Consigliato
Mobile	90–98%	300–1200ms	Alto	Ottimo per alta difficoltà

Nota: i tassi di successo sono stime basate su test della community e dipendono da pattern di traffico, geolocalizzazione e configurazione.

Implementazione pratica: Python + curl_cffi + ProxyHat

Ecco un esempio completo che usa curl_cffi per l'impersonazione TLS Chrome e i proxy residenziali ProxyHat per l'accesso all'endpoint BFF GraphQL di Glassdoor.

1. Installazione delle dipendenze

pip install curl_cffi

2. Estrazione del token CSRF dalla pagina pubblica

from curl_cffi import requests as cffi_requests
import re, json

PROXY_URL = "http://user-country-US:PASSWORD@gate.proxyhat.com:8080"

def fetch_csrf_and_cookies(employer_url: str):
    """Carica la pagina HTML pubblica, estrae gd-csrf-token e cookie DataDome."""
    session = cffi_requests.Session(impersonate="chrome")
    resp = session.get(employer_url, proxies={"https": PROXY_URL, "http": PROXY_URL}, timeout=30)
    if resp.status_code != 200:
        raise Exception(f"HTTP {resp.status_code} — possibile blocco DataDome")
    # Il token CSRF è in un meta tag o in un oggetto JS inline
    match = re.search(r'gd-csrf-token["\']?\s*[:=]\s*["\']([a-f0-9-]+)["\']', resp.text)
    csrf_token = match.group(1) if match else None
    if not csrf_token:
        raise Exception("CSRF token non trovato nella pagina")
    cookies = session.cookies.get_dict()
    return csrf_token, cookies, session

3. Query GraphQL BFF per le recensioni

GRAPHQL_URL = "https://www.glassdoor.com/bff/"

REVIEW_QUERY = """
query EmployerReviews($employerId: Long!, $cursor: String) {
  employer(id: $employerId) {
    reviews(cursor: $cursor, limit: 10) {
      nodes {
        id
        ratingOverall
        pros
        cons
        jobTitle { name }
        date
      }
      pageInfo { nextCursor hasNextPage }
    }
  }
}
"""

def fetch_reviews(session, csrf_token: str, employer_id: int, cursor: str = None):
    headers = {
        "Content-Type": "application/json",
        "gd-csrf-token": csrf_token,
        "Accept": "application/json",
        "Origin": "https://www.glassdoor.com",
        "Referer": f"https://www.glassdoor.com/Reviews/",
    }
    payload = {
        "query": REVIEW_QUERY,
        "variables": {"employerId": employer_id, "cursor": cursor},
    }
    resp = session.post(
        GRAPHQL_URL,
        json=payload,
        headers=headers,
        proxies={"https": PROXY_URL, "http": PROXY_URL},
        timeout=30,
    )
    if resp.status_code == 403:
        raise Exception("403 Forbidden — DataDome ha bloccato la richiesta")
    data = resp.json()
    reviews = data.get("data", {}).get("employer", {}).get("reviews", {})
    return reviews.get("nodes", []), reviews.get("pageInfo", {})

4. Parsing di un nodo recensione

def parse_review(node: dict) -> dict:
    """Estrae i campi rilevanti da un nodo recensione GraphQL."""
    return {
        "review_id": node.get("id"),
        "rating_overall": node.get("ratingOverall"),
        "pros": node.get("pros", ""),
        "cons": node.get("cons", ""),
        "job_title": node.get("jobTitle", {}).get("name", ""),
        "date": node.get("date", ""),
    }

# Esempio di utilizzo
if __name__ == "__main__":
    employer_url = "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
    csrf, cookies, session = fetch_csrf_and_cookies(employer_url)
    reviews, page_info = fetch_reviews(session, csrf, employer_id=9079)
    for r in reviews:
        parsed = parse_review(r)
        print(f"{parsed['rating_overall']}★ — {parsed['job_title']} — {parsed['pros'][:80]}...")
    print(f"Prossima pagina: {page_info.get('hasNextPage')} cursor={page_info.get('nextCursor')}")

5. Esempio in Node.js con fetch e proxy

// Richiede Node.js 18+ e un agent proxy compatibile
// npm install undici

import { fetch, Agent } from "undici";

const PROXY_URL = "http://user-country-US:PASSWORD@gate.proxyhat.com:8080";
const dispatcher = new Agent({
  // Configurazione proxy tramite undici ProxyAgent se necessario
});

async function fetchReviews(employerId, csrfToken, cursor = null) {
  const query = `
    query EmployerReviews($employerId: Long!, $cursor: String) {
      employer(id: $employerId) {
        reviews(cursor: $cursor, limit: 10) {
          nodes { id ratingOverall pros cons jobTitle { name } date }
          pageInfo { nextCursor hasNextPage }
        }
      }
    }`;
  const resp = await fetch("https://www.glassdoor.com/bff/", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "gd-csrf-token": csrfToken,
      "Accept": "application/json",
    },
    body: JSON.stringify({ query, variables: { employerId, cursor } }),
  });
  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
  const data = await resp.json();
  return data.data.employer.reviews;
}

Per l'uso con SOCKS5, sostituisci la URL del proxy con socks5://user-country-US:PASSWORD@gate.proxyhat.com:1080.

Paginazione, sessioni sticky e logica di retry

Cursor di paginazione

Le recensioni su Glassdoor usano paginazione basata su cursor (non offset). Il campo pageInfo.nextCursor nella risposta GraphQL contiene il cursor per la pagina successiva. Quando hasNextPage è false, hai raggiunto la fine.

Sessioni sticky per mantenere i cookie DataDome

I cookie DataDome sono legati all'IP che ha superato la challenge. Se ruoti IP a ogni richiesta, perdi i cookie e devi superare di nuovo la challenge JS. La soluzione è usare una sessione sticky ProxyHat che mantiene lo stesso IP per un periodo configurabile:

# Sessione sticky: stesso IP per tutta la durata della sessione
PROXY_STICKY = "http://user-session-rev-google-001:PASSWORD@gate.proxyhat.com:8080"

Usa un ID sessione univoco per ogni azienda che stai scrapearando. Quando incontri un blocco (403 o redirect DataDome), genera un nuovo ID sessione per ottenere un IP fresco.

Pacing e rate limiting

Un ritmo aggressivo è il modo più rapido per farsi bloccare. Linee guida pratiche:

• 1 richiesta ogni 3–5 secondi per sessione sticky singola.
• Max 200–300 richieste per sessione prima di ruotare IP.
• Concorrenza limitata: 5–10 sessioni parallele con IP diversi, non di più.
• Jitter casuale: aggiungi ±1–2 secondi di variazione agli intervalli.

import time, random

def paced_loop(fetch_fn, max_pages=50):
    for i in range(max_pages):
        try:
            result = fetch_fn()
            yield result
        except Exception as e:
            print(f"Blocco alla pagina {i}: {e}")
            # Ruota sessione e riprova
            time.sleep(30)
            continue
        time.sleep(3 + random.uniform(0, 2))  # 3–5 secondi con jitter

Logica di challenge-retry

Quando DataDome lancia una challenge, la risposta è tipicamente un HTTP 403 con un body HTML contenente "datadome" o un redirect a /dd/. La strategia di retry:

1. Rileva il blocco (status 403, 429, o redirect a DataDome).
2. Interrompi la sessione corrente.
3. Crea una nuova sessione con un nuovo ID sticky (user-session-abc{random}).
4. Ricarica la pagina HTML pubblica per ottenere nuovi cookie DataDome.
5. Riprova la query GraphQL.
6. Se fallisce 3 volte consecutive, pausa di 10–15 minuti.

Errori comuni e casi limite

• Usare requests invece di curl_cffi — la signature TLS di requests viene identificata immediatamente da DataDome. Usa sempre curl_cffi con impersonate="chrome".
• Dimenticare l'header gd-csrf-token — senza di esso, l'endpoint BFF restituisce 403 o 400.
• Ruotare IP a ogni richiesta — invalida i cookie DataDome. Usa sessioni sticky per batch di richieste correlate.
• Non inviare header Referer e Origin — Glassdoor verifica che la richiesta GraphQL provenga dal suo dominio.
• Ignorare il robots.txt — verifica sempre https://www.glassdoor.com/robots.txt prima di iniziare.
• Troncare il testo delle recensioni — le pagine pubbliche mostrano solo le prime righe. Il testo completo può richiedere login, che non è coperto da questa guida.

Configurazione specifica ProxyHat

Per configurare i proxy residenziali ProxyHat per il scraping di Glassdoor, consulta la documentazione ufficiale. I parametri chiave:

Parametro	Valore	Note
Gateway	gate.proxyhat.com	HTTP e SOCKS5
Porta HTTP	8080	Default per tutti gli esempi
Porta SOCKS5	1080	Per uso con client SOCKS5
Geo-targeting	user-country-US	IP statunitensi per Glassdoor US
Sessione sticky	user-session-{id}	Mantiene lo stesso IP
Città	user-country-US-city-newyork	Geo-targeting a livello città

Per casi d'uso correlati, vedi web scraping e SERP tracking. Per i prezzi, visita la pagina pricing.

Scraping etico e quando usare API ufficiali

Il scraping di Glassdoor solleva questioni etiche e legali significative. Ecco i principi da seguire:

1. Aggrega, non profilare

Le recensioni su Glassdoor sono anonime, ma combinando jobTitle, date e contenuto del testo, potresti teoricamente reidentificare un individuo. Limitati a dati aggregati: medie di valutazione per azienda/ruolo, distribuzione di pro/contro per topic, trend temporali. Non costruire profili individuali.

2. Non scrapearere dietro login

I dati dietro il wall di autenticazione (stipendi dettagliati, interviste complete, recensioni full-text) sono protetti da ToS e potenzialmente dal CFAA. L'accesso non autorizzato a contenuti dietro login è legalmente più rischioso dell'accesso a pagine pubbliche.

3. GDPR e dati dei dipendenti UE

Se la tua base operativa è nell'UE o elabori dati di dipendenti UE, il GDPR si applica. Le recensioni anonime possono comunque contenere dati personali indiretti (es. "sono l'unico Senior Data Engineer nell'ufficio di Milano"). Considera:

• Pseudonimizzazione dei dati estratti prima dell'archiviazione.
• Valutazione d'impatto (DPIA) se il trattamento è su larga scala.
• Base giuridica: l'interesse legittimo può applicarsi per ricerca di mercato, ma va documentato.

4. Quando usare un'API o licenza dati ufficiale

Se il tuo uso è commerciale, continuativo o ad alto volume, una licenza dati ufficiale di Glassdoor è quasi sempre l'opzione migliore. I vantaggi:

• Nessun rischio legale o di ToS.
• Dati completi, inclusi stipendi e interviste.
• Formato stabile e documentato.
• Supporto e SLA.

Il scraping ha senso per prototipi, ricerca accademica, o validazione di dati già licenziati. Per produzione commerciale, valuta prima la via ufficiale.

Punti chiave (Key Takeaways)

• Le pagine /Reviews/ di Glassdoor sono pubbliche e contengono recensioni troncate; i dati salariali completi sono dietro login e non vanno scrapati.
• Glassdoor usa DataDome + Cloudflare con fingerprinting TLS: curl_cffi con impersonate="chrome" è essenziale.
• Gli endpoint /graph e /bff/ restituiscono JSON strutturato ma richiedono gd-csrf-token e cookie DataDome validi.
• I proxy residenziali rotanti di ProxyHat (gate.proxyhat.com:8080) mantengono tassi di successo dell'85–95% contro DataDome.
• Usa sessioni sticky (user-session-{id}) per riutilizzare i cookie DataDome e ruota solo quando incontri blocchi.
• Pacing: 1 richiesta ogni 3–5 secondi, max 200–300 per sessione, jitter casuale.
• Per uso commerciale ad alto volume, una licenza dati ufficiale è quasi sempre preferibile al scraping.

FAQ

È legale scrapearere le recensioni pubbliche di Glassdoor?

L'accesso a pagine pubbliche di Glassdoor è tecnicamente possibile, ma la legalità dipende dalla giurisdizione e dall'uso. Negli USA, il CFAA può applicarsi ad accessi che superano misure tecniche di protezione. Nell'UE, il GDPR disciplina il trattamento di dati personali anche se pubblici. Consulta sempre i ToS della piattaforma e un legale prima di procedere. Per uso commerciale, una licenza dati ufficiale è l'opzione più sicura.

Quali proxy funzionano meglio per scrapearere Glassdoor?

I proxy residenziali rotanti sono la scelta migliore per Glassdoor perché DataDome assegna punteggi di rischio bassi agli IP ISP reali. I proxy datacenter vengono bloccati quasi immediatamente (tassi di successo 10–30%). I proxy mobile offrono tassi ancora più alti (90–98%) ma a costi superiori. ProxyHat offre tutti e tre i tipi tramite gate.proxyhat.com:8080 (HTTP) o :1080 (SOCKS5).

Come evitare i blocchi di DataDome su Glassdoor?

La combinazione vincente è: (1) curl_cffi con impersonate="chrome" per superare il fingerprinting TLS; (2) proxy residenziali con sessioni sticky per mantenere cookie DataDome validi; (3) pacing di 1 richiesta ogni 3–5 secondi con jitter; (4) rotazione IP solo quando incontri un 403 o redirect DataDome; (5) header browser realistici inclusi Referer, Origin e gd-csrf-token.

Cosa sono gli endpoint BFF GraphQL di Glassdoor?

Glassdoor usa un'architettura BFF (Backend-for-Frontend) con endpoint GraphQL su /graph e /bff/ che restituiscono JSON strutturato invece di HTML. Questi endpoint richiedono un header gd-csrf-token (estratto dalla pagina HTML iniziale) e cookie di sessione DataDome validi. Le query GraphQL permettono di specificare campi come ratingOverall, pros, cons e jobTitle, e usano paginazione basata su cursor.

Posso scrapearere i dati salariali di Glassdoor?

I dati salariali dettagliati su Glassdoor sono dietro un wall di autenticazione. Scrapearere contenuti dietro login viola quasi certamente i ToS della piattaforma e può esporti a responsabilità sotto il CFAA (USA) o normative equivalenti. Questa guida copre solo dati pubblici senza login. Per dati salariali completi, valuta una licenza dati ufficiale di Glassdoor.