अगर आपका Glassdoor scraper 2022 में बढ़िया चलता था और अब बस 403 errors ही दे रहा है, तो आप अकेले नहीं हैं। हर forum और community में एक ही सवाल घूम रहा है: "क्या किसी को पता है कि यह scraper अब क्यों काम नहीं कर रहा?"
सीधा जवाब: Glassdoor ने सब कुछ बदल दिया। Recruit Holdings ने जुलाई 2025 में Glassdoor को Indeed में मिला दिया, 1,300 कर्मचारियों की छंटनी की, और anti-bot सुरक्षा इतनी कड़ी कर दी कि साधारण Selenium और requests-based scrapers HTML का पहला byte लोड होने से पहले ही block हो जाते हैं। फरवरी 2026 तक Glassdoor logins पूरी तरह Indeed Login के जरिए हो रहे हैं — इसलिए कोई भी tutorial जो Glassdoor-specific login form पर निर्भर है, मूल स्तर पर ही टूट चुका है। दूसरी तरफ, platform पर अभी भी 180 million+ reviews, salaries, और insights मौजूद हैं, जो 2.5 million employers को कवर करते हैं। यह data HR benchmarking, competitive intelligence, और sales prospecting के लिए बहुत मूल्यवान है — बशर्ते आप इसे access कर सकें। यह guide उन बदलावों के बाद काम करने वाला version है, और इसमें तीनों Glassdoor data types — jobs, reviews, और salaries — एक ही जगह cover किए गए हैं। मैं आपको working 2025 code के साथ Python approach समझाऊँगा, बताऊँगा कि कौन-सी चीज़ें block करती हैं और उन्हें कैसे हराया जाए, और उन लोगों के लिए no-code shortcut भी दिखाऊँगा जो engineering से बचना चाहते हैं।
2025 में Python से Glassdoor Scrape क्यों करें?
Glassdoor सिर्फ job board नहीं है। यह web पर मौजूद सबसे rich employer-intelligence datasets में से एक है — जिसे लगभग Fortune 500 कंपनियों के एक-तिहाई हिस्से द्वारा इस्तेमाल किया जाता है और जो हर महीने लगभग 55 million unique visitors खींचता है। इन pages के पीछे छिपा data कई teams के असली business decisions को drive करता है।
अलग-अलग teams Glassdoor data का इस्तेमाल इस तरह करती हैं:
| Use Case | ज़रूरी Data Type | किसे फायदा होता है |
|---|---|---|
| Salary benchmarking | Salary distributions, sample sizes | HR, Total Rewards, Operations |
| Competitor hiring tracking | Job listings, posting velocity | Sales, Strategy, VC/Corp Dev |
| Employer brand monitoring | Review text, rating trends, CEO approval | HR, Marketing, Comms |
| Lead generation (growing companies) | Job listings + company info | Sales teams, SDRs |
| Market/academic research | तीनों data types | Analysts, Consultants, Researchers |
जब अक्टूबर 2025 के government shutdown के दौरान BLS jobs data प्रकाशित नहीं कर सका, तब Glassdoor की अपनी Economic Research team ने अपने dataset से एक वैकल्पिक jobs report जारी किया। इससे पता चलता है कि अब institutional analysts इस data को कितनी गंभीरता से लेते हैं।
Python अब भी preferred language है क्योंकि इसका ecosystem बेजोड़ है — browser automation के लिए Playwright, parsing के लिए parsel/lxml, TLS fingerprint bypass के लिए curl_cffi, और working patterns साझा करने वाला बहुत बड़ा community base। समस्या Python में नहीं है। समस्या यह है कि Glassdoor को scrape करना अब काफी मुश्किल हो गया है।
AI की मदद से Glassdoor data scrape करें Get Started Free
अगर आप Glassdoor data extraction के लिए no-code विकल्प चाहते हैं, तो Thunderbit आपकी मदद कर सकता है — custom Python stack बनाए और संभाले बिना आप jobs, reviews, और salary pages scrape कर सकते हैं।
आप Glassdoor से वास्तव में क्या Scrape कर सकते हैं?
ज़्यादातर tutorials सिर्फ job listings तक सीमित रहते हैं। लेकिन forum threads, GitHub issues, और Reddit questions के आधार पर जो user demand मैं ट्रैक कर रहा हूँ, उसमें सबसे ज़्यादा मांग उन दो data types की है जिन्हें कोई नहीं सिखाता: reviews और salaries। नीचे तीनों categories में क्या-क्या निकाला जा सकता है, उसका पूरा breakdown है।
Job Listings
सबसे आसानी से मिलने वाला data type। आप job title, company name, location, salary estimate, company rating, posted date, easy-apply badge, और job link निकाल सकते हैं। कुछ pages पर login के बिना भी job listings available होती हैं, हालांकि कुछ pages बाद Glassdoor login popup दिखा सकता है।
Company Reviews
Employer brand analysis के लिए यह सबसे दिलचस्प हिस्सा है। Extract होने वाले fields में शामिल हैं: overall rating, sub-ratings (work-life balance, culture & values, diversity & inclusion, career opportunities, comp & benefits, senior management), pros text, cons text, reviewer job title, review date, और employment status। पूरा review text login-gated होता है — snippet दिख जाएगा, लेकिन complete pros/cons देखने के लिए authentication चाहिए।
Salary Data
सबसे ज़्यादा माँगा जाने वाला और सबसे frustrating data type। आप job title, base pay range, total compensation range, number of salary reports, और location निकाल सकते हैं। लेकिन salary pages पूरी तरह login-gated हैं, और कई बार Glassdoor एक "contribute to unlock" flow भी जोड़ देता है जिसमें दूसरों के salaries देखने से पहले आपको अपनी salary submit करनी पड़ती है। इस पर working code देने वाला कोई competing tutorial नहीं है — हम इसे ठीक करेंगे।
Login क्या चाहिए और क्या नहीं
यह table आपको यह समझने में मदद करेगा कि कौन-से pages data देंगे और कौन-से empty result:
| Data Type | Login के बिना उपलब्ध? | नोट्स |
|---|---|---|
| Job listing titles & basic info | ज़्यादातर हाँ | कुछ pages बाद popup आ सकता है |
| Full job descriptions | आंशिक | अक्सर 2–3 views के बाद gated |
| Company reviews (full text) | नहीं — login चाहिए | snippet दिखता है, full text gated |
| Salary data | नहीं — login चाहिए | "contribute to unlock" भी लग सकता है |
आपका पुराना Glassdoor Scraper शायद क्यों टूट गया है
मैं साफ-साफ कहना चाहता हूँ: अगर आप 2021–2023 के किसी tutorial से code कॉपी कर रहे हैं, तो वह काम नहीं करेगा। GitHub पर सबसे ज़्यादा stars वाला पुराना Glassdoor Selenium scraper (MatthewChatham/glassdoor-review-scraper, लगभग 1.4k stars) 12+ open, unresolved issues के साथ पड़ा है — जिनमें "Glassdoor new UI design," "Cloudflare anti-bot protection," और "NoSuchElementException" शामिल हैं। यह repo लगभग abandoned है। Apify का glassdoor-jobs-scraper actor DEPRECATED marked है। ScrapeOps Glassdoor की overall scraping difficulty 9/10 और bypass difficulty 8/10 बताता है।
क्या बदला है और पुराना code क्यों टूटता है:
| Defense Layer | क्या बदला | Old scrapers पर असर |
|---|---|---|
| Cloudflare Bot Management | 2024 से JA3/JA4 fingerprinting और सख्त हुआ | Basic requests/Selenium scripts तुरंत 403 हो जाते हैं |
| Dynamic CSS class names | हर build पर class names randomize होते हैं | Tutorials वाले पुराने CSS selectors quietly fail हो जाते हैं |
| Rate limiting + session tracking | प्रति IP और per-session limits और कड़ी | कम pages के बाद ही scraping block हो जाती है |
| CAPTCHA challenges (संभावित Cloudflare Turnstile) | Pagination के दौरान ज़्यादा बार सामने आता है | Headless browsers challenge trigger करते हैं |
| Expanded login wall | ज़्यादा page types पर authentication जरूरी | Salary और review pages empty data लौटाते हैं |
| Indeed Login migration (Feb 2026) | Glassdoor login form पूरी तरह बदल गया | पुराने login DOM को target करने वाला code dead है |
Scrapfly की 2026 guide में स्पष्ट चेतावनी है: "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." और मार्च 2026 के एक DEV.to post में साफ कहा गया है: "Simple HTTP requests with requests or httpx get blocked instantly."
मैं जो countermeasures दिखाऊँगा — Patchright (stealth Playwright fork), data-test attribute selectors, rotating residential proxies, और authenticated persistent sessions — इन्हीं अलग-अलग layers को handle करने के लिए बनाए गए हैं।
Glassdoor API vs. Python Scraping: पहले सही तरीका चुनें
कई forum threads पूछते हैं, "क्या मुझे बस Glassdoor API इस्तेमाल कर लेना चाहिए?" — और जवाब है: नहीं, आप ऐसा नहीं कर सकते।
Legacy Glassdoor Partner API नए applicants के लिए बंद है। Developer portal अभी भी technically मौजूद है, लेकिन HTTP 403 लौटाता है। कभी भी public reviews endpoint था ही नहीं — MatthewChatham का scraper explicitly इस वजह से बनाया गया था "क्योंकि Glassdoor के पास reviews के लिए API नहीं है।" और Indeed के Publisher API के तहत reviews या salaries के लिए कोई migration path भी नहीं है।
सच में तुलना कुछ ऐसी है:
| Factor | Glassdoor Partner API v1 | Python Scraping | Thunderbit (no-code) |
|---|---|---|---|
| Access | नए applicants के लिए बंद | Open (आपको implement करना होगा) | Chrome extension |
| Job listings | Limited / sunset | मेहनत से available | Available |
| Company reviews | सार्वजनिक रूप से कभी नहीं थीं | हाँ (login चाहिए) | हाँ (Browser Mode के जरिए) |
| Salary data | सार्वजनिक रूप से कभी नहीं था | हाँ (login चाहिए) | हाँ |
| Rate limits | दस्तावेज़ित नहीं | pacing आप control करते हैं | Credit-based |
| Setup effort | नया app register नहीं कर सकते | कुछ घंटों से कुछ दिनों तक | लगभग 2 मिनट |
| Maintenance burden | लागू नहीं | बहुत ज़्यादा (HTML बदलते ही code टूटता है) | कम (AI fields फिर सुझा देता है) |
अगर आपको reviews या salary data चाहिए — और यह article पढ़ने वाले ज़्यादातर लोगों को चाहिए — तो Python scraping या no-code tool ही आपका वास्तविक विकल्प है।
शुरू करने से पहले
- Difficulty: Intermediate (Python और terminal की समझ होनी चाहिए)
- Time Required: पूरे setup के लिए लगभग 30–60 मिनट; उसके बाद हर data type के लिए लगभग 10 मिनट
- आपको क्या चाहिए होगा:
- Python 3.10+ (3.11 या 3.12 recommended)
- Chrome browser installed
- Glassdoor account (free — salary और review data के लिए ज़रूरी)
- Rotating residential proxies (कुछ pages से ज़्यादा scrape करने के लिए)
- Optional: Thunderbit Chrome Extension अगर आप no-code path चाहते हैं
2025 में Python से Glassdoor Scraping के लिए Tools और Libraries
Tooling landscape बहुत बदल चुका है। Glassdoor की मौजूदा defenses के खिलाफ वास्तव में जो काम करता है, वह यह है।
Glassdoor के लिए Patchright क्यों सबसे अच्छा विकल्प है
Patchright Playwright का stealth fork है, जो Runtime.Enable CDP leak को patch करता है — यही वह technical वजह है जिसकी वजह से vanilla Playwright Cloudflare-protected sites पर fail हो जाता है। इसका API Playwright जैसा ही है, इसलिए अगर आपको Playwright आता है, तो Patchright भी आता है। Version 1.58.2 (March 2026) current है और actively maintained है।
Alternatives की तुलना में:
- Vanilla Playwright: Runtime.Enable leak के कारण Glassdoor login page पर detect हो जाता है
- Selenium + undetected-chromedriver: undetected-chromedriver का आखिरी release February 2024 में आया था — यह effectively legacy हो चुका है। Scrapfly benchmark के अनुसार यह "हमारे test के हर domain पर fail" हुआ
- requests + BeautifulSoup: JavaScript render नहीं कर सकता, Cloudflare TLS fingerprinting के कारण तुरंत block हो जाता है
- curl_cffi: तेज़ path के लिए शानदार (browser से 10–20x तेज़) जब pages शुरुआती HTML में
__NEXT_DATA__भेजते हैं, लेकिन login या interstitial challenges नहीं संभाल सकता
Supporting Libraries
- parsel (1.11.0) या lxml (6.0.4): तेज़ HTML/XPath parsing
- csv या pandas: data export
- asyncio: तेज़ pagination के लिए async scraping
Proxies: सिर्फ Residential
Glassdoor की Cloudflare layer datacenter ASNs को बहुत aggressively challenge करती है। Residential proxies block rates को 20–30% से घटाकर 5% से नीचे ला सकते हैं। शुरुआती pricing लगभग $1.75/GB from IPRoyal (promotional) या Decodo से $3.00/GB है। Production scraping के लिए volume के अनुसार $3–8/GB budget रखें।
Proxy quality कैसी भी हो, requests के बीच random delays (कम से कम 3–8 seconds, लंबे runs के लिए 5–15 seconds) ज़रूरी हैं।
Step 1: अपना Python Environment सेट करें
अपना project folder बनाइए और recommended stack install कीजिए:
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: __NEXT_DATA__ extraction के लिए तेज़ path
pip install "curl_cffi==0.15.0"
आपको Patchright द्वारा Chromium binary डाउनलोड करते हुए दिखना चाहिए। अगर patchright install chromium fail हो जाए, तो disk space (~300MB) और Python version 3.10+ होने की जाँच करें।
Step 2: Patchright launch करें और Glassdoor पर जाएँ
यह baseline launch pattern है जो Glassdoor की Cloudflare layer के खिलाफ काम करता है:
from patchright.sync_api import sync_playwright
import random, time
with sync_playwright() as p:
browser = p.chromium.launch(
headless=False, # headless अभी भी ज़्यादा detectable है
channel="chrome", # bundled Chromium नहीं, असली Chrome इस्तेमाल करें
)
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"
)
# Login overlay हटाएँ — content अभी भी DOM में मौजूद है
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("Page loaded — job listings visible.")
यहाँ कुछ बातें ध्यान देने योग्य हैं। channel="chrome" flag Patchright को bundled Chromium के बजाय आपके installed Chrome binary का उपयोग करने को कहता है — इससे browser fingerprint ज़्यादा authentic लगता है। add_style_tag trick Glassdoor के login modal (#HardsellOverlay) को click किए बिना छिपा देता है। Scrapfly पुष्टि करता है कि "all of the content is still there, it's just covered up by the overlay" — यानी modal दिखने के बावजूद HTML में data मौजूद रहता है।
आपको Chrome window खुलती हुई दिखनी चाहिए, Glassdoor job search page पर navigate करना चाहिए, और login popup के बिना job listing cards दिखने चाहिए।
Step 3: Glassdoor Job Listings Scrape करें
Stable Selectors पहचानें
Glassdoor हर build पर CSS class names randomize करता है — इसलिए 2023 tutorial वाला .jobCard_xyz123 selector आज quietly कुछ भी नहीं लौटाएगा। इसके बजाय data-test attributes इस्तेमाल करें, जो Glassdoor की internal QA convention हैं और deploys के बीच stable रहते हैं।
Job listing fields के लिए selector reference:
| Field | Selector |
|---|---|
| Job card container | [data-test="jobListing"] |
| Job title | [data-test="job-title"] |
| Job link | a[data-test="job-link"] |
| Company name | [data-test="employer-name"] |
| Location | [data-test="emp-location"] |
| Salary range | [data-test="detailSalary"] |
| Company rating | [data-test="rating"] |
| Posted date | [data-test="job-age"] |
| Pagination next | [data-test="pagination-next"] |
Job Data Extract करें
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"Page {page_num}: No cards found — possible block or selector change.")
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"Page {page_num}: scraped {len(cards)} jobs")
# Pagination
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
CSV में Save करें
def save_to_csv(jobs, filename="glassdoor_jobs.csv"):
if not jobs:
print("No jobs to save.")
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"Saved {len(jobs)} jobs to {filename}")
Pagination limits पर एक नोट: Glassdoor total count चाहे कुछ भी हो, search results को लगभग 30 pages तक cap करता है। अगर आपको ज़्यादा coverage चाहिए, तो हर search को narrow करने के लिए filters (location, job type, salary range) का इस्तेमाल करें, बजाय 30-page cap से आगे जाने की कोशिश के।
मेरे testing में, 5 pages of job listings (लगभग 75 jobs) scrape करने में random delays के साथ करीब 45 seconds लगे। यही काम manually करने में कम से कम 20 minutes की copy-pasting लगती।
Step 4: Glassdoor Company Reviews Scrape करें
यह वह section है जिसका working code कोई और tutorial नहीं देता। Reviews के अंदर असली employer intelligence छिपी होती है — sentiment analysis, culture signals, management red flags।
Reviews Page पर जाएँ
Review URLs इस pattern का पालन करते हैं: /Reviews/{Company}-Reviews-E{id}.htm. आप Glassdoor पर किसी company को search करके और URL देखकर employer ID पा सकते हैं।
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)
Hidden BFF Endpoint (सबसे साफ रास्ता)
मेरी research से सबसे बड़ी discovery यह है: Glassdoor reviews के लिए एक working internal JSON API मौजूद है जो HTML parsing को पूरी तरह bypass कर देता है। Scrapfly scrapers repo इस endpoint को document करता है, और यह DOM scraping से कहीं ज़्यादा reliable है।
import json, re, requests
def get_review_ids(page):
"""Reviews page HTML से employerId और dynamicProfileId निकालें."""
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):
"""Structured review data के लिए Glassdoor के internal BFF endpoint को call करें."""
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 returned {resp.status_code} on page {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"Reviews page {pg}/{total_pages}: got {len(reviews)} reviews")
if pg >= total_pages:
break
time.sleep(random.uniform(3, 6))
return all_reviews
BFF endpoint आपको साफ JSON देता है जिसमें सारे review fields होते हैं — HTML parsing नहीं, CSS selector टूटने की समस्या नहीं। इसके लिए authenticated Playwright context के session cookies चाहिए (Step 6 में covered), और reviews page HTML से पहले employerId और dynamicProfileId निकालना होगा।
Reviews के लिए HTML Fallback Selectors
अगर BFF endpoint बदल जाए या आप DOM parsing पसंद करें, तो ये stable data-test selectors हैं:
| Field | Selector |
|---|---|
| Review container | [data-test="review"] |
| Headline | [data-test="review-title"] |
| Overall rating | [data-test="overall-rating"] |
| Pros | [data-test="pros"] |
| Cons | [data-test="cons"] |
| Date | [data-test="review-date"] |
| Author role | [data-test="author-jobTitle"] |
Step 5: Glassdoor Salary Data Scrape करें
Salary pages पूरी तरह login-gated हैं। इस code से real data आने से पहले आपके पास authenticated session होना चाहिए (Step 6)।
Salary Page पर जाएँ
Salary URLs इस pattern का पालन करते हैं: /Salary/{Company}-Salaries-E{id}.htm, और pagination _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"Salary page {pg}: No items — possible login gate or block.")
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"Salary page {pg}: scraped {len(items)} entries")
return all_salaries
ध्यान दें [class*="SalaryItem_jobTitle__"] prefix-match pattern पर। Glassdoor की salary page CSS-module-hashed class names इस्तेमाल करती है (जैसे SalaryItem_jobTitle__XWGpT), और hash suffix हर deploy पर बदल जाता है। prefix स्थिर रहता है — hash नहीं। पूरा class name कभी hardcode न करें।
Step 6: Glassdoor की Login Wall के पार जाएँ
यही वह critical piece है जो salary data और full review text unlock करता है। तरीका यह है: एक visible browser में manually login करें, authenticated session state save करें, और फिर उसे हर आगे के scraping run में reuse करें।
अपना Authenticated Session Save करें
यह script एक बार चलाएँ। यह Chrome window खोलती है, Glassdoor के login page पर जाती है (जो अब Indeed Login पर redirect हो जाता है), और आपको manually login करने का इंतज़ार करती है:
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("Browser window में login करें, फिर यहाँ Enter दबाएँ...")
input()
await context.storage_state(path=str(STATE_FILE))
print(f"Session saved to {STATE_FILE}")
await browser.close()
asyncio.run(login_and_save())
Login करने और Enter दबाने के बाद Patchright आपकी सारी cookies और local storage को glassdoor_state.json में save कर देता है। इस file में आपके gdId, GSESSIONID, cf_clearance, और auth tokens होते हैं।
Scraping के लिए Session Reuse करें
इसके बाद हर scraping run saved state load करेगा — manual login की ज़रूरत नहीं:
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
Saved session आम तौर पर 20–30 मिनट की active use तक टिकती है, उसके बाद Glassdoor फिर challenge कर सकता है। लंबे scraping runs के लिए एक check जोड़ें: अगर किसी ऐसे page से zero results मिले जिसमें data होना चाहिए, तो session refresh करने के लिए login script दोबारा चलाएँ।
Login Popup पहचानें और हटाएँ
Partially gated pages के लिए (जहाँ data दिखता है लेकिन modal उसे ढक लेता है), पहले बताए CSS injection approach काम करती है:
page.add_style_tag(content="""
#HardsellOverlay, .LoginModal { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
यह तभी काम करता है जब HTML के अंदर data पहले से मौजूद हो और सिर्फ overlay उसे छिपा रहा हो। Fully server-side-gated pages (salaries, deep review pages) के लिए Step 6 वाला authenticated session ही एकमात्र रास्ता है।
अपने Glassdoor Scraper को चलाए रखने के Tips
Glassdoor अपना frontend अक्सर update करता है। अपने scraper में resilience कैसे जोड़ें, यह रहा।
Class Names के बजाय data-test Attributes को प्राथमिकता दें
Glassdoor CSS class names randomize करता है, लेकिन data-test attributes अक्सर stable रहते हैं। हमेशा .jobCard_abc123 की बजाय [data-test="jobListing"] चुनें। जहाँ data-test उपलब्ध नहीं है (जैसे salary field classes), वहाँ prefix-match pattern इस्तेमाल करें: [class*="SalaryItem_jobTitle__"]।
Proxies Rotate करें और Delays Randomize करें
Rotating residential proxies इस्तेमाल करें — datacenter IPs को लगभग तुरंत challenge कर दिया जाता है। Page loads के बीच 3–8 seconds के random delays रखें (लंबे runs के लिए 5–15 seconds)। अगर संभव हो तो US business hours के दौरान scraping से बचें, जब Cloudflare की behavioral detection सबसे aggressive होती है।
Breakage पर नज़र रखें
अपने scraper में एक simple check जोड़ें: अगर किसी ऐसे page से, जिसमें data होना चाहिए, zero extracted records आते हैं, तो उसे empty result न मानें — selector failure मानें और alert भेजें। हर हफ्ते एक छोटा test scrape चलाइए ताकि breakage जल्दी पकड़ में आ जाए — Glassdoor frontend changes बिना announcement के deploy करता है।
संभव हो तो __NEXT_DATA__ Fast Path इस्तेमाल करें
Glassdoor एक Next.js + Apollo GraphQL app है। कई pages शुरुआती HTML में <script id="__NEXT_DATA__"> tag के रूप में पूरा GraphQL cache JSON में भेजते हैं। इसे parse करना DOM scraping से कहीं ज़्यादा resilient है और Hardsell overlay को पूरी तरह bypass कर देता है:
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
यह structured Apollo cache लौटाता है जिसमें job, review, और salary fields सब होते हैं — CSS selectors की ज़रूरत नहीं। यह सबसे resilient extraction strategy है, क्योंकि यही data Glassdoor के React frontend को power करता है।
Code छोड़ें: Thunderbit से Glassdoor Scrape करें (Python की ज़रूरत नहीं)
यह लेख पढ़ने वाले हर व्यक्ति developer नहीं हैं। HR teams, recruiters, sales ops analysts, और market researchers को भी Glassdoor data चाहिए — और इसके लिए उन्हें Playwright contexts और proxy rotation संभालने की ज़रूरत नहीं होनी चाहिए।
Thunderbit एक AI Web Scraper Chrome Extension है जो बिना code लिखे वही jobs, reviews, और salary data निकाल सकता है। मैं Thunderbit team में काम करता हूँ, इसलिए यह बात साफ़ कह रहा हूँ — लेकिन इसे यहाँ शामिल करने की वजह यह है कि यह Glassdoor scraping की दो सबसे मुश्किल समस्याओं को वाकई हल करता है।
Glassdoor पर Thunderbit कैसे काम करता है
Workflow बस दो clicks का है:
- Chrome में कोई भी Glassdoor page खोलें (job search, company reviews, salary page)
- Thunderbit sidebar में AI Suggest Fields पर क्लिक करें — AI page DOM पढ़कर columns सुझाता है (job title, company, rating, salary range, pros, cons, आदि)
- Scrape पर क्लिक करें — data बिना CSS selectors या browser automation code के table में extract हो जाता है
Thunderbit के पास एक pre-built Glassdoor company scraper template है जो एक ही run में company के 23+ fields निकालता है। Job listings, reviews, या salaries के लिए generic AI Suggest Fields workflow किसी भी Glassdoor URL पर काम करता है।
Code के बिना Login Wall संभालना
Glassdoor के लिए Thunderbit की सबसे बड़ी structural advantage यही है। Browser Mode आपके अपने Chrome session के अंदर चलता है — अगर आप Chrome में पहले से Glassdoor में logged in हैं, तो Thunderbit automatically वही cookies inherit कर लेता है। जो salary और review login wall server-side scrapers को रोकता है, वह यहाँ लागू ही नहीं होता। कोई cookie management नहीं, persistent contexts नहीं, session code नहीं।
Enrichment के लिए Subpage Scraping
किसी list page (जैसे search से 30 companies) से शुरुआत करें, Thunderbit को rows enumerate करने दें, फिर subpage scraping चालू करके हर company के review या salary page पर जाएँ और table को full descriptions, review text, या salary details से enrich करें।
Business Tools में Export करें
Python scripts जो CSV या JSON output देते हैं, उनके उलट Thunderbit सीधे Google Sheets, Airtable, Notion, या Excel में export करता है — हर plan पर free। यह उन teams के लिए खास तौर पर उपयोगी है जिन्हें data share और analyze करना होता है।
Python बनाम Thunderbit: किसे कब इस्तेमाल करें
| Scenario | Recommended Approach |
|---|---|
| Recurring data pipeline बनाना | Python + Patchright |
| One-off research या छोटी team project | Thunderbit |
| हर field पर programmatic control चाहिए | Python |
| आज ही Glassdoor data चाहिए, developer नहीं हैं | Thunderbit |
| एक ही run में 1,000+ pages scrape करनी हैं | Python + proxies |
| 30 companies के साथ enrichment करनी है | दोनों चलेंगे — Thunderbit setup में तेज़ है |
Thunderbit pricing free से शुरू होती है (6 pages/month), और Pro plan $38/month में 3,000 credits देता है। 1 credit per output row (subpage scraping के लिए 2 credits) के हिसाब से यह लगभग 33 runs of 30 enriched companies per month के लिए पर्याप्त है।
Glassdoor scraping के लिए Thunderbit आज़माएँ
क्या Glassdoor scrape करना legal है?
मैं इसे संक्षेप में और factual रखूँगा। Glassdoor की Terms of Service automated scraping को साफ़ तौर पर मना करती हैं: "You may not use any robot, spider, scraper... to access the Services for any purpose without our express written permission."
लेकिन कानूनी स्थिति सिर्फ एक ToS clause जितनी simple नहीं है:
- Meta v. Bright Data (N.D. Cal., Jan 2024): अदालत ने कहा कि अगर आप कभी login नहीं करते, तो आपने ToS स्वीकार ही नहीं की — और public logged-off scraping उसे violate नहीं करती
- hiQ Labs v. LinkedIn (9th Cir.): CFAA सार्वजनिक रूप से उपलब्ध data के automated collection पर लागू नहीं होता — लेकिन fake accounts और logged-in scraping अलग मामला है
- Van Buren v. United States (Supreme Court, 2021): CFAA के तहत "exceeds authorized access" की व्याख्या सीमित की गई
Practical takeaway: public job listings को बिना login किए scrape करना तुलनात्मक रूप से safer legal zone में आता है। Logged-in session के साथ scraping का मतलब है कि आपने signup के समय ToS स्वीकार की थी, और वहाँ यह explicitly prohibited है। यह बात Python scripts और Thunderbit के Browser Mode, दोनों पर समान रूप से लागू होती है।
चाहे जो भी तरीका अपनाएँ, कुछ ethical guidelines ज़रूर follow करें:
- Human browsing speed से काफी कम rate limit रखें
- Personally identifying reviewer information scrape या resell न करें
- robots.txt निर्देशों का सम्मान करें
- केवल वही fields निकालें जिनकी आपको वास्तव में ज़रूरत है
निष्कर्ष: आपके लिए कौन-सा तरीका सही है?
इस guide में Glassdoor के तीनों data types — jobs, reviews, और salaries — को cover किया गया, और working 2025 code दिया गया जो Indeed Login migration, Cloudflare Bot Management, और CSS-module class name rotation जैसी समस्याओं को ध्यान में रखता है, जिन्होंने पुराने हर tutorial को तोड़ दिया था।
यह रहा decision framework:
| आपकी स्थिति | सबसे अच्छा तरीका |
|---|---|
| Developer हैं और data pipeline बना रहे हैं | Python + Patchright (ऊपर दिए गए step-by-step को follow करें) |
| One-off research या recurring छोटे pulls | Thunderbit (no code, browser-based) |
| सिर्फ basic job listings छोटे scale पर चाहिए | पहले देख लें कि Glassdoor API access अभी भी उपलब्ध है या नहीं (संभवतः नहीं) |
| खास तौर पर salary या review data चाहिए | Python scraping या Thunderbit ही चाहिए — API ने ये कभी cover नहीं किए |
| Non-developer team को shared data चाहिए | Thunderbit → Google Sheets में export |
Glassdoor की defenses आगे भी evolve होती रहेंगी। Selectors टूटेंगे। नए challenges आएँगे। इस guide को bookmark करें — और अगर आप web scraping tools और techniques पर और गहराई से देखना चाहते हैं, तो हमारे ये posts देखें: best automated web scraping tools, Python से website data कैसे scrape करें, और best job scraping tools। आप Thunderbit YouTube Channel पर walkthroughs भी देख सकते हैं।
Glassdoor data extraction के लिए Thunderbit आज़माएँ Get Started Free
FAQs
1. क्या बिना login किए Glassdoor scrape किया जा सकता है?
हाँ, ज़्यादातर job listing data और top-line company ratings के लिए। नहीं, full salary breakdowns या पहली कुछ pages के बाद complete review text के लिए। #HardsellOverlay सिर्फ CSS-only modal है — underlying HTML में पहले page का data फिर भी मौजूद रहता है — लेकिन deeper content server-side पर Glassdoor की "give-to-get" wall के पीछे gated होता है।
2. 2025 में Glassdoor scrape करने के लिए कौन-सी Python library सबसे अच्छी है?
Patchright (एक stealth Playwright fork) default recommendation है। यह Runtime.Enable CDP leak को patch करता है जो vanilla Playwright में होता है और जिसे Cloudflare explicitly check करता है। जिन listing pages में शुरुआती HTML के अंदर __NEXT_DATA__ आता है, वहाँ impersonate="chrome124" के साथ curl_cffi 10–20x तेज़ है, लेकिन login-gated pages नहीं संभाल सकता।
3. Glassdoor scrape करते समय block होने से कैसे बचें?
Patchright या rebrowser-playwright इस्तेमाल करें (vanilla Playwright या Selenium नहीं)। Residential proxies rotate करें — datacenter IPs तुरंत challenge हो जाते हैं। Pages के बीच 3–8 seconds के random delays रखें। Cookies (gdId, cf_clearance, GSESSIONID) को requests के across persist करें। लगभग 20–30 मिनट के session window के बाद re-challenge की उम्मीद रखें।
4. क्या scraping की जगह Glassdoor API इस्तेमाल कर सकते हैं?
असल में नहीं। Legacy Partner API new applicants के लिए बंद है, public reviews endpoint कभी था ही नहीं, और Indeed के Publisher API के तहत कोई migration path नहीं है। Reviews और salary data के लिए scraping या Thunderbit जैसा no-code tool ही practical विकल्प है।
5. Glassdoor scrapers कितनी बार टूटते हैं?
काफी अक्सर। Glassdoor बिना announcement के frontend changes deploy करता है, और CSS-module class name hashes हर build पर बदलते हैं। सबसे stable extraction strategies हैं: (1) data-test attribute selectors, (2) __NEXT_DATA__ JSON blob, और (3) internal BFF reviews endpoint। Zero-results check ज़रूर रखें और breakage जल्दी पकड़ने के लिए हर हफ्ते छोटा test scrape चलाएँ।
और जानें
