Om din Glassdoor-scraper fungerade klockrent 2022 men nu bara spottar ur sig 403-fel, är du verkligen inte ensam. I forum trillar samma fråga in gång på gång: "Vet någon varför den här scrapen inte fungerar längre?"
Det korta svaret är att Glassdoor har ändrat i princip allt. Recruit Holdings slog ihop Glassdoor med Indeed i juli 2025, sade upp 1 300 anställda, och stramade åt bottenskyddet så hårt att vanliga Selenium-baserade och requests-baserade scrapers blockeras redan innan första HTML-svaret hinner laddas. I februari 2026 hanteras Glassdoor-inloggningar helt via Indeed Login — så varje guide som hårdkodar ett Glassdoor-specifikt inloggningsformulär är i praktiken redan trasig från start. Samtidigt finns det fortfarande över 180 miljoner samlade omdömen, löner och insikter från 2,5 miljoner arbetsgivare. Den datan är otroligt värdefull för HR-benchmarking, konkurrensbevakning och prospektering — om du lyckas komma åt den. Den här guiden är versionen som faktiskt fungerar efter alla dessa förändringar, och den täcker alla tre Glassdoor-datatyperna (jobb, omdömen OCH löner) på ett och samma ställe. Jag går igenom Python-upplägget med fungerande kod för 2025, förklarar exakt vad som stoppar dig och hur du tar dig förbi det, och visar dessutom en no-code-genväg för dig som helst vill slippa bygga allt själv.
Varför skrapa Glassdoor med Python 2025?
Glassdoor är mycket mer än en vanlig platsbank. Det är en av webben mest innehållsrika datakällor för arbetsgivarinsikter — använd av ungefär en tredjedel av Fortune 500-bolagen och med omkring 55 miljoner unika besökare per månad. Informationen bakom sidorna används för riktiga affärsbeslut i flera olika team.
Så här används Glassdoor-data i praktiken:
| Användningsområde | Typ av data som behövs | Vem gynnas |
|---|---|---|
| Lönjämförelser | Lönefördelningar, antal datapunkter | HR, Total Rewards, Operations |
| Spårning av konkurrenters rekrytering | Platsannonser, publiceringstakt | Sales, Strategy, VC/Corp Dev |
| Övervakning av employer brand | Omdömestext, rating-trender, VD-godkännande | HR, Marketing, Communications |
| Leadgenerering (växande bolag) | Platsannonser + företagsinfo | Säljteam, SDR:er |
| Marknads- och akademisk research | Alla tre | Analytiker, konsulter, forskare |
När BLS inte kunde publicera jobbsiffror under den amerikanska nedstängningen i oktober 2025, publicerade Glassdoors eget Economic Research-team en alternativ jobbrapport baserad på sin egen data. Så pass seriöst tar institutionella analytiker den här datan i dag.
Python är fortfarande förstahandsvalet eftersom ekosystemet är svårt att slå — Playwright för webbläsarautomation, parsel/lxml för parsing, curl_cffi för att kringgå TLS-fingerprinting, och ett enormt community som delar fungerande upplägg. Problemet är inte Python. Problemet är att Glassdoor har blivit betydligt knepigare att skrapa.
Skrapa Glassdoor-data med AI Get Started Free
Om du vill ha ett no-code-alternativ för att extrahera data från Glassdoor kan Thunderbit hjälpa dig att hämta jobb, omdömen och lönesidor utan att bygga och underhålla en egen Python-stack.
Vilken Glassdoor-data kan du faktiskt skrapa?
De flesta guider täcker bara platsannonser. Men det som användare faktiskt efterfrågar mest — utifrån foruminlägg, GitHub-ärenden och Reddit-frågor jag följt — är de två datatyper som nästan ingen lär ut: omdömen och löner. Här är hela bilden av vad som går att extrahera i alla tre kategorierna.
Platsannonser
Den mest lättillgängliga datatypen. Du kan hämta: jobbtitel, företagsnamn, plats, löneestimat, företagsbetyg, publiceringsdatum, badge för enkel ansökan och länken till jobbet. Platsannonser finns delvis tillgängliga utan inloggning, även om Glassdoor kan visa en inloggningsruta efter några sidor.
Företagsomdömen
Här blir det riktigt intressant för analys av employer brand. Fält som går att extrahera inkluderar: totalbetyg, delbetyg (work-life balance, kultur & värderingar, mångfald & inkludering, karriärmöjligheter, ersättning & förmåner, ledning), text med fördelar, text med nackdelar, recensentens jobbtitel, datum för omdömet och anställningsstatus. Fullständig omdömestext kräver inloggning — du ser ett utdrag, men hela pros/cons är låsta bakom autentisering.
Lönedata
Den mest efterfrågade och mest frustrerande datatypen. Du kan extrahera: jobbtitel, grundlöneintervall, total kompensation, antal lönerapporter och plats. Men lönesidorna kräver alltid inloggning, och Glassdoor lägger ibland dessutom på ett flöde där du måste bidra med din egen lön för att låsa upp andras. Ingen konkurrerande guide visar fungerande kod för detta — det gör vi här.
Vad kräver inloggning och vad gör det inte?
Den här tabellen sparar dig från att upptäcka på det hårda sättet vilka sidor som bara kommer att ge tom data:
| Datatyp | Tillgänglig utan inloggning? | Kommentarer |
|---|---|---|
| Jobbtitlar och grundinfo i annonser | Oftast ja | Popup kan dyka upp efter några sidor |
| Fullständiga jobbeskrivningar | Delvis | Ofta låst efter 2–3 visningar |
| Företagsomdömen (full text) | Nej — inloggning krävs | Utdrag syns, full text är låst |
| Lönedata | Nej — inloggning krävs | Kan även kräva "contribute to unlock" |
Varför din gamla Glassdoor-scraper troligen är trasig
Jag vill vara tydlig här: om du kopierar kod från en guide från 2021–2023 kommer den inte att fungera. Den mest stjärnmärkta äldre Glassdoor-Selenium-scrapern på GitHub (MatthewChatham/glassdoor-review-scraper, cirka 1,4k stjärnor) har 12+ öppna, olösta problem — inklusive "Glassdoor new UI design", "Cloudflare anti-bot protection" och "NoSuchElementException". Repot är i praktiken övergivet. Apifys glassdoor-jobs-scraper actor är markerad som DEPRECATED. ScrapeOps bedömer Glassdoor till 9/10 i total scrapping-svårighet och 8/10 i kringgåendesvårighet.
Det här är vad som har ändrats och varför gammal kod går sönder:
| Försvarslager | Vad som ändrats | Effekt på gamla scrapers |
|---|---|---|
| Cloudflare Bot Management | Striktare JA3/JA4-fingerprinting sedan 2024 | Enkla requests-/Selenium-skript får 403 direkt |
| Dynamiska CSS-klassnamn | Klassnamn slumpas om vid varje build | Gamla CSS-selectors från guider slutar fungera tyst |
| Rate limiting + sessionsspårning | Strängare gränser per IP och session | Scrapers blockeras efter färre sidor |
| CAPTCHA-utmaningar (troligen Cloudflare Turnstile) | Vanligare, särskilt vid paginering | Headless-browsers triggar utmaningar |
| Utökad inloggningsvägg | Fler sidtyper kräver autentisering | Löne- och omdömessidor ger tom data |
| Flytt till Indeed Login (feb 2026) | Glassdoors inloggningsformulär är helt ersatt | Kod som riktar sig mot gamla inloggnings-DOM:en är död |
Scrapflys guide från 2026 innehåller en tydlig varning: "Glassdoor is known for its high blocking rate, so if you get None values while running the Python code, it's likely you're getting blocked." Och ett DEV.to-inlägg från mars 2026 säger det rakt ut: "Simple HTTP requests with requests or httpx get blocked instantly."
Motåtgärderna jag visar dig — Patchright (en stealth-fork av Playwright), väljare baserade på data-test, roterande residential proxies och autentiserade persistenta sessioner — är specifikt framtagna för att hantera just dessa lager.
Glassdoor API vs. Python-scraping: välj rätt metod först
Många forumtrådar frågar: "Ska jag bara använda Glassdoor API?" — och svaret är: det går inte.
Det gamla Glassdoor Partner API:t är stängt för nya ansökningar. Utvecklarportalen finns fortfarande tekniskt sett kvar men returnerar HTTP 403. Det fanns aldrig något publikt omdömes-endpoint — MatthewChathams scraper skapades uttryckligen "because Glassdoor doesn't have an API for reviews." Och det finns ingen migreringsväg för omdömen eller löner via Indeeds Publisher API.
Här är den ärliga jämförelsen:
| Faktor | Glassdoor Partner API v1 | Python-scraping | Thunderbit (no-code) |
|---|---|---|---|
| Åtkomst | Stängt för nya ansökningar | Öppet (du bygger själv) | Chrome-tillägg |
| Platsannonser | Begränsat/avvecklat | Tillgängligt med arbete | Tillgängligt |
| Företagsomdömen | Fanns aldrig publikt | Ja (inloggning krävs) | Ja (via Browser Mode) |
| Lönedata | Fanns aldrig publikt | Ja (inloggning krävs) | Ja |
| Rate limits | Ej dokumenterade | Du styr takten själv | Kreditbaserat |
| Uppstartstid | Går inte att registrera nya appar | Några timmar till dagar | ~2 minuter |
| Underhåll | N/A | Hög (HTML-ändringar bryter kod) | Låg (AI föreslår fält igen) |
Om du behöver omdömen eller lönedata — och de flesta som läser detta gör det — är Python-scraping eller ett no-code-verktyg i praktiken dina enda realistiska alternativ.
Innan du börjar
- Svårighetsgrad: Medel (du bör vara bekväm med Python och terminalen)
- Tidsåtgång: Cirka 30–60 minuter för hela setupen; därefter ~10 minuter per datatyp
- Det du behöver:
- Python 3.10+ (3.11 eller 3.12 rekommenderas)
- Chrome installerat
- Ett Glassdoor-konto (gratis — krävs för lönedata och omdömen)
- Roterande residential proxies (för att skrapa mer än ett fåtal sidor)
- Valfritt: Thunderbit Chrome Extension om du vill ha no-code-vägen
Verktyg och bibliotek för att skrapa Glassdoor med Python 2025
Verktygslandskapet har förändrats kraftigt. Här är det som faktiskt fungerar mot Glassdoors nuvarande skydd.
Varför Patchright är det bästa valet för Glassdoor
Patchright är en stealth-fork av Playwright som patchar Runtime.Enable-CDP-läckan — den specifika tekniska orsak till att vanliga Playwright misslyckas på Cloudflare-skyddade sajter. Den använder exakt samma API som Playwright, så kan du Playwright kan du Patchright. Version 1.58.2 (mars 2026) är aktuell och aktivt underhållen.
Jämfört med alternativen:
- Vanilla Playwright: Blir upptäckt på Glassdoors inloggningssida på grund av Runtime.Enable-läckan
- Selenium + undetected-chromedriver: undetected-chromedrivers senaste release kom i februari 2024 — den är i praktiken legacy. Scrapflys benchmark visade att den "failed on every domain in our test"
- requests + BeautifulSoup: Kan inte rendera JavaScript och blockeras direkt av Cloudflares TLS-fingerprinting
- curl_cffi: Utmärkt för snabbspåret (10–20x snabbare än en webbläsare) när sidor levererar
__NEXT_DATA__i den initiala HTML:en, men klarar inte inloggning eller mellanliggande utmaningar
Stödjande bibliotek
- parsel (1.11.0) eller lxml (6.0.4): Snabb HTML/XPath-parsing
- csv eller pandas: Export av data
- asyncio: Asynkron scraping för snabbare paginering
Proxies: endast residential
Glassdoors Cloudflare-lager utmanar datacenter-ASN:er aggressivt. Residential proxies sägs sänka blockningsgraden från 20–30% till under 5%. Startpriser ligger runt $1,75/GB från IPRoyal (kampanj) eller $3,00/GB från Decodo. För produktion bör du räkna med $3–8/GB beroende på volym.
Slumpmässiga pauser mellan förfrågningar (minst 3–8 sekunder, 5–15 sekunder för längre körningar) är nödvändiga oavsett proxy-kvalitet.
Steg 1: Sätt upp din Python-miljö
Skapa projektmappen och installera den rekommenderade stacken:
mkdir glassdoor-scraper && cd glassdoor-scraper
python3.11 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
# Core stack
pip install patchright==1.58.2 parsel==1.11.0
# Install browser binaries
patchright install chromium
# Optional: fast path for __NEXT_DATA__ extraction
pip install "curl_cffi==0.15.0"
Du bör se Patchright ladda ned en Chromium-binär. Om patchright install chromium misslyckas, kontrollera att du har tillräckligt med diskutrymme (~300 MB) och att din Python-version är 3.10+.
Steg 2: Starta Patchright och navigera till Glassdoor
Här är det grundläggande startmönstret som fungerar mot Glassdoors Cloudflare-lager:
from patchright.sync_api import sync_playwright
import random, time
with sync_playwright() as p:
browser = p.chromium.launch(
headless=False, # headless är fortfarande lättare att upptäcka
channel="chrome", # använd riktig Chrome, inte den medföljande Chromium
)
context = browser.new_context(
viewport={"width": 1440, "height": 900},
locale="en-US",
timezone_id="America/New_York",
user_agent=(
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/134.0.0.0 Safari/537.36"
),
)
page = context.new_page()
page.goto(
"https://www.glassdoor.com/Job/new-york-data-engineer-jobs-"
"SRCH_IL.0,8_IC1132348_KO9,22.htm"
)
# Dölj inloggningsöverlägget — innehållet finns fortfarande i DOM:en
page.add_style_tag(content="""
#HardsellOverlay, .LoginModal { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
page.wait_for_selector("[data-test='jobListing']")
print("Sidan laddades — platsannonserna syns.")
Några saker att notera här. Flaggan channel="chrome" säger åt Patchright att använda din installerade Chrome-binär i stället för den medföljande Chromium — det ger en mer autentisk webbläsarfingerprint. Tricket med add_style_tag döljer Glassdoors inloggningsmodal (kallad #HardsellOverlay) utan att du klickar på något. Scrapfly bekräftar att "all of the content is still there, it's just covered up by the overlay" — HTML-koden innehåller datan oavsett om modalrutan visas eller inte.
Du bör se ett Chrome-fönster öppnas, gå till Glassdoors söksida för jobb och visa kort med platsannonser utan att inloggningspopupen blockerar vyn.
Steg 3: Skrapa Glassdoors platsannonser
Identifiera stabila selectors
Glassdoor slumpmässar CSS-klassnamn vid varje build — så .jobCard_xyz123-selectorn från en guide från 2023 kommer att ge tomt resultat i dag utan att säga ifrån. Använd i stället data-test-attribut, som är Glassdoors interna QA-konvention och tenderar att vara stabila mellan deploymentar.
Här är selector-referensen för fält i platsannonser:
| Fält | Selector |
|---|---|
| Container för jobbkort | [data-test="jobListing"] |
| Jobbtitel | [data-test="job-title"] |
| Jobblänk | a[data-test="job-link"] |
| Företagsnamn | [data-test="employer-name"] |
| Plats | [data-test="emp-location"] |
| Löneintervall | [data-test="detailSalary"] |
| Företagsbetyg | [data-test="rating"] |
| Publiceringsdatum | [data-test="job-age"] |
| Nästa sida i paginering | [data-test="pagination-next"] |
Extrahera jobbinformation
from parsel import Selector
import csv, random, time
def scrape_jobs(page, max_pages=5):
all_jobs = []
for page_num in range(1, max_pages + 1):
html = page.content()
sel = Selector(text=html)
cards = sel.css('[data-test="jobListing"]')
if not cards:
print(f"Sida {page_num}: Inga kort hittades — möjligt block eller ändrad selector.")
break
for card in cards:
job = {
"title": card.css('[data-test="job-title"]::text').get("").strip(),
"company": card.css('[data-test="employer-name"]::text').get("").strip(),
"location": card.css('[data-test="emp-location"]::text').get("").strip(),
"salary": card.css('[data-test="detailSalary"]::text').get("").strip(),
"rating": card.css('[data-test="rating"]::text').get("").strip(),
"link": card.css('a[data-test="job-link"]::attr(href)').get(""),
"posted": card.css('[data-test="job-age"]::text').get("").strip(),
}
if job["link"] and not job["link"].startswith("http"):
job["link"] = "https://www.glassdoor.com" + job["link"]
all_jobs.append(job)
print(f"Sida {page_num}: skrapade {len(cards)} jobb")
# Paginering
next_btn = page.query_selector('[data-test="pagination-next"]')
if next_btn and page_num < max_pages:
next_btn.click()
time.sleep(random.uniform(3, 8))
page.wait_for_selector("[data-test='jobListing']")
else:
break
return all_jobs
Spara till CSV
def save_to_csv(jobs, filename="glassdoor_jobs.csv"):
if not jobs:
print("Inga jobb att spara.")
return
keys = jobs[0].keys()
with open(filename, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=keys)
writer.writeheader()
writer.writerows(jobs)
print(f"Sparade {len(jobs)} jobb till {filename}")
En viktig sak om pagineringsgränser: Glassdoor begränsar sökresultat till ungefär 30 sidor oavsett total mängd. Om du behöver mer täckning bör du använda filter (plats, jobbkategori, löneintervall) för att smalna av varje sökning i stället för att försöka paginera förbi gränsen.
I mina tester tog det runt 45 sekunder att skrapa 5 sidor med platsannonser (ungefär 75 jobb) med slumpmässiga pauser. Att göra samma sak manuellt hade tagit minst 20 minuter av copy-paste.
Steg 4: Skrapa Glassdoors företagsomdömen
Det här är avsnittet som ingen annan guide ger fungerande kod för. Omdömen är där den verkliga arbetsgivarintelligensen finns — sentimentanalys, signaler om kultur och varningsflaggor kring ledning.
Navigera till omdömessidan
URL:er för omdömen följer mönstret: /Reviews/{Company}-Reviews-E{id}.htm. Du hittar arbetsgivar-ID genom att söka efter ett företag på Glassdoor och titta på URL:en.
def navigate_to_reviews(page, company_reviews_url):
page.goto(company_reviews_url)
page.add_style_tag(content="""
#HardsellOverlay, .LoginModal { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
page.wait_for_selector('[data-test="review"]', timeout=15000)
Det dolda BFF-endpointet (den renaste vägen)
Här är den största upptäckten i min research: Glassdoor-omdömen har ett fungerande internt JSON-API som helt kringgår HTML-parsning. Scrapflys scraper-repo dokumenterar detta endpoint, och det är betydligt mer tillförlitligt än DOM-scraping.
import json, re, requests
def get_review_ids(page):
"""Hämta employerId och dynamicProfileId från HTML-koden på omdömessidan."""
html = page.content()
sel = Selector(text=html)
script_text = sel.xpath(
"//script[contains(text(), 'profileId')]/text()"
).get("")
employer_match = re.search(r'"employer"\s*:\s*(\{[^}]+\})', script_text)
if employer_match:
meta = json.loads(employer_match.group(1))
return meta.get("id"), meta.get("profileId")
return None, None
def fetch_reviews_bff(page, employer_id, profile_id, max_pages=5):
"""Anropa Glassdoors interna BFF-endpoint för strukturerad omdömesdata."""
all_reviews = []
cookies = {c["name"]: c["value"] for c in page.context.cookies()}
for pg in range(1, max_pages + 1):
payload = {
"applyDefaultCriteria": True,
"employerId": employer_id,
"dynamicProfileId": profile_id,
"employmentStatuses": ["REGULAR", "PART_TIME"],
"language": "eng",
"onlyCurrentEmployees": False,
"page": pg,
"pageSize": 10,
"sort": "DATE",
"textSearch": "",
}
resp = requests.post(
"https://www.glassdoor.com/bff/employer-profile-mono/employer-reviews",
json=payload,
cookies=cookies,
headers={"Content-Type": "application/json"},
)
if resp.status_code != 200:
print(f"BFF returnerade {resp.status_code} på sida {pg}")
break
data = resp.json()
reviews = data.get("data", {}).get("employerReviews", {}).get("reviews", [])
total_pages = data.get("data", {}).get("employerReviews", {}).get("numberOfPages", 1)
for r in reviews:
all_reviews.append({
"title": r.get("summary", ""),
"rating": r.get("ratingOverall"),
"pros": r.get("pros", ""),
"cons": r.get("cons", ""),
"author_role": r.get("jobTitle", {}).get("text", ""),
"date": r.get("reviewDateTime", ""),
"recommend": r.get("isRecommend"),
})
print(f"Omdömessida {pg}/{total_pages}: fick {len(reviews)} omdömen")
if pg >= total_pages:
break
time.sleep(random.uniform(3, 6))
return all_reviews
BFF-endpointet ger dig ren JSON med alla omdömesfält — ingen HTML-parsing, inga trasiga CSS-selectors. Du behöver sessionscookies från en autentiserad Playwright-context (beskrivs i steg 6 nedan), och du behöver först extrahera employerId och dynamicProfileId från HTML-koden på omdömessidan.
HTML-fallback-selectors för omdömen
Om BFF-endpointet ändras eller om du föredrar DOM-parsing, här är de stabila data-test-selectorerna:
| Fält | Selector |
|---|---|
| Container för omdöme | [data-test="review"] |
| Rubrik | [data-test="review-title"] |
| Totalbetyg | [data-test="overall-rating"] |
| Fördelar | [data-test="pros"] |
| Nackdelar | [data-test="cons"] |
| Datum | [data-test="review-date"] |
| Författarens roll | [data-test="author-jobTitle"] |
Steg 5: Skrapa Glassdoors lönedata
Lönesidorna är helt låsta bakom inloggning. Du måste ha en autentiserad session (steg 6) innan någon av dessa koder faktiskt returnerar riktig data.
Navigera till lönesidan
Löne-URL:er följer mönstret: /Salary/{Company}-Salaries-E{id}.htm, med paginering som _P{n}.htm.
def scrape_salaries(page, salary_url, max_pages=3):
all_salaries = []
for pg in range(1, max_pages + 1):
url = salary_url if pg == 1 else salary_url.replace(".htm", f"_P{pg}.htm")
page.goto(url)
page.add_style_tag(content="""
#HardsellOverlay { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
time.sleep(random.uniform(3, 7))
html = page.content()
sel = Selector(text=html)
items = sel.css('[data-test="salary-item"]')
if not items:
print(f"Lönesida {pg}: Inga objekt — möjligt inloggningslås eller blockering.")
break
for item in items:
salary = {
"job_title": item.css('[class*="SalaryItem_jobTitle__"]::text').get("").strip(),
"salary_range": item.css('[class*="SalaryItem_salaryRange__"]::text').get("").strip(),
"count": item.css('[class*="SalaryItem_salaryCount__"]::text').get("").strip(),
}
all_salaries.append(salary)
print(f"Lönesida {pg}: skrapade {len(items)} poster")
return all_salaries
Observera prefix-match-mönstret [class*="SalaryItem_jobTitle__"]. Glassdoors lönesida använder CSS-modul-hashade klassnamn (t.ex. SalaryItem_jobTitle__XWGpT) där hash-suffixet ändras vid varje deploy. Prefixet förblir stabilt — inte hashen. Hårdkoda aldrig hela klassnamnet.
Steg 6: Kom förbi Glassdoors inloggningsvägg
Det här är den kritiska delen som låser upp lönedata och fullständig omdömestext. Upplägget: logga in manuellt en gång i en synlig webbläsare, spara den autentiserade sessionsstatusen och återanvänd den sedan för alla efterföljande scraping-körningar.
Spara din autentiserade session
Kör det här skriptet en gång. Det öppnar ett Chrome-fönster, går till Glassdoors inloggningssida (som nu omdirigerar till Indeed Login) och väntar på att du loggar in manuellt:
import asyncio
from pathlib import Path
from patchright.async_api import async_playwright
STATE_FILE = Path("glassdoor_state.json")
async def login_and_save():
async with async_playwright() as p:
browser = await p.chromium.launch(headless=False, channel="chrome")
context = await browser.new_context(
viewport={"width": 1366, "height": 800},
locale="en-US",
)
page = await context.new_page()
await page.goto("https://www.glassdoor.com/profile/login_input.htm")
print("Logga in i webbläsarfönstret och tryck sedan Enter här...")
input()
await context.storage_state(path=str(STATE_FILE))
print(f"Session sparad till {STATE_FILE}")
await browser.close()
asyncio.run(login_and_save())
När du har loggat in och tryckt Enter sparar Patchright alla cookies och lokala data i glassdoor_state.json. Den här filen innehåller dina gdId, GSESSIONID, cf_clearance och autentiseringstokens.
Återanvänd sessionen för scraping
Varje efterföljande scraping-körning laddar den sparade staten — ingen manuell inloggning behövs:
async def scrape_with_auth(target_url):
async with async_playwright() as p:
browser = await p.chromium.launch(headless=True, channel="chrome")
context = await browser.new_context(
storage_state="glassdoor_state.json"
)
page = await context.new_page()
await page.goto(target_url)
await page.add_style_tag(
content="#HardsellOverlay{display:none!important}"
)
await page.wait_for_load_state("networkidle")
html = await page.content()
await browser.close()
return html
Den sparade sessionen räcker vanligtvis 20–30 minuters aktiv användning innan Glassdoor kräver ny verifiering. För längre scraping-körningar bör du lägga in en kontroll: om en sida som borde innehålla data returnerar noll resultat, kör login-skriptet igen för att uppdatera din state-fil.
Identifiera och stänga inloggningspopupen
För delvis låsta sidor (platsannonser som visar data men täcks av en modal) fungerar CSS-injektionen från tidigare steg:
page.add_style_tag(content="""
#HardsellOverlay, .LoginModal { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
Detta fungerar bara när HTML redan innehåller datan under överlägget. För helt server-side-låsta sidor (löner, djupa omdömessidor) är den autentiserade sessionen från steg 6 enda vägen.
Tips för att hålla din Glassdoor-scraper igång
Glassdoor uppdaterar sitt gränssnitt ofta. Så här bygger du in motståndskraft i din scraper.
Föredra data-test-attribut framför klassnamn
Glassdoor slumpmässar CSS-klassnamn men brukar behålla data-test-attributen stabila. Använd alltid [data-test="jobListing"] framför .jobCard_abc123. När data-test saknas (som för lönesidans klassnamn), använd prefix-matchning: [class*="SalaryItem_jobTitle__"].
Rotera proxies och slumpa fördröjningar
Använd roterande residential proxies — datacenter-IP:er utmanas nästan direkt. Lägg in slumpmässiga pauser på 3–8 sekunder mellan sidladdningar (5–15 sekunder vid längre körningar). Undvik om möjligt att skrapa under amerikansk kontorstid, då Cloudflares beteendedetektion brukar vara som mest aggressiv.
Bevaka när något går sönder
Bygg in en enkel kontroll i din scraper: om en sida som borde innehålla data returnerar noll extraherade poster, behandla det som ett selector-fel (inte som ett tomt resultat) och larma dig själv. Kör ett litet test varje vecka för att upptäcka brott tidigt — Glassdoor ändrar frontend utan förvarning.
Använd snabbspåret med __NEXT_DATA__ när det går
Glassdoor är en Next.js- och Apollo GraphQL-app. Många sidor levererar ett <script id="__NEXT_DATA__"> med hela GraphQL-cachen som JSON. Att parsa detta är betydligt mer robust än DOM-scraping och går helt runt Hardsell-överlägget:
import json
def extract_next_data(html):
sel = Selector(text=html)
raw = sel.css("script#__NEXT_DATA__::text").get()
if raw:
return json.loads(raw)["props"]["pageProps"].get("apolloCache", {})
return None
Detta ger dig den strukturerade Apollo-cachen med alla jobb-, omdömes- och lönefält — inga CSS-selectors behövs. Det är den mest robusta extraktionsstrategin som finns, eftersom det är samma data som driver Glassdoors React-frontend.
Hoppa över koden: skrapa Glassdoor med Thunderbit (ingen Python krävs)
Alla som läser detta är inte utvecklare. HR-team, rekryterare, sales ops-analytiker och marknadsforskare behöver också Glassdoor-data — och ska inte behöva hantera Playwright-contexts och proxyrotation för att få ut den.
Thunderbit är ett AI Web Scraper Chrome-tillägg som kan extrahera samma jobb-, omdömes- och löndata utan att du skriver en enda rad kod. Jag jobbar i Thunderbit-teamet, så det vill jag vara öppen med — men anledningen till att jag tar upp det här är att det faktiskt löser de två svåraste problemen i Glassdoor-scraping.
Så fungerar Thunderbit på Glassdoor
Flödet är två klick:
- Öppna valfri Glassdoor-sida i Chrome (jobbsökning, företagsomdömen, lönesida)
- Klicka på AI Suggest Fields i Thunderbit-sidebaren — AI:n läser sidans DOM och föreslår kolumner (jobbtitel, företag, betyg, löneintervall, pros, cons osv.)
- Klicka på Scrape — datan extraheras till en tabell utan CSS-selectors eller webbläsarautomationskod
Thunderbit har en färdig Glassdoor company scraper-mall som extraherar över 23 fält per företag i en körning. För platsannonser, omdömen eller löner hanterar det generiska flödet AI Suggest Fields vilken Glassdoor-URL som helst.
Hantera inloggningsväggen utan kod
Det här är Thunderbits strukturella fördel för Glassdoor specifikt. Browser Mode kör i din egen Chrome-session — om du är inloggad på Glassdoor i Chrome så ärver Thunderbit automatiskt de cookies du redan har. Löne- och omdömessidorna som stoppar server-side-scrapers gäller då inte på samma sätt. Ingen cookiehantering, inga persistenta contexts, ingen sessionskod.
Subpage-scraping för mer data
Börja från en list-sida (t.ex. 30 företag från en sökning), låt Thunderbit läsa raderna och aktivera sedan subpage scraping för att besöka varje företags omdömes- eller lönesida och berika tabellen med fulla beskrivningar, omdömestext eller lönedetaljer.
Exportera till affärsverktyg
Till skillnad från Python-skript som ger CSV eller JSON exporterar Thunderbit direkt till Google Sheets, Airtable, Notion eller Excel — gratis på alla planer. Särskilt användbart för team som vill dela och analysera data tillsammans.
Python vs. Thunderbit: när ska du välja vad?
| Scenario | Rekommenderad metod |
|---|---|
| Bygga en återkommande datapipeline | Python + Patchright |
| Engångsresearch eller litet teamprojekt | Thunderbit |
| Du vill ha programmatisk kontroll över varje fält | Python |
| Icke-utvecklare som behöver Glassdoor-data idag | Thunderbit |
| Skrapa 1 000+ sidor i en enda körning | Python + proxies |
| Skrapa 30 företag med enrichment | Båda fungerar — Thunderbit går snabbast att komma igång med |
Thunderbits pris börjar gratis (6 sidor/månad), med Pro-planen för $38/månad för 3 000 krediter. Med 1 kredit per output-rad (2 krediter för subpage scraping) räcker det till ungefär 33 körningar med 30 berikade företag per månad.
Testa Thunderbit för Glassdoor-scraping
Är det lagligt att skrapa Glassdoor?
Jag håller det här kort och rakt. Glassdoors användarvillkor förbjuder uttryckligen automatiserad scraping: "You may not use any robot, spider, scraper... to access the Services for any purpose without our express written permission."
Det juridiska läget är ändå mer nyanserat än en enda ToS-klausul:
- Meta v. Bright Data (N.D. Cal., jan 2024): Domstolen slog fast att om du aldrig loggar in så har du aldrig accepterat villkoren, och scraping av offentligt tillgänglig utloggad data bryter inte mot dem
- hiQ Labs v. LinkedIn (9th Cir.): CFAA gäller inte automatiserad insamling av offentligt tillgänglig data — men fejkade konton och scraping bakom inloggning är en annan sak
- Van Buren v. United States (USA:s högsta domstol, 2021): Begränsade tolkningen av "exceeds authorized access" under CFAA
Den praktiska slutsatsen: att skrapa offentliga platsannonser utan att logga in ligger i en relativt säkrare juridisk zon. Skrapar du med en inloggad session innebär det att du accepterade villkoren vid registrering, och där förbjuds det uttryckligen. Detta gäller lika mycket för Python-skript som för Thunderbits Browser Mode.
Etiska riktlinjer som är värda att följa oavsett:
- Begränsa takten långt under mänsklig webbläsningshastighet
- Skrapa inte eller vidareförsälj inte personligt identifierbar information om recensenter
- Respektera robots.txt-anvisningar
- Hämta bara de fält du faktiskt behöver
Slutsats: vilken metod passar dig bäst?
Den här guiden täckte alla tre Glassdoor-datatyperna — jobb, omdömen och löner — med fungerande kod för 2025 som tar höjd för Indeed Login-migreringen, Cloudflare Bot Management och rotationen av CSS-modulklassnamn som slog ut alla äldre guider.
Här är beslutsramverket:
| Din situation | Bästa väg |
|---|---|
| Utvecklare som bygger en datapipeline | Python + Patchright (följ stegen ovan) |
| Engångsresearch eller återkommande små uttag | Thunderbit (no-code, webbläsarbaserat) |
| Du behöver bara enkla platsannonser i liten skala | Kontrollera om Glassdoor API-åtkomst fortfarande går att få först (troligen inte) |
| Du behöver specifikt löne- eller omdömesdata | Du måste använda Python-scraping eller Thunderbit — API:t täckte aldrig detta |
| Team med icke-utvecklare som behöver delad data | Thunderbit → exportera till Google Sheets |
Glassdoors skydd kommer fortsätta utvecklas. Selectors kommer att gå sönder. Nya utmaningar kommer att dyka upp. Bokmärk den här guiden — och om du vill fördjupa dig i verktyg och tekniker för webbskrapning, kolla våra inlägg om bästa automatiserade web scraping-verktygen, hur man skrapar data från en webbplats med Python och bästa jobbskrapningsverktygen. Du kan också se genomgångar på Thunderbits YouTube-kanal.
Testa Thunderbit för att extrahera Glassdoor-data Get Started Free
Vanliga frågor
1. Kan man skrapa Glassdoor utan att logga in?
Ja, för det mesta av platsannonsdatan och de övergripande företagsbetygen. Nej, för fullständiga lönefördelningar eller hela omdömestexter bortom de första sidorna. #HardsellOverlay är en modal som bara byggs med CSS — den underliggande HTML-koden innehåller fortfarande data från första sidan — men djupare innehåll är server-side-låst bakom Glassdoors "give-to-get"-vägg.
2. Vilket Python-bibliotek fungerar bäst för att skrapa Glassdoor 2025?
Patchright (en stealth-fork av Playwright) är standardrekommendationen. Det patchar Runtime.Enable-CDP-läckan som vanlig Playwright har och som Cloudflare specifikt kontrollerar. För list-sidor som levererar __NEXT_DATA__ i den initiala HTML:en är curl_cffi med impersonate="chrome124" 10–20x snabbare men kan inte hantera inloggningslåsta sidor.
3. Hur undviker jag att bli blockerad när jag skrapar Glassdoor?
Använd Patchright eller rebrowser-playwright (inte vanilla Playwright eller Selenium). Rotera residential proxies — datacenter-IP:er utmanas direkt. Lägg in slumpmässiga pauser på 3–8 sekunder mellan sidor. Behåll cookies (gdId, cf_clearance, GSESSIONID) mellan förfrågningar. Räkna med ett sessionsfönster på 20–30 minuter innan du måste verifiera igen.
4. Finns det ett Glassdoor API jag kan använda i stället för scraping?
I praktiken nej. Det gamla Partner API:t är stängt för nya ansökningar, ett publikt omdömes-endpoint har aldrig funnits, och det finns ingen migreringsväg via Indeeds Publisher API. Scraping eller ett no-code-verktyg som Thunderbit är de enda praktiska alternativen för omdömen och lönedata.
5. Hur ofta går Glassdoor-scrapers sönder?
Ganska ofta. Glassdoor släpper frontend-ändringar utan förvarning, och CSS-modulernas klassnamnshashar roterar vid varje build. De mest stabila extraktionsmetoderna är: (1) data-test-attribut, (2) __NEXT_DATA__-JSON-blocket och (3) det interna BFF-endpointet för omdömen. Bygg in en kontroll för nollresultat och kör ett litet test varje vecka för att upptäcka brott tidigt.
Läs mer
- Master Python Web Scraper: Steg-för-steg-guide med exempel
- Python Web Scraping Tutorial: Hämta data från en webbplats
- How to Use BeautifulSoup: En Python-handledning för web scraping
- Python Web Scraping Tutorial: Så här skrapar du en webbplats
- Hur man skriver en web scraper med Python: från start till mål
