🔥 Glassdoor jobs scraper
Pricing
$25.00/month + usage
ℹ️ Elevate your job search with the sleek Glassdoor Scraper for Apify. Tailor-made for the modern job seeker, it's your secret weapon in the job market. Dive into a world of opportunities with custom searches, precise filtering. Fast, efficient, and incredibly user-friendly 🚀✨
All notable changes to glassdoor-scraper are documented here.
Format: Keep a Changelog . Versioning: SemVer .
Pay-per-event is live, and it gets cheaper on higher Apify plans.
The monthly rental is gone. From 22 September 2026 you pay only for the jobs you actually get, and platform usage is included rather than billed on top of a subscription.
Automatic discounts on higher Apify plans. Applied from your subscription tier, nothing to ask for:
| Per 1,000 jobs | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Jobs | $0.40 | $0.35 | $0.30 | $0.28 |
| ➕ Company insights | $1.00 | $0.80 | $0.60 | $0.50 |
| ➕ Salary benchmark | $1.00 | $0.80 | $0.60 | $0.50 |
| Everything on | $2.40 | $1.95 | $1.50 | $1.28 |
Search by city and by company works again.
Glassdoor moved the two lookups that turn a city name or a company name into an id. The scraper was
still calling the old addresses, which now return a "page not found", so any run that searched by
keyword + location or by company name failed straight away with location-unresolved or
employer-unresolved. Searching by pasted URL, by job ID, or by keyword alone was unaffected.
Nothing was lost on Glassdoor's side — the lookups were consolidated, not removed, and they return the same ids as before. The scraper now calls the new addresses.
Four output fixes found by benchmarking this scraper against its competitors.
job_types reads like a list of job types again. It was shipping Glassdoor's internal
translation keys — search-jobs.job-type-options.contract — on every row. It now carries the same
clean values the previous Glassdoor scraper did: FULL_TIME, PART_TIME, CONTRACT,
INTERNSHIP, TEMPORARY. A type we have not seen before comes through in the same shape rather
than being dropped, and job_type_labels still carries Glassdoor's own display text.rate-limited. Every throttled request was landing
in your failed rows as parse-error, which said the data could not be read when in fact it was
never fetched. Blocked and not-found requests were mislabelled the same way and are now
waf-blocked and not-found.company_city is filled. It was declared and left empty on every row; it now carries the
employer's city, taken from its headquarters.job_location.unknown keeps its name. It looks like a placeholder and is not: it is the field
name the previous scraper used for the displayable location ("New York, NY"), and renaming it
would break existing integrations. city, state and country hold the parsed parts.A run that gets moved to another server no longer starts over — or charges you twice.
Apify sometimes moves a running Actor to a different server. Until now this scraper lost everything it had done and began again from the first page, re-delivering jobs you already had and billing for them a second time. It now picks up where it left off.
maxItems stays honest across a move. A run asked for 500 jobs delivers 500 in total, not 500
more after the move.New pricing: $0.40 per 1,000 jobs, full description included. Most runs get cheaper.
We benchmarked the eight busiest Glassdoor scrapers on Apify against the same search, then repriced against what we found. The headline number drops from $1.00 to $0.40 per 1,000 jobs — the same price as the category leader — and the full job description, which used to cost extra, is now part of the price of a job. Two optional add-ons carry the depth nobody else sells.
job-basic and job-detailed are replaced by job,
company-insights and salary-benchmark, so old invoices and new ones list different lines.One flat row. The v2 object is gone, and nothing you already read has moved.
Rows carried the same data twice: the field names from the previous Glassdoor scraper at the top
level, and a v2 object repeating them under modern names. You had to know which half to read, and
the two halves disagreed about how to say the same thing. There is now a single set of fields.
v2 object no longer exists. Everything it carried is now a normal field on the row,
named the same way the rest of the row is named. Twenty-one of its entries were simply duplicates
of a field you already had, and were dropped rather than renamed.v2: company_rating (the employer's
Glassdoor score, which had no legacy field at all), company_ratings with its ten detailed
scores, company_sector, company_type, company_id, company_profile_url, job_easy_apply,
job_expired, job_source, job_seo_url, job_age_in_days, job_type_labels,
job_description_snippet, company_details and job_salary_benchmark.job_location and job_salary gained keys instead of gaining neighbours. job_location now
carries id, type (city / state / country / metro) and country_id; job_salary carries
median and source. Their existing keys are unchanged.company_description is filled when Fetch company details is on. It was always empty
before — the one legacy field Glassdoor can now answer.Three fields are deliberately kept in both forms, because the two renderings serve different purposes and dropping either would break someone:
| field | keeps | gains |
|---|---|---|
| employment type | job_types, Glassdoor's raw key | job_type_labels, e.g. ["Full-time"] |
| posting age | job_publication_age, e.g. "14 days ago" | job_age_in_days, e.g. 14 |
| job link | job_url, the tracking link | job_seo_url, the readable one |
job_location.state — the state or region, e.g. New York State. Absent on a country-wide job.job_location.latitude / job_location.longitude — coordinates. Their precision follows the
job's location scope, not its address: a country-wide French listing answers 46 / 2, the
centroid of France. job_location.type tells you which scope applies.job_occupation and job_occupation_id — Glassdoor's normalised occupation and its stable
numeric key. This is not a duplicate of job_normalized_title, which is localised: on a
live glassdoor.fr run the two differed on 11 rows out of 12 — ingénieur front end (h/f)
against front end engineer. It is what lets one role be grouped across country sites.Five more were probed and deliberately left out, so nobody re-opens them without new evidence:
map.postalCode exists but is null on every job tested, header.urgencySignal (the only candidate
for the always-empty job_candidate_numbers) likewise, payPercentile25 / payPercentile75 return
0 on listings — a job only ever carries the low, median and high — and divisionEmployerName is
null throughout. Seniority, language, shift and job-poster fields are rejected by the API outright.
v1_compat view is removed. With one set of fields there is nothing left to switch
between. If you linked to ?view=v1_compat, use ?view=overview; the columns you were reading
are all there.company_rating and the overall score in company_ratings are both kept on purpose. They look
like the same number and usually are, but they come from different places in Glassdoor and
disagree on about a quarter of rows — measured on live data, 1 against 2.6 on one job.What the market pays, next to what the job pays.
"Add salary benchmark" — a new option that answers the question a salary range on its own cannot: is this job paid well? Every job gains Glassdoor's own market estimate for the same role in the same place — base pay, additional pay (bonus, commission, profit sharing) and total pay, each from the 10th to the 90th percentile, with the currency, the pay period and Glassdoor's confidence rating. A New York software engineer benchmarks at $83,013 / $125,658 / $190,213 base, $43,124 median on top, and $168,783 median all in.
The additional-pay percentiles are worth calling out on their own: almost nobody publishes the bonus side of a role, and it is often a quarter of the package.
It joins on data every row already carries — Glassdoor's normalised job title and the structured location — so there is nothing extra to configure. And it is asked once per role and place, not once per job: 30 real jobs held 11 distinct roles, so a live run resolved 18 roles in 2 batched calls. Off by default.
⚠️ The benchmark is always ANNUAL, and the row says so in payPeriod. Glassdoor annualises
these estimates whatever the trade — a New York server comes back at $43,520, not at an hourly
rate — so a job advertised at "$50–100 per hour" is not below a $138,057 benchmark. The two
figures are in different units until you convert, and shipping the period alongside the numbers
is what keeps that from becoming a silent error.
industry is a required argument on Glassdoor's side and changes nothing: five different industry
ids returned the same figures to the cent. It is sent to satisfy the schema and never presented as
a filter.
The currency symbol is derived from the ISO code rather than taken from Glassdoor, which returns it
as an HTML entity (€ instead of €). That also collapsed two copies of the same table into
one, shared with job_salary.currency_symbol.
Two ratings we were not shipping, and the company behind the job.
businessOutlook (the share of
reviewers positive about where the company is heading) and diversityAndInclusion were being
requested by nobody, at exactly the same fill rate as the eight we already shipped. They cost no
extra request and are on every row now, in both modes. The README, the schema and the Jobs view
said eight; they now say ten, because that is what arrives."Fetch company details" — a new option that adds what Glassdoor knows about the employer, which no job query returns at any price:
It is asked once per company, not once per job, and up to 30 companies share a single request. That matters because employers repeat: 700 real jobs held only 192 distinct employers. A run of 1,000 jobs therefore costs about 10 extra requests — against the 1,000 that fetching descriptions costs. Off by default, since it does add a little time to each page.
A company with no Glassdoor profile, or a batch that fails, leaves the row exactly as it was: company details are an enrichment, never a condition for a job to ship.
Six fields that were sitting in the API untouched — including one that was blank since v1.
job_remote / v2.remote — whether the role is work-from-home. This field has existed in the
output since the very first version and was always null: Glassdoor does expose it, under
remoteWorkTypes, and nobody had asked for it. It comes back on 30% of an ordinary search and
100% of a remote-filtered one. A job Glassdoor says nothing about stays empty rather than being
reported as on-site — absence is not proof.
v2.seoUrl — the clean, readable listing URL Glassdoor itself links to, instead of only the
tracking redirect.
v2.company.profileUrl — the employer's Glassdoor page. The API has no field for it, so it is
built from the employer id and was checked against live pages before shipping.
v2.expired — whether the listing is still live.
v2.jobSource — where Glassdoor imported the listing from, e.g. "Indeed Job Search Platform".
v2.descriptionSnippet — a ~160-character opening excerpt of the description (124-175 across
the sample), served by the search itself. It is what makes a run without descriptions actually
triageable: you can tell what a job is about before deciding to pay for the full text. It is an
excerpt, not a summary, and only sometimes ends in an ellipsis — hence the name. It shows up as
the Description preview column. Comes in two flavours, like the full description does:
descriptionSnippet is plain text, descriptionSnippetHtml keeps the <b> Glassdoor wraps
around your searched keyword.
All six arrive with the search response: no extra request, no extra cost, both modes.
Readable job link, Remote, Expired, Listing source and Company profile are now
columns in the Jobs view, and the Legacy (v1) view gained job_remote and job_posted_date,
which had nothing to show until now.
Two candidates were probed and deliberately dropped: payPercentile25 / payPercentile75 return
0 on every job tested, and organic reports true even on sponsored listings. Shipping either
would have meant shipping a field that is always wrong.
The company profile and all 8 ratings now come with every job, description or not.
company_size and company_revenue shipped the literal string "Unknown". Glassdoor sends
"Unknown" / "Unknown / Non-Applicable" rather than omitting an unknown value; those now come
back empty, like every other missing field. Affects roughly one employer in five.company_short_name returned the full company name. It now uses Glassdoor's actual short name
("NVIDIA" rather than "NVIDIA Corporation").job_location.country now prefers Glassdoor's own country name, so it resolves for any
country instead of only the 20 the country selector offers — including in the job-ID mode, which
never goes through a search and would otherwise have been the one mode left without a country.Currency and country, in every mode.
min and max but currency: null, so a €45,000 job and a $45,000 one were indistinguishable
in the same dataset. Glassdoor serves the currency on the search response itself — we simply
weren't asking for it. currency, currency_symbol and estimated (employer-stated vs
Glassdoor estimate) are now filled in both modes, at no extra cost or time.job_location.country was always empty. It is now resolved for all 20 supported country
sites, in both modes.city took whatever came before the
first comma, so a country-scoped listing became city: "united states" and a Brazilian
region-wide one became city: "trabalho remoto" — literally remote work. city is now filled
only when the job really is city-scoped, and left empty otherwise.v2.country — the country name, resolved from Glassdoor's own country id.v2.locationType — what location refers to: C city, S state or region, N country,
M metro area. Lets you tell a city listing from a nationwide one without parsing strings.v2.locationId / v2.countryId — Glassdoor's own identifiers, for joining runs together.What a search can actually return, said honestly — and quicker runs.
Runs announced 2,000 results and delivered about 500. Glassdoor advertises a huge total — 93,361 on one search we probed — but stops serving new results after roughly 500–700 jobs, then simply offers no further page. Paginating to exhaustion returned 547 unique jobs at 30 per page, 554 at 50 and 543 at 100: it is a limit on results, not on pages, so a larger page size does not reach further. The old "Glassdoor returns at most 2,000 results, so we'll fetch 2,000" line came from an early estimate that was never paginated to the end, and it promised four times what any run could deliver. The run log, the Maximum jobs field and the README now state the measured figure. Two consequences worth knowing:
job_id. Each
narrower search gets its own allowance and the results barely overlap: on a live test one
filtered variation returned 739 jobs, 699 of which never appeared in the unfiltered run.The Docker image only kept building thanks to a cache. The build installed pnpm@latest,
an unpinned version. pnpm moved to 12.x, whose new install engine cannot reconcile the
node_modules shipped in the Apify base image, and every fresh build failed. Existing builds
survived on a layer cache, so nothing looked wrong — one cache eviction and the Actor would have
become unbuildable with no code change to blame. pnpm is now pinned to the version that produced
the lockfile. This is the same class of failure that broke the previous Glassdoor scraper.
Runs are about 20% faster, and cost a fifth as much to operate. Measured over 11 live runs sweeping concurrency and memory against the same search:
| before | now | |
|---|---|---|
| concurrent requests | 10 | 25 |
| memory | 4 GB | 1 GB |
| seconds per job | 0.219 | 0.164 |
The scraper is limited by the network, not the machine: CPU sits at 9–13% and memory peaks around 175 MB whatever it is given, so 4 GB was twelve times what a run uses. 25 requests at a time is a measured peak and not a floor — 50 was slower than 25 — and no run was blocked or failed at any level tested. Your price is unchanged, since billing is per delivered job; runs simply finish sooner.
Amazon also removes
Amazon.com Services LLC — while Apple leaves Applebee's alone, because the match is on whole
words. Excluded jobs never reach your dataset and never trigger a details request, and the run
keeps paginating until it reaches your maximum: on a live test, excluding two employers dropped 15
jobs and still delivered the 20 requested. The count is reported at the end of the run.
(Glassdoor has no exclusion filter of its own — its filter bar offers Easy Apply, Remote, Company
rating, Date posted and Salary range — so this is applied as results arrive.)"fulltime") was rejected outright with
"Field input.jobType must be array", without ever reaching the compatibility layer. The old
field now accepts both the old single value and a list, so those tasks run again; the picker you
see in the Console moved to Type of employment and is unchanged. Nothing to redo on your side.Pay-per-event billing, and the cost work that makes it viable.
Apify retires the rental pricing model on 2026-10-01; Actors left on it are migrated to pay-per-usage, where the developer earns nothing. This release moves the Actor to pay-per-event and cuts the platform cost it now has to absorb.
job-basic $0.001 ($1 per 1,000) · job-detailed $0.003 ($3 per 1,000) ·
apify-actor-start $0.005 per run.failed: true rows are still never charged. apify-default-dataset-item is deliberately not
declared — it would bill them.safeCharge() now refuses platform-managed events outright: charging apify-actor-start
from code fails the run./graph crawl moves to the cheaper datacenter pool. Measured over 8 cities and
1,912 jobs: /graph is unaffected by the pool, while lookups score 8/8 on residential against
4/8 on datacenter — so neither pool alone is right. Cost per 1,000 enriched jobs falls from
$0.100 to $0.013.apify-actor-start at a single charge per run./partner/jobListing.htm?…), never a full address, and we shipped it as-is — so v2.applyUrl
and job_apply_url couldn't be opened or clicked without knowing to prepend the site yourself.
Both now carry the complete URL (verified: it resolves straight to the job listing). job_url was
already complete, so rows used to contradict themselves.v2.jobUrl), built from the job id alone — so it is
there in the fast mode too, where the previous scraper had no link at all. The legacy job_url
field now falls back to it instead of staying empty.v2.jobTypes): Full-time, Part-time, Contract — the previous
scraper exposed Glassdoor's raw internal keys (search-jobs.job-type-options.fulltime), which it
still does under the legacy field, untouched.Location locked in: cambridge; it now says
Location locked in: Cambridge, MA (US), so a wrong pick is obvious on the first run. Add the
state or country to your search (Cambridge, UK) — or paste a Glassdoor search URL — to force the
one you mean.location: "new york" with 11,228 US-wide jobs. The lookup now retries on a fresh exit IP
(measured 20/20 successful resolutions, versus 6/8 before), and when a location genuinely
cannot be matched the run stops with a clear message and charges nothing instead of quietly
scraping the wrong thing. Searching by company name gets the same treatment — it used to crash the
whole run on the same blip.AUTH_SERVICE_URL /
AUTH_SERVICE_KEY are set as documented — both those names and COOKIE_SERVICE_* are accepted.🎯 Title match — results now stay on topic. Glassdoor matches a keyword one word at a time and, once the genuinely-matching jobs run out, keeps padding the results with loosely related roles. A search for AI engineer drifted into anything containing "engineer" — attorneys, machinists, project schedulers. The new Title match setting fixes that:
Replayed against a real customer run, Strict took the dataset from 46% to 100% on-topic. Skipped jobs are always reported at the end of the run, and are never charged.
sgocId; the taxonomy was discovered from live jobs and every category was filter-verified. The
previous scraper's "Domain" filter targeted ids that are now dead on Glassdoor's side — this
replaces it with the current, working taxonomy./graph)"HUGE") to a filter that
expects a numeric bucket id — Glassdoor ignored it and returned every size. Now mapped to 1–5."EASY_APPLY_ONLY", which made the whole search query error out; now sends the numeric 1.industryNId, each id verified live. Also
fixes the industry filter for previous-version inputs, which likewise never worked before.select editor sends its
value as a string even when the field is declared integer, so postedWithinDays, minRating
and radiusKm arrived as "7"/"4"/"50" and failed Zod validation (expected number, received stringminRating still enforces its 0–5 bound. (minRating/radiusKm were latent —
they only worked while left at their default.)Initial build. Replaces the broken glassdoor-jobs-scraper.
cf_clearance; the actor itself is
a pure-HTTP scraper (CheerioCrawler + impit, Firefox fingerprint, no browser in the runtime).POST /graph GraphQL, gd-csrf-token: 1 (literal — no token minting).scrapeDetails: full description + employer dossier (size, industry, revenue,
8 detailed ratings) — one extra request per job.v2 block,
so existing glassdoor-jobs-scraper buyers do not break. v1 inputs are auto-detected and
force scrapeDetails.totalJobsCount, never silently truncated.job-list-page ($0.004), job-detail ($0.006).job_salary was corrected: v1 shipped min/max inverted, pay_period hardcoded "hourly",
and hourly figures for annual jobs. Now min < max, real period, matching figures.company_size / company_industries are now populated (v1 hardcoded them to null).lint / tsc strict / lint:secrets /
lint:kv-leak all green. End-to-end smoke verified through the production residential proxy.COOKIE_FILE
pointing at a jar captured via camouxai. Not production-deployable without it./optimize-perf).