אם הסקרייפר שלך ל-Glassdoor עבד מצוין ב-2022, והיום הוא מחזיר רק 403 — אתה ממש לא לבד. כמעט כל פורום מלא באותה שאלה: "מישהו יודע למה הסקרייפר הזה כבר לא עובד?"
התשובה הקצרה: Glassdoor שינתה הכול. Recruit Holdings שילבה את Glassdoor בתוך Indeed ביולי 2025, פיטרה 1,300 עובדים, והקשיחה את שכבת ההגנה נגד בוטים עד כדי כך שגם סקרייפרים רגילים מבוססי Selenium ו-requests נחסמים עוד לפני שהבייט הראשון של ה-HTML נטען. נכון לפברואר 2026, ההתחברות ל-Glassdoor מתבצעת לגמרי דרך Indeed Login — כך שכל מדריך שמקודד טופס התחברות ייעודי ל-Glassdoor כבר שבור מהיסוד. ובינתיים, הפלטפורמה עדיין מחזיקה 180 מיליון+ ביקורות, משכורות ותובנות יחד על פני 2.5 מיליון מעסיקים. זהו מידע יקר ערך במיוחד לבנצ'מרקינג של HR, מודיעין תחרותי ולידים למכירות — אם רק מצליחים להגיע אליו. המדריך הזה הוא הגרסה שעובדת אחרי כל השינויים האלה, והוא מכסה את כל שלושת סוגי הנתונים של Glassdoor (משרות, ביקורות וגם משכורות) במקום אחד. אראה לכם את הגישה ב-Python עם קוד עובד ל-2025, אסביר בדיוק מה חוסם אתכם ואיך מתגברים על זה, ואציג קיצור דרך ללא קוד למי שמעדיף לדלג על כל הצד ההנדסי.
למה בכלל לגרד את Glassdoor עם Python ב-2025?
Glassdoor היא הרבה יותר מלוח דרושים. זהו אחד ממאגרי מודיעין המעסיקים העשירים ביותר ברשת — בשימוש של בערך שליש מחברות Fortune 500 ומושך סביב 55 מיליון מבקרים חודשיים ייחודיים. הנתונים שמאחורי הדפים האלה מזינים החלטות עסקיות אמיתיות בצוותים שונים.
כך צוותים שונים משתמשים בפועל בנתוני Glassdoor:
| מקרה שימוש | איזה סוג נתונים צריך | מי נהנה מזה |
|---|---|---|
| השוואת משכורות | התפלגות שכר, גדלי מדגם | HR, תגמולים כוללים, תפעול |
| מעקב אחר גיוס אצל מתחרים | מודעות דרושים, קצב פרסום | מכירות, אסטרטגיה, VC/Corp Dev |
| ניטור מיתוג מעסיק | טקסט ביקורות, מגמות דירוג, אישור מנכ״ל | HR, שיווק, תקשורת |
| יצירת לידים (חברות בצמיחה) | מודעות דרושים + מידע על החברה | צוותי מכירות, SDRs |
| מחקר שוק/אקדמי | כל שלושת הסוגים | אנליסטים, יועצים, חוקרים |
כשה-BLS לא הצליח לפרסם נתוני משרות בזמן השבתת הממשלה באוקטובר 2025, צוות המחקר הכלכלי של Glassdoor פרסם דו״ח חלופי על משרות מתוך המאגר שלו. כך ברצינות מתייחסים היום אנליסטים מוסדיים למידע הזה.
Python נשארה השפה המועדפת כי האקוסיסטם שלה פשוט מצוין — Playwright לאוטומציה של דפדפן, parsel/lxml לניתוח HTML, curl_cffi לעקיפת fingerprint של TLS, וקהילה עצומה שחולקת דפוסי עבודה שעובדים. הבעיה היא לא Python. הבעיה היא ש-Glassdoor נהייתה הרבה יותר קשה לגרידה.
לגרד נתוני Glassdoor עם AI Get Started Free
אם אתם מחפשים חלופה ללא קוד לחילוץ נתונים מ-Glassdoor, Thunderbit יכול לעזור לכם לגרד משרות, ביקורות ודפי משכורות בלי לבנות ולתחזק סטאק Python מותאם אישית.
אילו נתונים מ-Glassdoor באמת אפשר לגרד?
רוב המדריכים מכסים רק מודעות דרושים. אבל הביקוש מצד המשתמשים — על סמך שרשורי פורומים, issues ב-GitHub ושאלות ב-Reddit שעקבתי אחריהן — הוא הגבוה ביותר דווקא לשני סוגי הנתונים שאף אחד כמעט לא מלמד: ביקורות ו-משכורות. הנה הפירוק המלא של מה שאפשר לחלץ בכל שלוש הקטגוריות.
מודעות דרושים
זהו סוג הנתונים הנגיש ביותר. אפשר לשלוף: כותרת המשרה, שם החברה, מיקום, הערכת שכר, דירוג החברה, תאריך פרסום, תג easy-apply וקישור למשרה. חלק ממודעות הדרושים זמינות גם בלי להתחבר, אם כי Glassdoor עשויה להציג חלון התחברות אחרי כמה דפים.
ביקורות על חברות
כאן זה נהיה מעניין לניתוח מיתוג מעסיק. השדות שאפשר לחלץ כוללים: דירוג כללי, דירוגי משנה (איזון עבודה-חיים, תרבות וערכים, גיוון והכלה, הזדמנויות קריירה, תגמול והטבות, הנהלה בכירה), טקסט יתרונות, טקסט חסרונות, תפקיד הכותב, תאריך הביקורת ומצב תעסוקה. הטקסט המלא של הביקורת מוגן מאחורי התחברות — תראו רק תקציר, אבל היתרונות/חסרונות המלאים דורשים אימות.
נתוני משכורות
זהו הסוג המבוקש ביותר וגם המתסכל ביותר. אפשר לחלץ: כותרת משרה, טווח שכר בסיסי, טווח תגמול כולל, מספר דיווחי שכר ומיקום. אבל דפי השכר חסומים לגמרי מאחורי התחברות, וב-Glassdoor לפעמים מוסיפים גם זרימת "תרומה כדי לפתוח" שבה צריך להזין את השכר שלכם לפני שרואים של אחרים. אף מדריך מתחרה לא מספק קוד שעובד לזה — אנחנו נתקן את זה.
מה דורש התחברות ומה לא
הטבלה הבאה תחסוך לכם את החוויה הלא נעימה של לגלות בדרך הקשה אילו דפים יחזירו נתונים ריקים:
| סוג נתונים | זמין בלי התחברות? | הערות |
|---|---|---|
| כותרות משרות ומידע בסיסי | ברוב המקרים כן | חלון קופץ עשוי להופיע אחרי כמה דפים |
| תיאורי משרה מלאים | חלקית | לעיתים נחסמים אחרי 2–3 צפיות |
| ביקורות חברה (טקסט מלא) | לא — נדרשת התחברות | תקציר נראה, טקסט מלא חסום |
| נתוני משכורות | לא — נדרשת התחברות | ייתכן שגם יידרש "תרום כדי לפתוח" |
למה הסקרייפר הישן שלך ל-Glassdoor כנראה שבור
אני רוצה לומר את זה בצורה ישירה: אם אתה מעתיק קוד ממדריך של 2021–2023, הוא לא יעבוד. הסקרייפר הוותיק והפופולרי ביותר ל-Glassdoor ב-Selenium ב-GitHub (MatthewChatham/glassdoor-review-scraper, כ-1.4k כוכבים) כולל 12+ issues פתוחים ולא פתורים — כולל "Glassdoor new UI design", "Cloudflare anti-bot protection" ו-"NoSuchElementException". הפרויקט למעשה נזנח. ה-actor של Apify בשם glassdoor-jobs-scraper מסומן כ-DEPRECATED. ScrapeOps מדרגת את Glassdoor כקשה 9/10 באופן כללי ו-8/10 בקושי עקיפה.
הנה מה השתנה ולמה קוד ישן נשבר:
| שכבת הגנה | מה השתנה | ההשפעה על סקרייפרים ישנים |
|---|---|---|
| Cloudflare Bot Management | Fingerprinting קשיח יותר של JA3/JA4 מאז 2024 | סקריפטים פשוטים של requests/Selenium נחסמים מיד עם 403 |
| שמות מחלקות CSS דינמיים | שמות המחלקות רנדומליים בכל build | סלקטורים ישנים ממדריכים נשברים בשקט |
| הגבלת קצב + מעקב אחר סשן | מגבלות הדוקות יותר לפי IP ולפי סשן | הסקרייפר נחסם אחרי פחות דפים |
| אתגרי CAPTCHA (כנראה Cloudflare Turnstile) | תכופים יותר, במיוחד בעימוד | דפדפנים headless מפעילים אתגרים |
| הרחבת חומת ההתחברות | יותר סוגי דפים דורשים אימות | דפי משכורות וביקורות מחזירים נתונים ריקים |
| מעבר ל-Indeed Login (פבר׳ 2026) | טופס ההתחברות של Glassdoor הוחלף לחלוטין | כל קוד שמכוון ל-DOM הישן של ההתחברות מת |
המדריך של Scrapfly ל-2026 כולל אזהרה מפורשת: "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." ופוסט ב-DEV.to ממרץ 2026 אומר את זה בלי לעגל פינות: "Simple HTTP requests with requests or httpx get blocked instantly."
אמצעי ההתגברות שאציג כאן — Patchright (פיצ'ר stealth של Playwright), סלקטורים מסוג data-test, פרוקסי residential מסתובבים, וסשנים מתמשכים עם אימות — נבנו בדיוק כדי להתמודד עם כל אחת מהשכבות האלה.
Glassdoor API מול גרידה ב-Python: קודם בוחרים גישה נכונה
בשרשורי פורומים רבים שואלים: "פשוט להשתמש ב-Glassdoor API?" — והתשובה היא: אי אפשר.
ה-Partner API הישן של Glassdoor סגור למבקשים חדשים. פורטל המפתחים עדיין קיים טכנית, אבל מחזיר HTTP 403. מעולם לא היה endpoint ציבורי לביקורות — הסקרייפר של MatthewChatham נוצר במפורש "כי ל-Glassdoor אין API לביקורות." וגם אין מסלול הגירה לביקורות או משכורות דרך Publisher API של Indeed.
הנה ההשוואה הכנה:
| גורם | Glassdoor Partner API v1 | גרידה ב-Python | Thunderbit (ללא קוד) |
|---|---|---|---|
| גישה | סגור למבקשים חדשים | פתוח (אתם מיישמים) | תוסף Chrome |
| מודעות דרושים | מוגבל/בשלב סיום | זמין עם מאמץ | זמין |
| ביקורות חברה | מעולם לא היה ציבורי | כן (נדרשת התחברות) | כן (דרך Browser Mode) |
| נתוני משכורות | מעולם לא היה ציבורי | כן (נדרשת התחברות) | כן |
| הגבלות קצב | לא מתועד | אתם שולטים בקצב | מבוסס קרדיטים |
| מאמץ התקמה | אי אפשר להירשם לאפליקציות חדשות | שעות עד ימים | כ-2 דקות |
| עלות תחזוקה | לא רלוונטי | גבוהה (שינויי HTML שוברים קוד) | נמוכה (AI מציע שדות מחדש) |
אם אתם צריכים ביקורות או נתוני משכורות — וכמעט כל מי שקורא את זה צריך — גרידה ב-Python או כלי ללא קוד הם למעשה האפשרות הריאלית היחידה.
לפני שמתחילים
- רמת קושי: בינונית (כדאי להרגיש בנוח עם Python ועם הטרמינל)
- זמן נדרש: כ-30–60 דקות להגדרה מלאה; כ-10 דקות לכל סוג נתונים אחרי זה
- מה צריך:
- Python 3.10+ (מומלץ 3.11 או 3.12)
- דפדפן Chrome מותקן
- חשבון Glassdoor (חינם — נדרש לנתוני משכורות וביקורות)
- פרוקסי residential מסתובבים (אם מגרדים יותר מכמה דפים)
- אופציונלי: תוסף Thunderbit ל-Chrome אם רוצים את המסלול ללא קוד
כלים וספריות לגרידה מ-Glassdoor עם Python ב-2025
הנוף הטכנולוגי השתנה דרמטית. הנה מה שבאמת עובד מול ההגנות הנוכחיות של Glassdoor.
למה Patchright היא הבחירה הטובה ביותר ל-Glassdoor
Patchright היא גרסת stealth של Playwright שמתקנת את דליפת Runtime.Enable ב-CDP — הסיבה הטכנית הספציפית לכך ש-Playwright רגיל נכשל באתרים שמוגנים ב-Cloudflare. היא משתמשת בדיוק באותו API כמו Playwright, כך שאם אתם מכירים Playwright, אתם מכירים גם Patchright. גרסה 1.58.2 (מרץ 2026) היא העדכנית ומתוחזקת באופן פעיל.
בהשוואה לחלופות:
- Playwright רגיל: מזוהה בקלות בדף ההתחברות של Glassdoor בגלל דליפת Runtime.Enable
- Selenium + undetected-chromedriver: הגרסה האחרונה של undetected-chromedriver היא מפברואר 2024 — בפועל זו טכנולוגיה ישנה. הבנצ'מרק של Scrapfly מצא שהוא "failed on every domain in our test"
- requests + BeautifulSoup: לא יכולים לרנדר JavaScript, ונחסמים מיד על ידי fingerprinting של TLS ב-Cloudflare
- curl_cffi: מצוין למסלול המהיר (מהיר פי 10–20 מדפדפן) כשדפים שולחים
__NEXT_DATA__ב-HTML הראשוני, אבל לא יודע להתמודד עם התחברות או אתגרי ביניים
ספריות תומכות
- parsel (1.11.0) או lxml (6.0.4): ניתוח HTML/XPath מהיר
- csv או pandas: ייצוא נתונים
- asyncio: גרידה אסינכרונית לעימוד מהיר יותר
פרוקסי: רק Residential
שכבת Cloudflare של Glassdoor מאתגרת באגרסיביות ASN של datacenter. לפי הדיווחים, פרוקסי residential מורידים את שיעור החסימות מ-20–30% לפחות מ-5%. מחיר התחלתי הוא בערך $1.75/GB מ-IPRoyal (מבצעי) או $3.00/GB מ-Decodo. לגרידה ב-production כדאי לתקצב $3–8 לכל GB, בהתאם לנפח.
עיכובים אקראיים בין בקשות (לפחות 3–8 שניות, ו-5–15 שניות בריצות ארוכות יותר) הם חיוניים בלי קשר לאיכות הפרוקסי.
שלב 1: הקמת סביבת Python
צרו תיקיית פרויקט והתקינו את הסטאק המומלץ:
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"
אתם אמורים לראות את Patchright מורידה בינארי של Chromium. אם patchright install chromium נכשל, בדקו שיש מספיק מקום בדיסק (~300MB) ושהגרסה של Python היא 3.10+.
שלב 2: הפעלה של Patchright וניווט ל-Glassdoor
זהו דפוס ההפעלה הבסיסי שעובד מול שכבת Cloudflare של Glassdoor:
from patchright.sync_api import sync_playwright
import random, time
with sync_playwright() as p:
browser = p.chromium.launch(
headless=False, # headless עדיין מזוהה יותר בקלות
channel="chrome", # השתמשו ב-Chrome אמיתי, לא ב-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"
)
# סגירת שכבת ההתחברות — התוכן עדיין קיים ב-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("הדף נטען — כרטיסי המשרות גלויים.")
שימו לב לכמה דברים כאן. הדגל channel="chrome" אומר ל-Patchright להשתמש בבינארי של Chrome שמותקן אצלכם במקום ב-Chromium המצורף — זה יוצר fingerprint אמיתי יותר של דפדפן. הטריק של add_style_tag מסתיר את חלון ההתחברות של Glassdoor (שנקרא #HardsellOverlay) בלי ללחוץ על שום דבר. Scrapfly מאשרים ש"כל התוכן עדיין שם, הוא פשוט מכוסה על ידי ה-overlay" — ה-HTML מכיל את הנתונים בלי קשר לשאלה אם המודאל מוצג.
אתם אמורים לראות חלון Chrome נפתח, להגיע לדף החיפוש של Glassdoor ולהציג כרטיסי משרות בלי חלון ההתחברות שיחסום את התצוגה.
שלב 3: גרידה של מודעות דרושים מ-Glassdoor
זיהוי סלקטורים יציבים
Glassdoor ממחזרת שמות מחלקות CSS בכל build — לכן הסלקטור .jobCard_xyz123 ממדריך משנת 2023 פשוט יחזיר כלום היום. במקום זה, השתמשו במאפייני data-test, שהם מוסכמת QA פנימית של Glassdoor ונשארים יציבים בין פריסות.
הנה מפת הסלקטורים לשדות של מודעות דרושים:
| שדה | סלקטור |
|---|---|
| קונטיינר של כרטיס משרה | [data-test="jobListing"] |
| כותרת המשרה | [data-test="job-title"] |
| קישור למשרה | a[data-test="job-link"] |
| שם החברה | [data-test="employer-name"] |
| מיקום | [data-test="emp-location"] |
| טווח שכר | [data-test="detailSalary"] |
| דירוג החברה | [data-test="rating"] |
| תאריך פרסום | [data-test="job-age"] |
| עמוד הבא בעימוד | [data-test="pagination-next"] |
חילוץ נתוני משרות
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
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}")
הערה על מגבלות עימוד: Glassdoor מגבילה תוצאות חיפוש לכ-30 עמודים בערך, בלי קשר למספר הכולל. אם צריך כיסוי רחב יותר, עדיף להשתמש בפילטרים (מיקום, סוג משרה, טווח שכר) כדי לצמצם כל חיפוש במקום לנסות לדפדף מעבר לתקרה.
בבדיקות שלי, גרידה של 5 עמודים של משרות (כ-75 משרות) לקחה בערך 45 שניות עם עיכובים אקראיים. לעשות את אותו דבר ידנית היה לוקח לפחות 20 דקות של העתק-הדבק.
שלב 4: גרידה של ביקורות חברה ב-Glassdoor
זהו החלק שאף מדריך אחר לא נותן לו קוד שעובד. ביקורות הן המקום שבו באמת נמצא מודיעין המעסיק — ניתוח סנטימנט, אותות על תרבות, סימני אזהרה בהנהלה.
ניווט לדף הביקורות
כתובות URL של ביקורות נראות כך: /Reviews/{Company}-Reviews-E{id}.htm. אפשר למצוא את מזהה המעסיק על ידי חיפוש החברה ב-Glassdoor ובדיקת ה-URL.
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)
נקודת BFF חבויה (המסלול הנקי ביותר)
הנה הממצא הגדול ביותר מהמחקר שלי: ל-Glassdoor יש API פנימי עובד מבוסס JSON שעוקף לחלוטין ניתוח HTML. מאגר ה-scrapers של Scrapfly מתעד את נקודת הקצה הזו, והיא אמינה הרבה יותר מגרידה של ה-DOM.
import json, re, requests
def get_review_ids(page):
"""Extract employerId and dynamicProfileId from the reviews page HTML."""
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):
"""Call Glassdoor's internal BFF endpoint for structured review data."""
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 נותנת JSON נקי עם כל שדות הביקורת — בלי ניתוח HTML, בלי שבירת סלקטורים. תצטרכו cookies של סשן מאומת דרך Playwright (מכוסה בשלב 6 בהמשך), ותצטרכו לחלץ קודם את employerId ואת dynamicProfileId מתוך ה-HTML של דף הביקורות.
סלקטורים חלופיים ב-HTML לביקורות
אם נקודת ה-BFF משתנה או שאתם מעדיפים ניתוח DOM, אלה ה-data-test היציבים:
| שדה | סלקטור |
|---|---|
| קונטיינר ביקורת | [data-test="review"] |
| כותרת | [data-test="review-title"] |
| דירוג כללי | [data-test="overall-rating"] |
| יתרונות | [data-test="pros"] |
| חסרונות | [data-test="cons"] |
| תאריך | [data-test="review-date"] |
| תפקיד הכותב | [data-test="author-jobTitle"] |
שלב 5: גרידה של נתוני משכורות מ-Glassdoor
דפי משכורות חסומים לחלוטין מאחורי התחברות. חייבים סשן מאומת (שלב 6) לפני שהקוד הזה יחזיר נתונים אמיתיים.
ניווט לדף המשכורות
כתובות URL של משכורות נראות כך: /Salary/{Company}-Salaries-E{id}.htm, עם עימוד כ-_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. בדפי המשכורות של Glassdoor נעשה שימוש במחלקות CSS מסוג CSS Module עם hash, למשל SalaryItem_jobTitle__XWGpT, כאשר הסיומת של ה-hash משתנה בכל פריסה. הפריפיקס נשאר יציב — ה-hash לא. לעולם אל תקבעו hardcode לשם המחלקה המלא.
שלב 6: מעבר מעל חומת ההתחברות של Glassdoor
זהו החלק הקריטי שפותח את נתוני המשכורות ואת טקסט הביקורות המלא. הגישה: להתחבר פעם אחת ידנית בדפדפן גלוי, לשמור את מצב הסשן המאומת, ואז להשתמש בו שוב בכל ריצת גרידה עתידית.
שמירת הסשן המאומת
הריצו את הסקריפט הזה פעם אחת. הוא פותח חלון Chrome, נכנס לעמוד ההתחברות של Glassdoor (שכעת מפנה ל-Indeed 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("Log in in the browser window, then press Enter here...")
input()
await context.storage_state(path=str(STATE_FILE))
print(f"Session saved to {STATE_FILE}")
await browser.close()
asyncio.run(login_and_save())
אחרי שתתחברו ותלחצו Enter, Patchright שומרת את כל ה-cookies ואת ה-local storage בקובץ glassdoor_state.json. הקובץ הזה מכיל את gdId, GSESSIONID, cf_clearance וטוקני האימות.
שימוש חוזר בסשן לגרידה
כל ריצת גרידה לאחר מכן טוענת את המצב השמור — בלי התחברות ידנית נוספת:
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
הסשן השמור מחזיק בדרך כלל 20–30 דקות של שימוש פעיל לפני ש-Glassdoor מאתגרת מחדש. לריצות גרידה ארוכות יותר, כדאי להוסיף בדיקה: אם דף שאמור להכיל נתונים מחזיר אפס תוצאות, הריצו שוב את סקריפט ההתחברות כדי לרענן את קובץ המצב.
זיהוי וסגירה של חלון ההתחברות
בדפים חסומים חלקית (משרות שמציגות נתונים אבל עם מודאל מעליהם), שיטת הזרקת ה-CSS מהשלבים הקודמים עובדת:
page.add_style_tag(content="""
#HardsellOverlay, .LoginModal { display: none !important; }
body { overflow: auto !important; position: initial !important; }
""")
זה עובד רק כשה-HTML כבר מכיל את הנתונים מתחת לשכבת ההתחברות. בדפים חסומים לחלוטין בצד השרת (משכורות, דפי ביקורות עמוקים), הסשן המאומת משלב 6 הוא הדרך היחידה.
טיפים לשמירה על סקרייפר Glassdoor שעובד לאורך זמן
Glassdoor מעדכנת את ה-frontend לעיתים קרובות. הנה איך לבנות חוסן בסקרייפר שלך.
העדיפו data-test על פני שמות מחלקות
Glassdoor עושה רנדומיזציה לשמות מחלקות CSS, אבל נוטה לשמור על data-test יציבים. תמיד עדיף [data-test="jobListing"] על פני .jobCard_abc123. כשאין data-test זמין (כמו בשדות משכורת), השתמשו בתבנית prefix-match: [class*="SalaryItem_jobTitle__"].
החלפת פרוקסי והוספת השהיות אקראיות
השתמשו בפרוקסי residential מסתובבים — IPs של datacenter נחסמים כמעט מיד. הוסיפו השהיות אקראיות של 3–8 שניות בין טעינות דף (5–15 שניות בריצות ארוכות). אם אפשר, הימנעו מגרידה בשעות העבודה בארה״ב, כשהזיהוי ההתנהגותי של Cloudflare אגרסיבי יותר.
ניטור שבירות
בנו בדיקה פשוטה בתוך הסקרייפר: אם דף שאמור להכיל נתונים מחזיר אפס רשומות מחולצות, התייחסו לזה ככישלון סלקטורים ולא כסט נתונים ריק — ושלחו לעצמכם התראה. הריצו פעם בשבוע גרידת בדיקה קטנה כדי לתפוס שבירות מוקדם — Glassdoor פורסמת שינויי frontend בלי הודעה.
השתמשו בנתיב המהיר של __NEXT_DATA__ כשאפשר
Glassdoor היא אפליקציית Next.js + Apollo GraphQL. דפים רבים כוללים תג <script id="__NEXT_DATA__"> עם כל מטמון ה-GraphQL כ-JSON. ניתוח של זה עמיד הרבה יותר מגרידת DOM ועוקף לחלוטין את שכבת Hardsell:
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
זה מחזיר את מטמון Apollo המובנה עם כל שדות המשרות, הביקורות והמשכורות — בלי צורך בסלקטורים של CSS. זו אסטרטגיית החילוץ העמידה ביותר שקיימת, כי זה בדיוק אותו נתון שמזין את ה-frontend של Glassdoor ב-React.
אפשר גם בלי קוד: לגרד את Glassdoor עם Thunderbit
לא כל מי שקורא את זה הוא מפתח. צוותי HR, מגייסים, אנליסטים של תפעול מכירות וחוקרי שוק צריכים גם הם נתונים מ-Glassdoor — ולא אמורים לנהל Playwright, סשנים ופרוקסי רק כדי להשיג אותם.
Thunderbit הוא תוסף AI Web Scraper ל-Chrome שיכול לחלץ את אותם נתוני משרות, ביקורות ומשכורות בלי לכתוב שורת קוד אחת. אני עובד בצוות Thunderbit, אז אהיה גלוי לגבי זה — אבל הסיבה שאני כולל אותו כאן היא שהוא באמת פותר את שתי הבעיות הכי קשות בגרידה מ-Glassdoor.
איך Thunderbit עובד על Glassdoor
הזרימה היא שתי לחיצות:
- פותחים כל דף של Glassdoor ב-Chrome (חיפוש משרות, ביקורות חברה, דף משכורות)
- לוחצים AI Suggest Fields בסיידבר של Thunderbit — ה-AI קורא את ה-DOM של הדף ומציע עמודות (כותרת משרה, חברה, דירוג, טווח שכר, יתרונות, חסרונות וכו׳)
- לוחצים Scrape — הנתונים מחולצים לטבלה בלי סלקטורי CSS או קוד אוטומציית דפדפן
ל-Thunderbit יש תבנית מובנית לגרידת חברות ב-Glassdoor שחולצת 23+ שדות לכל חברה בריצה אחת. עבור משרות, ביקורות או משכורות, זרימת AI Suggest Fields הגנרית מטפלת בכל URL של Glassdoor.
התמודדות עם חומת ההתחברות בלי קוד
זהו היתרון המבני של Thunderbit במיוחד עבור Glassdoor. Browser Mode רץ בתוך סשן Chrome שלך — אם אתה כבר מחובר ל-Glassdoor ב-Chrome, Thunderbit יורש את ה-cookies האלה אוטומטית. חומת ההתחברות של משכורות וביקורות, שחוסמת סקרייפרים בצד השרת, פשוט לא רלוונטית. בלי ניהול cookies, בלי contexts מתמשכים, בלי קוד סשנים.
גרידת תתי-דפים להעשיר את המידע
אפשר להתחיל מדף רשימה (למשל 30 חברות מחיפוש), לתת ל-Thunderbit למנות את השורות, ואז להפעיל subpage scraping כדי לבקר בכל דף ביקורות או משכורות של חברה ולהעשיר את הטבלה בתיאורים מלאים, טקסט ביקורות או פרטי שכר.
ייצוא לכלי עבודה עסקיים
בשונה מסקריפטי Python שמייצאים CSV או JSON, Thunderbit מייצאת ישירות ל-Google Sheets, Airtable, Notion או Excel — בחינם בכל תוכנית. זה שימושי במיוחד לצוותים שצריכים לשתף ולנתח את הנתונים ביחד.
Python מול Thunderbit: מתי משתמשים במה
| תרחיש | הגישה המומלצת |
|---|---|
| בניית צינור נתונים קבוע | Python + Patchright |
| מחקר חד-פעמי או פרויקט קטן של צוות | Thunderbit |
| צריך שליטה פרוגרמטית בכל שדה | Python |
| מי שאינו מפתח וצריך נתוני Glassdoor היום | Thunderbit |
| גרידה של 1,000+ דפים בריצה אחת | Python + proxies |
| גרידה של 30 חברות עם העשרה | שתי האפשרויות עובדות — Thunderbit מהיר יותר להגדרה |
מחירי Thunderbit מתחילים בחינם (6 דפים לחודש), עם תוכנית Pro ב-$38 לחודש עבור 3,000 קרדיטים. בקרדיט אחד לשורת פלט (2 קרדיטים לגרידת תת-דף), זה מספיק בערך ל-33 ריצות של 30 חברות מועשרות בחודש.
נסו את Thunderbit לגרידה מ-Glassdoor
האם מותר לגרד נתונים מ-Glassdoor מבחינה חוקית?
אשמור את זה קצר ועובדתי. תנאי השימוש של Glassdoor אוסרים במפורש גרידה אוטומטית: "You may not use any robot, spider, scraper... to access the Services for any purpose without our express written permission."
אבל הנוף המשפטי מורכב יותר מסעיף ToS אחד:
- Meta v. Bright Data (מחוז צפון קליפורניה, ינואר 2024): בית המשפט קבע שאם אף פעם לא התחברתם, מעולם לא הסכמתם ל-ToS, וגרידה ציבורית של מידע לא מחובר אינה מפרה אותו
- hiQ Labs v. LinkedIn (המעגל ה-9): ה-CFAA לא חל על איסוף אוטומטי של נתונים ציבוריים נגישים — אבל חשבונות מזויפים וגרידה מתוך סשן מחובר הם סיפור אחר
- Van Buren v. United States (בית המשפט העליון, 2021): צמצם את המונח "exceeds authorized access" תחת ה-CFAA
המסקנה המעשית: גרידה של מודעות דרושים ציבוריות בלי להתחבר נמצאת באזור משפטי בטוח יחסית. גרידה עם סשן מחובר משמעותה שקיבלתם את ה-ToS בהרשמה, והם אוסרים זאת במפורש. זה נכון גם לסקריפטים ב-Python וגם ל-Browser Mode של Thunderbit.
כמה כללי אתיקה שכדאי לעמוד בהם בכל מקרה:
- להגביל קצב הרבה מתחת למהירות גלישה אנושית
- לא לגרד או למכור מחדש מידע מזהה אישית של סוקרים
- לכבד הנחיות robots.txt
- למשוך רק את השדות שבאמת צריך
סיכום: איזו שיטה מתאימה לכם?
המדריך הזה כיסה את כל שלושת סוגי הנתונים של Glassdoor — משרות, ביקורות ומשכורות — עם קוד 2025 עובד, שמתחשב במעבר ל-Indeed Login, ב-Cloudflare Bot Management, ובהחלפת שמות מחלקות מסוג CSS Module ששברה כל מדריך ישן.
הנה מסגרת ההחלטה:
| המצב שלכם | הנתיב הטוב ביותר |
|---|---|
| מפתח/ת שבונה צינור נתונים | Python + Patchright (עקבו אחרי הצעדים שלמעלה) |
| מחקר חד-פעמי או שאיבת נתונים קטנה וחוזרת | Thunderbit (ללא קוד, מבוסס דפדפן) |
| צריך רק מודעות דרושים בסיסיות בהיקף קטן | בדקו קודם אם עדיין יש גישה ל-Glassdoor API (כנראה שלא) |
| צריך במיוחד נתוני משכורות או ביקורות | חייבים להשתמש בגרידה ב-Python או ב-Thunderbit — ה-API מעולם לא כיסה את אלה |
| צוות של לא-מפתחים שצריך נתונים משותפים | Thunderbit → ייצוא ל-Google Sheets |
ההגנות של Glassdoor ימשיכו להתפתח. סלקטורים יישברו. אתגרים חדשים יופיעו. שמרו את המדריך הזה — ואם אתם רוצים מבט עמוק יותר על כלי וטכניקות לגרידת רשת, תבדקו גם את הפוסטים שלנו על כלי web scraping אוטומטיים הטובים ביותר, איך לגרד נתונים מאתר עם Python, ו-כלי גרידת משרות הטובים ביותר. אפשר גם לצפות בהדרכות בערוץ ה-YouTube של Thunderbit.
נסו את Thunderbit לחילוץ נתונים מ-Glassdoor Get Started Free
שאלות נפוצות
1. אפשר לגרד את Glassdoor בלי להתחבר?
כן, עבור רוב נתוני המשרות ודירוגי החברה ברמה גבוהה. לא, עבור פירוט מלא של משכורות או טקסט ביקורות מלא מעבר לכמה הדפים הראשונים. ה-#HardsellOverlay הוא מודאל מבוסס CSS בלבד — ה-HTML הבסיסי עדיין מכיל נתוני עמוד ראשון — אבל תוכן עמוק יותר מוגן בצד השרת מאחורי חומת ה"תן כדי לקבל" של Glassdoor.
2. איזו ספריית Python הכי מתאימה לגרידת Glassdoor ב-2025?
Patchright (גרסת stealth של Playwright) היא ההמלצה כברירת מחדל. היא מתקנת את דליפת Runtime.Enable ב-CDP שיש ב-Playwright רגיל וש-Cloudflare בודקת במפורש. עבור דפי רשימה ששולחים __NEXT_DATA__ ב-HTML הראשוני, curl_cffi עם impersonate="chrome124" מהיר פי 10–20, אבל לא יכול להתמודד עם דפים שחסומים מאחורי התחברות.
3. איך נמנעים מחסימה בזמן גרידה מ-Glassdoor?
השתמשו ב-Patchright או rebrowser-playwright (לא ב-Playwright רגיל ולא ב-Selenium). החליפו פרוקסי residential — IPs של datacenter נחסמים כמעט מיד. הוסיפו השהיות אקראיות של 3–8 שניות בין דפים. שמרו cookies (gdId, cf_clearance, GSESSIONID) בין בקשות. צפו לחלון סשן של 20–30 דקות לפני אתגר מחדש.
4. יש Glassdoor API שאפשר להשתמש בו במקום לגרד?
בפועל לא. ה-Partner API הישן סגור למבקשים חדשים, endpoint ציבורי לביקורות מעולם לא היה, ואין מסלול הגירה דרך Publisher API של Indeed. גרידה או כלי ללא קוד כמו Thunderbit הם האפשרות המעשית היחידה לביקורות ולנתוני משכורות.
5. כל כמה זמן סקרייפרים של Glassdoor נשברים?
לעיתים קרובות. Glassdoor פורסמת שינויי frontend בלי הודעה, וה-hashes של מחלקות CSS Module מתחלפים בכל build. אסטרטגיות החילוץ היציבות ביותר הן: (1) סלקטורים של data-test, (2) בלוק JSON של __NEXT_DATA__, ו-(3) endpoint פנימי של BFF לביקורות. בנו בדיקה של אפס תוצאות והריצו גרידת בדיקה קטנה מדי שבוע כדי לתפוס שבירות מוקדם.
למידע נוסף
