# Company Hiring Signals Monitor: Open Jobs, New & Closed Roles (`lindenbyte/company-hiring-signals-monitor`) Actor

Paste company domains and get their open jobs straight from the official job-board APIs (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio). Hiring-signal summaries per company, new and closed roles since the last run. Pay per result.

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

## Pricing

from $1.05 / 1,000 job rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Company Hiring Signals Monitor: open jobs, new and closed roles per company

Paste a list of company domains and get every **open job** and a **hiring-signal summary** per company, read straight from the official public job-board APIs of the applicant tracking systems (ATS) those companies use: **Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee and Personio**. Schedule it and get only the **new** roles since the last run, plus how many roles **closed**.

No browser, no proxies, no login, no scraping of job-board HTML. The Actor looks at the company's careers page to find the ATS, then calls that system's public JSON/XML job API.

### What you can do with it

- **Sales and lead generation**: find companies that are hiring for the role your product replaces or supports (SDRs, data engineers, DevOps, compliance) and reach out while the need is fresh.
- **Recruiting and staffing agencies**: watch target accounts and get an alert the day a new role opens.
- **Competitor and market intelligence**: track a competitor's or a whole sector's hiring by department, location and seniority, and see growth or freezes over time.
- **Investor and analyst research**: weekly open-role counts, roles posted in the last 7/30/90 days, net change since last run.
- **Job seekers**: monitor your dream companies, filter by keyword, department, location or remote.

### How it works

1. For each company domain it opens the website, follows the careers link (and common paths such as /careers and /jobs), and looks for links or embeds of a supported ATS. Pasting a board URL (for example `https://jobs.lever.co/palantir`) skips this step.
2. If the pages show no ATS link (many sites load jobs with JavaScript), it tries the domain name as a board name (`stripe` for stripe.com) on every supported system. These matches are marked `confidence: "low"` in the summary; switch it off with "Try the domain name as a board name".
3. It reads the whole public job list, normalizes it to one format and compares it with the list from the previous run (kept in a named key-value store in your account).
4. You get job rows, one summary row per company, and a free status row for every company where no readable board was found.

### Input

| Field | What it does |
|---|---|
| `companies` | Domains (`stripe.com`), careers URLs or job-board URLs. |
| `atsBoards` | Optional direct boards, `system:slug` per line, e.g. `greenhouse:stripe`, `lever:palantir`, `ashby:ashby`, `workable:blueground`, `smartrecruiters:BoschGroup`, `recruitee:bunq`, `personio:personio`. |
| `onlyNewJobs` | Monitoring mode (default on): job rows only for roles not open on the previous run. Already-seen jobs are free, and so is the summary of a company with no new and no closed roles since the last run. |
| `emitOnBaseline` | Output current jobs on the first run for a company (default on). Off = remember silently, then only truly new jobs. |
| `stateKey` | Monitor name. Different names keep separate memories. |
| `keywordFilter`, `departmentFilter`, `locationFilter`, `remoteOnly` | Filters. Rows that do not match are free. |
| `outputJobRows`, `includeCompanySummary` | Choose job rows, summaries or both. |
| `includeDescription` | Add a plain-text description (up to 4,000 characters). |
| `maxJobsPerCompany` | Cost cap on job rows per company per run (default 500). Summaries always cover the full board. |
| `guessBoardFromDomain` | Try the domain name as a board name when no link is found (default on). |

### Output

Three kinds of rows in one dataset (`rowType`):

**Job row** (charged as `job-row`)

```json
{
  "rowType": "job",
  "company": "bunq",
  "domain": "bunq.com",
  "ats": "recruitee",
  "atsSlug": "bunq",
  "jobId": "2828933",
  "title": "Senior Compliance Officer",
  "department": null,
  "location": "London, England, United Kingdom",
  "country": "United Kingdom",
  "remote": false,
  "workplaceType": "hybrid",
  "employmentType": "full-time",
  "seniority": "senior",
  "postedAt": "2026-11-16T16:33:49.000Z",
  "url": "https://careers.bunq.com/o/senior-compliance-officer",
  "applyUrl": "https://careers.bunq.com/o/senior-compliance-officer/c/new",
  "isNew": null,
  "firstSeenAt": null,
  "scrapedAt": "2026-11-16T20:14:52.545Z"
}
```

`isNew` and `firstSeenAt` are filled from the second run on. `seniority` is a guess from the title (intern, entry, mid, senior, staff-principal, lead, manager, director, executive, unspecified); `unspecified` means the title says nothing.

**Company summary** (charged as `company-summary`, except unchanged companies in monitoring mode, see below): `openRoles`, `remoteRoles`, `byDepartment`, `byLocation`, `byCountry`, `bySeniority`, `byEmploymentType`, `velocity` (`postedLast7Days`, `postedLast30Days`, `postedLast90Days`, `medianAgeDays`), `newSinceLastRun`, `closedSinceLastRun`, `netChange`, `previousOpenRoles`, `closedJobs` (id, title, URL, first seen), `boardUrl`, `detectedVia`, `confidence`, `changedSinceLastRun` (`true`/`false`, `null` on the first run), `charged`.

**Unchanged companies are free.** With `onlyNewJobs` on (the default), a company with 0 new and 0 closed roles since the previous run still gets its summary row, marked `changedSinceLastRun: false, charged: false`, and you are not charged for it. First (baseline) runs, companies with changes, and runs with `onlyNewJobs` off are charged as usual. The status message and `RUN-SUMMARY` show how many summaries were free.

Real example (bunq, first run): `openRoles` 24, `postedLast30Days` 14, `byDepartment` `{"Support & Operations": 8, "Growth": 3, ...}`, `byLocation` `{"Amsterdam, Noord-Holland, Netherlands": 15, ...}`.

**Status row** (free): `status` is `no-ats-detected`, `unsupported-ats` (for example Workday: recognised, not read), `fetch-failed` or `board-not-found`, with a `detail` explaining what was tried.

### Pricing

Pay per result: a small fee when the run starts, a fee per job row and a fee per company summary. Status rows, filtered-out jobs, already-seen jobs and summaries of companies that did not change since the last run (monitoring mode) are free. Set a maximum charge per run in the Apify console and the Actor stops cleanly when it is reached.

### Limits (please read)

- **Only these systems are read**: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio. Workday, iCIMS, Taleo, SuccessFactors, Teamtailor, BambooHR, Jobvite and others are recognised when linked, reported as `unsupported-ats`, and not read. Companies on a custom career site without any of the supported systems return `no-ats-detected`.
- **Detection depends on the careers page.** Pages that render everything with JavaScript may hide the ATS link; the domain-name guess then catches many, but not all, and can in rare cases match an unrelated company with the same name (marked `confidence: "low"`). If you know the board, use `atsBoards`.
- **You see what the company publishes.** Boards can hide jobs, and some ATS publish no posting date (then `postedAt` is empty and velocity covers only dated roles). Greenhouse's `postedAt` is the first-published date; Lever and Ashby give creation or publish time; Workable gives a date without time.
- `department`, `seniority`, `remote` and `employmentType` come from the ATS fields where they exist and are normalized by simple rules. Treat `seniority` as a hint.
- Very large boards: SmartRecruiters is read up to 10,000 postings per company. Beyond that, new/closed tracking is switched off for that company and the summary says `boardTruncated: true`.
- Workable allows limited requests per IP address; a very large number of Workable companies in one run can hit its rate limit (the affected company gets a status row).
- Closed roles are jobs that disappeared from the board between two runs; a company can also remove a job for reasons other than filling it.
- The memory used for "new" and "closed" is updated on every run, including runs with "Only new jobs" off. Use different `stateKey` values for separate monitors.
- Public job data only. No recruiter names, e-mail addresses or applicant data are collected or output.

### Tips

- Cheapest trend monitoring across hundreds of companies: turn `outputJobRows` off and schedule weekly; you pay only the summaries of companies whose openings changed.
- Alerts: schedule daily with `onlyNewJobs` on and connect the dataset to a webhook, Slack, Zapier or Make.
- Sales signals: `keywordFilter` such as `SDR, sales development` or `data engineer, kubernetes` on a list of target accounts.

Not affiliated with Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee or Personio, or with any of the companies you monitor. All names are trademarks of their owners. This Actor uses only publicly available, unauthenticated job-board endpoints.

### Changelog

- **2026-11-17 (0.1.4):** In monitoring mode (`onlyNewJobs`, default), the summary of a company with no new and no closed roles since the last run is now free (`changedSinceLastRun: false`, `charged: false`). Scheduled monitors only pay for companies that changed.
- **2026-11-17 (0.1.3):** Fix: on a first (baseline) run, jobs above `maxJobsPerCompany` no longer come back as "new" on the next run.
- **2026-11-16:** First release.

### More from Lindenbyte

- [Website Contact Page & Company Profile Finder](https://apify.com/lindenbyte/website-contact-company-profile-finder): Turn a list of domains into company profiles: contact page, contact form provider, social profiles and logo.
- [SEC Form D Feed: Recently Funded Companies & Private Placements](https://apify.com/lindenbyte/sec-form-d-recently-funded-companies): Daily feed of new SEC Form D filings: companies that just raised money, with amounts, industry and state.
- [Bulk Website Tech Stack Detector (7,000+ technologies)](https://apify.com/lindenbyte/bulk-website-tech-stack-detector): Detect the CMS, ecommerce platform, analytics and frameworks behind a list of websites.
- [UK Companies House New Company Finder (Leads by SIC & Date)](https://apify.com/lindenbyte/uk-companies-house-new-companies): Newly incorporated UK companies from the Companies House API, filtered by date, SIC code and location.

See all our Actors at [apify.com/lindenbyte](https://apify.com/lindenbyte).

# Actor input Schema

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

Company websites (stripe.com), careers pages (https://example.com/careers) or job-board URLs (https://jobs.lever.co/palantir). The Actor finds which applicant tracking system (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio) the company uses by reading the careers page, then reads that system's official public job API.

## `atsBoards` (type: `array`):

Skip detection and name the board yourself, one per line as system:slug. Systems: greenhouse, lever, ashby, workable, smartrecruiters, recruitee, personio. Examples: greenhouse:stripe, lever:palantir, ashby:ashby, workable:blueground, smartrecruiters:BoschGroup, recruitee:bunq, personio:personio. Add @eu for Lever EU boards (lever:acme@eu).

## `onlyNewJobs` (type: `boolean`):

Remembers each company's open jobs (in your named key-value store 'hiring-signals-monitor-state') and outputs job rows only for roles that were not open on the previous run. Already-seen jobs are free. Company summaries are always output; the summary of a company with no new and no closed roles since the previous run is free (marked charged: false). Off = output every current open job on every run.

## `emitOnBaseline` (type: `boolean`):

Only for monitoring mode. The first run for a company has nothing to compare to. On = output its current jobs (up to 'Max jobs per company'). Off = silently remember them and output only the summary, so you only ever get truly new jobs afterwards (cheapest way to start).

## `stateKey` (type: `string`):

Monitors with different names keep separate memories (e.g. one per client, schedule or Slack channel). Change it to start a fresh baseline. Note: the memory is updated on every run, also when 'Only new jobs' is off. Leave empty to use the name "default".

## `keywordFilter` (type: `array`):

Optional. Case-insensitive; a job is kept if its title, department, team or location contains at least one keyword (its description too when 'Include job descriptions' is on). Example: python, data engineer, kubernetes. Jobs that do not match are free.

## `departmentFilter` (type: `array`):

Optional. Case-insensitive 'contains' match on the department or team name, e.g. engineering, sales, marketing. Department names differ per company, so check the summary's byDepartment first.

## `locationFilter` (type: `array`):

Optional. Case-insensitive 'contains' match on the job location, e.g. berlin, germany, united states.

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

Keep only jobs the company marks as remote (or whose location says remote). Hybrid and on-site jobs are skipped (free).

## `outputJobRows` (type: `boolean`):

One row per job (event 'job-row'). Turn off to get only company summaries (cheap hiring-trend monitoring across many companies).

## `includeCompanySummary` (type: `boolean`):

One row per company (event 'company-summary'): open roles, split by department, location and seniority, roles posted in the last 7/30/90 days, new and closed roles since the last run, and the change in headcount demand. In monitoring mode, summaries of companies that did not change since the last run are free.

## `includeDescription` (type: `boolean`):

Adds a plain-text description (up to 4,000 characters) to each job row. Makes the API calls larger and slower, especially for Greenhouse. Also lets keywords match the description.

## `maxJobsPerCompany` (type: `integer`):

Cost cap: at most this many job rows are output (and charged) per company per run, newest first. Summaries always cover the whole board. In monitoring mode, new jobs above the cap are output on the next run.

## `guessBoardFromDomain` (type: `boolean`):

If no ATS link is found on the careers pages (many sites load jobs with JavaScript), try 'stripe' for stripe.com on each supported system. Matches are marked confidence 'low' in the summary. Turn off if you only want boards that the company's own pages link to.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "notion.so",
    "hotjar.com",
    "bunq.com"
  ],
  "atsBoards": [],
  "onlyNewJobs": true,
  "emitOnBaseline": true,
  "keywordFilter": [],
  "departmentFilter": [],
  "locationFilter": [],
  "remoteOnly": false,
  "outputJobRows": true,
  "includeCompanySummary": true,
  "includeDescription": false,
  "maxJobsPerCompany": 500,
  "guessBoardFromDomain": true
}
```

# Actor output Schema

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

No description

## `runSummary` (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.com",
        "notion.so",
        "hotjar.com",
        "bunq.com"
    ],
    "atsBoards": [],
    "keywordFilter": [],
    "departmentFilter": [],
    "locationFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lindenbyte/company-hiring-signals-monitor").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.com",
        "notion.so",
        "hotjar.com",
        "bunq.com",
    ],
    "atsBoards": [],
    "keywordFilter": [],
    "departmentFilter": [],
    "locationFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lindenbyte/company-hiring-signals-monitor").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.com",
    "notion.so",
    "hotjar.com",
    "bunq.com"
  ],
  "atsBoards": [],
  "keywordFilter": [],
  "departmentFilter": [],
  "locationFilter": []
}' |
apify call lindenbyte/company-hiring-signals-monitor --silent --output-dataset

```

## MCP server setup

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

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/tOPOeE2fjQQadFnw1/builds/ziTyDwRWlz0g7l8eo/openapi.json
