# Hiring Velocity Signals — Greenhouse, Lever, Ashby + 4 more ATS (`agilityy/hiring-velocity-signals`) Actor

Track any company's public job board over time: new vs closed roles, growth %, 30-day trend, median days-to-fill, department mix and per-role opened/closed events. Schedule it daily and the history builds up in your own account.

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

## Pricing

from $25.00 / 1,000 company hiring signals

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 Velocity Signals — know when any company speeds up or slows down hiring

You give it the companies you care about. Every run you get **one row per company** that tells you whether that
company is hiring faster or slower than last time: open roles, roles opened and closed, growth %, 30-day trend,
median days-to-fill, what functions and seniority levels are being hired, AI/ML share, remote share, and the exact
titles that appeared or disappeared. Optionally, **one row per role** that opened or closed, for alerts and for your
own history of postings.

Put your 200 target accounts in, schedule it daily, and each morning you know which of them just opened five sales
roles, which froze hiring, and how long their engineering roles take to fill. The history accumulates in your own
Apify account from your first run.

The data is read from each company's public job board on Greenhouse, Lever, Ashby, Workable, SmartRecruiters,
Recruitee or Personio, through the vendors' own public JSON/XML feeds (the same data a visitor to the careers page
sees). No login, no HTML scraping, no personal data.

### Who it is for

- **Sales and revenue operations** — growth in open roles is one of the strongest buying signals; a hiring freeze is a
  churn risk. Feed the rows into your CRM and route accounts by `signal`.
- **Recruiters and staffing agencies** — see which clients are ramping, which roles stay open longest, where to pitch.
- **Investors and analysts** — track portfolio and competitor headcount momentum weekly, from primary data.
- **Talent-intelligence and people-analytics teams** — days-to-fill and posting lifecycle for the companies you
  benchmark against, measured the same way for every company.

If you want this for thousands of companies you did not pick yourself, with history that already exists, use
**Hiring Signals Feed** (daily archive of 21,000+ companies, pay per row) instead.

### What you get

#### Company signal row (one per company per run)

| Field | What it tells you |
|---|---|
| `company`, `provider`, `slug`, `careersUrl` | The company and its public job board |
| `snapshotAt`, `previousSnapshotAt`, `daysSincePrevious`, `snapshotsRecorded` | When this and the previous reading were taken |
| `signal` | `ACCELERATING` (3+ new roles and +20 %), `STEADY`, `FLAT`, `CONTRACTING` (board shrank 30 %+ with nothing new), `BOARD_EMPTY` (all roles gone); `BASELINE` on a company's first run |
| `openRoles`, `previousOpenRoles`, `newRoles`, `closedRoles`, `netChange`, `growthPct` | Change since the previous run |
| `trend30dPct`, `rolesOpened30d`, `rolesClosed30d` | Rolling 30-day momentum |
| `medianDaysToFill` | How long the roles that closed had been open, counted from the posting date (first sighting when the vendor gives none) |
| `functions` | Open roles by function: Engineering, Data & AI, Product, Design, Sales, Marketing, Customer, Operations, Finance, People, Legal, Clinical, Other |
| `seniorityMix` | Entry, Mid, Senior, Staff/Principal, Manager, Director, Executive |
| `aiRoles`, `aiRoleSharePct` | AI / ML / LLM roles and their share of the board |
| `remoteSharePct`, `topDepartments`, `topLocations` | Where and what the company hires for |
| `newRoleTitles`, `closedRoleTitles` | The titles that moved (up to 15 each) |

Example:

```json
{ "company": "Notion", "provider": "ashby", "signal": "ACCELERATING", "openRoles": 143, "previousOpenRoles": 131,
  "newRoles": 14, "closedRoles": 2, "netChange": 12, "growthPct": 9.2, "trend30dPct": 18.4, "medianDaysToFill": 27,
  "functions": [{"name": "Engineering", "roles": 61}, {"name": "Sales", "roles": 24}], "aiRoleSharePct": 11.2,
  "remoteSharePct": 34.3, "newRoleTitles": ["Enterprise Account Executive", "Staff Software Engineer, AI"] }
```

Functions and seniority are derived from job titles and departments with explainable keyword rules, so they are
comparable across companies whose department names differ.

#### Job event row (one per role that opened or closed, `emitJobs` on)

| Field | What it tells you |
|---|---|
| `eventType` | `opened` or `closed` |
| `company`, `provider`, `slug`, `jobId`, `url` | The company and the role's public page |
| `title`, `department`, `location`, `remote` | As published on the board |
| `firstSeen`, `closedAt`, `daysOpen` | Posting lifecycle; `daysOpen` is set on `closed` events |

### Input

- `companies` (required) — one entry per company: a board slug (`stripe`, auto-detected across all seven vendors) or
  a careers URL (`https://boards.greenhouse.io/figma`, `https://jobs.lever.co/<slug>`,
  `https://jobs.ashbyhq.com/notion`, `https://apply.workable.com/<slug>`, SmartRecruiters, Recruitee and Personio
  board URLs). 50–500 companies per run is typical.
- `emitJobs` (true) — also write one row per role that opened or closed.
- `emitBaselineJobs` (false) — on a company's first run every role would count as newly opened; leave off so the first
  run bills signals only.
- `stateStoreName` (`hiring-velocity-state`) — the key-value store in your account that keeps snapshots between runs.
  Use different names for different watch-lists. Snapshots are stored as 128 shard records, so a run costs about 128
  store writes however many companies it covers.
- `archiveDatasetName` (optional) — a named dataset in your account that keeps every signal and job event beyond
  run-dataset retention. Recommended for scheduled runs.
- `maxConcurrency` (5) — boards fetched in parallel.
- `qualityStoreName` (`hiring-quality`) — a named key-value store with one `RUN_QUALITY` record per day: boards
  fetched vs not found, HTTP errors per vendor, open roles per vendor, day-over-day change, and two accuracy spot
  checks (25 boards re-counted on the vendor's public careers page, 10 closed roles re-fetched to confirm they are
  gone). The same record is in every run's key-value store; set the name empty to skip the named copy.

```json
{ "companies": ["stripe", "https://jobs.ashbyhq.com/notion", "https://boards.greenhouse.io/figma"], "emitJobs": true }
```

### How to run it

1. **Console** — paste your list, click **Run**. The first run writes `BASELINE` rows; the second run gives you
   signals.
2. **Schedule** — Apify → Schedules → daily (for example `0 6 * * *` UTC). Signals need two runs; the 30-day trend
   and days-to-fill mature over a few weeks.
3. **Deliver** — connect the dataset to Slack, Google Sheets, your CRM, Make, Zapier or a webhook with Apify
   Integrations, or read it with the API:

```
POST https://api.apify.com/v2/acts/agilityy~hiring-velocity-signals/runs?token=<your token>
     body: the input JSON above
GET  https://api.apify.com/v2/acts/agilityy~hiring-velocity-signals/runs/last/dataset/items?token=<your token>&format=csv
```

4. **AI agents (MCP)** — Apify's MCP server (`https://mcp.apify.com`) exposes this product as a tool; add
   `agilityy/hiring-velocity-signals` to the tools your agent may call and it receives the same rows.

### Pricing (pay per row)

| Event | Price |
|---|---|
| `company-signal` — one row per company per run | **$0.025** launch price until 2027-01-21 (list price $0.05) |
| `job-event` — one row per role that opened or closed | $0.004 |

Plus Apify compute for the run, a few cents. Examples at the launch price:

- 200 companies, daily: 200 × $0.025 × 30 ≈ **$150 per month** in signals (≈ $300 at list price), plus about
  $0.004 per role that opens or closes.
- 50 companies, weekly: 50 × $0.025 × 4 ≈ **$5 per month**.
- Set `emitJobs: false` to pay for signals only.

### Limits and good to know

- Companies whose board cannot be found or whose board has no public feed produce no row and are not billed; the
  run's quality record counts them.
- A company's first run is a `BASELINE`: there is nothing to compare against yet. Growth and trend need at least two
  runs; `trend30dPct` needs 30 days of your own history.
- Workable, Personio and Recruitee rate-limit per IP; requests to them are paced automatically, so very large lists
  on those vendors take longer rather than fail.
- Only official, public job-board feeds are read. No login, no HTML scraping, no personal data.

### FAQ

**Can I backfill history from before my first run?** No. Snapshots start on your first run; the 30-day trend and
days-to-fill fill in as your history grows. For 21,000+ companies with history that already exists, use **Hiring
Signals Feed**.

**Why does `medianDaysToFill` stay empty at first?** It is computed from roles that closed while you were tracking
them. It appears after your first closures and becomes stable after 30–60 days.

**Can I get benchmarks from this history?** Yes. **Hiring Pulse Benchmarks** reads the same state store and gives you
benchmarks by industry, company size and job-board vendor, leaderboards and a weekly Markdown report.

**Is there a free market-wide view?** The weekly Hiring Pulse report across 21,000+ companies is free at
https://hiring.agilityy.com/ ; bulk access (monthly CSV, Snowflake share) is described at
https://hiring.agilityy.com/for-data-teams/ .

### Related

**Hiring Signals Feed** — the same rows for 21,000+ companies, read every day, pay per row. **Company Hiring Lookup** —
one profile per company, right now, no history. **Greenhouse / Lever / Ashby / Workable Jobs Scraper** — one row per
open role. **YC Companies Hiring Tracker** — this product with the 650+ Y Combinator job boards built in.

# Actor input Schema

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

One entry per company. Accepts a bare slug (auto-detected across Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee and Personio) or a careers URL such as https://boards.greenhouse.io/stripe, https://jobs.lever.co/<slug>, https://jobs.ashbyhq.com/notion, https://apply.workable.com/<slug>, https://careers.smartrecruiters.com/<Company>, https://<slug>.recruitee.com, https://<slug>.jobs.personio.de.

## `emitJobs` (type: `boolean`):

Also output one record for every role that opened or closed since the previous snapshot (useful for alerting and for building a historical postings dataset).

## `emitBaselineJobs` (type: `boolean`):

On a company's first run every role counts as newly opened. Off by default so the first run does not bill one event per existing role.

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

Named key-value store in your Apify account where snapshots are kept between runs. Use different names to track separate portfolios.

## `archiveDatasetName` (type: `string`):

If set, every signal and job event is also appended to this named dataset in your account, so your history survives run-dataset retention. Recommended for scheduled runs, e.g. hiring-archive.

## `maxConcurrency` (type: `integer`):

How many job boards to fetch in parallel.

## `qualityStoreName` (type: `string`):

Named key-value store that keeps one RUN_QUALITY record per day (key = date): boards fetched vs not found, HTTP errors per vendor, open roles per vendor, day-over-day change, and the careers-page and closure spot checks. The same record is always in the run's key-value store. Leave empty to skip the named copy.

## Actor input object example

```json
{
  "companies": [
    "stripe",
    "https://jobs.ashbyhq.com/notion",
    "figma"
  ],
  "emitJobs": true,
  "emitBaselineJobs": false,
  "stateStoreName": "hiring-velocity-state",
  "maxConcurrency": 5,
  "qualityStoreName": "hiring-quality"
}
```

# 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 = {
    "companies": [
        "stripe",
        "https://jobs.ashbyhq.com/notion",
        "figma"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agilityy/hiring-velocity-signals").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 = { "companies": [
        "stripe",
        "https://jobs.ashbyhq.com/notion",
        "figma",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("agilityy/hiring-velocity-signals").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 '{
  "companies": [
    "stripe",
    "https://jobs.ashbyhq.com/notion",
    "figma"
  ]
}' |
apify call agilityy/hiring-velocity-signals --silent --output-dataset

```

## MCP server setup

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

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/abUY6WVZaELJbLR7t/builds/Cj0PRhBEeE1Ng4uvv/openapi.json
