# Glassdoor Reviews Scraper (`automation-lab/glassdoor-reviews-scraper`) Actor

Scrape employee reviews from Glassdoor. Extract ratings, pros, cons, job titles, and more for any company. Uses multiple filter strategies to collect diverse reviews.

- **URL**: https://apify.com/automation-lab/glassdoor-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 3 total users, 1 monthly users, 87.5% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Reviews Scraper

Scrape employee reviews from Glassdoor for any company. Extract ratings, pros, cons, job titles, recommendations, CEO approval, and more -- structured and ready for analysis.

### What does Glassdoor Reviews Scraper do?

This actor scrapes employee reviews from Glassdoor company pages. It handles Glassdoor's aggressive anti-bot protection (Cloudflare Managed Challenge) using residential proxies and an anti-fingerprint browser. You can provide direct Glassdoor review URLs or simply type a company name -- the scraper will find the right page automatically.

#### Key features

- 🔗 **Direct URL or company name** -- paste a Glassdoor reviews URL or just type "Google", "Apple", etc.
- 🏢 **Multiple companies** -- scrape employee reviews for several companies in a single run
- 🔢 **Configurable limits** -- set how many reviews to extract per company (limited by Glassdoor's public access -- typically ~3 per company without login)
- 🔃 **Sort control** -- sort by newest or highest rating
- 📊 **Full review data** -- ratings, pros, cons, advice, job title, employment status, and sentiment indicators
- 🛡️ **Anti-bot resilient** -- automatic retry with fresh browser sessions, anti-fingerprint browser technology, and residential proxy rotation

### Who is it for?

- 👩‍💼 **HR professionals** -- benchmark your employer brand against competitors, track employee sentiment trends, and identify retention risk factors before they become crises
- 🔍 **Job seekers** -- research prospective employers at scale, compare culture and compensation across target companies, and make data-driven career decisions
- 📈 **Investors and analysts** -- evaluate company culture and management quality as part of due diligence for investments, acquisitions, or equity research
- 🧑‍💻 **Management consultants** -- deliver client reports backed by quantitative employee sentiment data rather than anecdotal evidence
- 🎓 **Academic researchers** -- study workplace satisfaction, organizational behavior, and labor market dynamics across thousands of companies
- 🤝 **Recruitment agencies** -- identify companies with high turnover signals to prospect for new business, or validate client claims about company culture

### Why use this scraper instead of doing it manually?

- ⚡ **Scale**: Manually copying Glassdoor reviews is slow -- 50 reviews would take over an hour. This scraper does it in minutes
- 🗂️ **Structure**: Get clean, structured JSON/CSV/Excel data ready for analysis instead of copy-pasting text
- 🕒 **Automation**: Schedule recurring runs to track review trends over time using Apify's built-in scheduling
- 🛡️ **Anti-bot handling**: Glassdoor uses aggressive Cloudflare protection that blocks simple scrapers. This actor handles it with residential proxies and anti-fingerprint browser technology
- 🔌 **API access**: Integrate review data directly into your applications, dashboards, or AI workflows

### Data you can extract

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | String | Name of the company |
| `companyUrl` | String | Glassdoor reviews URL for the company |
| `reviewerTitle` | String | Job title of the reviewer |
| `currentEmployee` | Boolean/null | `true` if current employee, `false` if former, `null` if unknown |
| `rating` | Number/null | Overall rating (1-5 stars) |
| `reviewDate` | String | Date the review was posted |
| `headline` | String | Review headline/summary |
| `pros` | String | Positive aspects mentioned by the reviewer |
| `cons` | String | Negative aspects mentioned by the reviewer |
| `advice` | String | Advice to management (if provided) |
| `recommend` | Boolean/null | Whether the reviewer recommends the company |
| `ceoApproval` | Boolean/null | Whether the reviewer approves of the CEO |
| `businessOutlook` | String | Business outlook: Positive, Negative, Neutral, or empty |
| `ratingWorkLifeBalance` | Number/null | Work-life balance sub-rating (1-5) |
| `ratingCultureAndValues` | Number/null | Culture & values sub-rating (1-5) |
| `ratingDiversityAndInclusion` | Number/null | Diversity & inclusion sub-rating (1-5) |
| `ratingSeniorLeadership` | Number/null | Senior leadership sub-rating (1-5) |
| `ratingCareerOpportunities` | Number/null | Career opportunities sub-rating (1-5) |
| `ratingCompensationAndBenefits` | Number/null | Compensation & benefits sub-rating (1-5) |
| `scrapedAt` | String | ISO 8601 timestamp when the review was scraped |

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

The scraper uses a pay-per-event pricing model. You only pay for what you use.

| Event | Free plan | Bronze | Silver | Gold | Platinum | Diamond | Description |
|-------|-----------|--------|--------|------|----------|---------|-------------|
| Run started | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 | One-time charge per run |
| Review scraped | $0.00345 | $0.003 | $0.00234 | $0.0018 | $0.0012 | $0.00084 | Per review extracted |

#### Cost examples (Free plan pricing)

| Scenario | Reviews | Estimated cost |
|----------|---------|---------------|
| Quick check (1 company) | ~3 | ~$0.02 |
| Competitor comparison (5 companies) | ~15 | ~$0.06 |
| Industry scan (10 companies) | ~30 | ~$0.11 |
| Large-scale research (50 companies) | ~150 | ~$0.53 |

> **Note:** Glassdoor currently limits unauthenticated access to approximately 3 reviews per company. The scraper extracts all publicly visible reviews per company, so total output scales with the number of companies rather than the `maxReviews` setting.

Paid plan users pay less per review — the more you use Apify, the lower the per-review cost.

**Free plan**: Apify provides $5 in free monthly credits -- enough for many company lookups.

**Note:** Actual costs include Apify platform fees for compute and residential proxy usage. The estimates above cover only the actor's per-event charges.

### How to scrape Glassdoor reviews step by step

1. Go to the [Glassdoor Reviews Scraper](https://apify.com/automation-lab/glassdoor-reviews-scraper) page on Apify Store
2. Click **Start** to open the input configuration
3. Enter one or more company URLs or names in the **Company URLs or names** field
4. Set the **Max reviews per company** (default: 50, start small for testing)
5. Choose the **Sort order** -- "Most recent" or "Highest rating"
6. Click **Start** to begin scraping
7. Wait for the run to complete (1-5 minutes depending on review count)
8. Download your results from the **Dataset** tab in JSON, CSV, or Excel format

### Input parameters

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `companyUrls` | Array of strings | Glassdoor review URLs or company names | Required |
| `maxReviews` | Integer | Max reviews per company (1-1000) | 50 |
| `sortBy` | String | Sort order: `newest` or `rating` | `newest` |
| `proxy` | Object | Proxy configuration (SHADER with RESIDENTIAL fallback) | Auto-configured |

#### Input example

```json
{
    "companyUrls": [
        "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm",
        "Apple",
        "Microsoft"
    ],
    "maxReviews": 50,
    "sortBy": "newest"
}
````

#### Accepted URL formats

The scraper accepts various Glassdoor URL formats:

- **Review page URL**: `https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm`
- **Any Glassdoor URL with employer ID**: `https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.htm`
- **Company name**: `Google` (the scraper will search Glassdoor and find the right page)

### Output

Each review is output as a JSON object:

```json
{
    "companyName": "Google",
    "companyUrl": "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm",
    "reviewerTitle": "Software Engineer",
    "currentEmployee": true,
    "rating": 4,
    "reviewDate": "Mar 15, 2026",
    "headline": "Great company with room to grow",
    "pros": "Excellent benefits, smart colleagues, interesting projects, great work-life balance",
    "cons": "Can be bureaucratic, promotion process is slow, some teams have unclear direction",
    "advice": "More transparency in the promotion process would help retain talent",
    "recommend": true,
    "ceoApproval": true,
    "businessOutlook": "Positive",
    "ratingWorkLifeBalance": 4,
    "ratingCultureAndValues": 4,
    "ratingDiversityAndInclusion": 4,
    "ratingSeniorLeadership": 3,
    "ratingCareerOpportunities": 4,
    "ratingCompensationAndBenefits": 5,
    "scrapedAt": "2026-03-27T12:00:00.000Z"
}
```

### Tips for best results

- 🐣 **Start small**: Set `maxReviews` to 10-20 for your first run to verify it works, then increase
- 🔗 **Use URLs when possible**: Direct Glassdoor review URLs are faster and more reliable than company name search
- 💸 **Monitor costs**: Each employee review costs ~$0.003 in per-event charges plus platform compute costs. Large runs (500+ reviews) use more resources
- 🗓️ **Schedule recurring runs**: Use Apify's scheduling to track review trends weekly or monthly
- 🔗 **Combine with other scrapers**: Pair with [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper) for a complete company research dataset
- 🔄 **Handle Cloudflare blocks**: If a run fails due to Cloudflare challenges, wait a few minutes and retry -- protection levels fluctuate

### Integrations

Connect Glassdoor Reviews Scraper with your existing tools and workflows:

- 📊 **Google Sheets** -- automatically export new employee reviews to a spreadsheet for team dashboards. Set up a recurring schedule to track sentiment trends weekly
- 💬 **Slack / Microsoft Teams** -- get notified when scraping completes so you can immediately review the data
- 🔔 **Webhooks** -- trigger downstream processing (sentiment analysis, database updates) when a run finishes
- 🔧 **Zapier / Make** -- build multi-step automations: scrape reviews, analyze sentiment with AI, update a CRM, and alert stakeholders
- 🖥️ **Custom API** -- access results programmatically for integration into internal tools, BI platforms, or AI pipelines

### API usage

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~glassdoor-reviews-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyUrls": ["https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"],
    "maxReviews": 50,
    "sortBy": "newest"
  }'
```

#### Node.js (JavaScript)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/glassdoor-reviews-scraper').call({
    companyUrls: ['https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm'],
    maxReviews: 50,
    sortBy: 'newest',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} reviews`);
for (const review of items) {
    console.log(`${review.rating}/5 - ${review.headline} (${review.reviewerTitle})`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("automation-lab/glassdoor-reviews-scraper").call(run_input={
    "companyUrls": ["https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"],
    "maxReviews": 50,
    "sortBy": "newest",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print(f"{item['companyName']}: {item['headline']} ({item['rating']}/5)")
```

### Use with AI agents via MCP

Glassdoor Reviews Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/glassdoor-reviews-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/glassdoor-reviews-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

- "Use automation-lab/glassdoor-reviews-scraper to get the latest 20 employee reviews for Google and summarize the main pros and cons"
- "Compare employee sentiment between Apple and Microsoft using their Glassdoor reviews"
- "Get 50 Glassdoor reviews for Amazon and identify the most common complaints about management"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality

This actor scrapes only publicly available data from Glassdoor's website. No login credentials are used, and no private or user-specific data is accessed. The scraping complies with standard web scraping practices:

- Only publicly visible reviews are collected
- No account creation or login bypass is involved
- Data is accessed through a standard web browser (the same way any user would view it)
- The actor respects rate limits by processing pages sequentially with natural delays

Users are responsible for ensuring their use of the scraped data complies with applicable laws and Glassdoor's Terms of Service in their jurisdiction.

### FAQ

**Q: Why did my run fail with 0 reviews?**
A: Glassdoor uses aggressive Cloudflare anti-bot protection. If all retry attempts get blocked, the run completes with 0 results. This can happen when Cloudflare is in heightened protection mode. Try again after 15-30 minutes -- protection levels fluctuate throughout the day.

**Q: Why are some fields empty (recommend, ceoApproval, businessOutlook)?**
A: In Glassdoor's current design, sentiment indicators (recommend, CEO approval, business outlook) are shown as page-level aggregate statistics rather than per-review data. These fields may be null for individual reviews.

**Q: Can I scrape reviews in languages other than English?**
A: The scraper currently returns reviews in the default language shown on Glassdoor for the given URL. Most Glassdoor pages default to English. International Glassdoor sites (e.g., glassdoor.de) may return reviews in other languages.

**Q: How many reviews can I scrape per company?**
A: Glassdoor currently shows approximately 3 reviews per page for unauthenticated sessions and requires login to view additional pages. This means each company typically yields around 3 reviews per run. The `maxReviews` parameter still controls the upper limit, but actual output depends on what Glassdoor makes publicly available without authentication.

**Q: Why does this scraper use residential proxies?**
A: Glassdoor uses Cloudflare Managed Challenge which blocks datacenter IP addresses. The scraper uses a tiered proxy strategy: it first tries SHADER proxies (cheaper) and automatically falls back to RESIDENTIAL proxies if Cloudflare blocks the request. This optimizes cost while maintaining reliability.

### Technical details

#### Anti-bot handling

Glassdoor uses Cloudflare Managed Challenge to protect against automated access. This scraper:

1. Uses a **tiered proxy strategy** -- SHADER proxies first for cost savings, with automatic fallback to RESIDENTIAL proxies
2. Launches an **anti-fingerprint browser** (camoufox) when available, falling back to Chromium with stealth patches
3. Rotates proxy sessions with **fresh browser contexts** per retry
4. Detects Cloudflare challenge pages and automatically retries with new sessions
5. Employs realistic browser fingerprints (viewport, locale, headers)

#### Pagination

Reviews are paginated at ~3 per page (Glassdoor's current layout for unauthenticated users). The scraper automatically navigates through pages until the requested number of reviews is collected or no more reviews are available.

#### Rate limiting

The scraper processes one page at a time with natural delays between requests. Each retry uses a completely new browser session to avoid session-based blocking.

### Related scrapers

- [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper) -- scrape job listings from Glassdoor search results
- [LinkedIn Jobs Enrichment](https://apify.com/automation-lab/linkedin-jobs-enrichment) -- enrich job listings with company details
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) -- scrape job listings from Google Jobs

# Actor input Schema

## `companyUrls` (type: `array`):

List of Glassdoor company review URLs (e.g. https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm) or company names to search for. You can mix URLs and names.

## `maxReviews` (type: `integer`):

Maximum number of employee reviews to extract per company. Start with 20 for a quick test.

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

How to sort employee reviews on Glassdoor.

## `proxy` (type: `object`):

The scraper uses a tiered proxy strategy: SHADER (cheaper) is tried first, with automatic fallback to RESIDENTIAL if Cloudflare blocks the request. This optimizes cost while maintaining reliability.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
  ],
  "maxReviews": 20,
  "sortBy": "newest"
}
```

# Actor output Schema

## `overview` (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 = {
    "companyUrls": [
        "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
    ],
    "maxReviews": 20,
    "sortBy": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/glassdoor-reviews-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 = {
    "companyUrls": ["https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"],
    "maxReviews": 20,
    "sortBy": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/glassdoor-reviews-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 '{
  "companyUrls": [
    "https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm"
  ],
  "maxReviews": 20,
  "sortBy": "newest"
}' |
apify call automation-lab/glassdoor-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glassdoor Reviews Scraper",
        "description": "Scrape employee reviews from Glassdoor. Extract ratings, pros, cons, job titles, and more for any company. Uses multiple filter strategies to collect diverse reviews.",
        "version": "0.2",
        "x-build-id": "57y4H8aAAKN1n1Rl4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~glassdoor-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-glassdoor-reviews-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/automation-lab~glassdoor-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-glassdoor-reviews-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/automation-lab~glassdoor-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-glassdoor-reviews-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": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "🏢 Company URLs or names",
                        "type": "array",
                        "description": "List of Glassdoor company review URLs (e.g. https://www.glassdoor.com/Reviews/Google-Reviews-E9079.htm) or company names to search for. You can mix URLs and names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of employee reviews to extract per company. Start with 20 for a quick test.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "rating"
                        ],
                        "type": "string",
                        "description": "How to sort employee reviews on Glassdoor.",
                        "default": "newest"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The scraper uses a tiered proxy strategy: SHADER (cheaper) is tried first, with automatic fallback to RESIDENTIAL if Cloudflare blocks the request. This optimizes cost while maintaining reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
