# Glassdoor Jobs Scraper (`simpleapi/glassdoor-jobs-scraper`) Actor

🔎 Glassdoor Jobs Scraper extracts public Glassdoor listings by keyword/location—titles, companies, locations, salaries, ratings, descriptions & URLs—at scale. 📊 Export CSV/JSON. ⚙️ For recruiters, talent intel, market research & ATS enrichment. 🚀 Fast, reliable.

- **URL**: https://apify.com/simpleapi/glassdoor-jobs-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 13 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Glassdoor Scraper — Job Listings, Salary Ranges and Company Data

The Glassdoor Jobs Scraper extracts job listings from Glassdoor by keyword, location, or bulk search URL — returning job title, company, job URL, posted date, numeric salary (min/median/max), Easy Apply status, seniority, and employer firmographics (headquarters, size, revenue, website) as one JSON row per listing. Recruiters building pipelines, sales teams targeting companies that are hiring, and labour-market researchers tracking wage trends use it instead of manual browsing. Configure one search and the dataset is ready to filter, export, or pipe downstream.

### What is Glassdoor Jobs Scraper?

Glassdoor Jobs Scraper is an Apify Actor that queries Glassdoor's own job-search backend (the same BFF endpoint glassdoor.com uses) and returns structured job and company data as JSON, CSV, or Excel. **No Glassdoor account, login, or API key is required** — it runs anonymously against Glassdoor's public search and public employer-overview pages.

- **Two ways to find jobs:** a keyword + location search across 25 Glassdoor country domains, or bulk Glassdoor job-search URLs for power users (`urls`), bypassing keyword/country entirely.
- **Core identifying fields:** job title, job ID, canonical job URL, and the employer's name, short name, and profile URL for every listing.
- **Real numeric salary data:** parsed minimum/median/maximum pay (10th/50th/90th percentile) and currency — not just a text string.
- **Employer enrichment:** headquarters, employee-size band, revenue, website, description, and tagline, pulled from the same employer Overview page fetch.
- **Server- and client-side filters:** salary range, listing freshness, job type, seniority, industry, domain, employer size, remote-only, Easy Apply, search radius, and minimum employer rating.
- **Export formats:** JSON, CSV, and Excel via the Apify dataset, or pulled programmatically through the Apify API.

### What data can I extract with Glassdoor Jobs Scraper?

Every run returns job fields, salary fields, and employer fields in a single flat-ish JSON row, plus the full raw payload for anyone who wants the untransformed source.

| Field | Example value | Use case |
| --- | --- | --- |
| `job_title` | `"Senior Backend Engineer"` | Role matching and search relevance |
| `job_id` | `"1009876543"` | Stable per-listing identifier for de-duplication |
| `job_normalized_title` | `"Backend Engineer"` | Grouping listings by role family |
| `job_url` | `"https://www.glassdoor.com/job-listing/..."` | Direct link for applicants or CRM records |
| `job_location` | `{"unknown":"Austin, TX","city":"austin","country":"us","zip":"78701"}` | Geographic filtering and mapping |
| `job_description` | `"We are looking for a backend engineer..."` | Plain-text description for parsing/NLP |
| `job_description_html` | `"<p>We are looking...</p>"` | Original formatted description for re-display |
| `job_posted_date` | `"2026-07-18"` | Listing recency |
| `job_remote` | `false` | Remote/on-site segmentation |
| `job_salary` | `{"currency":"USD","min":95000,"median":120000,"max":150000,...}` | Compensation benchmarking |
| `job_easy_apply` | `true` | Application-friction scoring |
| `job_age_days` | `7` | Freshness / staleness checks |
| `job_job_types` | `["fulltime"]` | Contract-type segmentation |
| `job_levels` | `"Mid-Senior level"` | Seniority segmentation |
| `job_benefits_tags` | `["Health insurance","401(k)"]` | Benefits comparison |
| `job_shifts_and_schedule_tags` | `["Day shift"]` | Schedule filtering |
| `job_sponsored` | `false` | Sponsored vs organic listing flag |
| `job_industry` | `"Information Technology"` | Sector segmentation |
| `job_language` | `"en"` | Localization/routing |
| `company_uri_providers` | `[{"provider":"glassdoor","url":"..."}]` | Canonical employer profile link |
| `company_name` | `"Acme Robotics"` | Employer identification |
| `company_short_name` | `"Acme-Robotics"` | Slug used in Glassdoor URLs |
| `company_logo` | `"https://media.glassdoor.com/..."` | Branding/display |
| `company_headquarters_location` | `{"city":"seattle","unknown":"Seattle, WA"}` | Employer geography |
| `company_sizes_str` | `"1001 to 5000 Employees"` | Company-size segmentation |
| `company_website` | `"https://acme-robotics.com/"` | Domain enrichment / firmographics |
| `company_revenue` | `"$100 to $500 million (USD)"` | Firmographic scoring |
| `company_url` | `"https://www.glassdoor.com/Overview/..."` | Full employer profile |
| `company_description` | `"Acme Robotics builds warehouse automation..."` | Company context |
| `company_tag_line` | `"Automation for everyone"` | Employer branding |
| `company_industries` | `["Information Technology"]` | Sector filtering |
| `all` | *(full raw jobview + employer payload)* | Access to every field Glassdoor served, unmodified |
| `scrapedAt` | `"2026-07-25T14:03:11.482Z"` | Data-freshness / audit timestamp |

#### Salary, seniority and posted date

`job_salary` carries the parsed compensation object — `currency`, `currency_symbol`, `pay_period`, an `estimated` flag (true when Glassdoor labels the figure an estimate rather than employer-disclosed pay), and the `min`/`median`/`max` figures taken directly from Glassdoor's 10th/50th/90th percentile pay object. Values are `null`, never fabricated, when Glassdoor doesn't disclose pay for that listing — use `includeNoSalaryJob` to decide whether those rows are collected at all. `job_levels` carries the seniority text Glassdoor/Indeed attaches to the listing (e.g. "Mid-Senior level"), and `job_posted_date` plus `job_age_days` give both an absolute date and a rolling day-count for tracking how fresh a listing is. A recruiting team can sort a run by `job_salary.median` to find the highest-paying open roles for a title, or filter on `job_age_days` to flag postings that have been open unusually long.

#### Location, industry and job-type targeting

`job_location` breaks a listing's location into `city`, `country`, and `zip` alongside the raw `unknown` string Glassdoor displayed, so results can be grouped or mapped without re-parsing free text. `job_industry` and `company_industries` carry the employer's primary sector, matching the `industryType`/`domainType` inputs used to narrow a search. `job_job_types` and `job_remote` mark contract style and remote/on-site status, matching the `jobType` and `remoteWorkType` inputs. Together these fields let a downstream dataset be sliced by geography, sector, and work arrangement without any extra scraping.

### Why not build this yourself?

Glassdoor has no public, self-serve developer API — there is no documented endpoint a developer can request a key for and call directly. Reproducing this data yourself means reverse-engineering Glassdoor's internal `job-search-next/bff/jobSearchResultsQuery` endpoint, its cursor-based pagination, and a location-lookup AJAX call, then keeping all three working as Glassdoor changes them.

#### Why is scraping Glassdoor job search harder than it looks?

Glassdoor's search results and employer pages are not static HTML you can parse once and forget. The employer Overview page recently migrated from a single `__NEXT_DATA__`/`apolloState` JSON blob to React Server Components streaming (`self.__next_f.push(...)` chunks) — a format change that silently breaks any scraper written against the old shape. Anonymous requests are also rate-limited and fingerprinted, so a plain HTTP client gets blocked quickly at any real volume. This Actor impersonates a real Chrome TLS fingerprint, parses both the legacy and current RSC page formats, and escalates through direct → Apify datacenter → Apify residential proxy tiers automatically when a request is blocked, going "sticky residential" for the rest of a run once that tier succeeds.

Building and maintaining this yourself means owning proxy rotation, TLS fingerprinting, cursor pagination, and page-format migrations indefinitely. Use the official Glassdoor site directly if you only need to look up a handful of jobs by hand; use this Actor when you need the same data at scale, on a repeatable schedule, as structured JSON.

### How to use data extracted from Glassdoor?

#### Recruiters and talent sourcing

Recruiters run a search on `keyword` + `location`, narrow it with `seniorityType` and `minSalary`, and get back `job_title`, `company_name`, `job_url`, and `job_salary` for every open role that matches — a ready-made market map of who is hiring for a given role and what they're paying, without opening dozens of browser tabs.

#### Sales teams targeting hiring companies

A company posting several roles in `job_industry` or `domainType` categories relevant to your product is a buying signal. Sales and lead-gen teams filter by `industryType`/`domainType` and `companyName`, then pull `company_name`, `company_website`, and `company_headquarters_location` for every employer actively hiring in that space to build a targeted outreach list.

#### Labour market and compensation researchers

Researchers run the same search across `domainType`/`industryType` categories and locations, then aggregate `job_salary.median` and `job_age_days` to study pay distribution and hiring velocity by sector or region — using `minSalary`/`maxSalary` to bucket results into pay bands without needing Glassdoor's own (login-gated) salary-explorer tools.

#### AI agents and automated pipelines

Because the Actor is a standard Apify Actor, it can be wired into an agent pipeline as a callable job-search tool: an agent passes `keyword`, `location`, and filter parameters, and reads back structured `job_title`/`job_salary`/`company_name` fields instead of scraping HTML itself.

### 🔼 Input sample

All 21 inputs are optional — nothing is `required` in the schema. Provide either `keyword` (+ optionally `country`/`location`) or `urls`; if `urls` is set, it takes priority and `keyword`/`country` are ignored.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `keyword` | No | string | Role, skills, or title to search for. Ignored if `urls` is set. | `"Software Engineer"` |
| `maxItems` | No | integer | Max jobs to collect for the run (min `1`, max `10000`). Default `20`. | `100` |
| `urls` | No | array | Bulk Glassdoor job-search URLs to run directly, bypassing `keyword`/`country`. | `["https://www.glassdoor.com/Job/software-engineer-jobs-SRCH_KO0,16.htm"]` |
| `requestDelayMs` | No | integer | Delay between paginated requests, in ms (min `0`, max `60000`). Default `0`. | `500` |
| `country` | No | string (enum, 25 values) | Which regional Glassdoor site to search. Default `"us"`. | `"gb"` |
| `location` | No | string | City or region to search around. Default `""` (worldwide). | `"London"` |
| `includeNoSalaryJob` | No | boolean | Include listings that don't disclose pay. Default `false`. | `false` |
| `companyName` | No | string | Substring filter on employer name. Default `""`. | `"Amazon"` |
| `minSalary` | No | integer | Minimum salary floor, in the site's local currency (min `0`). Default `0`. | `80000` |
| `maxSalary` | No | integer | Maximum salary ceiling, same currency. `0`/empty = no cap. | `150000` |
| `fromAge` | No | string (enum) | Listing freshness: `ANY`, `1`, `3`, `7`, `14`, `30` (days). Default `"ANY"`. | `"7"` |
| `jobType` | No | string (enum) | `all`, `fulltime`, `parttime`, `contract`, `temporary`, `temp-to-hire`, `internship`, `entrylevel`, `apprenticeship`. Default `"all"`. | `"fulltime"` |
| `radius` | No | string (enum, km) | `0`, `6`, `12`, `18`, `31`, `62`, `124`. Default `"18"`. | `"31"` |
| `industryType` | No | string (enum) | `ALL`, `FINANCIAL`, `MANAGEMENT_AND_CONSULTING`, `HUMAN_RESSOURCES_AND_RECRUITMENT`, `INFORMATION_TECHNOLOGIE`. Default `"ALL"`. | `"INFORMATION_TECHNOLOGIE"` |
| `domainType` | No | string (enum) | `ALL`, `ADMINISTATION`, `AFFAIRS`, `CONSEIL`, `FORMATION`, `ENGENERING`, `FINANCE`, `HUMAN_RESSOURCES_AND_RECRUITMENTS`, `INFORMATION_TECHNOLOGIE`, `LEGAL`, `MEDIA_AND_COMMUNICATION`, `PRODUCT_PROJECT_MANAGEMENT`, `SCIENCE_RESEARCH`, `SELL_AREA`. Default `"ALL"`. | `"ENGENERING"` |
| `employerSizes` | No | string (enum) | `ALL`, `TINY`, `SMALL`, `MEDIUM`, `LARGE`, `HUGE`. Default `"ALL"`. | `"LARGE"` |
| `applicationType` | No | string (enum) | `ALL`, `EASY_APPLY_INCLUDED`, `EASY_APPLY_ONLY`. Default `"ALL"`. | `"EASY_APPLY_ONLY"` |
| `remoteWorkType` | No | string (enum) | `ANY`, `REMOTE_ONLY`. Default `"ANY"`. | `"REMOTE_ONLY"` |
| `seniorityType` | No | string (enum) | `all`, `internship`, `entrylevel`, `midseniorlevel`, `director`, `executive`. Default `"all"`. | `"midseniorlevel"` |
| `minRating` | No | string (enum) | Minimum employer rating: `0`, `1`, `2`, `3`, `4`, `5`. Default `"0"`. | `"4"` |
| `proxyConfiguration` | No | object | Apify Proxy configuration. Default `{"useApifyProxy": false}` (runs direct, then escalates automatically if blocked). | `{"useApifyProxy": true}` |

`country` supports: `us`, `ar`, `au`, `be_nl`, `be_fr`, `br`, `ca_en`, `ca_fr`, `de`, `es`, `fr`, `hk`, `in`, `ie`, `it`, `mx`, `nl`, `nz`, `at`, `ch_de`, `ch_fr`, `sg`, `gb`, `jp`, `kr` — each maps to a real regional Glassdoor domain (e.g. `gb` → `glassdoor.co.uk`).

#### Example input

```json
{
  "keyword": "Data Analyst",
  "country": "us",
  "location": "Chicago",
  "radius": "31",
  "maxItems": 100,
  "minSalary": 70000,
  "fromAge": "7",
  "jobType": "fulltime",
  "seniorityType": "midseniorlevel",
  "minRating": "3",
  "includeNoSalaryJob": false
}
```

#### Common pitfall

Enum casing is not consistent across parameters — `jobType` and `seniorityType` use lowercase values (`"fulltime"`, `"midseniorlevel"`), while `industryType`, `domainType`, `employerSizes`, `applicationType`, `remoteWorkType`, and `fromAge` use uppercase (`"ALL"`, `"REMOTE_ONLY"`, `"7"` is fine but `"ANY"` must stay capitalized). Passing `"remote_only"` or `"Fulltime"` will not match the schema's enum and the filter is silently ignored — copy the exact casing shown above.

### 🔽 Output sample

Every run pushes one dataset item per job, in the same flat shape shown in the fields table above. Export as JSON, CSV, or Excel from the Apify dataset, or pull it with the Apify API.

```json
{
  "job_title": "Senior Backend Engineer",
  "job_id": "1009876543",
  "job_normalized_title": "Backend Engineer",
  "job_url": "https://www.glassdoor.com/job-listing/senior-backend-engineer-acme-robotics-JV_IC1147401_KO0,23_KE24,38.htm",
  "job_location": {
    "unknown": "Austin, TX",
    "city": "austin",
    "country": "us",
    "zip": "78701"
  },
  "job_description": "We are looking for a Senior Backend Engineer to join our platform team...",
  "job_description_html": "<p>We are looking for a Senior Backend Engineer to join our platform team...</p>",
  "job_posted_date": "2026-07-18",
  "job_remote": false,
  "job_salary": {
    "currency": "USD",
    "currency_symbol": "$",
    "pay_period": "yearly",
    "estimated": true,
    "min": 118000,
    "median": 142000,
    "max": 168000
  },
  "job_easy_apply": true,
  "job_age_days": 7,
  "job_job_types": ["fulltime"],
  "job_levels": "Mid-Senior level",
  "job_benefits_tags": ["Health insurance", "401(k)", "Paid time off"],
  "job_shifts_and_schedule_tags": null,
  "job_sponsored": false,
  "job_industry": "Information Technology",
  "job_language": "en",
  "company_uri_providers": [
    { "provider": "glassdoor", "url": "https://www.glassdoor.com/Overview/Working-at-Acme-Robotics-EI_IE1147401.htm" }
  ],
  "company_name": "Acme Robotics",
  "company_short_name": "Acme-Robotics",
  "company_logo": "https://media.glassdoor.com/sql/1147401/acme-robotics-squarelogo.png",
  "company_headquarters_location": {
    "city": "austin",
    "unknown": "Austin, TX"
  },
  "company_sizes_str": "1001 to 5000 Employees",
  "company_website": "https://acme-robotics.com/",
  "company_revenue": "$100 to $500 million (USD)",
  "company_url": "https://www.glassdoor.com/Overview/Working-at-Acme-Robotics-EI_IE1147401.htm",
  "company_description": "Acme Robotics builds warehouse automation systems for logistics operators.",
  "company_tag_line": "Automation for everyone",
  "company_industries": ["Information Technology"],
  "all": {
    "header": { "...": "full raw Glassdoor header block: employer id, pay object, job-type flags, ageInDays, etc." },
    "job": { "...": "full raw Glassdoor job block: listingId, discoverDate, description fragments, etc." },
    "overview": { "...": "full raw Glassdoor employer overview block, when resolved" }
  },
  "scrapedAt": "2026-07-25T14:03:11.482Z"
}
```

Note: the normalized output does not surface an employer star-rating as its own field. `minRating` is applied internally as a filter against Glassdoor's raw rating data, but the numeric rating itself is only reachable inside the `all` raw payload (`all.header.employer.ratings.overallRating`) — there is no dedicated `company_rating` column. If you need that number as a normalized field, pull it from `all`.

### How do you filter and target specific job listings?

Two ways to define a search: a free-text `keyword` (best when you know the exact title or skill you're after) or the structured `industryType`/`domainType` category filters (best for scanning a whole sector without guessing every title variant that sector uses). Combine `keyword` with `industryType`/`domainType` to narrow a broad title search to one sector.

Scope precision comes from `location` + `radius` (in kilometres, from an exact-spot `0` up to a `124` km regional search) and `country`, which points the whole search at one of 25 regional Glassdoor domains. Quality thresholds are `minRating` (drop employers below a star-rating floor), `minSalary`/`maxSalary` (drop roles outside a pay band), and `fromAge` (drop anything older than 1/3/7/14/30 days). `seniorityType` and `jobType` narrow by career stage and contract style; `applicationType` isolates Easy Apply listings; `remoteWorkType` isolates remote-only roles.

Volume is controlled by `maxItems` (hard cap on rows returned) and `requestDelayMs` (pacing between the internal paginated requests, which fetch 30 listings per page under the hood).

```json
{ "keyword": "Product Manager", "location": "Berlin", "radius": "12", "jobType": "fulltime" }
```

```json
{ "domainType": "ENGENERING", "seniorityType": "director", "minSalary": 150000, "minRating": "4" }
```

```json
{ "keyword": "Customer Support", "fromAge": "3", "remoteWorkType": "REMOTE_ONLY", "applicationType": "EASY_APPLY_ONLY", "maxItems": 200 }
```

### ▶️ Want to try other job/company scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| [LinkedIn Company Scraper: Search By Name, Keyword or URL](../LinkedIn-Company-Scraper-Search-By-Name-Keyword-Or-URL) | Public LinkedIn company profiles resolved from a name or keyword — industry, size, HQ, specialties, employees, posts. |
| [LinkedIn Company About Scraper With Firmographic Enrichment](../linkedin-company-about-scraper-with-firmographic-enrichment) | Full LinkedIn firmographics — founded year, org type, follower count, numeric employee count/range, jobs-search deep link. |
| [LinkedIn Company Employees Scraper With Growth Tracker](../linkedin-company-employees-scraper-with-growth-tracker) | Public employee rosters per company with a headcount snapshot for tracking hiring growth over time. |
| [LinkedIn B2B Email Scraper](../LinkedIn-B2B-Emails-Scraper) | B2B and personal emails discovered from LinkedIn via search, with optional decision-maker seniority scoring. |
| [LinkedIn Profile Scraper](../Linkedin-Profile-Scraper) | Individual LinkedIn profile data — experience, education, posts — from a list of profile URLs. |

### How to extract Glassdoor data programmatically

The Actor runs as a standard Apify Actor: one authenticated POST call starts a run, and results come back as structured JSON from the dataset — no browser or Glassdoor session needed on your side.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("glassdoor-jobs-scraper-pay-per-events").call(run_input={
    "keyword": "Data Engineer",
    "location": "New York",
    "minSalary": 100000,
    "seniorityType": "midseniorlevel",
    "maxItems": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["job_title"], item["company_name"], item["job_salary"]["median"])
```

#### Export to spreadsheets or CRM

Every Apify dataset can be exported directly to CSV or Excel from the Console, or fetched via the API in either format. Map `job_title`, `company_name`, `job_url`, `job_salary.median`, and `job_posted_date` to your CRM's role, account, source-link, expected-pay, and date-added columns respectively — no extra transformation needed.

### Is it legal to scrape Glassdoor job listings?

Yes. Job listings and employer profile data are business/product information that Glassdoor publishes for public discovery, not personal data about an individual — this Actor does not collect reviewer names or other personal reviewer content. Scraping publicly accessible business data is generally permissible, though your use remains subject to Glassdoor's Terms of Service and, depending on your jurisdiction, database-rights law rather than GDPR/CCPA (which govern personal data, not job postings or company facts). Consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

**What happens to a job listing that expires or gets removed from Glassdoor?**
It simply won't appear in a new run's results once Glassdoor's search stops returning it. The Actor only reflects what Glassdoor's live search currently serves; use `job_posted_date` and `job_age_days` on each row to judge how fresh a listing was at scrape time, and re-run your search periodically to catch newly expired postings dropping out.

**Can I get salary data along with the main job records?**
Yes, by default. `job_salary` (currency, pay period, and min/median/max figures) ships on every row where Glassdoor discloses pay. Set `includeNoSalaryJob` to `true` if you also want listings that don't disclose pay, with `job_salary` fields returned as `null`.

**How accurate is the salary and company data?**
The Actor returns data exactly as Glassdoor's search and employer-overview pages serve it at request time. Salary figures marked `estimated: true` are Glassdoor's own algorithmic estimate rather than employer-disclosed pay — treat those as directional, not exact, and re-verify time-sensitive figures before using them in a compensation decision.

**How many job listings can I get per run?**
Up to `maxItems`, which accepts 1 to 10,000 (default 20). Internally the Actor paginates through Glassdoor's search results 30 listings per page until it reaches your `maxItems` or runs out of matching listings.

**How do I combine location, salary, and seniority filters in one search?**
Set `location` + `radius` for geography, `minSalary`/`maxSalary` for pay band, and `seniorityType` for career stage in the same input object — all filters apply together, not as alternatives. See the filtering guide above for worked examples.

**Does this scraper work with Claude, ChatGPT, and AI agent frameworks?**
It's callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make an authenticated HTTP call — including custom tool-use setups for Claude or ChatGPT — can trigger a run and read back the dataset.

**How does it compare to other Glassdoor scrapers?**
This Actor's differentiator is parsing Glassdoor's numeric percentile pay object (`min`/`median`/`max`) and enriching every listing with employer firmographics from the same Overview-page fetch, rather than returning only title/company/location text. Evaluate any Glassdoor scraper on exactly those two axes — parsed numeric salary vs. a raw pay string, and whether employer data is included at all — since pricing and speed vary by provider and listing.

**Can I use this without a Glassdoor account or API key?**
Yes. No Glassdoor login, cookies, or developer account are required — the Actor only needs an Apify account to run, and `proxyConfiguration` is optional (used for automatic block-recovery, not authentication).

### Conclusion

Glassdoor Jobs Scraper turns keyword- or URL-based Glassdoor searches into structured, filterable JSON — job details, numeric salary, and employer firmographics in one row, without a Glassdoor login or developer account. It's built for recruiters mapping the hiring market, sales teams spotting active hiring signals, and researchers tracking pay and demand trends. Configure your filters, start a run in the Apify Console, and export the results wherever your workflow needs them.

# Actor input Schema

## `keyword` (type: `string`):

💼 Type the **role, skills, or title** you care about (e.g. *Software Engineer*, *Data Analyst*). This is your main search — make it sparkle! ✨ Leave *Optional bulk URLs* empty to use this mode.

## `maxItems` (type: `integer`):

🎁✨ Set your **sweet spot** — from a tiny taste 🧁 to a **big harvest** 🌾! Higher = more rows in your dataset — **max 500** for power users. 📈🚀

## `urls` (type: `array`):

🧑‍💻 Power-user mode: paste one or more **Glassdoor job-search URLs** (e.g. `https://www.glassdoor.com/Job/software-engineer-jobs-SRCH_KO0,16.htm`) to run them directly, bypassing *keyword*/*country* above. Leave empty to use the simple keyword search instead.

## `requestDelayMs` (type: `integer`):

🕰️ Add a small **pause between paginated requests** (in milliseconds) to go easier on the site — helpful on stricter networks/proxies. **0** = no extra delay. ⚡

## `country` (type: `string`):

🗺️ Choose the **country / language** version of Glassdoor that matches your job hunt. Each option is a real regional site — pick where you want to search! 🌟

## `location` (type: `string`):

🌆🎯 Narrow the map: *London*, *Berlin*, *Bay Area*… or leave **blank** for a **worldwide vibe** 🌍✨ — your call!

## `includeNoSalaryJob` (type: `boolean`):

✅ **On** — you’ll also see posts where pay isn’t shown (still useful!). ❌ **Off** — focus only on listings that mention compensation. 💵

## `companyName` (type: `string`):

🎯 Type part of a **company name** to lean toward those employers — or leave empty to see everyone. ✨

## `minSalary` (type: `integer`):

🎯 Only show roles **at or above** this number (uses the **local currency** for the site you picked). Set **0** for *no minimum* — dream big! 🌈

## `maxSalary` (type: `integer`):

🎀 Cap the range if you want — or leave empty / use **0** for *no upper limit*. Same currency as the site you chose! 🌍

## `fromAge` (type: `string`):

🆕 Prefer **brand-new posts** or don’t mind older ones? Pick how many **days back** you’re happy with — great for staying on top of new openings! ⚡

## `jobType` (type: `string`):

🧩 **Full-time**, **part-time**, **contract**, **internship**… pick what fits your life stage. Choose **All** to keep every option on the table! 🎉

## `radius` (type: `string`):

🗺️ When you use a **place**, this is the **circle around it** — wider = more nearby cities; tighter = closer to home. 🏡

## `industryType` (type: `string`):

🎯 **All** = every industry 🌈 — or pick a **sector** to zoom in (finance 💰, consulting 📊, HR 👥, tech 💻…). Default: **All**. ✨

## `domainType` (type: `string`):

🗂️ **All** = open playing field 🌿 — or choose a **domain** (engineering ⚙️, legal ⚖️, sales 📣…). Default: **All**. 🎨

## `employerSizes` (type: `string`):

🐣🌆 From **tiny teams** to **huge enterprises** — pick your **company-size vibe** or stay **All** for everything! 💼✨

## `applicationType` (type: `string`):

🖱️ **All** = every style ✨ — **Easy Apply included** = mix of flows — **Easy Apply only** = one-click heaven! 🎯 Default: **All**.

## `remoteWorkType` (type: `string`):

🌍 **Any** = remote **and** on-site listings 🏢 — **Remote only** = lean into **WFH-friendly** roles! 🛋️✨ Default: **Any**.

## `seniorityType` (type: `string`):

🌱 Match your **career chapter**: intern 🎓, entry 🌿, mid–senior 📊, director 👔, executive ⭐ — or **All** to explore! 🚀

## `minRating` (type: `string`):

💖 Only show employers rated **at least** this high by the community — or **0** for *no bar*. Trust your gut! 🤝

## `proxyConfiguration` (type: `object`):

🛡️ **Optional.** Use Apify’s proxies for **extra reliability** or when browsing from certain regions — pick what feels right for you. ✨ **Default:** start without extra routing; you can always enable more here! 🚀💫

## Actor input object example

```json
{
  "keyword": "Software Engineer",
  "maxItems": 20,
  "urls": [],
  "requestDelayMs": 0,
  "country": "us",
  "location": "",
  "includeNoSalaryJob": false,
  "companyName": "",
  "minSalary": 0,
  "fromAge": "ANY",
  "jobType": "all",
  "radius": "18",
  "industryType": "ALL",
  "domainType": "ALL",
  "employerSizes": "ALL",
  "applicationType": "ALL",
  "remoteWorkType": "ANY",
  "seniorityType": "all",
  "minRating": "0",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "Software Engineer",
    "urls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/glassdoor-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keyword": "Software Engineer",
    "urls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/glassdoor-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "Software Engineer",
  "urls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/glassdoor-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simpleapi/glassdoor-jobs-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xErQBvzsdpeMig0vJ/builds/h9U6r9alY8GoP5kW5/openapi.json