# Glassdoor Salaries Scraper: Pay by Company, Title & City (`epicscrapers/glassdoor-salaries-scraper`) Actor

Get Glassdoor salary data for any company, job title and city: base, bonus and total pay P10–P90, salary counts, currency and confidence. All of a company's salaries, or one title across all companies. Filter by years of experience. No login, no duplicates.

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

## Pricing

from $1.90 / 1,000 salary row saveds

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 Salaries Scraper: pay by company, job title, location and experience

<p align="center">
  <b>Base pay · Bonus &amp; stock · Total pay P10–P90 · Salary counts · Any company, title, city or country</b><br>
  <sub>No Glassdoor account · No duplicates · Bad inputs are skipped, never fail the run</sub>
</p>

Glassdoor Salaries Scraper turns Glassdoor's salary data into a spreadsheet. Give it companies, job titles, places, or any mix of them. You get one row per job title at each company in each place, with the full pay picture Glassdoor shows: base pay, additional pay (bonus, stock, commission) and total pay at the 10th, 25th, 50th, 75th and 90th percentiles. Each row also has the number of salaries behind it, the currency and a link to the Glassdoor page.

<table>
  <tr>
    <td width="33%" valign="top">
      <b>🏢 Whole companies</b><br>
      Enter just a company and get every job title Glassdoor has for it.<br>
      <sub>Microsoft US: 7,730 titles · Amazon US: 16,708</sub>
    </td>
    <td width="33%" valign="top">
      <b>🌍 Whole markets</b><br>
      Enter just a job title and compare it across every company, in a city, state or country.<br>
      <sub>"Software engineer", US: 104,361 estimates</sub>
    </td>
    <td width="33%" valign="top">
      <b>📊 Full pay statistics</b><br>
      Means and P10–P90 for base, additional and total pay on every row, plus <code>salaryCount</code> and confidence.<br>
      <sub>No missing ranges</sub>
    </td>
  </tr>
</table>

- **Your inputs are actually used.** Each company, title and location you enter is its own search, and the log shows exactly what each one matched ("London → metro London (England, United Kingdom)").
- **No duplicates.** Each estimate (company × title × place × experience × pay period) is saved and charged once per run, even when several inputs reach it.
- **Built for bulk.** In a test, one run pulled every US salary of 15 large employers (133,267 rows) in about 8 minutes. Schedule it or call it from the API.

### Who it's for

| You are…                              | Use it to…                                                                                                                       |
| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| Compensation or HR analyst            | Benchmark pay bands for your roles against competitors, city by city, with P25/P50/P75 ready for a band model.                   |
| Recruiter or talent-intelligence team | See what target employers pay a role before you make an offer or pitch a candidate.                                              |
| Job-market or economics researcher    | Pull a title across all companies in a country or state, or every title at a set of employers, and analyze it in your own tools. |
| HR-tech or data developer             | Feed a salary feature or dashboard from the API with a stable, flat schema.                                                      |

### Quick start

1. Click <kbd>Try for free</kbd> and sign in to Apify.
2. Add **Companies** (names, Glassdoor URLs or ids) and/or **Job titles**.
3. Optionally add **Locations** ("New York", "Texas", "London", "Germany"). Empty means the United States.
4. Set **Max rows per search** to `50` for a first run, click <kbd>Start</kbd>, then export from the **Output** tab as JSON, CSV or Excel.

```json
{
    "companies": ["Microsoft"],
    "jobTitles": ["Software Engineer"],
    "locations": ["United States", "London"],
    "maxResults": 5
}
```

### Real output

From the input above (run on 2026-10-21; all 9 rows, a few columns):

| jobTitle                    | location               | currency | basePayMean | totalPayP10 | totalPayP50 | totalPayP90 | salaryCount |
| --------------------------- | ---------------------- | -------- | ----------: | ----------: | ----------: | ----------: | ----------: |
| Software Engineer           | United States          | USD      |     161,193 |     153,947 |     218,041 |     318,812 |      44,791 |
| Software Developer          | United States          | USD      |     133,957 |      98,438 |     145,342 |     216,234 |         570 |
| Software Engineer I         | United States          | USD      |     126,480 |     121,478 |     156,046 |     207,440 |          58 |
| Developer                   | United States          | USD      |     121,905 |      70,705 |     121,905 |     219,107 |          43 |
| Software Engineer/Developer | United States          | USD      |     157,926 |     145,503 |     206,774 |     302,248 |          36 |
| Software Engineer           | London, United Kingdom | GBP      |      69,918 |      50,000 |      70,000 |     105,000 |         370 |
| Software Developer          | London, United Kingdom | GBP      |      65,903 |      36,000 |      55,000 |     107,000 |          49 |
| Developer                   | London, United Kingdom | GBP      |      65,428 |      30,000 |      50,000 |     180,000 |           9 |
| Software Engineer I         | London, United Kingdom | GBP      |      56,316 |      53,720 |      56,218 |      58,716 |           1 |

The first row with all fields:

```json
{
    "companyId": 1651,
    "companyName": "Microsoft",
    "companyLegalName": "Microsoft Corporation",
    "companyLogoUrl": "https://media.glassdoor.com/sql/1651/microsoft-squarelogo-1479856042252.png",
    "companyRating": 3.9,
    "jobTitle": "Software Engineer",
    "jobTitleId": 4279,
    "location": "United States",
    "locationId": 1,
    "locationType": "COUNTRY",
    "yearsOfExperience": null,
    "payPeriod": "ANNUAL",
    "currency": "USD",
    "basePayMean": 161192.71,
    "basePayP10": 120975.31,
    "basePayP25": 138584.69,
    "basePayP50": 161192.71,
    "basePayP75": 187488.9,
    "basePayP90": 214780.12,
    "additionalPayMean": 56847.98,
    "additionalPayP10": 32971.83,
    "additionalPayP25": 42635.99,
    "additionalPayP50": 56847.98,
    "additionalPayP75": 79587.17,
    "additionalPayP90": 104031.8,
    "totalPayP10": 153947.14,
    "totalPayP25": 181220.68,
    "totalPayP50": 218040.69,
    "totalPayP75": 267076.07,
    "totalPayP90": 318811.92,
    "salaryCount": 44791,
    "confidence": "CONFIDENT",
    "url": "https://www.glassdoor.com/Salary/Microsoft-Software-Engineer-Salaries-E1651_D_KO10,27.htm",
    "searchCompany": "Microsoft",
    "searchJobTitle": "Software Engineer",
    "scrapedAt": "2026-10-21T01:06:48.765Z"
}
```

### Input

| Field                | What it does                                                                                                                                                                                                   |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `companies`          | Company names, Glassdoor URLs from any Glassdoor domain (overview, reviews or salary pages) or employer ids. A salary page URL also sets its job title and location.                                           |
| `jobTitles`          | Job titles or keywords. Matching is broad: "software engineer" also returns "Software Developer" and "Software Engineer I".                                                                                    |
| `locations`          | Cities, metros, states or countries. Add the country if a name is ambiguous ("Paris, France", "London, Ontario"). `Worldwide` returns a company in every country where it has salaries. Empty = United States. |
| `yearsOfExperience`  | Experience bands. Glassdoor applies them only to a company together with a job title.                                                                                                                          |
| `maxResults`         | Rows per search (each company × title × location × band). `0` = everything, up to 20,000 per search.                                                                                                           |
| `sortBy`             | `mostReported` (default), `highestPay` or `lowestPay`. Decides which rows you keep when a search has more than `maxResults`.                                                                                   |
| `payPeriod`          | Convert every row to `ANNUAL`, `MONTHLY` or `HOURLY`. Empty = as Glassdoor reports each job (hourly jobs stay hourly).                                                                                         |
| `proxyConfiguration` | Apify Proxy is on by default. Glassdoor limits requests per IP, so the Actor spreads its requests over several proxy IPs.                                                                                      |

#### How searches combine

<table>
  <tr><th>You enter</th><th>You get</th></tr>
  <tr><td>Companies only</td><td>Every job title of each company (in each location)</td></tr>
  <tr><td>Job titles only</td><td>Each title across all companies (in each location)</td></tr>
  <tr><td>Companies + job titles</td><td>Each title at each company (in each location)</td></tr>
  <tr><td>A Glassdoor salary page URL</td><td>That page's company, title and place</td></tr>
</table>

### Output fields

| Group      | Fields                                                                                                                         |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Company    | `companyId`, `companyName`, `companyLegalName`, `companyLogoUrl`, `companyRating`                                              |
| Job        | `jobTitle`, `jobTitleId`, `yearsOfExperience`                                                                                  |
| Location   | `location`, `locationId`, `locationType` (CITY, METRO, STATE, COUNTRY)                                                         |
| Pay        | `payPeriod`, `currency`, `basePayMean`, `basePayP10`–`P90`, `additionalPayMean`, `additionalPayP10`–`P90`, `totalPayP10`–`P90` |
| Confidence | `salaryCount` (salaries behind the estimate), `confidence`                                                                     |
| Links      | `url` (the Glassdoor salary page for that title, company and place)                                                            |
| Run        | `searchCompany`, `searchJobTitle`, `scrapedAt`                                                                                 |

All pay figures in a row use its `currency` and `payPeriod`. Glassdoor does not publish a mean for total pay; `totalPayP50` is the median.

### Pricing

You pay per salary row saved, with no subscription. Platform usage and proxy are included.

<table>
  <tr><th>Apify plan</th><th>Free</th><th>Bronze</th><th>Silver</th><th>Gold</th></tr>
  <tr><td>Per 1,000 rows</td><td>$2.80</td><td>$2.50</td><td>$2.20</td><td>$1.90</td></tr>
</table>

A run with a spending limit fetches only as many rows as the limit pays for, then stops.

### Tips and limits

- **Big companies:** one search returns at most 20,000 rows. Amazon's 16,708 US titles fit in one search. To go further, add locations (states or cities); each one is a separate search.
- **Ambiguous places:** "London" means London, England; "Washington" means the Washington DC metro. Write "London, Ontario", or use a state abbreviation for a US state ("WA"). The run log shows what each location matched.
- **Small samples:** rows with a low `salaryCount` (1–5) are real Glassdoor estimates but noisy. Filter on `salaryCount` or `confidence` for benchmarking.
- **Title variants:** outside the US, Glassdoor sometimes returns several small estimates for the same title, company and place. The Actor keeps the one based on the most salaries. The run's `SUMMARY` record counts the others.
- **Bad input never fails a run:** an unknown company or place is skipped with a warning in the log, and the run finishes with the rest.

### Track salaries over time with scheduled runs

Glassdoor estimates move as new salaries come in. Run the same searches every month and compare the runs to see how pay changes at a company or for a title.

#### 1. Save your input as a task

Open the Actor, set your input, then click **Save as a new task**. A task is a saved input you can run again with one click or on a schedule.

#### 2. Schedule the task

In Apify Console, go to **Schedules**, click **Create new**, choose how often to run (for example on the 1st of every month, cron `0 6 1 * *`), and add your task. See [Schedules](https://docs.apify.com/platform/schedules).

Watch how to schedule an Actor:

https://www.youtube.com/watch?v=1jI7WcVQmwM

Or schedule a saved task:

https://www.youtube.com/watch?v=GRFW_Loo2dk

#### 3. Send the results to a spreadsheet

Connect Google in the task's **Integrations** tab to save every run to Google Sheets or Google Drive automatically:

https://www.youtube.com/watch?v=IFTeKdj6ZGM

#### 4. Get the data from the API

To feed your own app or dashboard, run the Actor and download its rows with the Apify API:

https://www.youtube.com/watch?v=ViYYDHSBAKM

### For AI agents

Actor: `epicscrapers/glassdoor-salaries-scraper`. Minimal input:

```json
{ "companies": ["Microsoft"], "jobTitles": ["Software Engineer"], "locations": ["London"], "maxResults": 20 }
```

- `companies` and `jobTitles` are string arrays; at least one of them must be non-empty. Companies accept names, Glassdoor URLs or numeric employer ids.
- `locations`: string array of city / metro / state / country names, or Glassdoor URLs; empty = United States; `"Worldwide"` = all countries for each company.
- Key output fields per row: `companyName`, `jobTitle`, `location`, `currency`, `payPeriod`, `basePayMean`, `additionalPayMean`, `totalPayP10`, `totalPayP25`, `totalPayP50`, `totalPayP75`, `totalPayP90`, `salaryCount`, `url`.
- One charged event per row. The run's `SUMMARY` key-value record lists skipped inputs and counts.

### FAQ

**Do I need a Glassdoor account?**

No. The Actor reads Glassdoor's public salary estimates. You don't need cookies or a login.

**Why are some job titles in my results different from what I typed?**

Glassdoor matches keywords broadly. "Software engineer" returns every matching title, such as "Software Developer". Each row's `jobTitle` is Glassdoor's title for that estimate, and `searchJobTitle` is what you typed.

**Can I compare hourly and salaried jobs?**

Yes. Set `payPeriod` to `ANNUAL`, and Glassdoor converts every row to yearly pay.

**How do I get salaries outside the United States?**

Add a location: a country ("Germany"), state ("Ontario") or city ("Bengaluru"). Pay comes in that place's currency. For a company in every country where it has salaries, use `"Worldwide"`.

**Is it legal?**

The Actor collects only aggregated salary estimates that Glassdoor shows publicly, with no personal data. You are responsible for how you use the data.

# Actor input Schema

## `companies` (type: `array`):

Company names ("Microsoft"), Glassdoor company URLs from any Glassdoor domain ("https://www.glassdoor.co.uk/Overview/Working-at-Google-EI_IE9079.11,17.htm") or Glassdoor employer ids ("1651"). A company with no job title returns all of its salaries. A Glassdoor salary page URL also brings its job title and location. Leave empty to search a job title across all companies.

## `jobTitles` (type: `array`):

Job titles or keywords, e.g. "Software Engineer", "nurse", "data analyst". Each one returns every matching job title ("software engineer" also finds "Senior Software Engineer"). With no company, it searches all companies on Glassdoor. Leave empty to get all job titles of the companies above.

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

Cities, metro areas, states or countries, e.g. "New York", "San Francisco", "Texas", "London", "Germany", "Bengaluru". Add the country when a name is ambiguous ("Paris, France", "London, Ontario") or paste a Glassdoor salary URL for that place. "Worldwide" returns a company in every country where it has salaries. Empty = United States (Glassdoor's default).

## `yearsOfExperience` (type: `array`):

Pay for people with this much experience, one row per band. Glassdoor applies it only to a company together with a job title, and then gives one estimate for that exact title. Leave empty for all experience levels.

## `maxResults` (type: `integer`):

Most salary rows to save for each search (each company × job title × location × experience band). 0 = all Glassdoor has, up to 20,000 per search.

## `sortBy` (type: `string`):

Which rows come first, and which are kept when a search has more than "Max rows per search".

## `payPeriod` (type: `string`):

Convert every row to one pay period, e.g. annual for comparing hourly and salaried jobs. Empty = as Glassdoor reports each job (annual, monthly or hourly).

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

Glassdoor limits requests per IP address. The Actor spreads its requests over several proxy IPs and changes IP when one is limited. Keep it on for large runs.

## Actor input object example

```json
{
  "companies": [
    "Microsoft",
    "https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.11,17.htm"
  ],
  "jobTitles": [
    "Software Engineer"
  ],
  "locations": [
    "United States",
    "London"
  ],
  "maxResults": 50,
  "sortBy": "mostReported",
  "payPeriod": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "companies": [
        "Microsoft",
        "https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.11,17.htm"
    ],
    "jobTitles": [
        "Software Engineer"
    ],
    "locations": [
        "United States",
        "London"
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/glassdoor-salaries-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 = {
    "companies": [
        "Microsoft",
        "https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.11,17.htm",
    ],
    "jobTitles": ["Software Engineer"],
    "locations": [
        "United States",
        "London",
    ],
    "maxResults": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/glassdoor-salaries-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 '{
  "companies": [
    "Microsoft",
    "https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.11,17.htm"
  ],
  "jobTitles": [
    "Software Engineer"
  ],
  "locations": [
    "United States",
    "London"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call epicscrapers/glassdoor-salaries-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,epicscrapers/glassdoor-salaries-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/OP2hrN48jKzssYhS7/builds/jYho4afvmGebm9Dyz/openapi.json
