# Glassdoor Scraper - Job Postings, Salaries & Ratings (`s-r/glassdoor-jobs-scraper`) Actor

Scrape Glassdoor job postings by keyword or a location search URL. Get title, employer, employer rating, location, salary range with its source, Easy Apply and job URL as JSON or CSV. A Glassdoor web scraping tool with job data for recruiters, job boards and salary research. No login.

- **URL**: https://apify.com/s-r/glassdoor-jobs-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 7 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 run start fees

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Glassdoor Jobs Scraper

Glassdoor Jobs Scraper returns public job search cards with the title, employer,
location, employer rating and salary range. It keeps the salary source beside the
amounts so you can distinguish an employer's published figure from a Glassdoor
estimate. Search by a list of terms, paste location-filtered Glassdoor search URLs,
and export one row per posting. Existing input names and output fields continue
to work.

### Glassdoor Jobs Scraper input

Use `queries` for search terms and `urls` for Glassdoor search URLs. Both accept a
list of strings. For existing integrations that send text instead, entries can be
separated by newlines, commas or semicolons. The singular aliases `query` and `url`
also work when the corresponding plural field is absent or empty. At least one
non-empty search term or URL is required.

This is the input used for the recorded default run:

```json
{"queries":["software engineer"]}
```

Each term contributes the first search page, normally thirty job cards. The default
`limit` is 200 jobs across all searches. The allowed total is clamped between one
and 600. An absent, null or zero limit uses the default 200, matching the existing
actor. `retries` defaults to three attempts per search and is bounded between one
and six. Search terms are processed before pasted URLs. At most twenty search
targets are processed in a run; a longer list produces a warning.

For a location-specific search, choose the location on Glassdoor and pass its
search URL in `urls`. The recorded Austin search used this exact URL:

```json
{"urls":["https://www.glassdoor.com/Job/austin-software-engineer-jobs-SRCH_IL.0,6_IC1139761_KO7,24.htm"]}
```

The keyword search uses the United States search surface. Pasted search URLs keep
their own filters. The actor does not add a date filter, country filter or employment
type that was absent from the supplied search. Narrow terms and specific location
URLs are useful when a broad search has many more matching jobs than the returned
sample.

### Output and salary fields

Each dataset row retains the original seventeen fields: `position`, `job_id`, `url`,
`title`, `employer`, `employer_rating`, `location`, `salary_text`, `salary_min`,
`salary_max`, `salary_currency`, `salary_source`, `salary_is_estimate`, `posted_age`,
`easy_apply`, `snippet` and `query`. Missing optional information is null. Job IDs
remain strings and positions remain integers. The employer rating and parsed salary
bounds are numeric values, rather than formatted text.

Additional fields are `source`, `platform`, `fetched_at`, `salary_currency_code` and
`salary_period`. The original `salary_currency` retains the printed symbol, such as
`$`. `salary_currency_code` provides the ISO currency code alongside it. Salary
periods distinguish hourly, daily, weekly, monthly and annual amounts. A single
salary figure is returned as equal minimum and maximum values. Amounts are not
converted into another currency or annualised.

This is a real row from the recorded software engineer response:

```json
{
  "job_id": "1010205632661",
  "url": "https://www.glassdoor.com/job-listing/software-engineering-manager-spang-company-JV_IC1145800_KO0,28_KE29,42.htm?jl=1010205632661",
  "title": "Software Engineering Manager",
  "employer": "Spang & Company",
  "employer_rating": 3.5,
  "location": "Mentor, OH",
  "salary_text": "$126K - $183K (Glassdoor est.)",
  "salary_min": 126000,
  "salary_max": 183000,
  "salary_currency": "$",
  "salary_source": "Glassdoor est.",
  "salary_is_estimate": true,
  "salary_currency_code": "USD",
  "salary_period": "YEAR",
  "posted_age": null,
  "easy_apply": true,
  "snippet": "This position will be responsible for leading the development of and the team assigned to embedded software, including project management, software design,…… Skills: CSS, FPGA, Firmware, JavaScript, Mentoring",
  "query": "software engineer",
  "source": "glassdoor-jobs-scraper",
  "platform": "glassdoor",
  "fetched_at": "2026-10-03T13:26:06.298Z",
  "position": 1
}
```

Treat `salary_source` as part of the salary value. Employer-provided figures and
Glassdoor estimates answer different questions, and averaging the two without
checking their origin can produce misleading comparisons. `salary_is_estimate`
is true for a Glassdoor estimate, false for another printed source and null if the
source is missing. `salary_text` preserves the source label and original display.

The `summary` key-value record reports jobs returned, searches run, jobs per search,
matching-job totals per search, salary coverage, estimate counts, employer-rating
coverage and Easy Apply counts. When one search fails but another succeeds, its
failure is retained in the `errors` record and the successful rows remain available.
The run also provides `OUTPUT` with delivery and charge information. Rows are
uniquely identified by `job_id`, deduplicated across searches, and numbered in
input order.

### Search coverage and limitations

These rows are a sample of a search, not a complete inventory of every matching
vacancy. The search surface supplies roughly thirty cards per search and does not
provide usable page-number pagination for this actor. `totalAvailablePerSearch`
shows the larger count reported by Glassdoor, where available. Adding distinct
searches can expand coverage; repeating the same search will not create additional
unique rows.

A card contains a description excerpt, not the full vacancy description.
`snippet` therefore remains an excerpt. Posting age stays null when Glassdoor does
not show it. The actor does not invent a posting date, employment type, exact city
or full description from a missing field. Job availability, ranking and matching-job
totals can change between runs. A recently removed posting may disappear even if
the search input is unchanged.

Searches that return no cards produce an empty successful run. A temporarily
unavailable search also produces an empty run with its reason recorded; it does
not create a placeholder job. Invalid search input is reported with an English
message. If only part of a list is available, inspect the warnings and errors as
well as the dataset.

### Use cases for a Glassdoor scraper

- **Recruiting and sourcing.** Track which employers are hiring for a role in a city,
  with their Glassdoor rating next to each posting, and follow the job URL to apply or
  reach out.
- **Glassdoor salary data for job postings.** Collect the salary ranges shown on job
  cards for a role or location and keep `salary_source` so employer-published figures
  and Glassdoor estimates stay separate in your analysis.
- **Job boards and aggregators.** Feed fresh postings into your own board or newsletter,
  deduplicated by `job_id` so the same vacancy is not listed twice.
- **Labour-market research.** Compare how many matching jobs Glassdoor reports per
  search (`totalAvailablePerSearch` in the summary) across roles and locations over time.
- **Sales and lead generation.** Companies that are hiring for a function are often
  buying tools for it; the employer and location fields give a ready lead list.

### Compared with other ways to get Glassdoor job data

Copying postings by hand works for a handful of jobs, but not for a weekly list across
roles and cities. Generic multi-board job scrapers cover several sites at once, but
often drop the salary source and the employer rating that make Glassdoor useful. This
actor focuses on Glassdoor job search only and keeps those fields: the printed salary
line, the parsed minimum and maximum as numbers, the currency symbol and ISO code, the
pay period, and whether the figure is a Glassdoor estimate. There is no login, cookie
or browser extension to set up, and you pay per delivered job rather than per compute
minute. It does not scrape company reviews, interview reports or full vacancy
descriptions; use a dedicated reviews tool if you need those.

### Pricing and free-plan limit

The existing pay-per-event pricing remains $0.002 for starting a run and $0.004
for each job actually delivered. An empty run has no job events; the start fee still
applies. Duplicate postings removed from the output are not charged again. Charges
are based on delivered rows, rather than the number of matches advertised by the
search page. The recorded thirty-job run corresponds to one start event and thirty
job events, or $0.122 in actor event fees.

Users without a paid Apify plan receive at most ten job rows per run. The run
output shows when the free-plan cap applies. Paid users retain their requested
limit within the six-hundred-job maximum. For a small paid test, choose a low
`limit` and inspect the output before expanding the search list.

### FAQ

#### Can I filter jobs by location?

Yes. Select a location on Glassdoor and paste the resulting search URL into `urls`.
This preserves the filters encoded in that URL. A plain keyword query uses the
United States search surface.

#### Why do I receive thirty jobs when the summary shows thousands?

The summary reports Glassdoor's matching-job total. The returned rows come from
the first search page. Those are different counts. Use additional distinct terms
or location searches to collect a broader sample.

#### Are all salary figures supplied by employers?

No. Some figures are Glassdoor estimates. Keep `salary_source` and
`salary_is_estimate` when exporting or aggregating salaries so the distinction
remains visible in the resulting dataset.

#### Does this actor return full descriptions or publication dates?

It returns the excerpt displayed on the search card. Posting age is supplied only
when present, and missing dates are not inferred. Fields that have no source value
stay null.

#### Is there an official Glassdoor jobs API?

Glassdoor does not offer an open job-search API that new developers can sign up for.
This actor works as a Glassdoor jobs API on the Apify platform: start a run through the
Apify API with `queries` or `urls`, then read the dataset as JSON, CSV or Excel. Runs can
also be scheduled or triggered from integrations.

#### Will my existing integrations continue to work?

The original input names, defaults, dataset field names and field types are
retained. New currency and period fields are added alongside the originals. The
old `summary` and `errors` records remain available.

# Actor input Schema

## `queries` (type: `array`):

One search per term. Glassdoor returns 30 jobs per search and does not paginate, so more terms is how you get more jobs.

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

Glassdoor search URLs to read as well. Use these for location-filtered searches: pick the location on the site and paste the URL from your browser.

## `limit` (type: `integer`):

How many jobs to return in total, 1 to 600. Each search contributes about 30.

## `retries` (type: `integer`):

Retry attempts per search, each with a rotated TLS fingerprint.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "data analyst"
  ],
  "urls": [
    "https://www.glassdoor.com/Job/austin-software-engineer-jobs-SRCH_IL.0,6_IC1139761_KO7,24.htm"
  ],
  "limit": 200,
  "retries": 3
}
```

# Actor output Schema

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

One row per job posting, with its salary range and where that figure came from.

## `summary` (type: `string`):

Jobs returned, searches run, how many jobs Glassdoor says exist per search, and the split between employer-published and Glassdoor-estimated salaries.

## `errors` (type: `string`):

Per-search failures with a code and a redacted message.

# 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 = {
    "queries": [
        "software engineer"
    ],
    "limit": 200,
    "retries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "queries": ["software engineer"],
    "limit": 200,
    "retries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "queries": [
    "software engineer"
  ],
  "limit": 200,
  "retries": 3
}' |
apify call s-r/glassdoor-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/tEu7vxfLVtYuXlHvK/builds/HG11nd09Czl8L2qk2/openapi.json
