# Glassdoor Jobs & Reviews Scraper (`cryptosignals/glassdoor-scraper`) Actor

Glassdoor scraper 2026 — extract company reviews, salaries and interview data without API key. Pay-per-result pricing. Returns structured JSON. Perfect for employer research, HR benchmarking and job market analysis.

- **URL**: https://apify.com/cryptosignals/glassdoor-scraper.md
- **Developed by:** [Web Data Labs](https://apify.com/cryptosignals) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 11 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 result scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 — Jobs, Reviews & Salary Data

Scrape Glassdoor job listings, company reviews, and salary data at scale — **no login required**. Search by keyword, location, or company name. Extract job titles, salaries, ratings, pros/cons, and more.

### Why Use This Glassdoor Scraper?

Glassdoor is the largest employer review platform, with millions of salary reports and company reviews. Whether you're benchmarking compensation, monitoring employer brand sentiment, or analyzing hiring trends — this scraper gives you structured data without needing a Glassdoor account.

**No login required.** No Glassdoor account needed. The scraper uses Playwright with stealth mode to extract data from publicly accessible pages.

### Features

- **Job listings** — Title, company, location, salary range, rating, posting date
- **Company reviews** — Reviewer title, overall rating, pros, cons, sub-ratings (work-life balance, compensation, career opportunities, culture, management)
- **Both modes** — Scrape jobs and reviews in a single run
- **Salary extraction** — Salary ranges where available
- **Sorting** — Sort by relevance, date, salary (high/low), or rating
- **Pagination** — Automatically follows pages to collect up to 500 results
- **Stealth mode** — Uses Playwright with fingerprint evasion for reliable access

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | Yes | `jobs` | `jobs`, `reviews`, or `both` |
| `keyword` | string | No | — | Job title or search term (e.g. `"data scientist"`) |
| `location` | string | No | — | City/state/country (e.g. `"New York, NY"`) |
| `companyName` | string | Conditional | — | Company name for reviews (required for `reviews` mode) |
| `maxResults` | integer | No | `5` | Maximum results to return (1–500) |
| `includeSalary` | boolean | No | `true` | Extract salary data when available |
| `sortBy` | string | No | `relevance` | `relevance`, `date`, `salary_high`, `salary_low`, `rating` |

### Example Input

#### Search for Jobs

```json
{
    "mode": "jobs",
    "keyword": "software engineer",
    "location": "San Francisco, CA",
    "maxResults": 50,
    "sortBy": "date"
}
````

#### Get Company Reviews

```json
{
    "mode": "reviews",
    "companyName": "Google",
    "maxResults": 100
}
```

#### Jobs + Reviews in One Run

```json
{
    "mode": "both",
    "keyword": "product manager",
    "companyName": "Meta",
    "location": "New York, NY",
    "maxResults": 30
}
```

### Output Format

#### Job Listing

```json
{
    "type": "job",
    "title": "Senior Software Engineer",
    "company": "Stripe",
    "location": "San Francisco, CA",
    "salary": "$180K - $250K (Glassdoor est.)",
    "rating": 4.2,
    "easyApply": true,
    "postedDate": "2d ago",
    "url": "https://www.glassdoor.com/job-listing/...",
    "jobType": "Full-time"
}
```

#### Company Review

```json
{
    "type": "review",
    "company": "Google",
    "reviewerTitle": "Senior Software Engineer",
    "overallRating": 4,
    "pros": "Great compensation, smart colleagues, interesting problems",
    "cons": "Bureaucracy in larger teams, slow promotion cycles",
    "workLifeBalance": 4,
    "compensation": 5,
    "careerOpportunities": 3,
    "culture": 4,
    "management": 3,
    "recommends": true,
    "date": "2026-03-15"
}
```

### How to Use with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

## Search for data science jobs in NYC
run = client.actor("cryptosignals/glassdoor-scraper").call(run_input={
    "mode": "jobs",
    "keyword": "data scientist",
    "location": "New York, NY",
    "maxResults": 30,
    "sortBy": "salary_high",
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{job['title']} at {job['company']} — {job.get('salary', 'N/A')}")
```

```python
## Get company reviews for competitive analysis
run = client.actor("cryptosignals/glassdoor-scraper").call(run_input={
    "mode": "reviews",
    "companyName": "Microsoft",
    "maxResults": 50,
})

for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{review['overallRating']}/5 — {review['pros'][:60]}...")
```

### Use Cases

- **Salary benchmarking** — Compare compensation across companies and locations for specific roles
- **Competitive intelligence** — Monitor what competitors' employees say about culture, management, and compensation
- **Job market analysis** — Track hiring trends, in-demand skills, and salary ranges by location
- **Employer branding** — Understand how your company is perceived vs. competitors on Glassdoor
- **HR & recruiting** — Benchmark salaries and identify companies with high turnover signals
- **Due diligence** — Research employee sentiment before acquisitions, partnerships, or job offers
- **Academic research** — Analyze workplace satisfaction trends across industries over time

### Working Around Bot Detection

Glassdoor uses aggressive bot detection including CAPTCHAs, session fingerprinting, and IP-based rate limiting. This scraper uses Playwright with stealth mode and Firefox fingerprinting to bypass basic detection, but for reliable results at scale you'll need residential proxies.

[ThorData residential proxies](https://thordata.partnerstack.com/partner/0a0x4nzh) provide rotating residential IPs that make requests appear to come from real browsers — essential for Glassdoor which aggressively blocks datacenter IPs. Configure them in the actor's proxy settings for consistent, reliable scraping.

**Tips for reliable Glassdoor scraping:**

- Always use residential proxies (datacenter IPs are blocked quickly)
- Keep `maxResults` under 100 for the most reliable results
- Space out runs — avoid hitting the same search multiple times per hour
- Use the `both` mode to get jobs and reviews in a single run instead of two separate runs

### Integrations

- **Google Sheets** — Export salary and review data to spreadsheets
- **Zapier / Make.com** — Get alerts when new jobs match your criteria
- **Slack** — Notify recruiting teams about new job postings
- **API** — Call programmatically from any language using the Apify API

### FAQ

**Is this legal?**
This scraper accesses publicly visible pages on Glassdoor. Always review Glassdoor's Terms of Service and your local laws before scraping.

**Do I need a Glassdoor account?**
No. The scraper accesses publicly visible job listings and review pages without logging in.

**Why do some runs return fewer results than expected?**
Glassdoor's bot detection may block some requests. Using residential proxies significantly improves reliability. Keep `maxResults` reasonable and space out your runs.

**Can I scrape salary data separately?**
Salary data is included in job results when `includeSalary` is enabled (it is by default). There is no separate salary-only mode.

# Actor input Schema

## `mode` (type: `string`):

What to scrape: job listings, company reviews, or both.

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

Job title or keyword to search for (e.g. 'software engineer', 'data scientist').

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

City, state, or country (e.g. 'San Francisco, CA', 'London'). Leave empty for worldwide.

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

Company name for reviews (e.g. 'Google', 'Microsoft'). Required for reviews mode.

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

Maximum number of results to scrape.

## `includeSalary` (type: `boolean`):

Try to extract salary information when available.

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

Sort order for job results.

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

Proxy settings. RESIDENTIAL proxies are REQUIRED for Glassdoor — datacenter IPs will be blocked with HTTP 403.

## Actor input object example

```json
{
  "mode": "jobs",
  "keyword": "software engineer",
  "maxResults": 5,
  "includeSalary": true,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "mode": "jobs",
    "keyword": "software engineer",
    "location": "",
    "companyName": "",
    "maxResults": 5,
    "includeSalary": true,
    "sortBy": "relevance",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/glassdoor-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 = {
    "mode": "jobs",
    "keyword": "software engineer",
    "location": "",
    "companyName": "",
    "maxResults": 5,
    "includeSalary": True,
    "sortBy": "relevance",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "jobs",
  "keyword": "software engineer",
  "location": "",
  "companyName": "",
  "maxResults": 5,
  "includeSalary": true,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call cryptosignals/glassdoor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=cryptosignals/glassdoor-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glassdoor Jobs & Reviews Scraper",
        "description": "Glassdoor scraper 2026 — extract company reviews, salaries and interview data without API key. Pay-per-result pricing. Returns structured JSON. Perfect for employer research, HR benchmarking and job market analysis.",
        "version": "1.0",
        "x-build-id": "ggTeeYZGHqSXcYDy2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~glassdoor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-glassdoor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/cryptosignals~glassdoor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-glassdoor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/cryptosignals~glassdoor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-glassdoor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "jobs",
                            "reviews",
                            "both"
                        ],
                        "type": "string",
                        "description": "What to scrape: job listings, company reviews, or both.",
                        "default": "jobs"
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job title or keyword to search for (e.g. 'software engineer', 'data scientist')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or country (e.g. 'San Francisco, CA', 'London'). Leave empty for worldwide."
                    },
                    "companyName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Company name for reviews (e.g. 'Google', 'Microsoft'). Required for reviews mode."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of results to scrape.",
                        "default": 5
                    },
                    "includeSalary": {
                        "title": "Include Salary Data",
                        "type": "boolean",
                        "description": "Try to extract salary information when available.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date",
                            "salary_high",
                            "salary_low",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for job results.",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. RESIDENTIAL proxies are REQUIRED for Glassdoor — datacenter IPs will be blocked with HTTP 403.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
