# Greenhouse, Lever, Ashby & Workable Jobs API + Job Monitor (`gapforge/ats-jobs-monitor`) Actor

Jobs API and job scraper: open jobs from Greenhouse, Lever, Ashby, Workable, Recruitee and Teamtailor company boards in one clean JSON feed. Schedule only-new mode to get only jobs not yet delivered, plus a free notice when a delivered job is taken down. Unofficial; reads public job board feeds.

- **URL**: https://apify.com/gapforge/ats-jobs-monitor.md
- **Developed by:** [GapForge](https://apify.com/gapforge) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 jobs

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

### What is the Greenhouse, Lever, Ashby, Workable, Recruitee & Teamtailor job scraper?

ATS Jobs Monitor is a jobs API and job scraper for the public job boards that companies host on **Greenhouse**, **Lever**, **Ashby**, **Workable**, **Recruitee** and **Teamtailor**. It reads those boards and returns their open jobs as one clean, consistent JSON feed. You give it a list of company boards; it gives you the same fields for every job, whichever system the company uses. The easiest way to try it: open the Input tab and click **Start**. The prefilled boards work as they are.

Turn on **Only new since last run**, add a schedule, and it becomes a job monitor: each run delivers only the postings you have not received before, and adds a free notice when a job it delivered earlier is no longer on its board. With **Maximum jobs per board** at or above each board's size, that answers the question "which of my target companies just opened or closed roles like this?" for job-alert products, talent and market research, competitor hiring signals, recruiting-agency lead lists and sales teams that watch for hiring in a target account.

### Why use it

- **One shape for six systems.** The six systems name things differently; you get the same fields every time, so one spreadsheet, database table or alert rule works for all of them.
- **Built for monitoring.** Only-new mode remembers what you already received and can also flag postings whose title, location, department, employment type or workplace type changed. You pay only for what is delivered.
- **Removed-job notices at no charge.** When a job the monitor delivered is gone from its board, the next run adds one row with `status` set to `removed`. These rows are not charged.
- **Pay ranges as text and as numbers** (minimum, maximum, currency, period) from Greenhouse, Lever and Ashby boards wherever the company publishes pay.
- **Light.** Plain HTTP against the boards' own public feeds, no browser.
- **Clean data, no people data.** Job-ad facts only. Descriptions are left out on purpose: the output stays small and cheap, and no recruiter contact details can slip in.

### What data do you get?

One item per open job:

- `id`: Stable key made of the source system, board name and job id
- `jobId`: Job id on the company's board
- `company`: Company name when the board gives one, otherwise the board name capitalized (for example `Acme`)
- `boardToken`: Board name as used in the board's address
- `title`: Job title
- `location`, `allLocations`: Main location, and every location listed
- `isRemote`: `true` when the board marks the job remote, or when it states no workplace type and a location says remote. On Ashby a job marked hybrid or onsite is also `true` when one of its locations says remote; hybrid jobs with office-only locations are `false`. `null` when the board gives neither a workplace type nor a location
- `workplaceType`: `remote`, `hybrid` or `onsite` when the board states it
- `department`, `team`: Department and team, exactly as the company writes them
- `employmentType`: `full-time`, `part-time`, `contract`, `internship`, `temporary` or `other` when stated
- `compensationSummary`: Pay range text when the company publishes pay on its board (Greenhouse, Lever and Ashby)
- `payMin`, `payMax`: Lowest and highest pay of the first published range, as numbers
- `payCurrency`: Currency code of the pay range, for example `USD`
- `payPeriod`: `year`, `month`, `week`, `day` or `hour` (`other` when the board states a period that is none of these); `null` when the board does not say. Greenhouse has no period field: the period is read from the range's label or note (`hour`, `day`, `week` or `month` when the label says so, `year` when it says annual, yearly or salary, otherwise `null`)
- `postedAt`, `updatedAt`: First published and last updated (UTC, ISO 8601)
- `jobUrl`, `applyUrl`: Public job page and public apply page (Greenhouse and Teamtailor give one link for both)
- `sourceAts`: `greenhouse`, `lever`, `ashby`, `workable`, `recruitee` or `teamtailor`
- `changeType`: `snapshot` in a normal run. In only-new mode: `new` (not delivered before under this state key; on a first run, or with a cap below the board's size, that includes older postings), `changed` or `removed`
- `status`: `open` for a job that is on the board; `removed` for a removed-job notice
- `removedDetectedAt`: In a removed-job notice: when this tool found the job missing (UTC). `null` for open jobs

Job-ad facts only. Job descriptions are not copied, and recruiter or hiring-manager names, mailboxes and phone numbers are never collected, even when a company writes them into an ad. Ad text is discarded while a feed is read and is not kept in the monitor's memory either. When a company chooses to hide pay on its board, it stays hidden here too.

### How to use it (step by step)

1. Open the Input tab. The prefilled boards already work.
2. In **Job boards**, add one entry per company. Write `greenhouse:NAME`, `lever:NAME`, `ashby:NAME`, `workable:NAME`, `recruitee:NAME` or `teamtailor:NAME`, or paste the board's address. NAME is the company's board name in that address, for example the `acme` in `boards.greenhouse.io/acme`, `jobs.lever.co/acme`, `jobs.ashbyhq.com/acme`, `apply.workable.com/acme`, `acme.recruitee.com` or `acme.teamtailor.com`. For Lever EU boards, paste the `jobs.eu.lever.co/NAME` address.
3. Optional: set **Title keywords** (for example `engineer`, `data scientist`) or **Remote jobs only** to narrow the results (it leaves out every job the board marks hybrid or onsite, even when one of its locations says remote), and **Maximum jobs per board** to cap the cost.
4. For monitoring, turn on **Only new since last run** and add a schedule (daily works well). Set **Maximum jobs per board** at or above each board's size: below it, each run delivers the next jobs up to the cap, so a large board arrives over several runs (marked `new`) before only fresh postings remain. Use a different **State key** for each schedule so their memories stay separate (keys are compared without regard to case, and an underscore counts as a dash). Turn on **Also deliver changed jobs** if you want a job again when its title, location, department, employment type or workplace type changes; each re-delivered job is charged as a job. **Report removed jobs** is on by default in this mode; turn it off if you want new jobs and nothing else.
5. Click **Start**. Results appear in the Output tab and can be exported as JSON, CSV or Excel.

### How much does it cost to monitor job boards?

You pay per job and per board check, only after they are delivered, plus Apify's start fee:

- **$0.0015 per job**, which is **$1.50 per 1,000 jobs**.
- **$0.002 per board check**, charged once for each company board that was read successfully.
- Removed-job notices are not charged.
- Apify also charges a small start fee of $0.00005 per run.

Examples: a first run over 20 boards that returns 1,000 jobs costs about $1.54. A daily only-new run over the same 20 boards that finds 15 new jobs costs about $0.06 (once the first runs have delivered each board's backlog). Apify's free plan includes $5 of monthly credit, enough for about 3,300 jobs from 20 boards. A board that cannot be read costs nothing, and a job is charged only after it is saved to your dataset. The tool stops cleanly when it reaches the maximum charge you set for the run and tells you so in the status message.

On paid Apify plans the per-job price is lower automatically (shown on the Pricing tab):

| Apify plan | Price per 1,000 jobs |
|---|---|
| Free | $1.50 per 1,000 |
| Starter | $1.25 per 1,000 |
| Scale | $1.10 per 1,000 |
| Business and above | $0.95 per 1,000 |

Typical board sizes in November 2026, to estimate a first run: Stripe about 785 jobs, Ramp about 179, Spotify about 87.

### Input example

```json
{
  "boards": ["greenhouse:stripe", "lever:spotify", "https://jobs.ashbyhq.com/ramp"],
  "maxJobsPerBoard": 200,
  "titleKeywords": ["engineer"],
  "remoteOnly": false,
  "onlyNew": true,
  "includeChanged": false,
  "includeRemoved": true,
  "stateKey": "daily-engineering"
}
```

### Output example: normalized job JSON

```json
{
  "id": "lever:exampleco:0a1b2c3d-1111-4222-8333-444455556666",
  "jobId": "0a1b2c3d-1111-4222-8333-444455556666",
  "company": "Example Co",
  "boardToken": "exampleco",
  "title": "Senior Backend Engineer",
  "location": "Toronto",
  "allLocations": ["Toronto", "Montreal"],
  "isRemote": false,
  "workplaceType": "hybrid",
  "department": "Engineering",
  "team": "Platform",
  "employmentType": "full-time",
  "compensationSummary": "CAD 150,000 - 190,000 per year salary",
  "payMin": 150000,
  "payMax": 190000,
  "payCurrency": "CAD",
  "payPeriod": "year",
  "postedAt": "2026-11-12T14:03:00Z",
  "updatedAt": null,
  "jobUrl": "https://jobs.lever.co/exampleco/0a1b2c3d-1111-4222-8333-444455556666",
  "applyUrl": "https://jobs.lever.co/exampleco/0a1b2c3d-1111-4222-8333-444455556666/apply",
  "sourceAts": "lever",
  "changeType": "new",
  "status": "open",
  "removedDetectedAt": null
}
```

A removed-job notice has the same fields. Only the ones the monitor remembers are filled in:

```json
{
  "id": "lever:exampleco:0a1b2c3d-1111-4222-8333-444455556666",
  "jobId": "0a1b2c3d-1111-4222-8333-444455556666",
  "company": "Example Co",
  "boardToken": "exampleco",
  "title": "Senior Backend Engineer",
  "location": null,
  "allLocations": [],
  "isRemote": null,
  "workplaceType": null,
  "department": null,
  "team": null,
  "employmentType": null,
  "compensationSummary": null,
  "payMin": null,
  "payMax": null,
  "payCurrency": null,
  "payPeriod": null,
  "postedAt": null,
  "updatedAt": null,
  "jobUrl": "https://jobs.lever.co/exampleco/0a1b2c3d-1111-4222-8333-444455556666",
  "applyUrl": null,
  "sourceAts": "lever",
  "changeType": "removed",
  "status": "removed",
  "removedDetectedAt": "2026-11-16T06:00:12Z"
}
```

The values above are made up to show the format (Example Co is not a real board), with the input example's `engineer` keyword and only-new mode.

### Integrations and API

Run it from the Apify API, the Apify CLI or the Apify clients for Python and JavaScript, on a schedule, or from automation tools that connect to Apify (for example Make, n8n or Zapier). A webhook can notify your system when a run finishes, so new and removed jobs can flow straight into a spreadsheet, a database, a chat channel or a CRM. AI agents can call it through the Apify MCP server; the input and output schemas tell them what to send and what comes back.

### FAQ and troubleshooting

#### How do I find a company's board name?

Open the company's careers page and look at where its job links point. If they go to `boards.greenhouse.io/NAME`, `job-boards.greenhouse.io/NAME`, `jobs.lever.co/NAME`, `jobs.eu.lever.co/NAME`, `jobs.ashbyhq.com/NAME`, `apply.workable.com/NAME`, `NAME.recruitee.com` or `NAME.teamtailor.com`, that NAME is the board name. You can also paste the whole address.

#### How do removed-job notices work?

In only-new mode the monitor remembers the title, job page and company of the jobs it delivered to you. When a board is read in full and one of those jobs (one that still matched your filters at the board's last read) is no longer listed there, the run adds one row for it with `status` and `changeType` set to `removed` and `removedDetectedAt` set to the time of the run. The row carries the job's `id`, `jobId`, `company`, `boardToken`, `title`, `jobUrl`, `sourceAts`, `changeType`, `status` and `removedDetectedAt`; the other fields are empty. A removal is reported once and is not charged. A board that could not be read in a run produces no notices in that run. Notices start with the second run of a state key, because the first run records what is on the boards. If a removed job comes back, it is delivered again as a new job and charged like one. `removedDetectedAt` is the time the tool noticed, not the time the company took the job down. The **Removed** view of the Output tab shows the status and removal time of each row.

#### How do title keywords match?

As whole words or phrases, not case-sensitive, and a plural "s" also matches. `ai` matches "AI Engineer" and "Applied AI" but not "Retail"; `intern` matches "Software Intern" but not "Internal Audit"; `engineer` also matches "Engineers".

#### A board "could not be read"

The status message names the board and the reason. "Not found" almost always means the board name is misspelled or the company moved to another system. "Redirects to the company's own site, not supported" means a Recruitee or Teamtailor board is served from the company's own website instead of its `recruitee.com` or `teamtailor.com` address; this tool does not read those. When a job board answers that it is receiving too many requests, the tool waits 2 seconds, then 4 seconds, and then reports the board. A board that could not be read is not charged, and the other boards in the run are still delivered.

#### The run finished with 0 results in only-new mode.

No new jobs appeared since the last run with the same state key. Only the board checks and Apify's start fee were charged.

#### Where is the only-new memory kept?

In a named key-value store in your own Apify account called `ats-jobs-monitor-state-KEY`, where KEY is your state key in lower case, with underscores turned into dashes. It holds the ids of delivered jobs and, for removed-job notices, their titles, job pages and company names. Delete it to start fresh.

#### It stopped early.

The status message says why. Most often the run reached your maximum charge; raise the limit and run again. In only-new mode the jobs that did not fit are delivered by the next run.

#### Why is `isRemote`, `employmentType` or `payPeriod` empty for some jobs?

The tool reports what each board states. Greenhouse boards have no remote or employment-type field, so `isRemote` there comes from the location text. Greenhouse pay ranges have no period field either, so `payPeriod` is read from the range's label or note: `hour`, `day`, `week` or `month` when they say so, `year` when they say annual, yearly or salary (for example "Base Salary"), and `null` otherwise (for example "On Target Earnings").

#### Why are some jobs old, or why do department names look like codes?

Companies keep some evergreen roles open for months, and some write cost-center codes into department names. Both are shown exactly as the company publishes them.

#### Is it legal?

It reads only the public job feeds companies publish for their own careers pages, at a polite rate that honors each site's robots.txt, and it stores no personal data. Requests to one site are at least half a second apart, and further apart (up to 10 seconds) when that site's robots.txt asks for a longer crawl delay. It does not log in anywhere and does not use an AI model. Check your own use (for example, contacting candidates) against the laws that apply to you.

#### Is this an official product of the job-board systems?

No. This tool is not affiliated with or endorsed by Greenhouse, Lever, Ashby, Workable, Recruitee, Teamtailor or any company whose board it reads.

#### Something looks wrong.

Open an Issue on this page with the run ID and we will look into it.

### Limits

- Greenhouse, Lever, Ashby, Workable, Recruitee and Teamtailor boards only. Personio, Workday, SmartRecruiters and other systems are not covered.
- No job descriptions and no contact details, on any system.
- Recruitee and Teamtailor boards are read at their `NAME.recruitee.com` and `NAME.teamtailor.com` addresses. A board that redirects to the company's own website is reported as not supported and is not charged.
- Up to 200 boards per run, and up to 10,000 jobs delivered per board (set by **Maximum jobs per board**).
- One board's feed can be at most 60 MB. That covers any Greenhouse board we know of (the jobs list is fetched without descriptions); Lever, Ashby and Recruitee feeds include descriptions we discard, so a single board above roughly 3,000 jobs there may be reported as unreadable (not yet measured on a real board of that size), and then it is not charged.
- A Teamtailor board is read in pages of 100 jobs. If a run cannot see the end of a board's list, the jobs it did read are still delivered, the status message names the board, and no removed-job notices are produced for that board in that run. If a page cannot be read at all, the board is reported as unreadable and not charged.
- Removed-job notices exist in only-new mode, for jobs this monitor delivered under the same state key. A normal run does not report removed postings.
- Workable gives a date without a time for `postedAt`, so its time of day reads `00:00:00Z`.
- `updatedAt` is available for Greenhouse only. Pay fields are filled only where the company publishes pay, and only for Greenhouse, Lever and Ashby boards; they are empty for Workable, Recruitee and Teamtailor jobs.
- `employmentType` is empty for Greenhouse and Teamtailor jobs, and `team` is filled for Lever and Ashby jobs only. For Workable jobs the workplace type is either `remote` or empty.
- Boards are read one at a time with a short pause between requests, so very long board lists take longer by design.

# Changelog

This Actor's version history is a separate document: https://apify.com/gapforge/ats-jobs-monitor/changelog.md

# Actor input Schema

## `boards` (type: `array`):

One entry per company board. Write greenhouse:NAME, lever:NAME, ashby:NAME, workable:NAME, recruitee:NAME or teamtailor:NAME, or paste the board's address: https://boards.greenhouse.io/NAME, https://jobs.lever.co/NAME (https://jobs.eu.lever.co/NAME for Lever EU boards), https://jobs.ashbyhq.com/NAME, https://apply.workable.com/NAME, https://NAME.recruitee.com or https://NAME.teamtailor.com. NAME is the company's board name as it appears in that address. Each board read successfully costs one board check.

## `maxJobsPerBoard` (type: `integer`):

Deliver at most this many jobs from each board. You pay per job delivered, so this also caps the cost. Default 1,000 when called from the API; the form starts at 20 so a first try costs a few cents. In only-new mode the jobs over the cap are delivered by later runs.

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

Keep only jobs whose title contains at least one of these whole words or phrases (not case-sensitive; a plural s also matches), e.g. engineer, data scientist. "ai" matches "AI Engineer" but not "Retail". Leave empty for all jobs.

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

Keep only remote jobs: jobs the board marks remote, or that list a remote location and are not marked hybrid or onsite. Every job the board marks hybrid or onsite is left out.

## `onlyNew` (type: `boolean`):

Deliver (and charge for) only jobs that earlier runs with the same state key have not delivered. With Maximum jobs per board below a board's size, each run delivers the next jobs up to that cap, so a large board arrives over several runs before only fresh postings remain. For monitoring, set the cap at or above the board size.

## `includeRemoved` (type: `boolean`):

With "Only new since last run" on: when a job that this monitor delivered earlier is no longer on its board, add one row with status = removed. These rows are not charged. A board that could not be read in a run never produces them. Notices start with the second run of a state key.

## `includeChanged` (type: `boolean`):

With "Only new since last run" on: also deliver a job again when its title, location, department, employment type or workplace type changed. It is marked changeType = changed. Each re-delivered job is charged as a job.

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

Name of the memory used by "Only new since last run". Use different keys for different schedules, e.g. daily-engineering. Letters, digits, dashes and underscores; keys are compared without regard to case, and an underscore counts as a dash. The memory (delivered job ids, and for removed-job notices the title, job page and company name of delivered jobs) is a key-value store in your account named ats-jobs-monitor-state-KEY; delete it to start fresh.

## Actor input object example

```json
{
  "boards": [
    "greenhouse:stripe",
    "lever:spotify",
    "ashby:ramp"
  ],
  "maxJobsPerBoard": 20,
  "remoteOnly": false,
  "onlyNew": false,
  "includeRemoved": true,
  "includeChanged": false,
  "stateKey": "default"
}
```

# Actor output Schema

## `overview` (type: `string`):

Jobs in the dataset, shown with the overview table view.

## `removed` (type: `string`):

The status and found-missing columns of every row. Rows with status removed are the removed-job notices (only-new mode); the table also lists the open jobs of the run.

## `allFields` (type: `string`):

Every field of every item in the dataset, as defined by the dataset schema.

# 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 = {
    "boards": [
        "greenhouse:stripe",
        "lever:spotify",
        "ashby:ramp"
    ],
    "maxJobsPerBoard": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("gapforge/ats-jobs-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 = {
    "boards": [
        "greenhouse:stripe",
        "lever:spotify",
        "ashby:ramp",
    ],
    "maxJobsPerBoard": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("gapforge/ats-jobs-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 '{
  "boards": [
    "greenhouse:stripe",
    "lever:spotify",
    "ashby:ramp"
  ],
  "maxJobsPerBoard": 20
}' |
apify call gapforge/ats-jobs-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gapforge/ats-jobs-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/hTKu1GMAYLuYVmRwK/builds/IVB50qBZgXtfaNXo4/openapi.json
