# Glassdoor Salary & Reviews Intel - Comp Benchmarks, Interviews (`seibs.co/glassdoor-salary-intel`) Actor

Salary distributions, rating sub-scores, review themes, and interview intel from logged-out public Glassdoor pages. Aggregates, not named reviewers. For comp benchmarking, recruiting, PE people-cost diligence. Glassdoor killed its public API in 2024, so there is no official feed.

- **URL**: https://apify.com/seibs.co/glassdoor-salary-intel.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 1 total users, 0 monthly users, 70.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 company records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Glassdoor Salary & Reviews Intel

> **TL;DR for comp / total-rewards teams, recruiters, and PE people-cost diligence:** Pulls salary distributions, company rating sub-scores, aggregated review themes, and interview intel straight off Glassdoor's **logged-out public pages** - then turns them into clean, anonymized aggregates you can benchmark against. Glassdoor killed its public API in 2024 and gates the data behind Cloudflare, so there is no official feed; this reads the same pages a browser shows without an account. Aggregates and short anonymized excerpts only - never named reviewers, usernames, or full review bodies. Free Apify plan covers exploration runs on your $5 platform credit.

### Run it in 30 seconds

```python
## Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/glassdoor-salary-intel").call(run_input={
    "mode": "full_intel",
    "companies": ["Stripe", "Databricks"],
    "apify_proxy_groups": ["RESIDENTIAL"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
````

Or via curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/seibs.co~glassdoor-salary-intel/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "full_intel", "companies": ["Stripe", "Databricks"]}'
```

Or click "Try for free" on this page if you prefer the no-code UI.

### What you get

Each run produces:

- A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
- Views for `overview` (agent skim), `companies` (one row per company, all sub-scores), `salaries` (per-role comp), and `interviews`
- A sample-output preview at [`.actor/sample-output.json`](./.actor/sample-output.json)

Per record type:

- `company_record` - profile + overall rating + culture / comp / work-life / management / career / diversity sub-scores, recommend-to-friend %, CEO approval %
- `salary_datapoint` - per role: base median with derived p25/p75, total-comp range, currency, pay period, sample count
- `review_intel` - one aggregated record per company: rating histogram, rating trend by year, top pros / cons / advice themes (keyword frequency over sampled snippets)
- `interview_intel` - difficulty score + label, positive/neutral/negative experience split, offer rate, common questions

### Live example output

The fastest way to see the shape is the bundled [`.actor/sample-output.json`](./.actor/sample-output.json): one `company_record` for a generic "Acme Software" with plausible sub-scores, two `salary_datapoint` rows, one `review_intel` aggregate, and one `interview_intel` record. Run with your own `companies` list to fetch live data; coverage and field completeness depend on what Glassdoor exposes publicly for each employer (see the FAQ on blocked errors).

### What does Glassdoor Salary & Reviews Intel do?

It resolves each company you give it (by name, or directly from a glassdoor.com URL) to its Glassdoor employer id, then fetches the logged-out public Overview / Salary / Reviews / Interview pages. Those pages hydrate from an embedded JSON blob (`__NEXT_DATA__` / Apollo cache), so the actor parses that JSON - not the rendered HTML - which is far more stable than Glassdoor's churning CSS classes. From it the actor extracts the company rating sub-scores, the per-role salary distributions, a sample of pros / cons / advice text, and the interview stats. It then computes the aggregates locally: salary percentiles, keyword-frequency review themes, the rating trend by year, and a normalized interview-difficulty score. No login, no cookies, no LLM in the loop.

### Responsible use / data scope

This actor is a **public-data tool**. It reads only logged-out, publicly-served Glassdoor pages - the same data a browser shows without an account. It does **not** log in, send cookies from your input, accept Glassdoor's terms, or bypass any paywall or login wall. If data requires an account, it is out of scope.

PII is minimized by design. The actor emits **salary aggregates, company rating sub-scores, and keyword-frequency review themes** - not named reviewers, usernames, or full individual review bodies. The only review text it surfaces is a small number of **short (<=200 char) excerpts with emails, @handles, URLs, and proper-name bigrams stripped**, included as illustrative color, not as attributed reviews. The theme extractors never retain author identity at all.

You are responsible for lawful use of the outputs. **GDPR (EU) and CCPA (CA) apply to personal data even when it is public** - keep data only as long as you need it, do not re-identify aggregates, and do not resell scraped personal data without a lawful basis. We deliberately scope to aggregates over named individuals precisely because aggregates are far lower-risk than named-person reviews.

### AI / RAG / Agent

A turn-key comp + culture feed for sales-AI, recruiting copilots, and diligence agents. Records arrive pre-aggregated - `base_median`, rating sub-scores, `difficulty_label`, theme lists - so an agent can answer "what does Stripe pay a senior PM and how hard is the interview" without parsing raw HTML or doing its own stats. Compatible with **LangChain**, **LlamaIndex**, **Pinecone**, **Weaviate**, **Chroma**, and any **MCP**-aware runtime. The `overview` dataset view is a narrow, token-efficient slice built for tool calls; a `mcp-glassdoor-salary-intel` twin (agentic payments) is on the roadmap.

### Features

- **5 modes** - overview, salaries, reviews intel, interview intel, or full intel - so you pay only for the layers you need.
- **Resolve by name or URL** - pass `"Stripe"` and the actor resolves the employer id via Glassdoor's public search, or paste a direct glassdoor.com Overview URL for an exact match.
- **Rating sub-scores** - overall plus culture, compensation, work-life, senior management, career opportunities, diversity, recommend-to-friend %, and CEO approval %.
- **Salary distributions** - per-role base median with derived p25/p75, total-comp range, currency, pay period, and the underlying sample count.
- **Aggregated review themes** - local keyword + bigram frequency over sampled pros / cons / advice snippets, plus a rating histogram and rating-trend-by-year series. No LLM, no named reviewers.
- **Interview intel** - normalized 1-5 difficulty, positive/neutral/negative experience split, offer rate, and a de-duplicated common-questions list.
- **Cloudflare-aware transport** - real Chrome TLS impersonation, low concurrency, request jitter, exponential backoff, and session rotation, over the Apify RESIDENTIAL proxy by default.
- **Monitor mode** - run on a schedule and get only the change-delta plus an optional Slack digest.
- **Cost-control** - per-run budget guard + demo-mode soft-fail so runs finish SUCCEEDED.

### Use cases

- **Compensation benchmarking** - pull `salary_datapoint` rows across a peer set and compare base medians / percentiles by role to calibrate offers.
- **Total-rewards & retention** - track culture, comp, work-life, and management sub-scores plus the rating trend by year as a retention-risk proxy.
- **PE / VC people-cost diligence** - read rating sub-scores, review themes, and interview difficulty across a target and its comparables before close.
- **Recruiting positioning** - know a competitor's interview difficulty, offer rate, and the pros/cons candidates cite before you pitch against them.
- **Comp-product backfill** - a clean public-pages pipe for teams that lost the official Glassdoor API in 2024.

### Modes

| Mode | What it returns per company |
|---|---|
| `company_overview` | One `company_record`: profile + overall rating + all sub-scores. |
| `salaries` | `company_record` **plus** per-role `salary_datapoint` rows (base median, p25/p75, total-comp range). |
| `reviews_intel` | `company_record` **plus** one aggregated `review_intel` record (histogram, trend by year, top pros/cons/advice themes). |
| `interview_intel` | `company_record` **plus** one `interview_intel` record (difficulty, experience split, offer rate, questions). |
| `full_intel` | All of the above (highest cost per company). |

### Input

See [`.actor/input_schema.json`](./.actor/input_schema.json) for the full form. Key fields:

```json
{
    "mode": "full_intel",
    "companies": ["Stripe", "Databricks"],
    "role_filter": ["software engineer", "product manager"],
    "max_salary_datapoints_per_company": 50,
    "max_reviews_sampled": 100,
    "include_interview": false,
    "apify_proxy_groups": ["RESIDENTIAL"],
    "concurrency": 2
}
```

`companies` accepts names or direct glassdoor.com URLs. A direct Overview URL (with an `EI_IE` employer id) is the most reliable. No login is required, and you should never paste session cookies - the actor only reads logged-out pages.

### Output

One `company_record` per company, followed (per mode) by `salary_datapoint` rows, a `review_intel` aggregate, and/or an `interview_intel` record.

```json
{
    "record_type": "company_record",
    "company": "Acme Software",
    "overall_rating": 3.9,
    "comp_benefits_rating": 3.7,
    "work_life_balance_rating": 3.5,
    "senior_management_rating": 3.3,
    "recommend_to_friend_pct": 78.0,
    "ceo_approval_pct": 86.0,
    "glassdoor_url": "https://www.glassdoor.com/Overview/Working-at-Acme-Software-EI_IE1000001.htm"
}
```

```json
{
    "record_type": "salary_datapoint",
    "company": "Acme Software",
    "role_title": "Senior Software Engineer",
    "base_p25": 167500,
    "base_median": 180000,
    "base_p75": 200000,
    "total_median": 235000,
    "currency": "USD",
    "sample_count": 612
}
```

A company that resolves but whose Salary / Reviews / Interview page is blocked still returns its `company_record`, plus a `fetch_error` record naming the page and how to recover. A company that cannot be resolved at all emits a top-level `fetch_error` with a `reason`.

### Pricing

Pay-per-event:

| Event | Price | When charged |
|---|---|---|
| `company_record` | $0.010 | Per company profile + rating sub-scores. |
| `salary_datapoint` | $0.004 | Per role salary row (salaries / full\_intel). |
| `review_enrichment` | $0.008 | Once per company when the review-intelligence aggregate is computed. |
| `interview_intel` | $0.010 | Once per company when interview intel is extracted. |
| `scheduled_delta_run` | $0.050 | Once per scheduled monitor-mode run. |

A run that returns nothing costs nothing. A 2-company `full_intel` run with ~40 salary rows each costs roughly $0.40 - $0.55 (2 company records + ~80 salary datapoints + 2 review aggregates + 2 interview records). Residential proxy bandwidth (needed because Glassdoor is behind Cloudflare) is the underlying cost the prices clear.

### FAQ

**Q: Is this the official Glassdoor API?**
A: No. Glassdoor **shut down its public/developer API in 2024** - there is no free tier, no signup, and no official feed. This actor reads the logged-out public pages a browser shows without an account and computes the aggregates itself. It is not affiliated with or endorsed by Glassdoor.

**Q: Why do some companies return blocked errors?**
A: Glassdoor sits behind Cloudflare and is aggressive about bot detection. The actor uses real Chrome TLS impersonation over the Apify **RESIDENTIAL** proxy, low concurrency, request jitter, and session rotation to look like a normal visitor, but a given page can still be challenged. When that happens the run still finishes SUCCEEDED and emits a `fetch_error` naming the page. Recovery: keep `apify_proxy_groups=["RESIDENTIAL"]`, lower `concurrency` to 1, and re-run - it usually clears.

**Q: Do you store reviewer identities?**
A: Never. The actor emits salary aggregates, rating sub-scores, and keyword-frequency review *themes*. It does not store or output reviewer names, usernames, or full individual review bodies. The only review text it surfaces is a small number of short (<=200 char) excerpts with emails, @handles, URLs, and proper-name bigrams stripped.

**Q: How do I get the most reliable match for a company?**
A: Paste the direct glassdoor.com Overview URL (the one with `EI_IE<number>` in it) into `companies`. Name resolution works for well-known employers, but a direct URL removes any ambiguity for common or generic names.

**Q: Why is RESIDENTIAL the default proxy when other actors use DATACENTER?**
A: Because of Cloudflare. Most of the portfolio's intel actors hit open JSON APIs or government sites where datacenter IPs are fine. Glassdoor is the one source where datacenter IPs get challenged immediately, so residential is the sensible default here. It costs more bandwidth, which the per-record pricing accounts for.

**Q: How current are the figures?**
A: As current as Glassdoor's public pages. Salary distributions and ratings are aggregates Glassdoor maintains; the rating-trend-by-year is computed from the dates on the sampled review snippets, so it reflects recent reviews, not the entire history.

**Q: Can I schedule this?**
A: Yes. Save your input as a Task and run it on a cron to track comp and rating drift over time. Pair with monitor mode (below) so you only get the delta.

### Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with one click - the foundation for schedules and monitor mode.

1. Click `Run` with your input configured.
2. Click `Save as task`.
3. Name it (e.g. `peer-set comp benchmark - monthly`).
4. Reload the task page and click `Start` anytime.

### Run this on a schedule with Apify Schedules

1. Save your input as a Task (above).
2. Go to https://console.apify.com/schedules and `Create new schedule`.
3. Pick your Task and set a cron expression (monthly on the 1st at 9am: `0 9 1 * *`).
4. Save. Each run refreshes the comp and rating figures for your peer set.

### Monitor mode (beta)

When this actor runs under an Apify Schedule, monitor mode emits only the change-delta (new / changed / removed records) instead of the full set, with a digest record at the top. The delta key is the company slug + record type + role, so a role's salary moving or a sub-score shifting shows up as a change. Provide `monitor_webhook_url` and the digest also fires to your Slack channel. Cost: one `scheduled_delta_run` event ($0.05) per scheduled run plus standard PPE on emitted delta records only.

### Related Actors

- [sec-edgar-intel](https://apify.com/seibs.co/sec-edgar-intel) - pair Glassdoor people-cost signals with exec comp and going-concern language from SEC filings for full diligence.
- [hiring-signal-intel](https://apify.com/seibs.co/hiring-signal-intel) - live job postings + hiring-surge flags; combine "they are hiring fast" with "here is what they pay and how candidates rate them".
- [b2b-sales-triggers](https://apify.com/seibs.co/b2b-sales-triggers) - turn comp / culture signals into outbound triggers for your AE/SDR team.

### Support

Open an issue via the Apify Store contact link. Include the run ID and input config so the issue is reproducible.

### Changelog

See [CHANGELOG.md](./CHANGELOG.md).

### Found this useful?

If this actor saved you time or money, please leave a quick review on the Apify Store. Reviews help other buyers find work that solves their problem: https://apify.com/seibs.co/glassdoor-salary-intel#reviews

# Actor input Schema

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

company\_overview = company profile + overall rating + sub-scores (one company\_record per company). salaries = that PLUS per-role salary datapoints. reviews\_intel = that PLUS one aggregated review-intelligence record per company (rating histogram, rating trend by year, top pros/cons/advice themes - aggregates, no named reviewers). interview\_intel = that PLUS interview difficulty, experience split, offer rate, and common questions. full\_intel = all of the above (highest cost).

## `companies` (type: `array`):

Company names to resolve (e.g. 'Stripe', 'Databricks') OR direct glassdoor.com URLs (e.g. 'https://www.glassdoor.com/Overview/Working-at-Stripe-EI\_IE671932.htm'). Names are resolved via Glassdoor's public search; a direct Overview/Reviews/Salary URL with an EI\_IE employer id is the most reliable. Hard cap of 25.

## `role_filter` (type: `array`):

Keep only salary datapoints whose role title contains one of these substrings (case-insensitive), e.g. \['software engineer', 'product manager', 'data']. Leave empty to keep every role Glassdoor exposes. Applies only in salaries / full\_intel modes. Hard cap of 20.

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

Optional location or country to scope salary and rating context where the Glassdoor page supports it (e.g. 'United States', 'London', 'Germany'). Leave empty for the company-wide / default-location figures Glassdoor serves.

## `max_salary_datapoints_per_company` (type: `integer`):

Hard cap on salary role rows returned per company (salaries / full\_intel modes). Each row is one salary\_datapoint charge. Default 50, max 300.

## `max_reviews_sampled` (type: `integer`):

How many recent public review snippets to sample when computing review themes and the rating trend. This drives the aggregation only - individual reviews are never emitted. More snippets = more stable themes, at slightly higher compute. Default 100, max 500.

## `include_interview` (type: `boolean`):

Also fetch the interview page and emit an interview\_intel record (difficulty, experience split, offer rate, common questions) even in non-interview modes. Off by default because it adds an interview\_intel charge per company. interview\_intel and full\_intel modes always include it.

## `contact_email` (type: `string`):

Optional contact email added to the request headers (good-citizen practice). Not required and never used to log in.

## `monitor_webhook_url` (type: `string`):

When this actor runs under an Apify Schedule (monitor mode), post the change digest to this Slack-compatible webhook URL.

## `use_apify_proxy` (type: `boolean`):

Route requests through Apify Proxy. Strongly recommended - Glassdoor sits behind Cloudflare and blocks un-proxied requests.

## `apify_proxy_groups` (type: `array`):

Apify Proxy groups. RESIDENTIAL is the default here (and recommended) because Glassdoor is behind Cloudflare - residential IPs plus real Chrome TLS impersonation look like a normal visitor, where datacenter IPs get challenged. If you see blocked errors, keep this on RESIDENTIAL and lower concurrency.

## `concurrency` (type: `integer`):

How many companies to fetch in parallel. Kept low on purpose - Glassdoor is aggressive about rate limits. Default 2, max 4. Lower it to 1 if you hit blocks.

## Actor input object example

```json
{
  "mode": "company_overview",
  "companies": [
    "Stripe",
    "Databricks"
  ],
  "role_filter": [],
  "location": "",
  "max_salary_datapoints_per_company": 50,
  "max_reviews_sampled": 100,
  "include_interview": false,
  "contact_email": "",
  "monitor_webhook_url": "",
  "use_apify_proxy": true,
  "apify_proxy_groups": [
    "RESIDENTIAL"
  ],
  "concurrency": 2
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, comp dashboards.

## `datasetItemsCompanies` (type: `string`):

Company profile + overall rating + every rating sub-score. Consumer: recruiting / total-rewards teams, PE people-cost diligence.

## `datasetItemsSalaries` (type: `string`):

Per-role base and total comp with derived percentiles and sample counts. Consumer: comp benchmarking, offer calibration.

## `datasetItemsMcp` (type: `string`):

First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call envelope. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls.

## `datasetItemsCsv` (type: `string`):

Spreadsheet-friendly export of the overview view. Consumer: comp / recruiting teams in Excel or Google Sheets.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "company_overview",
    "companies": [
        "Stripe",
        "Databricks"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/glassdoor-salary-intel").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "company_overview",
    "companies": [
        "Stripe",
        "Databricks",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/glassdoor-salary-intel").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "company_overview",
  "companies": [
    "Stripe",
    "Databricks"
  ]
}' |
apify call seibs.co/glassdoor-salary-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glassdoor Salary & Reviews Intel - Comp Benchmarks, Interviews",
        "description": "Salary distributions, rating sub-scores, review themes, and interview intel from logged-out public Glassdoor pages. Aggregates, not named reviewers. For comp benchmarking, recruiting, PE people-cost diligence. Glassdoor killed its public API in 2024, so there is no official feed.",
        "version": "0.1",
        "x-build-id": "m4d730f8pXJFPiLDz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seibs.co~glassdoor-salary-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seibs.co-glassdoor-salary-intel",
                "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/seibs.co~glassdoor-salary-intel/runs": {
            "post": {
                "operationId": "runs-sync-seibs.co-glassdoor-salary-intel",
                "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/seibs.co~glassdoor-salary-intel/run-sync": {
            "post": {
                "operationId": "run-sync-seibs.co-glassdoor-salary-intel",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "company_overview",
                            "salaries",
                            "reviews_intel",
                            "interview_intel",
                            "full_intel"
                        ],
                        "type": "string",
                        "description": "company_overview = company profile + overall rating + sub-scores (one company_record per company). salaries = that PLUS per-role salary datapoints. reviews_intel = that PLUS one aggregated review-intelligence record per company (rating histogram, rating trend by year, top pros/cons/advice themes - aggregates, no named reviewers). interview_intel = that PLUS interview difficulty, experience split, offer rate, and common questions. full_intel = all of the above (highest cost).",
                        "default": "company_overview"
                    },
                    "companies": {
                        "title": "Companies (names or Glassdoor URLs)",
                        "maxItems": 25,
                        "type": "array",
                        "description": "Company names to resolve (e.g. 'Stripe', 'Databricks') OR direct glassdoor.com URLs (e.g. 'https://www.glassdoor.com/Overview/Working-at-Stripe-EI_IE671932.htm'). Names are resolved via Glassdoor's public search; a direct Overview/Reviews/Salary URL with an EI_IE employer id is the most reliable. Hard cap of 25.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "role_filter": {
                        "title": "Role filter (salary datapoints)",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Keep only salary datapoints whose role title contains one of these substrings (case-insensitive), e.g. ['software engineer', 'product manager', 'data']. Leave empty to keep every role Glassdoor exposes. Applies only in salaries / full_intel modes. Hard cap of 20.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location / country scope (optional)",
                        "type": "string",
                        "description": "Optional location or country to scope salary and rating context where the Glassdoor page supports it (e.g. 'United States', 'London', 'Germany'). Leave empty for the company-wide / default-location figures Glassdoor serves.",
                        "default": ""
                    },
                    "max_salary_datapoints_per_company": {
                        "title": "Max salary datapoints per company",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on salary role rows returned per company (salaries / full_intel modes). Each row is one salary_datapoint charge. Default 50, max 300.",
                        "default": 50
                    },
                    "max_reviews_sampled": {
                        "title": "Max reviews sampled (theme aggregation only)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many recent public review snippets to sample when computing review themes and the rating trend. This drives the aggregation only - individual reviews are never emitted. More snippets = more stable themes, at slightly higher compute. Default 100, max 500.",
                        "default": 100
                    },
                    "include_interview": {
                        "title": "Include interview intel",
                        "type": "boolean",
                        "description": "Also fetch the interview page and emit an interview_intel record (difficulty, experience split, offer rate, common questions) even in non-interview modes. Off by default because it adds an interview_intel charge per company. interview_intel and full_intel modes always include it.",
                        "default": false
                    },
                    "contact_email": {
                        "title": "Contact email (optional, for User-Agent)",
                        "type": "string",
                        "description": "Optional contact email added to the request headers (good-citizen practice). Not required and never used to log in.",
                        "default": ""
                    },
                    "monitor_webhook_url": {
                        "title": "Monitor webhook URL (Slack / email, optional)",
                        "type": "string",
                        "description": "When this actor runs under an Apify Schedule (monitor mode), post the change digest to this Slack-compatible webhook URL.",
                        "default": ""
                    },
                    "use_apify_proxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Strongly recommended - Glassdoor sits behind Cloudflare and blocks un-proxied requests.",
                        "default": true
                    },
                    "apify_proxy_groups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Apify Proxy groups. RESIDENTIAL is the default here (and recommended) because Glassdoor is behind Cloudflare - residential IPs plus real Chrome TLS impersonation look like a normal visitor, where datacenter IPs get challenged. If you see blocked errors, keep this on RESIDENTIAL and lower concurrency.",
                        "default": [
                            "RESIDENTIAL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Max concurrent companies",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "How many companies to fetch in parallel. Kept low on purpose - Glassdoor is aggressive about rate limits. Default 2, max 4. Lower it to 1 if you hit blocks.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
