Comment scraper les avis et salaires Glassdoor en 2026 : BFF GraphQL, DataDome et proxies

Avertissement légal : Cet article traite de l'accès à des données publiques sur Glassdoor à des fins d'analyse du marché du travail. Avant tout scraping, vérifiez les Conditions d'Utilisation de Glassdoor, le Computer Fraud and Abuse Act (CFAA) aux États-Unis, et le RGPD (GDPR) dans l'Union européenne. Le scraping derrière un mur d'authentification ou l'extraction de données à caractère personnel sans base légale est déconseillé et peut être illégal.

Vous êtes data engineer en RH-analytics ou en analyse du marché du travail, et vous avez besoin de données d'avis et de salaires Glassdoor à grande échelle. Le problème : Glassdoor protège ses pages avec DataDome et Cloudflare Bot Management, ce qui rend un simple requests.get() quasi impossible sans infrastructure adaptée. Ce guide explique comment scraper Glassdoor de manière fiable en 2026, du HTML public au BFF GraphQL, avec des proxies résidentiels rotatifs.

Comment scraper Glassdoor en 2026 : vue d'ensemble

Le paysage anti-bot de Glassdoor a évolué. En 2026, la plateforme combine plusieurs couches de protection : DataDome pour le scoring IP et comportemental, Cloudflare Bot Management pour les challenges JavaScript et l'empreinte TLS, et un endpoint BFF GraphQL non documenté qui nécessite un jeton CSRF spécifique. La bonne nouvelle : une grande partie des avis d'entreprise est accessible publiquement, et le BFF GraphQL renvoie du JSON structuré bien plus facile à parser que le HTML.

Données accessibles sans login vs derrière authentification

Voici ce que vous pouvez légitimement viser sans compte Glassdoor :

• Sans login : aperçu d'entreprise, avis tronqués (premiers ~200 caractères de pros/cons), notes globales, titres de poste, localisation. URL typique : /Reviews/<company>-Reviews-E<id>.htm.
• Derrière authentification : avis complets (texte intégral des pros/cons), ventilations salariales détaillées par poste/lieu, entretiens, photos. Nous ne couvrons pas le scraping derrière login dans ce guide.

La stratégie recommandée est donc de cibler les avis tronqués publics et les notes agrégées, qui suffisent pour la plupart des cas d'usage en analyse de marché du travail.

La pile anti-bot de Glassdoor : DataDome + Cloudflare + TLS

Glassdoor utilise DataDome comme protection principale contre les bots automatisés. DataDome analyse l'IP, les en-têtes HTTP, le comportement de navigation et les empreintes TLS/JS pour attribuer un score de risque. Au-dessus de DataDome, Cloudflare Bot Management ajoute un défi JavaScript et une vérification d'empreinte TLS.

Pourquoi requests ou httpx standard échoue : leur empreinte TLS (suite cryptographique, ordre des extensions, ALPN) ne ressemble pas à celle d'un vrai navigateur Chrome. DataDome et Cloudflare détectent immédiatement cette anomalie et renvoient un challenge (code HTTP 403 ou 503) ou une page CAPTCHA.

Pourquoi curl_cffi est indispensable

La bibliothèque Python curl_cffi utilise libcurl avec impersonation TLS Chrome. Elle reproduit fidèlement l'empreinte TLS de Chrome 120+, y compris la signature ClientHello, l'ordre des cipher suites et les extensions TLS. C'est le standard de fait pour contourner les détections basées sur TLS en 2026.

pip install curl_cffi proxyhat-sdk

Le BFF GraphQL de Glassdoor : endpoint non documenté

Glassdoor expose un endpoint BFF (Backend For Frontend) GraphQL que son application web appelle en interne. Bien qu'il ne soit pas documenté publiquement, il est observable via les DevTools du navigateur (onglet Network, filtre « graphql »). Les deux endpoints couramment observés sont :

• https://www.glassdoor.com/graph — endpoint GraphQL principal
• https://www.glassdoor.com/bff/ — endpoint BFF retournant du JSON structuré pour les avis

Ces endpoints attendent une requête POST avec :

• Un header Content-Type: application/json
• Un header gd-csrf-token — jeton CSRF généré côté client, souvent dérivé d'un cookie de session
• Des cookies DataDome valides (datadome cookie) pour prouver que le client a passé le challenge initial

Le BFF GraphQL renvoie les avis au format JSON avec des champs directement exploitables : ratingOverall, pros (tronqué), cons (tronqué), jobTitle, location, date. C'est bien plus robuste que le parsing HTML, car Glassdoor change fréquemment sa structure HTML mais garde son schéma GraphQL relativement stable.

Pourquoi les proxies résidentiels battent le scoring IP de DataDome

DataDome attribue un score de risque par IP. Les plages IP de datacenters (AWS, GCP, Hetzner, OVH) sont systématiquement flaggées comme suspectes, souvent avant même la première requête. Les proxies résidentiels utilisent des adresses IP attribuées par des FAI réels à des foyers réels, ce qui donne un score de risque faible à modéré.

La rotation d'IP à chaque requête empêche DataDome de corréler un volume anormal sur une seule IP. Cependant, une rotation trop agressive sans session persistante peut elle-même déclencher un flag. D'où l'importance des sticky sessions (voir section pagination ci-dessous).

Exemple Python : scraper les avis Glassdoor via le BFF GraphQL avec ProxyHat

Voici un exemple complet en Python utilisant curl_cffi pour l'impersonation TLS Chrome, et le proxy résidentiel ProxyHat via gate.proxyhat.com:8080. Cet exemple poste une requête GraphQL au BFF de Glassdoor pour récupérer un avis tronqué.

import json
import requests
# Alternative avec curl_cffi pour l'impersonation TLS :
# from curl_cffi import requests as cffi_requests

# --- Configuration ProxyHat (proxy résidentiel rotatif) ---
PROXYHAT_USER = "user-country-US-session-glassdoor01"
PROXYHAT_PASS = "votre_mot_de_passe"
PROXY_URL = f"http://{PROXYHAT_USER}:{PROXYHAT_PASS}@gate.proxyhat.com:8080"

proxies = {
    "http": PROXY_URL,
    "https": PROXY_URL,
}

# --- Headers requis pour le BFF GraphQL ---
headers = {
    "Content-Type": "application/json",
    "gd-csrf-token": "TOKEN_CSRF_EXTRAIT_DU_COOKIE",  # voir section ci-dessous
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
    "Accept": "application/json",
    "Referer": "https://www.glassdoor.com/",
}

# --- Requête GraphQL pour récupérer les avis d'une entreprise ---
graphql_payload = {
    "operationName": "EmployerReviews",
    "variables": {
        "employerId": 6036,  # exemple : ID Glassdoor de l'entreprise
        "page": 1,
        "pageSize": 10,
    },
    "query": """
        query EmployerReviews($employerId: Int!, $page: Int!, $pageSize: Int!) {
          employerReviews(employerId: $employerId, page: $page, pageSize: $pageSize) {
            reviews {
              ratingOverall
              pros
              cons
              jobTitle
              location
              date
            }
            totalReviews
            nextPageCursor
          }
        }
    """,
}

# --- Avec curl_cffi (recommandé pour Glassdoor) ---
# response = cffi_requests.post(
#     "https://www.glassdoor.com/bff/",
#     json=graphql_payload,
#     headers=headers,
#     proxies=proxies,
#     impersonate="chrome120",
#     timeout=30,
# )

# --- Version requests standard (peut être bloquée par DataDome) ---
response = requests.post(
    "https://www.glassdoor.com/bff/",
    json=graphql_payload,
    headers=headers,
    proxies=proxies,
    timeout=30,
)

data = response.json()

for review in data.get("data", {}).get("employerReviews", {}).get("reviews", []):
    print(f"Note globale : {review['ratingOverall']}/5")
    print(f"Poste : {review['jobTitle']}")
    print(f"Pros (tronqué) : {review['pros'][:150]}...")
    print(f"Cons (tronqué) : {review['cons'][:150]}...")
    print("---")

Note : En production, remplacez requests par curl_cffi (lignes commentées) pour bénéficier de l'impersonation TLS Chrome. Sans cela, DataDome bloquera probablement vos requêtes avec un 403 dès la première tentative sur une IP résidentielle non établie.

Extraction du gd-csrf-token

Le header gd-csrf-token est généralement dérivé d'un cookie de session Glassdoor. Pour l'obtenir sans login :

1. Faites une requête GET initiale sur /Reviews/<company>-Reviews-E<id>.htm via curl_cffi avec le proxy ProxyHat.
2. Récupérez les cookies de réponse, notamment gd_csrf_token ou un cookie similaire.
3. Injectez cette valeur dans le header gd-csrf-token pour les requêtes GraphQL ultérieures.

# Étape 1 : requête GET initiale pour obtenir les cookies
session = cffi_requests.Session(impersonate="chrome120")

initial_resp = session.get(
    "https://www.glassdoor.com/Reviews/Acme-Corp-Reviews-E6036.htm",
    proxies=proxies,
    timeout=30,
)

# Étape 2 : extraire le token CSRF du cookie jar
csrf_token = None
for cookie in session.cookies:
    if "csrf" in cookie.name.lower():
        csrf_token = cookie.value
        break

if not csrf_token:
    print("CSRF token non trouvé — possible challenge DataDome. "
          "Changez d'IP proxy et réessayez.")
else:
    headers["gd-csrf-token"] = csrf_token
    # Proceed avec la requête GraphQL ci-dessus...

Pagination, sticky sessions et pacing

Curseurs de pagination

Le BFF GraphQL de Glassdoor utilise un système de curseur (nextPageCursor) plutôt qu'une pagination par offset. Chaque réponse contient le curseur de la page suivante, à passer dans variables.cursor de la requête suivante. Si le curseur est null, vous avez atteint la dernière page.

Sessions sticky pour conserver les cookies DataDome

Le cookie datadome est lié à l'IP qui l'a obtenu. Si vous changez d'IP à chaque requête, DataDome invalidera le cookie et vous devrez repasser le challenge. Solution : utilisez une sticky session ProxyHat pour garder la même IP pendant une session de pagination complète (typiquement 10–50 pages), puis changez d'IP pour la série suivante.

# Sticky session : l'ID de session fixe l'IP
PROXYHAT_USER = "user-country-US-session-batch-001"
# Toutes les requêtes avec ce username utiliseront la MÊME IP résidentielle
# Pour changer d'IP : changez l'ID de session
# user-country-US-session-batch-002 → nouvelle IP

Avec ProxyHat, le flag -session-{id} dans le username garantit que toutes les requêtes utilisant le même ID sont routées via la même IP résidentielle. Changez l'ID de session pour obtenir une nouvelle IP.

Pacing et logique de retry

Glassdoor et DataDome imposent des limites de débit implicites. Recommandations pratiques :

• Délai entre requêtes : 2 à 5 secondes par requête sur une même sticky session. Plus rapide = risque de blocage.
• Rotation de session : toutes les 20–30 requêtes, changez d'ID de session pour obtenir une nouvelle IP résidentielle.
• Retry sur challenge : si vous recevez un 403/503 ou une page contenant « datadome » dans le corps, attendez 10–30 secondes, changez de session (nouvelle IP) et réessayez. Maximum 3 retries par requête.
• Limite horaire : ~200–300 requêtes par sticky session par heure est un ordre de grandeur raisonnable pour rester sous le radar.

import time
import random

def scrape_reviews_with_retry(employer_id, max_pages=50):
    session_id = f"glassdoor-batch-{int(time.time())}"
    all_reviews = []
    cursor = None
    retries = 0
    page = 1

    while page <= max_pages:
        proxy_user = f"user-country-US-session-{session_id}"
        proxy_url = f"http://{proxy_user}:pass@gate.proxyhat.com:8080"

        payload = build_graphql_payload(employer_id, page, cursor)

        try:
            resp = cffi_requests.post(
                "https://www.glassdoor.com/bff/",
                json=payload,
                headers=headers,
                proxies={"https": proxy_url},
                impersonate="chrome120",
                timeout=30,
            )

            if resp.status_code in (403, 503):
                print(f"Challenge détecté (HTTP {resp.status_code}). "
                      f"Rotation d'IP...")
                session_id = f"glassdoor-batch-{int(time.time())}-r{retries}"
                retries += 1
                if retries >= 3:
                    print("Max retries atteint. Abandon de cette page.")
                    break
                time.sleep(random.uniform(10, 30))
                continue

            data = resp.json()
            reviews = data["data"]["employerReviews"]["reviews"]
            all_reviews.extend(reviews)
            cursor = data["data"]["employerReviews"]["nextPageCursor"]

            if not cursor:
                print("Fin de pagination atteinte.")
                break

            page += 1
            retries = 0
            time.sleep(random.uniform(2, 5))

        except Exception as e:
            print(f"Erreur : {e}. Retry dans 15s...")
            time.sleep(15)
            retries += 1
            if retries >= 3:
                break

    return all_reviews

Exemple Node.js : requête GraphQL via ProxyHat

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

const proxyUser = 'user-country-US-session-node-batch01';
const proxyUrl = `http://${proxyUser}:pass@gate.proxyhat.com:8080`;
const agent = new HttpsProxyAgent(proxyUrl);

const graphqlPayload = {
  operationName: 'EmployerReviews',
  variables: {
    employerId: 6036,
    page: 1,
    pageSize: 10,
  },
  query: `query EmployerReviews($employerId: Int!, $page: Int!, $pageSize: Int!) {
    employerReviews(employerId: $employerId, page: $page, pageSize: $pageSize) {
      reviews { ratingOverall pros cons jobTitle location date }
      totalReviews
      nextPageCursor
    }
  }`,
};

async function scrapeGlassdoorReviews() {
  const resp = await fetch('https://www.glassdoor.com/bff/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'gd-csrf-token': process.env.GD_CSRF_TOKEN,
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    },
    body: JSON.stringify(graphqlPayload),
    agent,
  });

  const data = await resp.json();
  const reviews = data.data.employerReviews.reviews;
  reviews.forEach(r => {
    console.log(`${r.jobTitle} — ${r.ratingOverall}/5`);
    console.log(`Pros: ${r.pros.substring(0, 100)}...`);
  });
}

scrapeGlassdoorReviews().catch(console.error);

Note : Pour Node.js, l'impersonation TLS native n'est pas disponible avec node-fetch. En production, envisagez d'utiliser Playwright avec un proxy ProxyHat pour passer les challenges DataDome côté navigateur, puis intercepter les requêtes GraphQL via page.route().

Erreurs courantes et cas limites

• Utiliser des proxies datacenter : DataDome flagge les IP datacenter dans ~90% des cas. Utilisez des résidentiels.
• Changer d'IP à chaque requête sans session : le cookie datadome devient invalide. Utilisez des sticky sessions de 20–30 requêtes.
• Ignorer l'empreinte TLS : requests et httpx ont une empreinte Python, pas Chrome. Utilisez curl_cffi avec impersonate="chrome120".
• Scraping trop rapide : plus de 1 requête/seconde sur une même session augmente le risque de blocage. Visez 2–5 secondes.
• CSRF token expiré : le token gd-csrf-token a une durée de vie limitée (souvent ~30 minutes). Régénérez-le périodiquement via une requête GET initiale.
• Structure GraphQL modifiée : Glassdoor peut changer les noms d'operations ou de champs. Surveillez les erreurs GraphQL dans les réponses et adaptez vos queries.

Configuration ProxyHat et liens utiles

Pour configurer vos proxies résidentiels ProxyHat, consultez la documentation officielle. Les points clés :

• Gateway : gate.proxyhat.com, port HTTP 8080, port SOCKS5 1080.
• Géo-ciblage : user-country-US pour les États-Unis, user-country-DE pour l'Allemagne, etc.
• Sticky session : user-session-{id} dans le username fixe l'IP pour la durée de la session.
• Combinaison : user-country-US-session-batch001:pass@gate.proxyhat.com:8080

Consultez également :

• Tarifs ProxyHat — plans de proxies résidentiels et datacenter
• Cas d'usage : web scraping — patterns de scraping à grande échelle
• Cas d'usage : SERP tracking — suivi des résultats de recherche
• Localisations ProxyHat — 195+ pays disponibles

Scraping éthique et quand utiliser une API officielle

Le scraping de Glassdoor soulève des questions éthiques et légales importantes :

Principes à respecter

• Agrégation uniquement : collectez des données agrégées et non personnelles (notes moyennes, distributions de salaires par poste). Évitez de stocker des avis identifiant nommément des individus.
• Pas de scraping derrière login : les données derrière authentification (avis complets, salaires détaillés) sont soumis aux Conditions d'Utilisation de Glassdoor. Les extraire sans autorisation viole probablement ces conditions et potentiellement le CFAA.
• RGPD pour les données UE : les avis d'employés européens peuvent contenir des données à caractère personnel. Le RGPD s'applique même aux données publiquement accessibles. Anonymisez systématiquement (suppression des noms, pseudonymisation des titres de poste si identifiables).
• Respect du robots.txt : vérifiez https://www.glassdoor.com/robots.txt et respectez les directives Disallow.
• Limitation du volume : ne saturiez pas l'infrastructure de Glassdoor. Un pacing raisonnable (200–300 requêtes/heure par session) est un maximum éthique.

Quand une licence de données officielle est préférable

Pour les cas d'usage commerciaux à grande échelle (plateformes d'analyse RH, produits SaaS de benchmarking salarial), une licence de données Glassdoor ou l'utilisation de partenaires data agréés est la voie la plus sûre. Glassdoor propose des programmes de partenariat data pour les entreprises. Avantages :

• Accès légal aux données complètes, y compris salaires détaillés
• Pas de risque de blocage IP ou de poursuite légale
• Données structurées, fiables et mises à jour en temps réel
• Conformité RGPD/CCPA gérée par le fournisseur

Le scraping doit être réservé aux cas où : (1) vous n'avez besoin que de données publiques agrégées, (2) le volume est modeste, (3) aucune API officielle ou licence n'est disponible ou économiquement viable, et (4) vous respectez toutes les lois applicables.

Points clés à retenir

Key Takeaways :

• Les avis tronqués et notes agrégées de Glassdoor sont accessibles publiquement sans login ; les salaires détaillés et avis complets sont derrière authentification — ne les scrapez pas.
• DataDome + Cloudflare Bot Management exigent l'impersonation TLS Chrome via curl_cffi — requests standard est insuffisant.
• Le BFF GraphQL (/bff/ ou /graph) renvoie du JSON structuré et nécessite un header gd-csrf-token valide.
• Les proxies résidentiels rotatifs ProxyHat avec sticky sessions (flag -session-{id}) offrent le meilleur équilibre entre fiabilité et coût.
• Pacing recommandé : 2–5 secondes par requête, rotation d'IP toutes les 20–30 requêtes, maximum ~300 requêtes/heure par session.
• Pour un usage commercial à grande échelle, une licence de données officielle est la solution la plus sûre et la plus durable.

FAQ

Les questions ci-dessous sont également disponibles en données structurées (schema.org FAQPage) pour les moteurs de recherche.

Qu'est-ce que le scraping Glassdoor et est-ce légal ?

Le scraping Glassdoor consiste à extraire automatiquement des données publiques (avis tronqués, notes, aperçus d'entreprise) via des requêtes HTTP programmées. La légalité dépend de la juridiction : aux États-Unis, le CFAA peut s'appliquer ; dans l'UE, le RGPD régule le traitement des données personnelles même publiques. Le scraping de données publiquement accessibles sans login est généralement moins risqué, mais il faut toujours respecter les Conditions d'Utilisation de Glassdoor et consulter un conseiller juridique.

Pourquoi les proxies sont-ils nécessaires pour scraper Glassdoor ?

Glassdoor utilise DataDome et Cloudflare Bot Management, qui détectent et bloquent les requêtes automatisées via le scoring d'IP, l'empreinte TLS et l'analyse comportementale. Sans proxy résidentiel rotatif, votre IP est bloquée après quelques requêtes. Les proxies résidentiels fournissent des adresses IP de FAI réels avec un faible score de risque, permettant de distribuer les requêtes sur de nombreuses IP pour rester sous les seuils de détection de DataDome.

Quel type de proxy fonctionne le mieux pour scraper Glassdoor ?

Les proxies résidentiels rotatifs sont le meilleur choix pour Glassdoor. Ils offrent des adresses IP attribuées par des FAI réels, ce qui donne un score de risque DataDome faible à modéré. Les proxies datacenter sont quasi-systématiquement bloqués. Les proxies mobiles sont excellents mais coûteux — réservez-les pour les challenges difficiles. Avec ProxyHat, utilisez les sticky sessions (flag -session-{id}) pour conserver la même IP pendant une session de pagination complète.

Comment éviter les blocages DataDome et Cloudflare sur Glassdoor ?

Combinez quatre stratégies : (1) utilisez curl_cffi avec impersonate="chrome120" pour reproduire l'empreinte TLS de Chrome ; (2) routez vos requêtes via des proxies résidentiels rotatifs ProxyHat avec sticky sessions de 20–30 requêtes ; (3) maintenez un pacing de 2–5 secondes entre requêtes sur une même session ; (4) implémentez une logique de retry qui change d'IP (nouvel ID de session) en cas de 403/503, avec un délai de 10–30 secondes avant retry.

Peut-on scraper les données salariales détaillées de Glassdoor ?

Les données salariales détaillées de Glassdoor (ventilations par poste, lieu, expérience) sont derrière un mur d'authentification. Les scraper nécessite de se connecter avec un compte, ce qui viole probablement les Conditions d'Utilisation de Glassdoor et peut être illégal au titre du CFAA. Ce guide ne couvre que les données publiques sans login (avis tronqués, notes agrégées). Pour les données salariales complètes, envisagez une licence de données officielle Glassdoor ou un partenaire data agréé.