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

Scrape Glassdoor job listings by keyword and location: title, company, location, salary range with median, job type, work mode, benefits, skills, company rating and link, in a clean standardized format. Filters, wide search and new-job monitoring. From $3 per 1,000 jobs.

- **URL**: https://apify.com/tacps126/glassdoor-jobs-scraper.md
- **Developed by:** [Tapaswai Ashok Choudhary](https://apify.com/tacps126) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Get job listings from **Glassdoor** by keyword and location as a clean, spreadsheet-ready dataset. Each job includes the title, company, location, **salary range (10th–90th percentile) with the median and the yearly equivalent**, whether the pay is employer-provided or a Glassdoor estimate, job type, work mode, benefits, the skills tagged on the posting, the company's Glassdoor rating and logo, and the link to the job. Export to JSON, CSV or Excel, send to Google Sheets or Slack, or call it as an API.

**Built for** recruiters and staffing agencies, job boards and aggregators, compensation and HR analysts benchmarking pay, sales teams looking for companies that are hiring, and job seekers who want new postings delivered to them.

### Why this scraper

- **Pay data included.** Glassdoor shows a pay range for most jobs. You get it as min/max/median with currency, period and yearly equivalent, plus a flag for employer-provided vs. estimated pay.
- **Rich, standardized records.** Work mode, employment type, seniority and job function are filled in the same way as in our other job scrapers (Indeed, LinkedIn, Greenhouse, Lever, Workday…), so you can combine sources in one table.
- **Any location.** Type a city, state or country in plain words (`Chicago, IL`, `London`, `Germany`). The Actor finds the matching Glassdoor location for you.
- **Wide search for more jobs.** Turn on *Wide search* and each query + location is searched from several angles (most relevant, newest, last 24 hours, last 3 days, full-time, contract, part-time) to collect several times more distinct jobs.
- **New-job monitoring.** Schedule it with *Only new jobs* and each run returns only postings you haven't received yet, so you pay only for new ones.
- **Filters applied for you.** Title keywords, work mode, employment type, seniority, job function, minimum salary, "with salary only", excluded companies. Filtered-out jobs are never charged.
- **No account needed.** Nothing to log in to.
- **Resilient.** If Glassdoor shows a security check, the search is retried automatically on a fresh connection. Results are saved as each search finishes, and a moved run resumes without charging twice.

### How to use it

1. Add **Search queries** (e.g. `registered nurse`, `data analyst`) and **Locations** (e.g. `Chicago, IL`).
2. Optionally pick **Posted within**, **Job type** and **Sort by**, and turn on **Wide search** for more results.
3. Press **Start**. Download results from the **Output** tab, or connect an integration.

#### Example input

```json
{
  "queries": ["data analyst", "software engineer"],
  "locations": ["Chicago, IL", "Austin, TX"],
  "datePosted": "7",
  "wideSearch": true,
  "maxItems": 500
}
```

### What you get

| Field | Description |
|-------|-------------|
| `title` / `company` | Job title and employer |
| `location`, `city`, `region`, `countryCode` | Where the job is |
| `salary` | `{min, max, currency, period, annualMin, annualMax}`: Glassdoor's 10th–90th percentile range |
| `salaryMedian`, `salaryIsEstimate` | Median pay; `true` when it's Glassdoor's estimate rather than the employer's |
| `workMode` | `remote`, `hybrid` or `onsite` when the posting says so |
| `employmentType`, `jobTypes` | Full-time, part-time, contract, internship… |
| `benefits` | E.g. health insurance, 401(k), paid time off |
| `skills` | Skills and requirements tagged on the posting |
| `summary` | The short description shown in search results |
| `seniority`, `jobFunction` | Derived from the title |
| `companyRating`, `companyLogo`, `employerId` | Employer details on Glassdoor |
| `easyApply`, `sponsored` | Glassdoor flags (`sponsored` = promoted by the employer) |
| `url`, `jobId` | Link to the job on Glassdoor and its listing id |
| `postedAtIso`, `postedDaysAgo` | When it was posted |
| `searchQuery`, `searchLocation` | Which search found it |

### How many jobs per search?

Each search returns the jobs on Glassdoor's first results page, about **30 per search**. For more jobs, add more locations or related queries, turn on **Wide search**, or schedule the Actor with **Only new jobs** to build up a complete feed over time. Full job descriptions aren't included; you get the summary shown in search results plus the tagged skills and benefits.

### Pricing

Pay per result: about **$3 per 1,000 jobs** (lower on higher Apify plans) plus a tiny start fee. Duplicates, filtered-out jobs and (with *Only new jobs*) already-delivered jobs are free. See the **Pricing** tab for exact rates, and set a maximum charge per run to cap spend.

On Apify's **free plan** each run returns up to 100 jobs, enough to try it out. Any paid Apify plan removes the limit.

### FAQ

**Why do some searches take longer?** Every search opens Glassdoor in a real browser. When Glassdoor shows a security check, the search is retried on a fresh connection.

**Is it legal?** The Actor collects publicly listed job ads. You're responsible for how you use the data, including any personal data, under the laws that apply to you.

### Support

Found a problem or need a field that isn't there yet? Open an issue on the **Issues** tab with your input and what you expected. Requests decide what gets built next.

# Actor input Schema

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

What to search for — job title, skill or company, one per line. Every query runs in every location.

## `locations` (type: `array`):

City, state or country (e.g. `Chicago, IL`, `London`, `Germany`), one per line. Leave empty to search all of the US.

## `datePosted` (type: `string`):

Only jobs posted in this window.

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

Only this type of job.

## `radius` (type: `integer`):

Distance around each location in miles.

## `sort` (type: `string`):

Order Indeed returns results in.

## `wideSearch` (type: `boolean`):

Run each search from several angles (most relevant and newest, last 1 and 3 days, full-time, contract and part-time) to collect many more different jobs per query and location. Takes a little longer.

## `includeSponsored` (type: `boolean`):

Keep jobs that employers promote on Glassdoor. They're marked with `sponsored: true`.

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

Maximum number of jobs to return in total.

## `titleIncludes` (type: `array`):

Keep a job only if its title contains any of these words (case-insensitive), e.g. `engineer`, `developer`.

## `titleExcludes` (type: `array`):

Drop a job whose title contains any of these words (case-insensitive), e.g. `intern`, `manager`.

## `locationIncludes` (type: `array`):

Keep a job only if its location contains any of these (case-insensitive), e.g. `Berlin`, `Remote`.

## `remoteOnly` (type: `boolean`):

Only remote jobs (uses Indeed's remote filter).

## `workModes` (type: `array`):

Keep only these work arrangements. Jobs whose posting doesn't state it are dropped when this is set.

## `employmentTypes` (type: `array`):

Keep only these employment types.

## `seniorities` (type: `array`):

Keep only these seniority levels.

## `jobFunctions` (type: `array`):

Keep only these job functions (engineering, data, sales, …).

## `descriptionIncludes` (type: `array`):

Keep a job only if its summary or skills mention any of these.

## `companyExcludes` (type: `array`):

Drop jobs from companies whose name contains any of these, e.g. staffing agencies.

## `minAnnualSalary` (type: `integer`):

Keep jobs paying at least this per year (hourly and monthly pay are converted), in the posting's currency. Jobs that don't publish pay are kept unless “Only jobs with salary” is on.

## `onlyWithSalary` (type: `boolean`):

Keep only jobs that publish their pay.

## `onlyNew` (type: `boolean`):

Return only jobs that no earlier run with the same input has delivered. Schedule the Actor and you pay only for new jobs.

## `monitorName` (type: `string`):

Optional name for the 'only new' history. Runs sharing a name share one history; leave empty to derive it from the sources.

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

Residential proxy in each location's country is used by default — Glassdoor blocks cloud IPs.

## `tenantId` (type: `string`):

Optional label used to keep separate histories for different clients or teams.

## `debug` (type: `boolean`):

Save extra diagnostics with the run.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "locations": [
    "Austin, TX"
  ],
  "sort": "relevance",
  "wideSearch": false,
  "includeSponsored": true,
  "maxItems": 200,
  "remoteOnly": false,
  "onlyWithSalary": false,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debug": false
}
```

# Actor output Schema

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

The produced items (default dataset items).

# 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"
    ],
    "locations": [
        "Austin, TX"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tacps126/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"],
    "locations": ["Austin, TX"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tacps126/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"
  ],
  "locations": [
    "Austin, TX"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call tacps126/glassdoor-jobs-scraper --silent --output-dataset

```

## MCP server setup

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