# Job Market Insights - Salary, Remote % and Skills Data (`hirebase/job-market-insights`) Actor

Aggregate hiring analytics for any slice of the job market: salary percentiles, share of remote roles, top technologies, skills and benefits, experience mix and who is hiring most. Filter a cohort like a job search, or scope it to single companies. Billed per query, not per job.

- **URL**: https://apify.com/hirebase/job-market-insights.md
- **Developed by:** [Hirebase](https://apify.com/hirebase) (community)
- **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. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Job Market Insights - Salary, Remote % and Skills Data

Describe a slice of the job market and get the **numbers behind it in one row**: salary percentiles, the share of roles that are remote, the technologies and skills employers actually ask for, the experience mix, and who is hiring most. Computed over live listings scraped straight from company career pages by [Hirebase](https://www.hirebase.org).

Job scrapers answer *which jobs*. This one answers *what the market looks like* - without paying for a single job row.

**Why this actor?**

- 📊 **A whole cohort in one row** - filter the way you would a job search, get one row of aggregates back.
- 💰 **Real salary distribution** - p25 / median / p75 / p90, the average, the full histogram, and the share of postings that disclose pay at all.
- 🏠 **Remote mix** - the remote / hybrid / in-person split, with salary broken out by each.
- 🛠 **Skills and tech that count** - the top technologies, skills and benefits with the share of postings asking for each.
- 🏢 **Company scope** - point it at company slugs instead, and compare employers side by side, one row each.
- 💸 **Billed per query, not per job** - a cohort of 250,000 jobs costs the same as one of 250.

### How to use it

1. Leave **Scope** on *Whole market* and describe the cohort with the filters: job titles, keywords, locations, workplace type, industry, seniority, posted-within, and so on.
2. Or set **Scope** to *One company at a time* and paste company slugs - each gets its own row. The cohort filters still apply on top, so you can ask "what does Stripe's remote engineering hiring look like".
3. Run. Every row is one query.

### Example input

```json
{
  "scope": "market",
  "jobTitles": ["Data Scientist"],
  "locationTypes": ["Remote"],
  "postedWithinDays": 30
}
```

### Output

One row per query. Real figures from the example above:

```json
{
  "label": "Data Scientist | Remote",
  "scope": "market",
  "totalJobs": 258,
  "medianSalary": 136000,
  "salaryCurrency": "USD",
  "pctDisclosingSalary": 63.95,
  "pctRemote": 100,
  "topCompany": "Booz Allen Hamilton",
  "topTechnology": "Python",
  "dominantExperienceLevel": "Senior",
  "newThisWeek": 64,
  "visaSponsorshipRate": 12.79,
  "recruiterAgencyRate": 5.04,
  "yoeMedian": 5,
  "topTechnologiesText": "Python 82%, SQL 53%, R 22%, AWS 19%, Tableau 14%",
  "topSkillsText": "Machine learning 49%, data science 39%, Data analysis 16%",
  "salaryP25": 113676.25,
  "salaryP50": 136000,
  "salaryP75": 168520,
  "salaryP90": 191460,
  "salaryCount": 143
}
```

The same row also carries the full breakdowns as nested arrays: `salaryHistogram`, `salaryByLevel`, `salaryByLocationType`, `levelBreakdown`, `locationTypeSplit`, `jobTypeSplit`, `educationSplit`, `companySizeSplit`, `industrySplit`, `subindustrySplit`, `topTechnologies`, `topSkills`, `topBenefits`, `topCompanies`, `topLocations`, `freshness`, `scores` and `scoresByLevel` - each with counts and percentages. Export to JSON, CSV or Excel, or pipe into Sheets, Make, n8n or a BI tool.

The `...Text` columns are the top five of a section as plain text, so the run's table is readable at a glance. Hirebase tags skills case-sensitively, so those summaries merge *"Machine learning"* and *"machine learning"*; the nested arrays keep the raw values.

### Great for

- **Compensation benchmarking** - what a role pays now, by seniority and by workplace type, in any market you can describe.
- **Talent and workforce planning** - where hiring is concentrated, which employers dominate a niche, how much of it is remote.
- **Recruiters pitching clients** - hard numbers for "this is what that role costs in this market".
- **Market research and content** - salary and skills reports that refresh on a schedule.
- **Tracking employers over time** - company scope on a daily or weekly schedule builds a time series of one company's hiring.

### Pricing

Billed **per query**, not per job. One row = one query = one charge, whether the cohort holds 250 jobs or 250,000. Company scope runs one query per slug, so five slugs is five charges. Cohorts that match no jobs are not saved and not charged - which is what happens when a company slug is wrong, so check the slug if a row is missing.

**Max queries** caps how many queries a run can make, so it doubles as a spending cap.

### FAQ

**Do I need an API key?**
No - API access is built into the actor.

**Where do I get company slugs?**
From the `companySlug` column of [Company Search](https://apify.com/hirebase/company-search) or any Hirebase job actor. It's the lower-case identifier (`stripe`), not the company name.

**Why is the median salary based on fewer jobs than the cohort?**
Only some postings disclose pay. `pctDisclosingSalary` tells you what share did, and `salaryCount` how many that was - the percentiles are computed over those.

**How fresh are the numbers?**
They're computed over the live index when you run it, and `generatedAt` records when. Repeat queries may be served from Hirebase's cache (`cached: true`).

**Can I get the individual jobs behind these numbers?**
Yes - put the same filters into [Job Search](https://apify.com/hirebase/job-search) and it returns the postings themselves.

**Is this legal?**
The data comes from publicly posted job listings on company career pages, accessed via the Hirebase API, and is reported only in aggregate.

# Actor input Schema

## `scope` (type: `string`):

Report on the whole market that matches your filters, or on one company at a time. Company scope runs one query per company slug, so you can compare employers side by side.

## `companySlugs` (type: `array`):

Only for company scope: one slug per line, e.g. <code>stripe</code>. This is the <code>companySlug</code> column of Company Search or any Hirebase job actor - not the company name. Each slug costs one query. The cohort filters below still apply on top.

## `keywords` (type: `array`):

Match anywhere in job descriptions, skills, technologies, and benefits (e.g. <code>Python</code>, <code>Kubernetes</code>).

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

Match against parsed job titles (e.g. <code>Software Engineer</code>, <code>Product Manager</code>).

## `jobCategories` (type: `array`):

Limit results to one or more Hirebase job categories.

## `locationTypes` (type: `array`):

Remote, hybrid, or in-person roles.

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

One per line, as <code>City, Region, Country</code>, <code>City, Country</code>, or just <code>City</code> (e.g. <code>Austin, Texas, United States</code>).

## `geoFilterMode` (type: `string`):

How strictly locations are matched: <code>auto</code> picks a sensible default, <code>strict</code> requires an exact area match, <code>weak</code> is more forgiving, <code>box</code> uses a bounding box. Only applies when Locations are set.

## `geoRadius` (type: `integer`):

Search radius around each location (default 25). Only applies when Locations are set.

## `geoRadiusUnit` (type: `string`):

Unit for the location radius.

## `jobTypes` (type: `array`):

Full-time, part-time, contract, or internship.

## `experienceLevels` (type: `array`):

Seniority of the role.

## `yoeMin` (type: `integer`):

Only jobs asking for at least this many years of experience.

## `yoeMax` (type: `integer`):

Only jobs asking for at most this many years of experience.

## `includeJobsWithoutYoe` (type: `boolean`):

When using a years-of-experience filter, also keep jobs that don't state a number.

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

Only jobs posted in the last N days. Leave empty for all.

## `postedOnOrAfter` (type: `string`):

Only jobs posted on or after this exact date, as <code>YYYY-MM-DD</code> (e.g. <code>2026-07-01</code>). Overrides "Posted within (days)" if both are set.

## `atsPlatforms` (type: `array`):

Only jobs scraped directly from these applicant tracking systems / career-page platforms.

## `industries` (type: `array`):

Company industry sectors.

## `subIndustries` (type: `array`):

Narrower company sub-industry tags (e.g. <code>Fintech</code>). Note: this filter is being rolled out on the Hirebase side and may not narrow results yet.

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

Only jobs from this specific company.

## `companyKeywords` (type: `array`):

Match in company descriptions, services, and products (e.g. <code>fintech</code>, <code>healthcare AI</code>).

## `companySizes` (type: `array`):

Company headcount buckets.

## `hideRecruitingAgencies` (type: `boolean`):

Exclude postings from recruiters and staffing agencies.

## `salaryMin` (type: `integer`):

Only jobs whose salary range reaches at least this amount (annual).

## `salaryMax` (type: `integer`):

Only jobs whose salary range starts at or below this amount (annual).

## `currency` (type: `string`):

Currency for the salary filter.

## `includeJobsWithoutSalary` (type: `boolean`):

When using a salary filter, also keep jobs that don't disclose salary.

## `visaSponsorship` (type: `string`):

Filter by whether the job offers visa sponsorship.

## `maxQueries` (type: `integer`):

Safety cap on how many queries this run makes (up to 50). You are charged per query, so this is also your spending cap for the run.

## Actor input object example

```json
{
  "scope": "market",
  "companySlugs": [
    "stripe"
  ],
  "jobTitles": [
    "Data Scientist"
  ],
  "geoFilterMode": "auto",
  "geoRadiusUnit": "mi",
  "includeJobsWithoutYoe": true,
  "postedWithinDays": 30,
  "hideRecruitingAgencies": false,
  "currency": "USD",
  "includeJobsWithoutSalary": true,
  "visaSponsorship": "any",
  "maxQueries": 10
}
```

# Actor output Schema

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

One dataset item per query: the cohort's KPIs and every breakdown.

# 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 = {
    "companySlugs": [
        "stripe"
    ],
    "jobTitles": [
        "Data Scientist"
    ],
    "postedWithinDays": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("hirebase/job-market-insights").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 = {
    "companySlugs": ["stripe"],
    "jobTitles": ["Data Scientist"],
    "postedWithinDays": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("hirebase/job-market-insights").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 '{
  "companySlugs": [
    "stripe"
  ],
  "jobTitles": [
    "Data Scientist"
  ],
  "postedWithinDays": 30
}' |
apify call hirebase/job-market-insights --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hirebase/job-market-insights"
        }
    }
}
```

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/1LaDQKYvdo54bQ3Tg/builds/fn9CeqToweeeaEBbt/openapi.json