# Company Hiring Signals: Greenhouse, Lever & Ashby Jobs API (`atesen-software/company-hiring-signals`) Actor

One row per company: open roles, new and closed roles since your last run, departments, seniority, remote share, locations and a ramping / steady / shrinking hiring signal. From the public Greenhouse, Lever and Ashby job-board APIs. For sales intelligence and account research.

- **URL**: https://apify.com/atesen-software/company-hiring-signals.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (community)
- **Categories:** Lead generation, Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.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

## Company Hiring Signals: Greenhouse, Lever & Ashby Jobs API

Find out which companies are hiring now, and how fast. Give this Actor a list of companies and get **one row per company**: open roles, new and closed roles since your last run, departments, seniority mix, remote share, top locations and a plain `ramping` / `steady` / `shrinking` hiring signal.

It reads the official public job-board APIs of **Greenhouse, Lever and Ashby**. No login, no proxy, no browser, no company websites crawled.

Built for sales intelligence and account research: SDR and AE teams who want hiring data as a buying signal, recruiting agencies looking for companies that are ramping, investors tracking portfolio and competitor headcount plans.

### What you get per company

| Field | Meaning |
|---|---|
| `company`, `ats`, `slug` | Company name (from Greenhouse, otherwise the slug), which ATS, the board slug |
| `openRoles` | Open roles that match your filters |
| `newRolesSinceLastRun`, `closedRolesSinceLastRun` | Role IDs that appeared or disappeared since your previous run. `null` on the first run (that run sets the baseline) |
| `closedRoleIds` | Up to 50 IDs of roles that closed |
| `rolesPostedLast30Days` | Roles first published in the last 30 days |
| `hiringSignal`, `signalBasis` | `ramping`, `steady`, `shrinking` or `unknown`, and what it was based on (rules below) |
| `departments` | Role count per department (top 25, rest under `(other)`) |
| `seniority` | Role count per seniority level, classified from the title |
| `remoteShare`, `hybridShare` | Share of roles marked remote / hybrid (0 to 1) |
| `topLocations`, `topCountries` | Five most common locations and country codes |
| `oldestPostedAt`, `newestPostedAt` | Oldest and newest posting dates |
| `sampleRoles` | Up to 5 roles (title + URL), new roles first, then newest |
| `guessedFrom` | `null` when you gave the ATS (`ats:slug` or a board URL). `slug-auto-detect` or `domain` when the board was found by trying the slug: check `company` and `sampleRoles` URLs, because a different company can own the same slug on another ATS |
| `source`, `attribution`, `checkedAt` | Which API the data came from and when |

Turn on **Include the full role list** to add a `roles` array: title, URL, department, team, location, country, workplace type, employment type, seniority, posted date and `isNew`.

Companies that are not found, invalid lines and API errors come back as rows with `status` = `not_found`, `invalid_input` or `error` and a `message`. They are not charged.

### Input

```json
{
  "companies": ["greenhouse:stripe", "lever:palantir", "ashby:ramp", "https://jobs.lever.co/palantir", "notion", "notion.so"],
  "onlyChanged": false,
  "includeRoles": false,
  "departments": ["Engineering"],
  "locations": ["US", "London"],
  "workplaceTypes": ["remote", "hybrid"],
  "seniority": ["senior", "staff_principal"]
}
```

Each company line can be:

- `ats:slug`, for example `greenhouse:stripe`, `lever:palantir`, `ashby:ramp` (fastest and exact)
- a job-board URL: `boards.greenhouse.io/…`, `job-boards.greenhouse.io/…`, `jobs.lever.co/…`, `jobs.ashbyhq.com/…`
- a bare slug such as `notion`: tried on Greenhouse, then Lever, then Ashby
- a domain such as `notion.so`: its first label (`notion`) is tried as a slug on the three APIs. This is a guess. The company website itself is never fetched, so a company whose board slug differs from its domain will come back `not_found`; give the `ats:slug` pair for those.

Bare slugs and domains are matched by name only: the first of the three APIs with a board of that name and open roles wins, so the row can belong to a different company with the same slug. Such rows carry `guessedFrom`; use `ats:slug` when you need an exact match. The same company given twice in one run (for example `stripe` and `greenhouse:stripe`) is checked and charged once.

All filters are optional and case-insensitive. A different filter set keeps its own change history.

### Example output

```json
{
  "company": "Acme",
  "ats": "greenhouse",
  "slug": "acme",
  "status": "ok",
  "openRoles": 42,
  "newRolesSinceLastRun": 6,
  "closedRolesSinceLastRun": 1,
  "previousOpenRoles": 37,
  "rolesPostedLast30Days": 11,
  "hiringSignal": "ramping",
  "signalBasis": "change-since-last-run",
  "departments": { "Engineering": 18, "Sales": 12, "Customer Success": 7, "Marketing": 5 },
  "seniority": { "senior": 14, "unspecified": 12, "manager": 6, "staff_principal": 4, "junior": 3, "director": 2, "intern": 1 },
  "remoteShare": 0.31,
  "topLocations": [{ "location": "New York, NY", "count": 15 }, { "location": "Remote - US", "count": 9 }],
  "oldestPostedAt": "2026-03-02T15:10:00.000Z",
  "newestPostedAt": "2026-11-07T09:00:00.000Z",
  "sampleRoles": [{ "title": "Senior Account Executive, EMEA", "url": "https://boards.greenhouse.io/acme/jobs/123" }],
  "source": "Greenhouse Job Board API (boards-api.greenhouse.io)",
  "checkedAt": "2026-11-08T12:00:00.000Z"
}
```

### How the hiring signal is decided

The rules are simple on purpose, so you can trust and explain them.

**From the second run on** (`signalBasis` = `change-since-last-run`), comparing with the previous run's open roles:

- `ramping`: at least **2 more** open roles **and** at least **10 % more**
- `shrinking`: at least **2 fewer** open roles **and** at least **10 % fewer**
- `steady`: anything in between
- `unknown`: no open roles now or before

**On the first run** (`signalBasis` = `posting-age`), there is no history yet:

- `ramping`: at least **40 %** of dated roles were first published in the last **30 days**
- `steady`: otherwise
- `unknown` (`not-enough-data`): fewer than 5 dated roles
- A single snapshot never says `shrinking`: old postings are often evergreen roles, not a slowdown.

Run it on a schedule (weekly works well) to get real change data. Ashby's `publishedAt` is the last publish date, so a re-published role can look newer than it is.

### Seniority rules (from the job title)

First matching rule wins:

1. `intern`: intern, internship, co-op, apprentice, trainee, working student
2. `executive`: chief (not chief of staff), CEO/CTO/CFO/COO/CMO/CIO/CPO, CISO, VP, vice president, SVP, EVP, president, general counsel (not associate / assistant / deputy)
3. `director`: director, head of
4. `manager`: manager / mgr, except titles that are usually individual roles (product, account, project, program, partner, customer success, marketing, solutions, territory and similar "… manager" titles)
5. `staff_principal`: staff, principal, distinguished, fellow, architect
6. `lead`: lead, team lead, tech lead
7. `senior`: senior, sr, III, IV
8. `junior`: junior, jr, entry level, graduate, new grad, associate, "Engineer I"
9. `unspecified`: no level word in the title

Keyword rules make mistakes on unusual titles; use the counts as a mix, not as an org chart.

### Use cases

- **Sales intelligence hiring data**: push companies that start ramping in Sales or Engineering into your CRM as warm accounts.
- **Account research**: see where a target company is hiring, which teams grow and how remote-friendly it is before a call.
- **Recruiting agencies**: find companies hiring now in your niche (filter by department, seniority and location).
- **Market and competitor tracking**: weekly watchlist with `onlyChanged` on, so you only see companies that moved.

### Monitoring with "only changed"

Turn on **Only companies that changed since the last run** and schedule the Actor. Role IDs are kept in a key-value store in your account. Each run returns rows only for companies with new or closed roles; unchanged companies are skipped and cost nothing. To keep the history, pick or create a key-value store in **Change-history store** and use the same store for every run of that watchlist (a different store per watchlist). Without a picked store the Actor still runs, treats every company as a first check, and says in the run notes that change history was unavailable.

### Limits (honest)

- Covers only companies that publish jobs through **Greenhouse, Lever or Ashby**. Companies on Workday, SmartRecruiters, iCIMS, Taleo, their own systems or only on job sites are not covered.
- **No LinkedIn, no Indeed**, no job aggregators. Data is what the company itself publishes on its ATS board.
- Lever and Ashby do not return a company display name, so `company` is the slug for those.
- Departments are whatever the company configured (some use cost-centre names or code names).
- Recruiter or hiring-manager names, e-mails and phone numbers are never returned. Job descriptions and custom ATS fields are dropped; only a fixed list of role fields is kept.
- Up to 1,000 companies per run, 2 in parallel by default to stay polite to the public APIs.

### Use via API

One request runs the Actor, waits for it and returns the dataset items as JSON. Send your token in the `Authorization` header, not in the URL:

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~company-hiring-signals/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies":["greenhouse:stripe","lever:palantir","ashby:ramp"]}'
```

The synchronous endpoint waits up to 300 seconds. For longer jobs start a run with `POST https://api.apify.com/v2/acts/atesen-software~company-hiring-signals/runs` and read the dataset when it finishes.

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/company-hiring-signals').call({ companies: ["greenhouse:stripe", "lever:palantir", "ashby:ramp"] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents (MCP)

Claude Desktop, Cursor, VS Code and other MCP clients can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Load only this Actor with:

```text
https://mcp.apify.com?tools=atesen-software/company-hiring-signals
```

Client config (sign in with Apify OAuth when the browser opens, or add an `Authorization: Bearer <APIFY_TOKEN>` header instead):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=atesen-software/company-hiring-signals" }
  }
}
```

Then ask in plain words, for example: "How many open roles do Stripe, Palantir and Ramp have right now, and in which teams?" The agent fills the same input fields you see on the Input tab, and runs are billed to your Apify account at the prices on the Pricing tab.

### Pricing

**Maximum items is a hard cap on charged rows.** Set `maxItems` in the run options (or `?maxItems=` in the API) and the run stops after that many companies: it never writes or charges more rows than that number. Leave it empty for no cap. Free status rows are not counted.

### FAQ

**Do I need an API key?** No. The three APIs are public read-only job-board endpoints.

**What am I charged for?** One event per company row with `status` = `ok`. Not-found companies, invalid lines, API errors and unchanged companies skipped by "only changed" are free. The run stops cleanly when your maximum cost per run is reached; companies not delivered keep their previous history, so they show up as changed next time.

**How do I find a company's slug?** Open its careers page and look at the job links: `boards.greenhouse.io/<slug>`, `jobs.lever.co/<slug>` or `jobs.ashbyhq.com/<slug>`. You can paste that URL as is.

**Why is the first run's `newRolesSinceLastRun` empty?** The first run sets the baseline. From the second run on with the same filters and store name you get new and closed counts.

**Can I get every job with descriptions?** This Actor is a company-level summary. The optional role list has titles, links, location and dates, without descriptions.

Data comes from public job postings published by each company through Greenhouse, Lever or Ashby. Atesen Software is not affiliated with these companies.

### Related actors

- [Career Jobs Scraper: Workday, Greenhouse, Lever, Teamtailor](https://apify.com/atesen-software/career-site-jobs-api)
- [Workday Jobs Scraper: All myworkdayjobs Jobs, No 2,000 Cap](https://apify.com/atesen-software/workday-jobs-scraper)
- [Remote Jobs Aggregator: Job Feed from 3 Boards](https://apify.com/atesen-software/remote-jobs-aggregator)

# Actor input Schema

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

One company per line. Examples: greenhouse:stripe, lever:palantir, ashby:ramp, https://jobs.lever.co/palantir, notion, notion.so. Up to 1,000 per run. Only the three public job-board APIs are called; company websites are never fetched.

## `onlyChanged` (type: `boolean`):

Return a row only when a company has new or closed roles compared with your previous run (same filters). The first run of a company always returns a row, because it sets the baseline. Unchanged companies are skipped and not charged.

## `includeRoles` (type: `boolean`):

Adds a roles array to each company row: title, URL, department, team, location, country, workplace type, employment type, seniority, posted date and an isNew flag. No descriptions and no recruiter data.

## `maxRolesPerCompany` (type: `integer`):

Only used with the full role list. Newest roles first. The counts in the row always use every matching role.

## `departments` (type: `array`):

Keep roles whose department or team contains one of these words (case-insensitive), e.g. Engineering, Sales. Empty = all.

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

Keep roles whose location contains one of these words, or whose two-letter country code matches, e.g. London, Germany, US. Empty = all.

## `workplaceTypes` (type: `array`):

Keep only these workplace types. Empty = all.

## `seniority` (type: `array`):

Keep only these seniority levels (classified from the job title by keyword rules listed in the README). Empty = all.

## `titleKeywords` (type: `array`):

Keep roles whose title contains one of these words, e.g. data, security, SDR. Empty = all.

## `stateStore` (type: `string`):

Key-value store that keeps the role IDs of each company between runs. Pick or create a store here to track new and closed roles. This works with the Actor's limited permissions. Leave it empty to use the named store below, or to run without change history.

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

Named key-value store in your account that keeps the role IDs of each company between runs. Use a different name to keep separate watchlists, or a new name to start a fresh baseline.

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

Kept low to be polite to the public APIs.

## Actor input object example

```json
{
  "companies": [
    "greenhouse:stripe",
    "greenhouse:airbnb",
    "lever:palantir",
    "ashby:ramp",
    "notion"
  ],
  "onlyChanged": false,
  "includeRoles": false,
  "maxRolesPerCompany": 1000,
  "stateStoreName": "company-hiring-signals-state",
  "maxConcurrency": 2
}
```

# Actor output Schema

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

One row per company with open roles, changes since the last run and the hiring signal

## `summary` (type: `string`):

Companies checked, not found, unchanged, errors and the reason the run stopped

# 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": [
        "greenhouse:stripe",
        "greenhouse:airbnb",
        "lever:palantir",
        "ashby:ramp",
        "notion"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/company-hiring-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": [
        "greenhouse:stripe",
        "greenhouse:airbnb",
        "lever:palantir",
        "ashby:ramp",
        "notion",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/company-hiring-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": [
    "greenhouse:stripe",
    "greenhouse:airbnb",
    "lever:palantir",
    "ashby:ramp",
    "notion"
  ]
}' |
apify call atesen-software/company-hiring-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atesen-software/company-hiring-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/uUzOTrxdizAQCUq8x/builds/c8aVMZ8CHEBs2LkhF/openapi.json
