# Salary Data API: Salary Benchmarks by Job Title & Location (`forgedata/salary-data`) Actor

Salary and compensation benchmarks for any job title and location, from pay ranges in live job postings on 15,700+ company career sites. Median, percentiles, typical range, top-paying companies. Refreshed daily. Batch runs or instant API.

- **URL**: https://apify.com/forgedata/salary-data.md
- **Developed by:** [Data Forge](https://apify.com/forgedata) (community)
- **Security:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 salary benchmarks

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Salary Data from Job Postings do?

It gives you **salary benchmarks for any job title and location** from the pay ranges employers publish in their own live job postings. For each title and place you get the median, the 10th to 90th percentiles, the typical range, the top-paying companies and example postings with links.

The data comes from the [Jobs Database](https://apify.com/forgedata/jobs-database): 1.2M+ open jobs from 15,700+ company career sites on Workday, Oracle, Greenhouse, Ashby, Lever, Recruitee and Personio, refreshed every day. Pay transparency laws in places like California, New York, Colorado and Washington mean a large share of these postings show a pay range, so the benchmarks reflect what companies are offering today, not last year's survey.

### Why use it?

- **Recruiters and hiring managers:** price a role before you post it, or check an offer against the market.
- **HR and compensation teams:** quick market checks by title, seniority and location.
- **Job boards and career tools:** show a salary range next to every job.
- **AI agents:** one call answers "what does a senior data engineer make in Austin?"

### How to use it

1. Add one or more **job titles**, for example `data engineer` or `account executive`.
2. Add **locations** if you want them, for example `usa`, `california`, `london` or `remote`. Leave it empty for anywhere.
3. Pick a **seniority** if you want one. It is read from the job title. Internships are left out unless you pick Intern.
4. Click **Start**. You get one benchmark per title and location.

### Example output

```json
{
  "jobTitle": "data engineer",
  "location": "usa",
  "seniority": "any",
  "currency": "USD",
  "basis": "annual",
  "sampleSize": 1240,
  "companies": 612,
  "salaryP10": 118000,
  "salaryP25": 139000,
  "salaryMedian": 162500,
  "salaryP75": 187000,
  "salaryP90": 214000,
  "typicalRangeLow": 141200,
  "typicalRangeHigh": 183900,
  "hourlyMedian": 78.13,
  "payTransparencyRate": 58.4,
  "topPayingCompanies": [{ "company": "Example Co", "medianSalary": 245000, "postings": 6 }],
  "examplePostings": [{ "title": "Senior Data Engineer", "company": "Example Co", "salaryMin": 210000, "salaryMax": 280000, "url": "https://..." }],
  "dataAsOf": "2026-10-30T08:20:00.000Z"
}
```

Numbers above are illustrative. Your results come from the live database.

### How the numbers are worked out

- Each posting's published range is turned into an annual figure (hourly x 2,080, monthly x 12) and its midpoint is used for the percentiles.
- Ranges that are not believable (for example "$1 to $5 a year") or wider than 4x are left out.
- Results are reported in the currency most matching postings use. Other currencies are listed separately in `otherCurrencies`.
- `sampleSize` is how many postings with pay went into the benchmark. `lowSample` is true below 10, so treat those as a rough guide.
- Advertised pay is what employers offer, not what people end up being paid.
- Most postings with pay come from tech and fast-growing companies (Greenhouse and Ashby career sites), so medians run higher than all-industry surveys. Use it to see what these employers advertise, not as a national average.

### Instant API (Standby)

Get one benchmark per HTTP request, with no run to wait for:

```
https://forgedata--salary-data.apify.actor/salary?title=data%20engineer&location=usa&token=YOUR_APIFY_TOKEN
```

Parameters: `title` (required), `location`, `seniority`, `remoteOnly`, `postedWithinDays`, `excludeKeywords`. Same price as a normal run. Use it from Claude, ChatGPT or Cursor through the Apify MCP server too.

### Pricing

$0.02 per benchmark ($20 per 1,000). Each benchmark sums up every matching posting, often hundreds, so 50 job titles in 5 cities costs $5. Benchmarks where no matching posting shows pay are free.

### Is it legal?

It only uses job postings that employers publish on their public career sites, read from each platform's public job board feed. No logins, no cookies and no personal data.

### Related

- [Jobs Database](https://apify.com/forgedata/jobs-database): search the jobs themselves.
- [Company Hiring Signals](https://apify.com/forgedata/company-hiring-signals): how much any company is hiring right now.

# Actor input Schema

## `jobTitles` (type: `array`):

One benchmark per title (and per location, if you add locations). Matching is by title words, so "data engineer" also covers "Senior Data Engineer".

## `locations` (type: `array`):

City, state or country. Shortcuts: usa, uk, europe, canada, india, latam, apac. Leave empty for anywhere.

## `seniority` (type: `string`):

Read from the job title. Internships are left out unless you pick Intern.

## `remoteOnly` (type: `boolean`):

Only count jobs marked as remote.

## `postedWithinDays` (type: `integer`):

Only use postings from the last N days. Leave empty for all open jobs.

## `excludeKeywords` (type: `array`):

Skip titles with these words, e.g. intern, contract.

## Actor input object example

```json
{
  "jobTitles": [
    "data engineer",
    "product manager"
  ],
  "locations": [
    "usa"
  ],
  "seniority": "any",
  "remoteOnly": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "jobTitles": [
        "data engineer",
        "product manager"
    ],
    "locations": [
        "usa"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("forgedata/salary-data").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 = {
    "jobTitles": [
        "data engineer",
        "product manager",
    ],
    "locations": ["usa"],
}

# Run the Actor and wait for it to finish
run = client.actor("forgedata/salary-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "jobTitles": [
    "data engineer",
    "product manager"
  ],
  "locations": [
    "usa"
  ]
}' |
apify call forgedata/salary-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,forgedata/salary-data"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rpSGUhP4r4ToM7F3v/builds/3sU6yEbC554psAvVF/openapi.json