# Glassdoor Interviews Scraper API - Questions, Process & Pay (`scrapifier/glassdoor-interviews-scraper`) Actor

🧑‍💼 Scrape Glassdoor interview experiences by company name or URL. Get the job title, difficulty, outcome, how the interview was obtained, the full process description, the questions asked, negotiation notes & dates. No login and no proxy needed.

- **URL**: https://apify.com/scrapifier/glassdoor-interviews-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** Jobs
- **Stats:** 96 total users, 42 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 Interviews Scraper API - Questions, Process & Pay

Scrape interview experiences and interview questions 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 interview you get the **job title**, the overall experience, the **difficulty**, the **outcome** (offer accepted, declined or no offer), how the interview was obtained, the length of the process in days, the **full process description**, the list of **questions asked** with their answer counts, negotiation notes, the candidate's advice, helpful votes, the employer's official response and the interview and posting dates. Filter by **job title**, difficulty, outcome and language, on **any Glassdoor country site**, with **no login, no cookies and no proxy**. You **pay per interview**.

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

### 🎯 Why scrape Glassdoor interviews?

- **Interview preparation**: pull the interview questions asked at a company for a given role, sorted by most recent, and see which rounds candidates describe and how long the process took.
- **Recruiting and HR benchmarking**: compare difficulty, outcome mix and process length across competitors to calibrate your own hiring funnel.
- **Career platforms and coaching**: feed interview questions and experiences into prep tools, newsletters or course material, refreshed on a schedule.
- **Research and journalism**: analyse hiring practices at scale: offer rates, negotiation notes, candidate sentiment over time.
- **Talent intelligence**: track how a company's interview process changes after a reorg, a hiring freeze or a leadership change.

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

| Field | Description |
|---|---|
| `interviewId` | Unique Glassdoor interview id |
| `url` | Link to the company's interviews page on Glassdoor |
| `employerId`, `employerName` | Glassdoor employer id and company name |
| `jobTitle` | Job title the candidate interviewed for |
| `location`, `locationType` | Interview location and its type (`CITY`, `STATE`...) |
| `experience` | Overall experience: `POSITIVE`, `NEGATIVE` or `NEUTRAL` |
| `difficulty` | `VERY_EASY`, `EASY`, `AVERAGE`, `DIFFICULT` or `VERY_DIFFICULT` |
| `outcome` | `ACCEPT_OFFER`, `DECLINE_OFFER` or `NO_OFFER` |
| `source`, `otherSource` | How the interview was obtained (`EMPLOYEE_REFERRAL`, `APPLIED_ONLINE`...), free text when "other" |
| `durationDays` | Length of the interview process in days |
| `processDescription` | Full description of the process, as written by the candidate |
| `negotiationDescription`, `advice` | Negotiation notes and advice from the candidate |
| `declinedReason`, `otherSteps` | Why the offer was declined, other steps in the process |
| `isCurrentEmployee`, `featured` | Written by a current employee, featured interview |
| `countHelpful`, `countNotHelpful` | Helpful and not-helpful votes |
| `interviewDateTime`, `reviewDateTime` | When the interview took place and when it was posted (ISO 8601) |
| `questions[]`, `questionCount` | Questions asked (`question`, `answerCount`), when `includeQuestions` is on, and their number |
| `companyResponses[]` | The employer's official responses (`text`, `author`, `dateTime`), when `includeCompanyResponses` is on |

With `flatten` enabled the nested `questions` and `companyResponses` are dropped and the questions are joined into one `questionsText` column, so the CSV or Excel export stays flat.

### 🚀 How to scrape Glassdoor interviews

1. Open the Actor and type one or more **company names** in `companyNames` (for example `Google`, `Microsoft`, `Airbnb`), or paste Glassdoor company URLs (Interviews page or any company page, any country site) in `startUrls`.
2. Optionally type a **job title** (`Software Engineer`, `Data Scientist`) to keep one role only, pick a **difficulty**, one or more **outcomes**, and the **sort order** (most relevant or most recent).
3. Set **Max interviews per company**. `0` collects as many as Glassdoor exposes; keep a cap for a first run.
4. Click **Start**. The Actor collects interviews page by page.
5. Open the **Storage** tab to preview the interviews 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 to refresh the questions every week.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Glassdoor company URLs | `startUrls` | array of URLs | none | Interviews page (`https://www.glassdoor.com/Interview/Google-Interview-Questions-E9079.htm`) or any company page, any Glassdoor country domain. |
| Company names | `companyNames` | array of strings | `["Google"]` | Company names resolved automatically on the chosen Glassdoor domain. |
| Job title | `jobTitle` | string | none | Keep only interviews for this role, matched the way Glassdoor's own job-title filter does (closely related titles included). Empty = all roles. |
| Max interviews per company | `maxInterviewsPerCompany` | integer | `100` | Interviews to collect per company. `0` = as many as Glassdoor exposes. |
| Sort interviews by | `sort` | select | `relevance` | `relevance` (most relevant / helpful) or `recent` (most recent). |
| Difficulty | `difficulty` | select | `""` (Any) | `VERY_EASY`, `EASY`, `AVERAGE`, `DIFFICULT` or `VERY_DIFFICULT`. Empty = all. |
| Outcome | `outcomes` | array of strings (multi-select) | none | Any of `ACCEPT_OFFER`, `DECLINE_OFFER`, `NO_OFFER`. Empty = all. |
| Interview language (ISO-3) | `interviewLanguage` | string | `eng` | ISO-639-2 code: `eng`, `fra`, `deu`, `spa`, `ita`, `por`, `nld`. |
| Glassdoor domain (for company names) | `country` | select | `www` | Domain used to resolve company names: `www` (glassdoor.com), `co.uk`, `ca`, `com.au`, `co.in` or `ie`. Pasted URLs keep their own domain. |
| Include interview questions | `includeQuestions` | boolean | `true` | Attach the list of questions asked during each interview. |
| Include company responses | `includeCompanyResponses` | boolean | `true` | Attach the employer's official responses to each interview. |
| Flat columns (CSV-friendly) | `flatten` | boolean | `false` | Questions joined into one text column, nested objects dropped, for clean CSV and Excel exports. |
| Report empty inputs | `emitInputStatus` | boolean | `true` | Add 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 have your own clean, ISP-grade IPs. |

Example input:

```json
{
  "companyNames": ["Google"],
  "jobTitle": "Software Engineer",
  "sort": "recent",
  "difficulty": "DIFFICULT",
  "maxInterviewsPerCompany": 100,
  "includeQuestions": true
}
```

Type the job title in full as Glassdoor spells it (`Software Engineer`, not `SWE`). To target one country office, paste that country's Glassdoor URL in `startUrls` instead of the company name, and set `interviewLanguage` to match.

### 📤 Output example

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

```json
{
  "interviewId": 4168541,
  "url": "https://www.glassdoor.com/Interview/Employer-Interview-Questions-E9079.htm",
  "employerId": 9079,
  "employerName": "Google",
  "jobTitle": "Software Engineer",
  "location": "Mountain View, CA",
  "experience": "POSITIVE",
  "difficulty": "DIFFICULT",
  "outcome": "ACCEPT_OFFER",
  "source": "EMPLOYEE_REFERRAL",
  "durationDays": 30,
  "processDescription": "Phone screen, then 5 onsite rounds covering data structures, algorithms and system design.",
  "questions": [ { "question": "Reverse a linked list in place.", "answerCount": 3 } ],
  "questionCount": 5,
  "interviewDateTime": "2026-04-01T07:00:00"
}
```

The run's OUTPUT record also holds the run statistics, the job title actually sent to Glassdoor (`resolved_job_title`) and, per company, an `input_status` entry (`ok`, `empty`, `not_found` or `no_employer_id`) so you can see at a glance which input produced nothing.

### 💡 Ready-to-run examples

**Google: latest interview questions and experiences**

```json
{ "companyNames": ["Google"], "maxInterviewsPerCompany": 200, "sort": "recent", "includeQuestions": true }
```

**Google Software Engineer: latest interview questions**

```json
{ "companyNames": ["Google"], "jobTitle": "Software Engineer", "maxInterviewsPerCompany": 200, "sort": "recent", "includeQuestions": true }
```

**Meta, Amazon, Apple: difficult interviews that led to an offer**

```json
{ "companyNames": ["Meta", "Amazon", "Apple"], "maxInterviewsPerCompany": 100, "sort": "relevance", "difficulty": "DIFFICULT", "outcomes": ["ACCEPT_OFFER", "DECLINE_OFFER"], "includeQuestions": true }
```

**Deloitte, PwC, KPMG, EY (UK): recent interview experiences, flat CSV**

```json
{ "companyNames": ["Deloitte", "PwC", "KPMG", "EY"], "country": "co.uk", "maxInterviewsPerCompany": 50, "sort": "recent", "flatten": true }
```

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

From **$3.00 per 1,000 interviews** 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 interviews stored: use `maxInterviewsPerCompany` to cap each company, and `jobTitle`, `difficulty` or `outcomes` to narrow the set before you pay for it.

### ⚙️ Performance, proxies and limits

- **No proxy needed, and not recommended.** The Actor runs reliably without one, so Apify Proxy is off by default. A proxy usually makes Glassdoor runs fail; only add one if you have your own clean, ISP-grade IPs.
- **Paging**: interviews are fetched 20 per request with a 1.2 second pause between pages and pushed to the dataset in batches of 200. Each page is retried up to 3 times.
- **Server-side filters**: `jobTitle` and `interviewLanguage` are applied by Glassdoor before pagination, so a run for one role is as fast and as cheap as the number of results you ask for. The job title is first resolved to Glassdoor's canonical title; if no exact title matches, it is sent as typed and the log lists the closest Glassdoor titles.
- **Difficulty and outcome**: Glassdoor treats them as hints, so the Actor checks every interview strictly before storing it. You only pay for matching interviews, but the run still reads through the non-matching ones, so a narrow filter on a large company takes longer.
- **Volume**: very large employers list tens of thousands of interviews. `0` in `maxInterviewsPerCompany` collects everything Glassdoor exposes; the default run has a 60 minute timeout, so raise it for uncapped runs on big companies.
- **Deduplication**: interviews are deduplicated by `interviewId` within each company, duplicates are counted in the run statistics.
- **Blocked runs**: if a page cannot be loaded after `maxChallengeRetries` attempts, the run ends with a `blocked` error in the OUTPUT record: retry later or raise `maxChallengeRetries`. The `input_status` report tells you which company came back empty or was not found.

### 🔌 Integrations and API

Run Glassdoor Interviews 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-interviews-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "companyNames": ["Google"], "jobTitle": "Software Engineer", "sort": "recent", "maxInterviewsPerCompany": 100, "includeQuestions": true }'
```

### ❓ FAQ

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

The Actor only reads interview experiences that Glassdoor publishes to anyone without logging in. They may contain personal data (job titles, locations), so process them in line with GDPR and other privacy laws, 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. The Actor works anonymously.

**Which Glassdoor URLs are supported?**

Any Glassdoor company URL: the Interviews page (`.../Interview/Company-Interview-Questions-E12345.htm`) or the company Overview or Reviews page. The Actor reads the employer id from the URL, and any country domain works (.com, .fr, .de, .co.uk...).

**Can I get interview questions for a specific job title?**

Yes. Keep `includeQuestions` on (the default) and type the role in `jobTitle` (`Software Engineer`, `Product Manager`, `Data Scientist`). Use the full title as Glassdoor spells it (case does not matter); abbreviations such as `SWE` or `PM` are not recognised, and the run log then lists the closest Glassdoor titles. The OUTPUT record shows the title actually used (`resolved_job_title`). Glassdoor groups closely related titles together (a `Product Manager` search also returns some `Project Manager` interviews); each item still carries its exact `jobTitle` if you need a stricter cut.

**Can I keep only difficult interviews, or only the ones that ended with an offer?**

Yes. Set `difficulty` to one of the five levels and `outcomes` to any combination of `ACCEPT_OFFER`, `DECLINE_OFFER` and `NO_OFFER`. Both are checked on every interview before it is stored, so non-matching interviews are never billed.

**How many interviews can I scrape per company?**

As many as Glassdoor lists: set `maxInterviewsPerCompany` to `0` to collect everything. Large companies have tens of thousands of interviews, so start with a few hundred to check the data before going wide.

**How do I target a specific country or office?**

Paste that country's Glassdoor URL in `startUrls` (any domain), or pick the matching `country` (glassdoor.co.uk, .ca, .com.au, .co.in, .ie) when using company names, and set `interviewLanguage` to match (`eng`, `fra`, `deu`...).

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

Yes. Every run's dataset downloads as CSV, XLSX, JSON or XML from the Storage tab. Turn on `flatten` for a clean spreadsheet (questions in one `questionsText` column), and the Google Sheets integration can push new interviews to a sheet automatically.

### 🔗 Related scrapers

- [Glassdoor Reviews Scraper](https://apify.com/scrapifier/glassdoor-reviews-scraper): employee reviews with ratings, pros, cons, advice and company responses.
- [Glassdoor Salaries Scraper](https://apify.com/scrapifier/glassdoor-salaries-scraper): salary estimates per job title and company.
- [Glassdoor Jobs Scraper](https://apify.com/scrapifier/glassdoor-jobs-scraper): job listings by keyword and location, with salary estimates.
- [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 Interviews 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 Interviews page (e.g. https://www.glassdoor.com/Interview/Google-Interview-Questions-E9079.htm) or any company page. Works on any Glassdoor country domain (.com, .fr, .de, .co.uk…). Leave empty to use company names below.

## `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.

## `jobTitle` (type: `string`):

Keep only interviews for this role, e.g. Software Engineer, Product Manager, Data Scientist. Matched the way Glassdoor's own job-title filter does (closely related titles included). Empty = all roles.

## `maxInterviewsPerCompany` (type: `integer`):

How many interviews to collect per company (0 = as many as Glassdoor exposes).

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

Order in which interviews are collected.

## `difficulty` (type: `string`):

Keep only interviews of this difficulty. Empty = all.

## `outcomes` (type: `array`):

Keep only these interview outcomes. Empty = all.

## `interviewLanguage` (type: `string`):

ISO-639-2 language code for the interviews (e.g. eng, fra, deu, spa, ita, por, nld). Defaults to English (eng).

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

Which Glassdoor domain to use when resolving company names. (Pasted URLs keep their own domain.)

## `includeQuestions` (type: `boolean`):

Attach the list of questions asked during each interview.

## `includeCompanyResponses` (type: `boolean`):

Attach the employer's official responses to each interview.

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

Keep only flat columns (questions joined into one text column, nested objects dropped) 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"
  ],
  "maxInterviewsPerCompany": 100,
  "sort": "relevance",
  "difficulty": "",
  "interviewLanguage": "eng",
  "country": "www",
  "includeQuestions": true,
  "includeCompanyResponses": true,
  "flatten": false,
  "emitInputStatus": true,
  "maxChallengeRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All Glassdoor interview experiences 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"
    ],
    "maxInterviewsPerCompany": 100,
    "interviewLanguage": "eng",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

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

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

```

## MCP server setup

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