# Glassdoor Reviews & Jobs Scraper (`data_wiki/glassdoor-reviews-jobs-scraper`) Actor

Download every Glassdoor employee review with no 200 cap, plus interview reports, salaries, company profiles and jobs for any company. No login needed. Great for employer research, competitor hiring analysis and checking a workplace before you apply.

- **URL**: https://apify.com/data_wiki/glassdoor-reviews-jobs-scraper.md
- **Developed by:** [Data WiKi](https://apify.com/data_wiki) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🚀 What is Glassdoor Reviews & Jobs Scraper?

Glassdoor Reviews & Jobs Scraper is an Apify Actor that works as a Glassdoor reviews scraper. It collects company profiles, employee reviews, interview reports, salaries and job listings from [Glassdoor](https://www.glassdoor.com) for the companies you name. The Actor sets no review limit of its own, and it needs no Glassdoor login or API key.

- **Five kinds of data in one run:** a company profile, reviews, interviews, salaries and jobs, each saved in its own table.
- **No review limit of its own:** leave **Max reviews** at `0` to collect every review the run can reach, or set a number per company.
- **Mixed input:** company names, Glassdoor links from any country or tab, and numeric employer IDs can share one list.
- **Live results:** rows appear in the Output tab while the run is going, and the log counts them as they are saved.
- **Easy export:** download JSON, CSV, Excel, XML or HTML, or read the dataset through the API.

### 📊 What data can you extract from Glassdoor?

Every row in the main table has a `type`: `company`, `review`, `interview`, `salary`, `job` or `error`. The Output tab also shows one table per type, so each kind of data has its own columns. A field that Glassdoor does not show for a row stays `null`. The tables below list the main fields; the dataset schema has a few more.

The company rows hold glassdoor company data such as size, industry and ratings.

**Company profile (`type` = `company`)**

| Field | Description | Example |
|---|---|---|
| `company_id`, `company_name`, `glassdoor_url`, `website` | Employer ID, name, overview page and company website | `Example Corp` |
| `headquarters`, `size`, `employees_min`, `employees_max`, `industry`, `sector`, `company_type`, `revenue`, `founded` | Basic company facts | `1001 to 5000 Employees` |
| `ceo_name`, `description`, `mission` | CEO and company text | text |
| `rating_overall`, `rating_culture_values`, `rating_diversity_inclusion`, `rating_work_life_balance`, `rating_senior_management`, `rating_compensation_benefits`, `rating_career_opportunities` | Overall rating and six sub-ratings, out of 5 | `3.8` |
| `recommend_to_friend_pct`, `ceo_approval_pct`, `business_outlook_positive_pct` | Share of reviewers who recommend, approve of the CEO or expect a positive outlook | `68.0` |
| `review_count`, `review_count_by_language`, `reviews_fetched_by_language`, `reviews_last_7_days`, `reviews_last_30_days` | Review totals, per language, and what this run collected | `1620` |
| `interview_count`, `interview_difficulty_avg`, `interview_experience`, `interview_source` | Interview totals and averages | `3.17` |
| `salary_job_title_count`, `salary_country`, `job_count`, `photo_count` | Salary, job and photo counts | `688` |
| `review_insights` | Simple counts and word frequencies calculated from the reviews your run collected | object |
| `scraped_at` | When the row was collected (UTC) | `2025-06-12T10:00:00+00:00` |

The fields `stock_symbol`, `salary_count_total` and `industry_benchmark` can be empty.

The seven rating fields are glassdoor ratings data out of 5. Together with the profile fields they make a company ratings dataset.

**Reviews (`type` = `review`)**

| Field | Description | Example |
|---|---|---|
| `review_id`, `review_url`, `date`, `datetime`, `language` | Review ID, link, date and review language | `eng` |
| `title`, `pros`, `cons`, `advice_to_management` | The text the reviewer wrote | text |
| `overall_rating` and six `rating_` fields | Overall rating and sub-ratings, out of 5 | `4.0` |
| `recommend_to_friend`, `ceo_approval`, `business_outlook` | Answers such as `positive` or `approve` | `positive` |
| `job_title`, `employment_status`, `is_current_employee`, `years_employed`, `location`, `location_type` | Reviewer role and work location (no name) | `Recruiter` |
| `helpful_count`, `not_helpful_count`, `featured`, `employer_responses` | Votes and employer replies | `0` |

**Interviews (`type` = `interview`)**

| Field | Description | Example |
|---|---|---|
| `interview_id`, `interview_url`, `date`, `interview_date` | ID, link and dates | `2025-05-30` |
| `job_title`, `location`, `outcome`, `experience`, `difficulty`, `how_obtained`, `duration_days` | Role, place and result of the interview process | `no_offer` |
| `process`, `questions`, `advice`, `negotiation` | Interview description, questions asked and advice | text |

**Salaries (`type` = `salary`)**

| Field | Description | Example |
|---|---|---|
| `job_title`, `job_title_id`, `country`, `currency`, `pay_period` | Job title and the country, currency and period the pay is for | `annual` |
| `salary_count`, `most_recent_submission` | Number of reports and date of the latest one | `42` |
| `base_pay`, `total_pay`, `additional_pay_mean` | Pay figures; total pay holds percentiles | object |

**Jobs (`type` = `job`)**

| Field | Description | Example |
|---|---|---|
| `job_id`, `title`, `normalized_title`, `company_id`, `company_name`, `company_rating` | Listing, title and hiring company | `Data Analyst` |
| `location`, `posted_days_ago`, `posted_date`, `easy_apply`, `sponsored`, `expired` | Place, age and listing status | `New York, NY` |
| `salary_min`, `salary_median`, `salary_max`, `salary_currency`, `pay_period`, `salary_source` | Pay estimate | `USD` |
| `skills`, `job_attributes`, `description_snippet`, `job_url`, `apply_url` | Skills, attributes and links | list |
| `description`, `company_details`, `coordinates` | Filled only when **Full job descriptions** is on | text |
| `search_keyword`, `search_location` | The search that found the job | `data analyst` |

These job rows are glassdoor job listings data from company pages and the keyword search.

**Problems (`type` = `error`)**: `input`, `company_id`, `dataset` and `error` explain which input or list could not be processed.

Review rows give you a glassdoor company reviews dataset for text analysis.

Interview rows form a glassdoor interview questions dataset.

Salary rows form a glassdoor salary dataset. Group them by `job_title` to compare employer salaries.

For employee review analysis, start with `pros`, `cons`, `title` and `overall_rating`. Export those fields as a sentiment analysis dataset.

### 💡 Use cases for Glassdoor data

- **Check a company before applying:** read `rating_overall`, the sub-ratings and the `pros` and `cons` of recent reviews before you send an application or accept an offer.
- **Employee sentiment analysis:** combine `pros`, `cons`, `overall_rating` and `date` from many reviews, or use the counts in `review_insights` as a starting point.
- **Interview preparation:** read `questions`, `process`, `difficulty` and `outcome` of past interviews at the company you apply to.
- **Salary benchmarking:** compare `base_pay` and `total_pay` percentiles per `job_title` and `currency`.
- **Competitor hiring analysis:** collect job rows for several companies and compare `title`, `location` and `posted_date`.
- **Employer reputation tracking:** schedule the Actor with `date_from` and compare `overall_rating` by `date` between runs.
- **Workplace culture comparison:** put `rating_culture_values`, `rating_work_life_balance` and `rating_senior_management` of two employers side by side.
- **Company due diligence:** combine `ceo_approval_pct`, `recommend_to_friend_pct` and review trends in one table.

The same rows help HR teams and analysts with employer research, and recruiters with market data. Plot `overall_rating` by `date` to see change over time.

### 🛠️ How to scrape Glassdoor reviews

Follow these steps to scrape glassdoor reviews for one company or many.

1. Create a free Apify account and open Glassdoor Reviews & Jobs Scraper in Apify Console.
2. Add company names, Glassdoor links or employer IDs to **Companies, links or IDs**.
3. Choose **Data to collect**: reviews, interviews and jobs. The company profile and salaries are always included.
4. Set **Max reviews per company** (`0` collects every review), and optionally **Only newer than** to keep recent rows.
5. Click **Start** and watch the log and the Output tab fill.
6. Download glassdoor reviews as JSON, CSV, Excel, XML or HTML.

> 💡 Start with a small **Max reviews per company**, such as 5, to see the result before a large run.

#### How to scrape Glassdoor interview questions

To scrape glassdoor interview questions, choose `interviews` in **Data to collect** and add the company name. This works as a glassdoor interview scraper for one company or a list. Read the interview questions by company in the `questions` field.

#### How to scrape Glassdoor salaries

To scrape glassdoor salaries, add the companies. Salary rows are always collected, so the Actor also works as a glassdoor salary scraper for any list of employers.

#### How to scrape Glassdoor company ratings

To scrape glassdoor company ratings, read the company row: `rating_overall` and the six sub-ratings. Read it first for company research before a job interview.

### 💰 How much does it cost to scrape Glassdoor?

Glassdoor Reviews & Jobs Scraper uses pay per event pricing. Every row saved to the main table is one `main_result` event: a company profile, a review, an interview, a salary row or a job. A run also pays one `apify-actor-start` event of $0.00005 for its 1,024 MB of memory. Apify platform usage (compute) is billed on top of the events above.

| Apify plan tier | Price per 1,000 results | Price per result |
|---|---|---|
| Free | $5.00 | $0.005 |
| Bronze | $4.50 | $0.0045 |
| Silver | $4.00 | $0.004 |
| Gold, Platinum, Diamond | $3.50 | $0.0035 |

Example: 1,000 results on the Free tier cost 1,000 x $0.005 = $5.00, plus $0.00005 for the start, which is $5.00005 before platform usage. The same 1,000 results on the Gold tier cost 1,000 x $0.0035 = $3.50, plus $0.00005, which is $3.50005.

> ⚠️ Salary rows are always collected, one per job title, and a large company can have hundreds. If a company has 600 job titles with salary data, they add 600 results, which is 600 x $0.005 = $3.00 on the Free tier. Error rows and the section tables are not billed as results.

You can set a spend limit on a run, and the Actor stops cleanly when it is reached. See the Pricing tab of the Actor for the current numbers.

### ⬇️ Input

All fields are optional, but a run needs at least one company or a job keyword or location. The form is prefilled with two example companies and small limits.

| Field | Meaning | Default |
|---|---|---|
| `urls` | Company names, Glassdoor company links from any tab and country, or numeric employer IDs. Leave empty only for the keyword job search. | empty |
| `get` | Lists to collect for every company: `reviews`, `interviews`, `jobs`. | `["reviews"]` |
| `max_reviews`, `max_interviews`, `max_jobs` | Rows per company; `0` collects all. Reviews and interviews come newest first. Jobs use the same limit for each company and for the keyword search. | `0` |
| `date_from` | Keep only rows on or after a date such as `2025-01-01`, or a relative value such as `90d`, `6m` or `2y`. | empty |
| `job_descriptions` | Add the full description, employer block and map position to each job (one extra request per job). | `false` |
| `proxyConfiguration` | Optional proxy. No proxy is used by default. | no proxy |

Reviews are fetched language by language: English, French, German, Spanish, Portuguese, Italian and Dutch. They are newest first inside each language, not across all languages. With a **Max reviews per company** limit, the limit fills from English first.

**Keyword job search.** Besides company jobs, the Actor can search jobs across all employers. Fill `job_keyword`, `job_location` or both, and the search runs once. These filters then apply: `job_type` (`any`, `fulltime`, `parttime`, `contract`), `job_remote_only`, `job_easy_apply_only`, `job_seniority` (`all`, `entrylevel`, `midseniorlevel`, `director`, `executive`, `internship`), `job_min_company_rating` (`any` or `1` to `5`), `job_min_salary` and `job_max_salary` (yearly, `0` means no limit), `job_radius_miles`, `job_posted_within_days` and `job_sort` (`relevance` or `date`). This search is the basis for job market analysis.

```json
{
  "urls": ["Example Corp"],
  "get": ["reviews"],
  "max_reviews": 2,
  "job_descriptions": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Replace `Example Corp` with a real company name or link.

### ⬆️ Output

The scraped rows appear as a dataset in the **Storage** tab. The table view does not show all fields, so export the dataset or open it through the API for the full rows. To export glassdoor reviews to excel, open the dataset in the Storage tab and choose Excel. The Output tab adds tables for companies, reviews, interviews, salaries, jobs and problems.

The sample below is an abbreviated illustration with made-up names, text and numbers that matches the input above. Your run returns real Glassdoor data. The company profile row is saved after its lists.

```json
[
  {
    "type": "review",
    "company_id": 1000001,
    "company_name": "Example Corp",
    "review_id": 900000001,
    "date": "2025-06-12",
    "language": "eng",
    "title": "Good team, slow promotions",
    "overall_rating": 4.0,
    "pros": "Flexible hours and a helpful team",
    "cons": "Promotions take a long time",
    "job_title": "Analyst",
    "is_current_employee": true,
    "location": "Example City",
    "rating_work_life_balance": 5.0,
    "recommend_to_friend": "positive",
    "ceo_approval": "approve"
  },
  {
    "type": "salary",
    "company_id": 1000001,
    "company_name": "Example Corp",
    "job_title": "Analyst",
    "country": "United States",
    "currency": "USD",
    "pay_period": "annual",
    "salary_count": 42,
    "total_pay": { "p10": 60000, "median": 75000, "p90": 95000 }
  },
  {
    "type": "company",
    "company_id": 1000001,
    "company_name": "Example Corp",
    "rating_overall": 3.8,
    "review_count": 1620,
    "reviews_fetched_by_language": { "eng": 2 },
    "review_insights": { "reviews_analyzed": 2, "average_rating": 4.0 }
  }
]
```

A run also saves a `RUN_SUMMARY` record in the key-value store with `companies`, `rows_saved`, `rows_charged`, `rows_by_type`, `problems`, `duration_seconds` and `spend_limit_reached`.

### ⚠️ Limitations and error handling

- The Actor returns public glassdoor employer data only. It does not read private pages, accounts or anything behind a login.
- A field that Glassdoor does not show stays `null`. `advice` and `negotiation` in interviews are filled only when Glassdoor shows them. Benefits are not collected.
- Salary rows state their `country`, and the figures are for that one country.
- If Glassdoor refuses requests, the Actor waits, switches to another connection and retries. When that keeps failing, the run stops and keeps every row already saved.
- A very large list takes a long time. Use `date_from` or a limit to keep a run short.
- The `review_insights` field is calculated only from the reviews your run collected, so a low `max_reviews` gives small counts.
- The Actor keeps no state between runs and does not remove rows you already have.

An input that cannot be processed becomes an error row in the main table and the errors table. It is not billed.

```json
{
  "type": "error",
  "input": "https://www.glassdoor.com/Example",
  "error": "no employer id (E<digits>) found in URL"
}
```

| Message or status | What it means | What to do |
|---|---|---|
| `Done: N rows saved, M problems.` | The run finished. | Open the Output tab. |
| `Spend limit reached after N rows.` | Your spend limit was reached and the run stopped cleanly. | Raise the maximum charge per run and run again. |
| `No rows collected - see the errors table or the log.` | Nothing was saved. | Check the company names or links, then run again. |
| `Input problem: ...` | The input could not be read, for example no company and no job keyword. | Add a company, link or ID, or a job keyword or location. |
| `no employer id (E<digits>) found in URL` | A link has no Glassdoor employer ID. | Use a company link from the reviews, interviews, salaries or overview tab. |

### 🔌 Integrating Glassdoor Reviews & Jobs Scraper with other apps

Run Glassdoor Reviews & Jobs Scraper from the Apify API and send the dataset to your tools with [Apify integrations](https://docs.apify.com/integrations). Use [Make](https://docs.apify.com/integrations/make), [Zapier](https://docs.apify.com/integrations/zapier) or [webhooks](https://docs.apify.com/integrations/webhooks) to pass a finished run to a spreadsheet, a database or a chat message. Keep the exported tables next to your own hr analytics data.

```bash
curl -X POST "https://api.apify.com/v2/actors/data_wiki~glassdoor-reviews-jobs-scraper/runs" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" -H "Content-Type: application/json" \
  -d '{"urls": ["Example Corp"], "get": ["reviews"], "max_reviews": 50}'
```

See the [Apify API reference](https://docs.apify.com/api/v2) for the other calls. Create a [schedule](https://docs.apify.com/actors/running/schedules), set `date_from` to a relative value such as `30d`, and compare the datasets of different runs for employee sentiment tracking. Compare `ceo_approval_pct` between runs when you do ceo approval rating tracking. AI agents can find and run this Actor through the [Apify MCP server](https://docs.apify.com/mcp).

### 🔗 Other Glassdoor and review scrapers by data_wiki

The first Actor below reads the same website. The other three come from the same developer and cover related data, so use them only if you also need that kind of data.

| Actor | What it extracts | When to use it |
|---|---|---|
| [Glassdoor Jobs Scraper](https://apify.com/data_wiki/glassdoor-jobs-scraper) | Job listings from keywords, search links, job links or job IDs, with pay and company details, and an optional market salary benchmark | You start from a job keyword and a location. Its reviews table holds review highlights and benefit mentions, not full reviews |
| [Contact Details Scraper](https://apify.com/data_wiki/contact-details-scraper) | Emails, phone numbers and social links from a list of websites | You want contact details for the `website` of a company you researched here |
| [BuiltWith Official Technology Scraper](https://apify.com/data_wiki/builtwith-official-technology-scraper) | The technologies a website is built with | You look at a company website next to its employer data; the link is weak |
| [Tripadvisor Review Scraper](https://apify.com/data_wiki/tripadvisor-review-scraper) | Reviews of hotels, restaurants and attractions on Tripadvisor | You need review text from travel places, not from employers |
| [Profile details for LinkedIn lists](https://apify.com/data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies) | Public LinkedIn profile records with career insights and employer details | You researched an employer and want details on specific people there. |
| [Travel place reviews from Tripadvisor](https://apify.com/data_wiki/tripadvisor-reviews-scraper) | Reviews of hotels, restaurants, attractions and tours | When you also compare how customers rate travel places |

For a keyword and location search on Glassdoor, the [keyword and location job search on Glassdoor](https://apify.com/data_wiki/glassdoor-jobs-scraper) Actor is built for that. [Emails and phone numbers from company websites](https://apify.com/data_wiki/contact-details-scraper) can follow once you have the `website` field. A [website technology lookup](https://apify.com/data_wiki/builtwith-official-technology-scraper) and [hotel and restaurant reviews](https://apify.com/data_wiki/tripadvisor-review-scraper) cover different subjects.

### ⚖️ Is it legal to scrape Glassdoor?

Glassdoor Reviews & Jobs Scraper only reads public Glassdoor pages that any visitor can open. It needs no login and does not read private data or accounts. You are responsible for following Glassdoor's terms and the laws that apply to you.

Reviews and interviews are written by employees. The rows hold the text, job title, location and years employed, but no reviewer name or account. The text can still identify a person, so collect it only with a legitimate reason, follow rules such as GDPR and CCPA, and never use the data to identify or contact reviewers. Read Apify's guides on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/), and ask a lawyer if you are unsure.

### ❓ FAQ

#### What does the Glassdoor reviews scraper collect?

It collects a company profile, reviews, interviews, salaries and jobs for each company you add. The profile and salaries are always included; reviews, interviews and jobs depend on **Data to collect**.

#### Do I need a Glassdoor login or API key?

No. As a Glassdoor scraper, the Actor reads public pages and needs no Glassdoor account. It also needs no glassdoor api key. You only need an Apify account to run it.

#### Is there a Glassdoor reviews API?

You run this Actor through the Apify API, which also gives you the dataset. It is not an official Glassdoor API. If you looked for a glassdoor api alternative, this Actor returns reviews, interviews, salaries and jobs as structured rows.

#### How many reviews can I get?

Leave **Max reviews per company** at `0` for every review the run can reach, because the Actor sets no review limit of its own. Reviews come newest first inside each language. Set a number when a script needs a fixed amount.

#### How much does it cost?

Each saved row costs $0.005 on the Free tier, down to $0.0035 on the Gold tier and above, plus a start event of $0.00005. See the cost section above for the table and the note on salary rows.

#### Which Glassdoor Actor should I use?

Use this Actor when you start from companies and want reviews, interviews and salaries, with optional jobs. Use Glassdoor Jobs Scraper when you start from a job keyword and a location and want job listings with an optional market salary benchmark. Both read public Glassdoor pages without a login.

#### Can I get only salaries?

Not alone. Salary rows are always collected with the company profile, which gives you glassdoor salary data for every company in the list. They also work as salary data by job title. Choose `interviews` in `get` and set `max_interviews` to `1` to keep the other lists small.

#### Why are some fields empty?

A field stays `null` when Glassdoor does not show it for that row. Fields such as `stock_symbol` can be empty for most companies.

#### Do I need proxies?

No. No proxy is used by default. If Glassdoor refuses requests, the Actor switches to another connection on its own, and you can set your own proxy in the input.

#### Can I use Glassdoor Reviews & Jobs Scraper through an MCP server?

Yes. AI agents can find and run Apify Actors through the [Apify MCP server](https://docs.apify.com/mcp), then read the dataset of the run.

### 💬 Your feedback

Found a bug or missing data? Open an issue from the Actor page in Apify Console and include the run link. Need a custom solution? Contact hello.datawiki@gmail.com.

# Actor input Schema

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

One entry per line. Use a company name (Stripe), a Glassdoor company link from any tab and any country (reviews, interviews, salaries, jobs, overview) or a numeric employer ID (671932). Names, links and IDs can be mixed. Leave empty only when you use the keyword job search below.

## `max_reviews` (type: `integer`):

Maximum reviews for each company, newest first within each review language. 0 collects every review (the Actor sets no review limit of its own).

## `max_interviews` (type: `integer`):

Maximum interview reports for each company, newest first. 0 collects all of them.

## `max_jobs` (type: `integer`):

Maximum jobs for each company and for the keyword job search. 0 collects everything the search can reach.

## `job_descriptions` (type: `boolean`):

Add the full description, employer block and map position to every job. This needs one extra request per job.

## `get` (type: `array`):

Pick the lists to collect for every company. The company profile and salaries are always included.

## `date_from` (type: `string`):

Keep only reviews, interviews and jobs on or after this date. Use a date such as 2025-01-01 or a relative value such as 90d, 6m or 2y. Leave empty for all time.

## `job_keyword` (type: `string`):

Search jobs by title or keyword, independent of the companies above. Leave this and the location empty to skip the job search.

## `job_location` (type: `string`):

City, state or country, or Remote.

## `job_type` (type: `string`):

Only jobs of this employment type.

## `job_remote_only` (type: `boolean`):

Return only remote jobs.

## `job_easy_apply_only` (type: `boolean`):

Return only jobs that can be applied to directly on Glassdoor.

## `job_seniority` (type: `string`):

Only jobs of this seniority level.

## `job_min_company_rating` (type: `string`):

Only jobs at companies rated at least this high, out of 5.

## `job_min_salary` (type: `integer`):

Only jobs with an estimated yearly pay of at least this amount. 0 means no minimum.

## `job_max_salary` (type: `integer`):

Only jobs with an estimated yearly pay of at most this amount. 0 means no maximum.

## `job_radius_miles` (type: `integer`):

Distance around the job location in miles. 0 means any distance.

## `job_posted_within_days` (type: `integer`):

Only jobs posted in the last N days. 0 means any age.

## `job_sort` (type: `string`):

Order of the job results. Newest first sorts the collected jobs by posting date.

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

Runs start without a proxy. If Glassdoor refuses the connection, the run switches to a datacenter proxy, then to a residential proxy, and keeps it for the rest of the run.

## Actor input object example

```json
{
  "urls": [
    "Stripe",
    "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
  ],
  "max_reviews": 5,
  "max_interviews": 2,
  "max_jobs": 20,
  "job_descriptions": false,
  "get": [
    "reviews"
  ],
  "date_from": "",
  "job_keyword": "",
  "job_location": "",
  "job_type": "any",
  "job_remote_only": false,
  "job_easy_apply_only": false,
  "job_seniority": "all",
  "job_min_company_rating": "any",
  "job_min_salary": 0,
  "job_max_salary": 0,
  "job_radius_miles": 0,
  "job_posted_within_days": 0,
  "job_sort": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every row of the run in order. Each row has a type: company, review, interview, salary or job.

## `companies` (type: `string`):

One row per company: size, industry, seven ratings, approval percentages and counts.

## `reviews` (type: `string`):

One row per employee review, newest first.

## `interviews` (type: `string`):

One row per interview report.

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

One row per job title with pay figures.

## `jobs` (type: `string`):

One row per job listing from company pages or the keyword job search.

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

Inputs or lists that could not be processed, with the reason.

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

Counts and timing of the 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 = {
    "urls": [
        "Stripe",
        "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
    ],
    "max_reviews": 5,
    "max_interviews": 2,
    "max_jobs": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_wiki/glassdoor-reviews-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 = {
    "urls": [
        "Stripe",
        "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm",
    ],
    "max_reviews": 5,
    "max_interviews": 2,
    "max_jobs": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_wiki/glassdoor-reviews-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 '{
  "urls": [
    "Stripe",
    "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
  ],
  "max_reviews": 5,
  "max_interviews": 2,
  "max_jobs": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_wiki/glassdoor-reviews-jobs-scraper --silent --output-dataset

```

## MCP server setup

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