# PayScale Salary & Company Culture Scraper (`crawlerbros/payscale-scraper`) Actor

Scrape PayScale.com salary research pages: company compensation & culture ratings, employee reviews, and job-title salary data by company, city, gender, degree, and experience. Free, no login required.

- **URL**: https://apify.com/crawlerbros/payscale-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Jobs, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## PayScale Salary & Company Culture Scraper

Scrape **PayScale.com** — one of the largest crowdsourced compensation databases on the web. Get a company's salary ranges, culture ratings, benefits, and gender pay-gap stats; read real employee reviews; look up salary data for any job title, skill, certification, degree, US state, or city; or trace a job's likely career-path promotions. No login, no API key, no paid proxy.

### What this actor does

- **Nine modes:** `companySalary`, `companyReviews`, `jobTitleSalary`, `jobTitleReviews`, `skillSalary`, `certificationSalary`, `degreeSalary`, `stateSalary`, `locationSalary`
- **Automatic company-name resolution** — type `Google` or `Tesla`, no need to know PayScale's exact listing name
- **Rich compensation data** — salary percentiles (10th–90th), bonus, commission, hourly rate, and total compensation
- **Culture & satisfaction ratings** — Fair Pay, Overall Employee Satisfaction, Manager Communication, Company Outlook, and more
- **Gender pay-gap & benefits data** — male/female percentage split, retirement & health benefit lists
- **Salary breakdowns** by job title, city, gender, degree/major, years of experience, employer, and employer type (public/private/government/nonprofit) — each row tagged `annual` or `hourly` pay unit
- **Career-path transitions** — for `jobTitleSalary`, the likely next-step roles (and their next steps) with the share of people who made that move and their compensation
- **Related entities** — similar companies, related job titles, related skills/certifications/degrees, or nearby cities, each with a comparison salary
- **Employee reviews** — either about a specific company (`companyReviews`) or about a job title across every company that reports it (`jobTitleReviews`)
- **Global** — 10 countries supported (US, UK, Australia, Canada, India, Germany, New Zealand, Philippines, South Africa, Singapore)
- **Empty fields are omitted** — every field present in a record has a real value

### Output: entity summary (all `*Salary` modes)

One summary record per run for `companySalary`, `jobTitleSalary`, `skillSalary`, `certificationSalary`, `degreeSalary`, `stateSalary`, and `locationSalary` — they all share the same shape:

- `parentType` — `company` / `jobTitle` / `skill` / `certification` / `degree` / `state` / `location`
- `name`, `slug`, `country`, `category` — PayScale's own axis label (`Employer`, `Job`, `Skill`, `Certification`, `Degree`, `State`, `Location`)
- `currencyCode`
- `averageSalary`, `salaryP10`, `salaryP25`, `salaryP75`, `salaryP90`, `salaryProfileCount`
- `averageBonus`, `averageHourlyRate`, `averageTotalComp`, `averageCommission`, `averageProfitSharing`
- `rating<Category>` — one field per PayScale culture metric (e.g. `ratingFairPay`, `ratingOverallEmployeeSatisfaction`, `ratingManagerCommunication`) — company pages only
- `genderMalePercentage`, `genderFemalePercentage`, `satisfactionRating`, `stressRating`
- `relatedEntities[]` — similar/related items for this axis (similar companies, related job titles, related skills/certs/degrees, or nearby cities), each `{name, url, medianSalary, profileCount}`
- `relatedCompanyNames[]` — company mode only: culture-comparison peer companies
- `benefitsDescription`, `retirementBenefits[]`, `healthBenefits[]` — company mode only
- `topLocations[]` — cities with reported salary data
- `payNarrative` — company mode only: PayScale's own plain-text pay summary
- `jobDescription` — job-title mode only: narrative description of the role
- `occupationalCategory`, `topSkills[]` — job-title mode only: O*NET/SOC occupational category and top associated skills
- `industries[]`, `foundedYear`, `employeeCountMin`, `employeeCountMax`, `website`, `organizationType`, `logoUrl` — company mode only
- `reviewCount` — job-title mode only
- `lastUpdated`, `sourceUrl`
- `recordType` — matches the mode name (e.g. `"companySalary"`, `"skillSalary"`), `scrapedAt`

Every `*Salary` run also emits **breakdown rows** (see below), and `jobTitleSalary` additionally emits **career-path rows** (see below).

### Output: salary breakdown (all `*Salary` modes)

- `parentType`, `parentName`, `parentSlug` — the entity this breakdown belongs to
- `dimensionType` — `job`, `city`, `gender`, `degree`, `yearsExperience`, `company`, or `employerType` (public/private/government/nonprofit)
- `dimensionLabel`, `dimensionName` — e.g. dimensionType=`job`, dimensionName=`"Software Engineer"`
- `payUnit` — `annual` or `hourly`; PayScale reports some breakdowns (e.g. hospitality, healthcare) as an hourly rate instead of an annual salary
- `dimensionUrl` — link to that breakdown's own PayScale page
- `profileCount` — number of contributing salary submissions
- `medianSalary`, `p10`, `p25`, `p75`, `p90` — in `payUnit` units
- `isEstimated` — true when PayScale flags the figure as statistically estimated
- `sourceUrl`, `recordType: "salaryByDimension"`, `scrapedAt`

### Output: career-path step (mode = `jobTitleSalary`)

- `parentJobTitle` — the job title that was queried
- `fromJobTitle`, `toJobTitle` — the transition (level 1 = directly from the queried title; level 2 = a further step)
- `toJobUrl`, `transitionPercent` (% of people who made this move), `toCompensation`, `toIsHourly`, `toCurrency`
- `level` — `1` or `2`
- `sourceUrl`, `recordType: "careerPathStep"`, `scrapedAt`

### Output: company employee review (mode = `companyReviews`)

- `companyName`, `companySlug`
- `jobTitle`, `city`, `country`
- `questionPrompt` — the prompt the review answers
- `reviewTitle`, `reviewBody`, `reviewPros`, `reviewCons`
- `reviewDate`
- `sourceUrl`, `recordType: "companyReview"`, `scrapedAt`

### Output: job-title employee review (mode = `jobTitleReviews`)

Reviews about a job title across every reporting company (not one specific employer):

- `jobTitle`, `jobSlug`
- `employerName` — the specific company the reviewer worked at (when PayScale reports it)
- `city`, `country`
- `questionPrompt`, `reviewTitle`, `reviewBody`, `reviewPros`, `reviewCons`, `reviewDate`
- `sourceUrl`, `recordType: "jobReview"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `companySalary` | `companySalary` / `companyReviews` / `jobTitleSalary` / `jobTitleReviews` / `skillSalary` / `certificationSalary` / `degreeSalary` / `stateSalary` / `locationSalary` |
| `companyName` | string | `Google` | Free-text company name (mode=companySalary/companyReviews) |
| `companySlug` | string | – | Exact PayScale slug, bypasses name resolution (advanced) |
| `jobTitle` | string | `Software Engineer` | Free-text job title (mode=jobTitleSalary/jobTitleReviews) |
| `skillName` | string | `Python` | Free-text skill (mode=skillSalary) |
| `certificationName` | string | `Project Management Professional (PMP)` | Free-text certification (mode=certificationSalary) |
| `degreeName` | string | `Bachelor of Science (BS / BSc)` | Free-text degree/major (mode=degreeSalary) |
| `stateName` | string | `California` | US state dropdown (mode=stateSalary) |
| `stateSlugOverride` | string | – | Exact PayScale `State=` slug for non-US provinces, e.g. `Ontario` (advanced) |
| `cityName` | string | `San Francisco` | Free-text US city (mode=locationSalary) |
| `stateAbbr` | string | `CA` | US state abbreviation dropdown for `cityName` (mode=locationSalary) |
| `locationSlugOverride` | string | – | Exact PayScale `Location=` slug for non-US cities, e.g. `Toronto-Ontario` (advanced) |
| `country` | string | `US` | `US`/`UK`/`AU`/`CA`/`IN`/`DE`/`NZ`/`PH`/`ZA`/`SG` |
| `dimensionType` | string | – | Only emit this breakdown type: `job`/`city`/`gender`/`degree`/`yearsExperience`/`company`/`employerType` |
| `payUnit` | string | – | Only emit breakdown rows reported as `annual` or `hourly` |
| `minSalary` / `maxSalary` | int | – | Drop breakdown rows outside this median-salary range |
| `minProfileCount` | int | – | Drop breakdown rows with fewer contributing submissions |
| `reviewPages` | int | `3` | Pages of reviews to fetch, ~7 per page (mode=companyReviews/jobTitleReviews) |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |

#### Example: company salary + culture snapshot

```json
{
  "mode": "companySalary",
  "companyName": "Salesforce",
  "maxItems": 30
}
````

#### Example: employee reviews for a company

```json
{
  "mode": "companyReviews",
  "companyName": "Netflix",
  "reviewPages": 5,
  "maxItems": 30
}
```

#### Example: job-title salary across all companies

```json
{
  "mode": "jobTitleSalary",
  "jobTitle": "Data Scientist",
  "dimensionType": "city",
  "maxItems": 30
}
```

#### Example: UK company salary data

```json
{
  "mode": "companySalary",
  "companyName": "Google",
  "country": "UK",
  "maxItems": 20
}
```

#### Example: salary premium for a skill

```json
{
  "mode": "skillSalary",
  "skillName": "Python",
  "maxItems": 30
}
```

#### Example: salary by certification

```json
{
  "mode": "certificationSalary",
  "certificationName": "Project Management Professional (PMP)",
  "maxItems": 30
}
```

#### Example: salary by US state

```json
{
  "mode": "stateSalary",
  "stateName": "Texas",
  "payUnit": "annual",
  "maxItems": 30
}
```

#### Example: salary in a specific city

```json
{
  "mode": "locationSalary",
  "cityName": "Austin",
  "stateAbbr": "TX",
  "maxItems": 30
}
```

#### Example: job-title reviews + career path

```json
{
  "mode": "jobTitleReviews",
  "jobTitle": "Software Engineer",
  "reviewPages": 3,
  "maxItems": 20
}
```

### Use cases

- **Job seekers & recruiters** — benchmark compensation before an offer or negotiation
- **Compensation & HR analytics** — build a market-rate salary database by role and location
- **Company research & due diligence** — check culture ratings, gender pay gap, and benefits before joining or investing
- **Competitive intelligence** — compare your company's pay and ratings against named competitors
- **Career-content publishers** — power "how much does X pay?" articles and job-title guides

### FAQ

**What is the data source?**
PayScale.com's public salary-research pages, which are crowdsourced from anonymous employee salary submissions and surveys.

**Is this affiliated with PayScale?**
No — this is an independent third-party actor using PayScale's publicly viewable research pages.

**Why does my company search return no results?**
PayScale lists employers under a specific legal-entity name (e.g. `Google, Inc.` rather than `Google`). This actor automatically tries several common name variants; if none resolve, find the exact name on payscale.com/research and pass it via the advanced `companySlug` field.

**How accurate are the salary figures?**
Figures are self-reported by individuals and aggregated statistically by PayScale; they're a market-rate estimate, not a guarantee for any specific role or offer.

**How fresh is the data?**
Each summary record includes `lastUpdated`, PayScale's own last-refresh timestamp for that page.

**Why do some records have fewer fields than others?**
Fields are only included when PayScale reports a value for that company/job/breakdown. A newer or smaller company will naturally have fewer contributing salary submissions and therefore fewer populated breakdown dimensions.

**Can I get salary data for a specific job title at a specific company?**
Run `jobTitleSalary` for the role and inspect the `salaryByDimension` rows with `dimensionType: "company"`, or run `companySalary` for the company and inspect rows with `dimensionType: "job"`.

**What's the difference between `annual` and `hourly` breakdown rows?**
PayScale reports some job titles and companies primarily as an hourly rate (common for hospitality, retail, and healthcare roles) instead of an annual salary. Every `salaryByDimension` row is tagged `payUnit: "annual"` or `payUnit: "hourly"` so the two are never mixed together — use the `payUnit` input filter to request only one.

**How does `locationSalary`/`stateSalary` work for non-US countries?**
`stateName` and `stateAbbr` are curated US dropdowns. For non-US provinces/cities (e.g. Canadian provinces), pass the exact PayScale slug via `stateSlugOverride` or `locationSlugOverride` instead — copy it from the `State=`/`Location=` segment of the matching payscale.com/research URL.

**What is a career-path row?**
For `jobTitleSalary`, PayScale predicts the roles people in this job most often move into next (and their next moves after that), with the share of people who made each transition and the resulting compensation. These are emitted as `recordType: "careerPathStep"` rows alongside the salary summary and breakdowns.

**Is a cost-of-living comparison available?**
Not currently. PayScale's cost-of-living calculator requires a from/city and to/city pair submitted through an interactive form rather than a stable, guessable URL, so it isn't included in this actor.

# Actor input Schema

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

What to fetch.

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

Free-text company name, e.g. `Google`, `Salesforce`, `Tesla`. Resolved automatically to PayScale's exact listing.

## `companySlug` (type: `string`):

Bypasses name resolution. Copy the exact `Employer=...` value from a payscale.com/research URL, e.g. `Google,_Inc.`. Use this if automatic name resolution fails for an obscure company.

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

Free-text job title, e.g. `Software Engineer`, `Registered Nurse`, `Project Manager`.

## `skillName` (type: `string`):

Free-text skill name, e.g. `Python`, `Project Management`, `Data Analysis`. Shows the salary premium PayScale attributes to this skill plus job/city/gender/experience breakdowns of who reports it.

## `certificationName` (type: `string`):

Free-text certification name, e.g. `Project Management Professional (PMP)`, `Certified Public Accountant (CPA)`.

## `degreeName` (type: `string`):

Free-text degree name, e.g. `Bachelor of Science (BS / BSc)`, `Master of Business Administration (MBA)`.

## `stateName` (type: `string`):

US state name. For non-US provinces/states (e.g. Canadian provinces), use `stateSlugOverride` below instead.

## `stateSlugOverride` (type: `string`):

Bypasses `stateName`. Copy the exact `State=...` value from a payscale.com/research URL, e.g. `Ontario` for a Canadian province. Use this for non-US countries.

## `cityName` (type: `string`):

Free-text US city name, e.g. `San Francisco`, `Austin`, `New York`. Combined with `stateAbbr` below to build the PayScale location page.

## `stateAbbr` (type: `string`):

2-letter US state abbreviation for `cityName`. For non-US cities, use `locationSlugOverride` below instead.

## `locationSlugOverride` (type: `string`):

Bypasses `cityName`/`stateAbbr`. Copy the exact `Location=...` value from a payscale.com/research URL, e.g. `Toronto-Ontario` for a non-US city.

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

Which country's PayScale salary data to use.

## `dimensionType` (type: `string`):

Only emit salary-breakdown rows of this type (all \*Salary modes). Leave blank to emit all available dimensions.

## `payUnit` (type: `string`):

Only emit salary-breakdown rows reported in this pay unit (all \*Salary modes). PayScale mixes annual-salary and hourly-rate breakdowns on the same page. Leave blank to emit both.

## `minSalary` (type: `integer`):

Drop breakdown rows with a median salary below this amount.

## `maxSalary` (type: `integer`):

Drop breakdown rows with a median salary above this amount.

## `minProfileCount` (type: `integer`):

Drop breakdown rows backed by fewer than this many salary submissions.

## `reviewPages` (type: `integer`):

Each page has up to 7 reviews. Fetches sequential pages until this limit or `maxItems` is reached.

## `maxItems` (type: `integer`):

Hard cap on emitted records. Actual output is often lower, capped by real data volume: salary modes (companySalary, jobTitleSalary, etc.) return the fixed set of breakdown rows PayScale shows on that single research page (typically well under 200); review modes are capped by the company/job's true total review count on PayScale (see `reviewPages`).

## Actor input object example

```json
{
  "mode": "companySalary",
  "companyName": "Google",
  "jobTitle": "Software Engineer",
  "skillName": "Python",
  "certificationName": "Project Management Professional (PMP)",
  "degreeName": "Bachelor of Science (BS / BSc)",
  "stateName": "California",
  "cityName": "San Francisco",
  "stateAbbr": "CA",
  "country": "US",
  "dimensionType": "",
  "payUnit": "",
  "reviewPages": 3,
  "maxItems": 50
}
```

# Actor output Schema

## `salaryAndCultureRecords` (type: `string`):

Dataset containing all scraped records.

# 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": "companySalary",
    "companyName": "Google",
    "jobTitle": "Software Engineer",
    "skillName": "Python",
    "certificationName": "Project Management Professional (PMP)",
    "degreeName": "Bachelor of Science (BS / BSc)",
    "stateName": "California",
    "cityName": "San Francisco",
    "stateAbbr": "CA",
    "country": "US",
    "dimensionType": "",
    "payUnit": "",
    "reviewPages": 3,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/payscale-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "companySalary",
    "companyName": "Google",
    "jobTitle": "Software Engineer",
    "skillName": "Python",
    "certificationName": "Project Management Professional (PMP)",
    "degreeName": "Bachelor of Science (BS / BSc)",
    "stateName": "California",
    "cityName": "San Francisco",
    "stateAbbr": "CA",
    "country": "US",
    "dimensionType": "",
    "payUnit": "",
    "reviewPages": 3,
    "maxItems": 50,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "companySalary",
  "companyName": "Google",
  "jobTitle": "Software Engineer",
  "skillName": "Python",
  "certificationName": "Project Management Professional (PMP)",
  "degreeName": "Bachelor of Science (BS / BSc)",
  "stateName": "California",
  "cityName": "San Francisco",
  "stateAbbr": "CA",
  "country": "US",
  "dimensionType": "",
  "payUnit": "",
  "reviewPages": 3,
  "maxItems": 50
}' |
apify call crawlerbros/payscale-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PayScale Salary & Company Culture Scraper",
        "description": "Scrape PayScale.com salary research pages: company compensation & culture ratings, employee reviews, and job-title salary data by company, city, gender, degree, and experience. Free, no login required.",
        "version": "1.0",
        "x-build-id": "5pMTHQ3rL2TMTgagL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~payscale-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-payscale-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/crawlerbros~payscale-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-payscale-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/crawlerbros~payscale-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-payscale-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "companySalary",
                            "companyReviews",
                            "jobTitleSalary",
                            "jobTitleReviews",
                            "skillSalary",
                            "certificationSalary",
                            "degreeSalary",
                            "stateSalary",
                            "locationSalary"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "companySalary"
                    },
                    "companyName": {
                        "title": "Company name (mode=companySalary / companyReviews)",
                        "type": "string",
                        "description": "Free-text company name, e.g. `Google`, `Salesforce`, `Tesla`. Resolved automatically to PayScale's exact listing.",
                        "default": "Google"
                    },
                    "companySlug": {
                        "title": "Exact PayScale company slug (advanced, optional)",
                        "type": "string",
                        "description": "Bypasses name resolution. Copy the exact `Employer=...` value from a payscale.com/research URL, e.g. `Google,_Inc.`. Use this if automatic name resolution fails for an obscure company."
                    },
                    "jobTitle": {
                        "title": "Job title (mode=jobTitleSalary / jobTitleReviews)",
                        "type": "string",
                        "description": "Free-text job title, e.g. `Software Engineer`, `Registered Nurse`, `Project Manager`.",
                        "default": "Software Engineer"
                    },
                    "skillName": {
                        "title": "Skill (mode=skillSalary)",
                        "type": "string",
                        "description": "Free-text skill name, e.g. `Python`, `Project Management`, `Data Analysis`. Shows the salary premium PayScale attributes to this skill plus job/city/gender/experience breakdowns of who reports it.",
                        "default": "Python"
                    },
                    "certificationName": {
                        "title": "Certification (mode=certificationSalary)",
                        "type": "string",
                        "description": "Free-text certification name, e.g. `Project Management Professional (PMP)`, `Certified Public Accountant (CPA)`.",
                        "default": "Project Management Professional (PMP)"
                    },
                    "degreeName": {
                        "title": "Degree / major (mode=degreeSalary)",
                        "type": "string",
                        "description": "Free-text degree name, e.g. `Bachelor of Science (BS / BSc)`, `Master of Business Administration (MBA)`.",
                        "default": "Bachelor of Science (BS / BSc)"
                    },
                    "stateName": {
                        "title": "US state (mode=stateSalary)",
                        "enum": [
                            "Alabama",
                            "Alaska",
                            "Arizona",
                            "Arkansas",
                            "California",
                            "Colorado",
                            "Connecticut",
                            "Delaware",
                            "District of Columbia",
                            "Florida",
                            "Georgia",
                            "Hawaii",
                            "Idaho",
                            "Illinois",
                            "Indiana",
                            "Iowa",
                            "Kansas",
                            "Kentucky",
                            "Louisiana",
                            "Maine",
                            "Maryland",
                            "Massachusetts",
                            "Michigan",
                            "Minnesota",
                            "Mississippi",
                            "Missouri",
                            "Montana",
                            "Nebraska",
                            "Nevada",
                            "New Hampshire",
                            "New Jersey",
                            "New Mexico",
                            "New York",
                            "North Carolina",
                            "North Dakota",
                            "Ohio",
                            "Oklahoma",
                            "Oregon",
                            "Pennsylvania",
                            "Rhode Island",
                            "South Carolina",
                            "South Dakota",
                            "Tennessee",
                            "Texas",
                            "Utah",
                            "Vermont",
                            "Virginia",
                            "Washington",
                            "West Virginia",
                            "Wisconsin",
                            "Wyoming"
                        ],
                        "type": "string",
                        "description": "US state name. For non-US provinces/states (e.g. Canadian provinces), use `stateSlugOverride` below instead.",
                        "default": "California"
                    },
                    "stateSlugOverride": {
                        "title": "Exact PayScale State= slug (advanced, optional)",
                        "type": "string",
                        "description": "Bypasses `stateName`. Copy the exact `State=...` value from a payscale.com/research URL, e.g. `Ontario` for a Canadian province. Use this for non-US countries."
                    },
                    "cityName": {
                        "title": "City (mode=locationSalary)",
                        "type": "string",
                        "description": "Free-text US city name, e.g. `San Francisco`, `Austin`, `New York`. Combined with `stateAbbr` below to build the PayScale location page.",
                        "default": "San Francisco"
                    },
                    "stateAbbr": {
                        "title": "US state abbreviation (mode=locationSalary)",
                        "enum": [
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "2-letter US state abbreviation for `cityName`. For non-US cities, use `locationSlugOverride` below instead.",
                        "default": "CA"
                    },
                    "locationSlugOverride": {
                        "title": "Exact PayScale Location= slug (advanced, optional)",
                        "type": "string",
                        "description": "Bypasses `cityName`/`stateAbbr`. Copy the exact `Location=...` value from a payscale.com/research URL, e.g. `Toronto-Ontario` for a non-US city."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "UK",
                            "AU",
                            "CA",
                            "IN",
                            "DE",
                            "NZ",
                            "PH",
                            "ZA",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Which country's PayScale salary data to use.",
                        "default": "US"
                    },
                    "dimensionType": {
                        "title": "Breakdown dimension filter",
                        "enum": [
                            "",
                            "job",
                            "city",
                            "gender",
                            "degree",
                            "yearsExperience",
                            "company",
                            "employerType"
                        ],
                        "type": "string",
                        "description": "Only emit salary-breakdown rows of this type (all *Salary modes). Leave blank to emit all available dimensions.",
                        "default": ""
                    },
                    "payUnit": {
                        "title": "Pay-unit filter",
                        "enum": [
                            "",
                            "annual",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Only emit salary-breakdown rows reported in this pay unit (all *Salary modes). PayScale mixes annual-salary and hourly-rate breakdowns on the same page. Leave blank to emit both.",
                        "default": ""
                    },
                    "minSalary": {
                        "title": "Min median salary (USD-equivalent)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop breakdown rows with a median salary below this amount."
                    },
                    "maxSalary": {
                        "title": "Max median salary (USD-equivalent)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop breakdown rows with a median salary above this amount."
                    },
                    "minProfileCount": {
                        "title": "Min contributing profiles",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop breakdown rows backed by fewer than this many salary submissions."
                    },
                    "reviewPages": {
                        "title": "Review pages to fetch (mode=companyReviews / jobTitleReviews)",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Each page has up to 7 reviews. Fetches sequential pages until this limit or `maxItems` is reached.",
                        "default": 3
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Actual output is often lower, capped by real data volume: salary modes (companySalary, jobTitleSalary, etc.) return the fixed set of breakdown rows PayScale shows on that single research page (typically well under 200); review modes are capped by the company/job's true total review count on PayScale (see `reviewPages`).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
