# Hiring Pulse Benchmarks — growth, days-to-fill, AI share (`agilityy/hiring-pulse-benchmarks`) Actor

Hiring benchmarks from daily job-board history, yours or ours: growth, roles opened and closed, median days-to-fill, remote share and department demand by industry, company size and job-board vendor, plus leaderboards and a publish-ready report.

- **URL**: https://apify.com/agilityy/hiring-pulse-benchmarks.md
- **Developed by:** [Agilityy Research](https://apify.com/agilityy) (community)
- **Categories:** Jobs, Business, Automation
- **Features:** Full permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 benchmark segment rows

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

## Hiring Pulse Benchmarks — growth, days-to-fill and AI share for the companies you track

You get **hiring benchmarks for your own tracked companies**: for all of them and per industry, company-size bucket
and job-board vendor, how fast hiring grew over the last 30 days, how many roles opened and closed, what share of
companies are accelerating or contracting, median days-to-fill (overall and by function), remote share, AI/ML share
and seniority mix. Plus **leaderboards** of the companies adding or cutting the most roles, growing or contracting
fastest, filling fastest, hiring the most AI/ML talent and most remote, and a **Markdown report** you can paste into a
newsletter, a board update or a client memo.

The input is the daily history that **Hiring Velocity Signals** keeps in your Apify account. Schedule that daily on
your list, run this weekly, and you have a benchmark series for your market, your portfolio or your client base that
nobody else has.

Want the market-wide view across 21,000+ companies without tracking anything? The weekly report computed from the
daily archive (public job boards on Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee and Personio) is free at
https://hiring.agilityy.com/ , and bulk access (monthly CSV, Snowflake share) is described at
https://hiring.agilityy.com/for-data-teams/ .

### Who it is for

- **Talent-intelligence and people-analytics teams** — "our days-to-fill for engineers is 38; the companies we
  compete with for talent fill in 29", measured the same way for every company.
- **VC platform teams and analysts** — a portfolio hiring pulse every Monday: who is ramping, who is cutting, where
  the AI hiring is.
- **Recruiting and staffing leaders** — which segments and functions are opening roles fastest, to point the team at.
- **Journalists and newsletter writers** — a publish-ready report with numbers that are reproducible.

### What you get

#### Segment rows (`rowType: segment`), one per segment per run

Segments are `ALL`, `industry:<name>`, `size:<bucket>` and `ats:<vendor>`; industry and size segments need at least
`minCompaniesPerSegment` companies.

| Field | Meaning |
|---|---|
| `segment`, `companies`, `windowDays`, `medianDataDays` | The segment, how many companies are in it, the trailing window, and how many days of history they have |
| `openRoles`, `openRolesWindowStart`, `netChange`, `growthPct`, `medianCompanyGrowthPct` | Open roles now vs at the start of the window |
| `rolesOpened`, `rolesClosed` | Roles opened and closed during the window |
| `acceleratingSharePct`, `contractingSharePct` | Share of companies whose latest signal is `ACCELERATING` / `CONTRACTING` |
| `medianDaysToFill`, `companiesWithFillData`, `closuresMeasured`, `evergreenClosuresExcluded` | Median days from posting date (first sighting when the vendor gives none) to closure; postings older than a year are excluded as evergreen |
| `remoteSharePct` | Median remote share across the segment's companies |
| `topDepartments` | The eight most common departments |
| `functions` | Per function (Engineering, Data & AI, Product, Design, Sales, Marketing, Customer, Operations, Finance, People, Legal, Clinical, Other): open roles, share, median days-to-fill |
| `aiRoles`, `aiRoleSharePct` | AI / ML / LLM roles and their share |
| `seniorityMixPct` | Entry, Mid, Senior, Staff/Principal, Manager, Director, Executive, as shares |

```json
{ "rowType": "segment", "segment": "industry:Fintech", "companies": 42, "windowDays": 30,
  "openRoles": 1870, "openRolesWindowStart": 1712, "netChange": 158, "growthPct": 9.2,
  "rolesOpened": 611, "rolesClosed": 453, "acceleratingSharePct": 23.8, "contractingSharePct": 7.1,
  "medianDaysToFill": 31, "remoteSharePct": 28.0, "aiRoleSharePct": 8.4,
  "functions": [{"name": "Engineering", "roles": 790, "sharePct": 42.2, "medianDaysToFill": 29}],
  "seniorityMixPct": {"Entry": 6.1, "Mid": 24.0, "Senior": 38.5, "Staff/Principal": 9.2, "Manager": 12.4, "Director": 7.0, "Executive": 2.8} }
```

#### Leaderboard rows (`rowType: leaderboard`), `leaderboardSize` per board

Boards: largest net additions and largest reductions of open roles, fastest growing and fastest contracting (by %),
fastest filling, heaviest AI/ML hiring, most remote.

| Field | Meaning |
|---|---|
| `board`, `rank`, `company`, `provider`, `industry`, `sizeBucket` | Which board, the position, the company |
| `openRoles`, `netChange`, `growthPct`, `opened`, `closed`, `signal` | The company's own numbers over the window |
| `medianDaysToFill`, `remoteSharePct`, `aiRoles`, `aiRoleSharePct`, `leadershipSharePct` | Fill speed, remote share, AI and leadership shares |
| `topDepartments`, `topFunctions` | Top three each |

#### The report

`PULSE_REPORT.md` in the run's key-value store, written for whoever reads it: **key findings first** (three to five
sentences on open roles and their change, the biggest movers, days-to-fill, AI/ML share, remote share), then **charts**
(open roles by function, the largest movers, the edition-by-edition trend: self-contained SVG, light and dark mode, no
scripts, also stored as `CHART-<name>.svg`), then the **headline numbers with their change since the previous edition**,
then every segment and leaderboard table and a closing note on sources and method. With `githubRepo` and `githubToken`
set, a **scheduled** run commits `reports/<date>.md`, `reports/latest.md` and `reports/charts/<date>-*.svg` to your
repository in one commit; turn on GitHub Pages and you have a public archive. Runs started from the Console, the API
or a test never commit unless you tick `forcePublish`, so a test run cannot overwrite the archive. Each committed
edition is summarised in the key-value store named by `historyStoreName`, which is where the "previous edition"
columns and the trend chart come from.

Functions and seniority are derived from job titles and departments with explainable keyword rules, so companies
whose department names differ remain comparable. Industry and team size come from an optional `UNIVERSE` record in
the same key-value store (`{ "<provider>-<slug>": { "company", "industry", "teamSize", … } }`); without it you still
get the `ALL` and `ats:` segments and every leaderboard.

### Input

- `stateStoreName` (`hiring-velocity-state`) — the key-value store your Hiring Velocity Signals runs write to.
- `windowDays` (30) — growth, opened/closed counts and days-to-fill are computed over this trailing window.
- `minCompaniesPerSegment` (5) — smaller industry/size/vendor segments are not reported.
- `leaderboardSize` (50) — companies per leaderboard.
- `minHistoryDays` (14) — companies with fewer days of history are tracked but not benchmarked yet, so a young store
  does not pull every segment towards zero. While no company qualifies, the report still shows what today's boards
  measure (open roles, functions, AI share, seniority, remote) and names the date the growth sections start. 0
  benchmarks everything.
- `maxStaleDays` (3) — companies whose latest reading is older than this are excluded, so companies you removed from
  your list stop influencing the benchmarks.
- `publishReport` (true) — write `PULSE_REPORT.md`.
- `githubRepo`, `githubToken`, `githubBranch` (`main`), `githubPath` (`reports`) — optional, to commit each report
  from scheduled runs; `forcePublish` (false) commits from a manual run on purpose.
- `historyStoreName` (`hiring-pulse-history`) — the store that keeps one summary per committed edition.

```json
{ "stateStoreName": "hiring-velocity-state", "windowDays": 30, "leaderboardSize": 25 }
```

### How to run it

1. Schedule **Hiring Velocity Signals** daily on your company list (same Apify account; note its `stateStoreName`).
2. After about two weeks, run this with the same `stateStoreName`, then schedule it weekly (for example Mondays
   `0 7 * * 1` UTC).
3. Read the rows from the dataset (CSV, JSON, Google Sheets or a webhook through Apify Integrations) and the report
   from the run's key-value store:

```
GET https://api.apify.com/v2/acts/agilityy~hiring-pulse-benchmarks/runs/last/dataset/items?token=<your token>&format=csv
GET https://api.apify.com/v2/acts/agilityy~hiring-pulse-benchmarks/runs/last/key-value-store/records/PULSE_REPORT.md?token=<your token>
```

4. **AI agents (MCP)** — Apify's MCP server (`https://mcp.apify.com`) exposes this product as a tool; add
   `agilityy/hiring-pulse-benchmarks` to the tools your agent may call and it can answer "how does our days-to-fill
   compare with the fintech segment?" from the segment rows.

### Pricing (pay per row)

| Event | Price |
|---|---|
| `benchmark-row` — one segment row per run | $0.10 |
| `leaderboard-row` — one ranked company per run | $0.02 |

Plus Apify compute, a few cents per run. Example: a weekly run with about 40 segments and 100 ranked companies is
≈ **$6 per run**, ≈ $25 per month. Lower `leaderboardSize` or raise `minCompaniesPerSegment` to pay less.

### Limits and good to know

- Benchmarks become meaningful after about two weeks of daily readings; days-to-fill needs 30–60 days of closures.
- Industry and size segments exist only for companies with metadata in the `UNIVERSE` record; without it, use the
  `ALL` and vendor segments and the leaderboards.
- Companies with no reading in the last `maxStaleDays` days are left out, so a missed day does not distort growth.
- Everything is computed from public job-board readings; no personal data.

### FAQ

**Can I benchmark against the 21,000+ company archive instead of my own list?** The weekly report from that archive is
free at https://hiring.agilityy.com/ ; the underlying daily rows are sold per row by
**Hiring Signals Feed**, and bulk access is described at https://hiring.agilityy.com/for-data-teams/ .

**Why are my industry segments empty?** Either fewer than `minCompaniesPerSegment` companies carry that industry, or
there is no `UNIVERSE` record in the store. Add one with `industry` and `teamSize` per company key.

**Why is days-to-fill missing for a function?** It needs at least three measured closures in that function within
the window.

# Actor input Schema

## `stateStoreName` (type: `string`):

The named key-value store your Hiring Velocity Signals runs write to.

## `windowDays` (type: `integer`):

Growth, opened/closed counts and days-to-fill are computed over this trailing window.

## `minCompaniesPerSegment` (type: `integer`):

Industry/size/ATS segments with fewer companies are not reported.

## `leaderboardSize` (type: `integer`):

How many companies to list on each leaderboard.

## `publishReport` (type: `boolean`):

Also store a publish-ready Markdown report in the run's key-value store.

## `maxStaleDays` (type: `integer`):

Companies whose latest snapshot is older than this are excluded, so companies removed from the collector list stop influencing benchmarks.

## `minHistoryDays` (type: `integer`):

Companies whose snapshots span fewer days than this are tracked but not benchmarked yet, so a young universe does not pull every segment towards zero. 0 benchmarks everything.

## `githubRepo` (type: `string`):

owner/name. If set together with githubToken, each run commits reports/<date>.md and reports/latest.md. Turn on GitHub Pages for a free public archive.

## `githubToken` (type: `string`):

Fine-grained token with Contents: read/write on that repo only.

## `githubBranch` (type: `string`):

Branch to commit the report to.

## `githubPath` (type: `string`):

Folder inside the repository for the report files.

## `forcePublish` (type: `boolean`):

Reports are committed to the repository only by scheduled runs, so a test or Console run can never overwrite the public archive. Tick this to commit from a manual run on purpose (for example to verify a new token).

## `historyStoreName` (type: `string`):

Named key-value store that keeps one summary per committed edition; it feeds the 'since previous edition' columns and the trend chart. Created on first use.

## Actor input object example

```json
{
  "stateStoreName": "hiring-velocity-state",
  "windowDays": 30,
  "minCompaniesPerSegment": 5,
  "leaderboardSize": 50,
  "publishReport": true,
  "maxStaleDays": 3,
  "minHistoryDays": 14,
  "githubBranch": "main",
  "githubPath": "reports",
  "forcePublish": false,
  "historyStoreName": "hiring-pulse-history"
}
```

# Actor output Schema

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

No description

## `report` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("agilityy/hiring-pulse-benchmarks").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("agilityy/hiring-pulse-benchmarks").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 '{}' |
apify call agilityy/hiring-pulse-benchmarks --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agilityy/hiring-pulse-benchmarks"
        }
    }
}
```

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/Qgm6t4majccBSYZre/builds/pgdNxJG8a611OYgn0/openapi.json
