# Glassdoor Salaries Scraper API - Base, Bonus & Total Pay (`scrapifier/glassdoor-salaries-scraper`) Actor

💰 Scrape Glassdoor salary estimates by company name or URL. Get base pay (low/median/high), total pay, bonus, stock & profit sharing per job title, with the number of reported salaries, currency & pay period. No login and no proxy needed.

- **URL**: https://apify.com/scrapifier/glassdoor-salaries-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** Jobs, Business
- **Stats:** 35 total users, 11 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.04 / 1,000 results

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 API - Base, Bonus & Total Pay

Scrape salary estimates from Glassdoor by company name or Glassdoor URL and export them as JSON, CSV or Excel, or pull them straight from the API.

⚡ For every job title reported at a company you get the **base pay low, median and high**, the **total pay** range, the **additional pay median** with its breakdown (cash bonus, stock, profit sharing, sales commission, tips), the **number of reported salaries**, the most recent report date, the currency, the pay period (annual, monthly or hourly), the region the figures cover and an optional full percentile range for base and total pay. Works with **no login, no cookies and no proxy**, on six Glassdoor domains (.com, .co.uk, .ca, .com.au, .co.in, .ie). You **pay per job-title row**.

[![Apify Actor](https://apify.com/actor-badge?actor=scrapifier/glassdoor-salaries-scraper)](https://apify.com/scrapifier/glassdoor-salaries-scraper)

### 🎯 Why scrape Glassdoor salaries?

- **Compensation benchmarking**: compare your pay bands with the base and total pay Glassdoor reports for the same job titles at competitors, in one spreadsheet instead of dozens of pages.
- **Recruiting and offers**: check the median and the 90th percentile for a role before you write an offer, so the package lands where candidates expect it.
- **Job search and negotiation**: pull every job title at a target employer with the number of reported salaries behind each figure, and walk into the interview with numbers.
- **Market research and consulting**: build salary tables by company, region and pay period for a whole sector, refreshed on a schedule.
- **Investing and due diligence**: compensation structure (how much of total pay is stock, bonus or commission) says a lot about how a company retains people. Pull it for a portfolio of employers.
- **Research and journalism**: assemble datasets of reported salaries per job title across companies for pay-gap or labor-market analysis.

### 📊 What data does Glassdoor Salaries Scraper extract?

| Field | Description |
|---|---|
| `employerId`, `employerName` | Glassdoor employer id and company name |
| `url` | Link to the company's salaries page on Glassdoor |
| `jobTitle`, `jobTitleId` | Job title and its Glassdoor id |
| `location` | Region the figures cover (for example `United States`) |
| `payPeriod` | `annual`, `monthly` or `hourly` |
| `currency` | Currency code (for example `USD`) |
| `salaryCount` | Number of salaries reported for this job title |
| `mostRecent` | Date of the most recent salary report (ISO 8601) |
| `basePayMin`, `basePayMedian`, `basePayMax` | Base pay at the 10th percentile (low), median and 90th percentile (high) |
| `totalPayMin`, `totalPayMedian`, `totalPayMax` | Total pay (base plus additional) at the 10th percentile, median and 90th percentile |
| `additionalPayMedian` | Median additional pay (bonus, stock, profit sharing and other cash on top of base) |
| `additionalPay.*` | Median breakdown: `cashBonus`, `stockBonus`, `profitSharing`, `salesCommission`, `tips` (when `includeAdditionalPay` is on) |
| `basePayPercentiles`, `totalPayPercentiles` | Full percentile range keyed `P10`, `P25`, `P50`, `P75`, `P90` (when `includePercentiles` is on) |

With `flatten` enabled the three nested objects (`additionalPay`, `basePayPercentiles`, `totalPayPercentiles`) are dropped so every row is a flat line for CSV and Excel.

### 🚀 How to scrape Glassdoor salaries

1. Open the Actor and type one or more **company names** in `companyNames` (for example `Google`, `Microsoft`, `Airbnb`), or paste Glassdoor company URLs (the Salaries page or any company page) in `startUrls`.
2. Pick the **pay period**: `annual`, `monthly` or `hourly`. Every figure in the run is reported in that period.
3. Choose the **Glassdoor domain** in `country` if you want figures for the UK, Canada, Australia, India or Ireland instead of the United States. It sets the region and the currency of the results.
4. Set **Max job titles per company**. `100` is the default; `0` collects every job title Glassdoor reports for the company.
5. Click **Start**. The Actor collects salary rows 20 job titles per request.
6. Open the **Storage** tab to preview the rows and export them as JSON, CSV, Excel or XML, or read them from the dataset API.

The same run can be started from the Apify API, the Python or JavaScript client, or put on a schedule for monthly benchmarking.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Glassdoor company URLs | `startUrls` | array of URLs | none | Glassdoor company URLs, the Salaries page (for example `https://www.glassdoor.com/Salary/Google-Salaries-E9079.htm`) or any company page, from any Glassdoor domain. Leave empty to use company names. |
| Company names | `companyNames` | array of strings | `["Google"]` | Company names resolved automatically on the chosen Glassdoor domain (for example `Google`, `Microsoft`, `Airbnb`). |
| Max job titles per company | `maxSalariesPerCompany` | integer | `100` | Job-title salary rows to collect per company. `0` = every job title Glassdoor reports. |
| Pay period | `payPeriod` | select | `annual` | `annual` (per year), `monthly` or `hourly`. |
| Glassdoor domain (for company names) | `country` | select | `www` | `www` (glassdoor.com), `co.uk`, `ca`, `com.au`, `co.in` or `ie`. Sets the region and currency of the figures. |
| Include full percentile breakdown | `includePercentiles` | boolean | `true` | Add the full percentile range (10th, 25th, 50th, 75th, 90th) for base and total pay next to the low/median/high summary. |
| Include additional pay breakdown | `includeAdditionalPay` | boolean | `true` | Add the median cash bonus, stock, profit sharing, sales commission and tips. |
| Flat columns (CSV-friendly) | `flatten` | boolean | `false` | Drop the nested percentile and additional-pay objects for clean CSV and Excel exports. |
| Report empty inputs | `emitInputStatus` | boolean | `true` | Write an `input_status` report (which input returned nothing and why) to the run's OUTPUT record. |
| Page load retries | `maxChallengeRetries` | integer | `6` | Retries when a page fails to load. Increase only if runs report being blocked. |
| Proxy | `proxyConfiguration` | object | off | Leave off. A proxy usually makes Glassdoor runs fail; only add one if you own clean, ISP-grade IPs. |

Example input:

```json
{
  "companyNames": ["Google"],
  "payPeriod": "annual",
  "country": "www",
  "maxSalariesPerCompany": 100,
  "includePercentiles": true,
  "includeAdditionalPay": true
}
```

A pasted URL only needs to contain the employer id (the `-E9079` part of `Google-Salaries-E9079.htm`); the Salaries, Overview or Reviews page of the company all work. The region and currency of the figures always follow the `country` setting, so pair a URL with the domain you want the salaries reported for.

### 📤 Output example

Each job title is one dataset item, exportable as JSON, CSV, Excel or via the API.

```json
{
  "employerId": 9079,
  "employerName": "Google",
  "url": "https://www.glassdoor.com/Salary/Employer-Salaries-E9079.htm",
  "jobTitle": "Software Engineer",
  "jobTitleId": 4279,
  "location": "United States",
  "payPeriod": "annual",
  "currency": "USD",
  "salaryCount": 111,
  "basePayMin": 50000,
  "basePayMedian": 70000,
  "basePayMax": 110000,
  "totalPayMedian": 80000,
  "additionalPayMedian": 39000,
  "additionalPay": { "cashBonus": 10000, "stockBonus": 22000, "profitSharing": 15000 }
}
```

The run's OUTPUT record also holds the run statistics (companies, unique rows, duplicates, requests, errors) and, per input, an `input_status` entry (`ok`, `empty`, `not_found` or `no_employer_id`) so you can see at a glance which company produced nothing.

### 💡 Ready-to-run examples

**Annual salaries of one company, full detail**

```json
{ "companyNames": ["Google"], "payPeriod": "annual", "country": "www", "maxSalariesPerCompany": 100, "includePercentiles": true, "includeAdditionalPay": true }
```

**Monthly figures for several companies side by side**

```json
{ "companyNames": ["Google", "Microsoft", "Airbnb"], "payPeriod": "monthly", "maxSalariesPerCompany": 100 }
```

**Hourly pay on the UK domain**

```json
{ "companyNames": ["Google"], "country": "co.uk", "payPeriod": "hourly", "maxSalariesPerCompany": 100 }
```

**Every job title from a Glassdoor URL, flat rows for Excel**

```json
{ "startUrls": [{ "url": "https://www.glassdoor.com/Salary/Google-Salaries-E9079.htm" }], "maxSalariesPerCompany": 0, "flatten": true }
```

### 💰 Pricing: how much does it cost to scrape Glassdoor salaries?

From **$3.00 per 1,000 job-title rows** on the free plan, with automatic volume discounts down to **$2.04 per 1,000** on higher Apify plans. You pay only for the results you receive, there is no subscription and no start fee. New Apify accounts get free monthly platform credits to try it.

Cost is driven purely by the number of job-title rows returned: use `maxSalariesPerCompany` to cap each company. Rows arrive sorted by number of reported salaries, so a cap of `100` keeps the 100 most-reported job titles. The optional percentile and additional-pay blocks do not change the price, they are part of the same row.

### ⚙️ Performance, proxies and limits

- **No proxy needed, and not recommended.** The Actor runs best without a proxy, and adding one usually makes runs fail. If you do add one, keep it to clean, ISP-grade IPs.
- **Speed**: rows are fetched 20 job titles per request and pushed to the dataset in batches of 200. The first request per run warms up the session; the rest are fast.
- **Order and cap**: Glassdoor returns job titles sorted by number of reported salaries, descending. `0` in `maxSalariesPerCompany` collects every job title; any other value stops at that count.
- **Region and currency**: the salary API runs on the domain chosen in `country` (glassdoor.com by default), which decides the `location` and `currency` of every row. Six domains are available: `www`, `co.uk`, `ca`, `com.au`, `co.in`, `ie`.
- **Deduplication**: rows are deduplicated by `jobTitleId` within a company; the duplicate count is reported in the OUTPUT statistics.
- **Session expiry**: if the session expires mid-run, the Actor renews it once and resumes.
- **Empty inputs**: a company name that Glassdoor does not know gets `not_found`, a URL without an employer id gets `no_employer_id`, and a company with no salary data gets `empty` in `input_status`. If the site cannot be reached at all, the OUTPUT record carries an `error`; retry later or raise `maxChallengeRetries`.
- **Run options**: the default run configuration is 4 GB of memory and a 60-minute timeout.

### 🔌 Integrations and API

Run Glassdoor Salaries Scraper from the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or on a [schedule](https://docs.apify.com/platform/schedules). Connect it to Make, Zapier, n8n, Google Sheets, Slack or any webhook through [Apify integrations](https://apify.com/integrations). Every run's dataset is available as JSON, CSV, Excel or XML from the dataset API.

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapifier~glassdoor-salaries-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "companyNames": ["Google"], "payPeriod": "annual", "country": "www", "maxSalariesPerCompany": 100 }'
```

### ❓ FAQ

**Is it legal to scrape Glassdoor salaries?**

The Actor only reads salary estimates that Glassdoor publishes to anyone without logging in. The figures are aggregated per job title, not tied to a person, but the dataset may still fall under GDPR and other privacy laws depending on how you combine it, so respect Glassdoor's terms of use and stay responsible for how you use the data. This is not legal advice.

**Do I need a Glassdoor account, login or cookies?**

No. Nothing to log in to, no cookies to paste, no proxy to configure.

**Where do the salary figures come from?**

They are Glassdoor's own aggregated estimates, computed from the salaries employees report for each job title. `salaryCount` tells you how many reports stand behind each row and `mostRecent` when the last one came in.

**Can I export Glassdoor salaries to Excel or Google Sheets?**

Yes. Every run's dataset downloads as CSV, XLSX, JSON or XML from the Storage tab, and the Google Sheets integration can push new rows to a sheet automatically. Turn on `flatten` for a clean one-line-per-job-title export.

**How many job titles can I scrape per company?**

As many as Glassdoor reports (set `maxSalariesPerCompany` to `0`). Since rows come sorted by number of reported salaries, a cap keeps the best-documented job titles and controls the cost of the run.

**How do I get salaries for a specific country?**

Pick the matching domain in `country`: `www` for the United States, `co.uk`, `ca`, `com.au`, `co.in` or `ie`. The region and currency of every row follow that domain, whether the company came from a name or a pasted URL.

**Which Glassdoor URLs are supported?**

Any Glassdoor company URL that carries the employer id: the Salaries page (`.../Salary/Company-Salaries-E12345.htm`) or the company Overview or Reviews page, pasted from any Glassdoor domain. The Actor reads the id and queries salaries on the domain set in `country`.

**How fresh is the data?**

Every run scrapes Glassdoor live. Schedule the Actor monthly or quarterly to keep a history of pay per job title.

### 🔗 Related scrapers

- [Glassdoor Jobs Scraper](https://apify.com/scrapifier/glassdoor-jobs-scraper): job listings by keyword and location, with salary estimates.
- [Glassdoor Reviews Scraper](https://apify.com/scrapifier/glassdoor-reviews-scraper): employee reviews with ratings, pros, cons, advice and company responses.
- [Glassdoor Interviews Scraper](https://apify.com/scrapifier/glassdoor-interviews-scraper): interview experiences and the questions asked, by company.
- [Glassdoor Company Overview Scraper](https://apify.com/scrapifier/glassdoor-company-scraper): the full company profile (ratings, CEO approval, size, HQ, revenue) by name or URL.
- [Glassdoor Company Search Scraper](https://apify.com/scrapifier/glassdoor-company-search-scraper): find companies by location, industry, minimum rating and size.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/scrapifier/welcome-to-the-jungle-scraper): jobs and company profiles in France and Europe.

### 💬 Support

Questions, bugs or a feature request? Open an issue in the **Issues** tab of this Actor, I answer quickly. If Glassdoor Salaries Scraper saves you time, a rating on the Store helps others find it.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Glassdoor company URLs: the Salaries page (e.g. https://www.glassdoor.com/Salary/Google-Salaries-E9079.htm) or any company page. A URL from any Glassdoor country domain is accepted (only the company id is read from it); the region and currency of the figures follow the Glassdoor domain setting below. Leave empty to use company names.

## `companyNames` (type: `array`):

Company names to resolve automatically on glassdoor.com (e.g. Google, Microsoft, Airbnb). For a specific country/office, paste that country's Glassdoor URL above instead.

## `maxSalariesPerCompany` (type: `integer`):

How many job-title salary rows to collect per company (0 = every job title Glassdoor reports).

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

The pay period the salary figures are reported in.

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

Which Glassdoor domain to query. It sets the region and currency of the salary figures, for pasted URLs too, and is used when resolving company names.

## `includePercentiles` (type: `boolean`):

Add the full percentile range (10th / 25th / 50th / 75th / 90th…) for base and total pay, alongside the low/median/high summary.

## `includeAdditionalPay` (type: `boolean`):

Add a breakdown of additional pay: cash bonus, stock, profit sharing, sales commission and tips (median).

## `flatten` (type: `boolean`):

Keep only flat columns (drops the nested percentile and additional-pay objects) for clean CSV/Excel exports.

## `emitInputStatus` (type: `boolean`):

Add an input_status report to the run's OUTPUT record.

## `maxChallengeRetries` (type: `integer`):

How many retry attempts if a page fails to load. Increase only if runs report being blocked.

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

Glassdoor answers datacenter addresses with a block page — measured: datacenter 403, residential 200 on the same request. Keep this on residential.

## Actor input object example

```json
{
  "companyNames": [
    "Google"
  ],
  "maxSalariesPerCompany": 100,
  "payPeriod": "annual",
  "country": "www",
  "includePercentiles": true,
  "includeAdditionalPay": true,
  "flatten": false,
  "emitInputStatus": true,
  "maxChallengeRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `salaries` (type: `string`):

All Glassdoor salary estimates extracted by this run.

# 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 = {
    "companyNames": [
        "Google"
    ],
    "maxSalariesPerCompany": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/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 = {
    "companyNames": ["Google"],
    "maxSalariesPerCompany": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/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 '{
  "companyNames": [
    "Google"
  ],
  "maxSalariesPerCompany": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapifier/glassdoor-salaries-scraper --silent --output-dataset

```

## MCP server setup

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