# Greenhouse, Lever, Ashby & Workable Job Board API (`plain-build/ats-job-boards-scraper`) Actor

Career site jobs from the Greenhouse, Lever, Ashby and Workable boards you list as vendor:slug, in one table: title, company (board slug where the vendor gives no name), location, department, type, date, snippet, apply link. No login, no key. Turn on Only new jobs for daily runs. No salary field.

- **URL**: https://apify.com/plain-build/ats-job-boards-scraper.md
- **Developed by:** [Plain Build](https://apify.com/plain-build) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

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

## Greenhouse, Lever, Ashby & Workable Job Board API

### What it does

Career site jobs from the Greenhouse, Lever, Ashby and Workable boards you list as vendor:slug, in one table: title, company (board slug where the vendor gives no name), location, department, type, date, snippet, apply link. No login, no key. Turn on Only new jobs for daily runs. No salary field.

The data comes from Greenhouse, Lever, Ashby and Workable through their public JSON endpoints (https://boards-api.greenhouse.io). This Actor is not affiliated with, endorsed by or sponsored by Greenhouse, Lever, Ashby and Workable. It reads only those endpoints, at most 4 requests at a time, and it checks robots.txt before the first request to each host.

### Who it is for

- Recruiting-tech teams and job aggregators filling a job board from the source boards of named companies
- Sales and growth people who sell to companies while they hire and want a daily list of new roles per account (Only new jobs on)
- Analysts following which companies open which roles, exported to CSV or Excel
- Developers who want one schema for Greenhouse, Lever, Ashby and Workable instead of four parsers
- Anyone with a list of Workable boards who needs them in the same table as Greenhouse, Lever and Ashby

### How it works

You give a list of boards as `vendor:slug`, for example `greenhouse:gitlab`. For each board the Actor reads the vendor's public job-board JSON: one request for Greenhouse, Lever and Ashby, page by page for Workable. Each job is mapped to the same fields, its description is cut to a short snippet, and contact details are removed from the text. A `keyword` keeps only jobs whose title contains it; `posted_after` keeps only newer jobs. When `max_items` is lower than the jobs found, the boards share it equally. Text fields are trimmed. Where Greenhouse gives a placeholder such as N/A as the location, the job's offices are used; where it gives only a workplace type such as Hybrid, the offices follow in brackets. A board where the filters keep nothing gives an uncharged `no_results` item. A board that does not exist becomes an uncharged error item, and the other boards still deliver; a run where no board exists fails.

### How to try it

1. Open the Input tab. The prefilled input returns 25 jobs shared between five known boards.
2. Click Start. A run usually finishes in under a minute.
3. Open the Output tab to see the results as a table, or export them as JSON, CSV or Excel.

To get new jobs the same day, schedule a daily run with `new_since_last_run` on. Each run then delivers and charges only jobs you have not had from this Actor. `max_items` and your spending limit keep the newest jobs; older ones come in the next run.

- With several boards, `max_items` and your spending limit are shared: each board gets its newest job, then its next, in turn. The jobs appear when the last board has answered. A run you abort before that delivers and charges nothing; a run near its timeout stops fetching and delivers what it has. With `new_since_last_run` on, the newest jobs of all boards come first instead.
- A board that no longer exists becomes an uncharged error item, and the other boards still run. When none of your boards exists, the run fails, so a scheduled run with a misspelt or deleted board shows as failed.
- A board where `keyword` and `posted_after` keep no job, or that has no open job, gives one uncharged `no_results` item, so you can tell a wrong keyword from a quiet board.
- Turn the option off to get every open job. Once you have used the option, a run with it off is remembered too.
- The memory is a key-value store named `ats-job-boards-scraper-state` in your account. Delete it to start again. It is one memory for all your boards and holds the newest 50,000 delivered jobs; a job older than that can come, and be charged, again if its board still lists it.
- Two runs at the same time can deliver and charge the same job, so leave a gap between scheduled runs.

Lever, Ashby and Workable give no company name, so `company` is the board's slug there. Workable's list has no job text, so `description_snippet` is empty there. Greenhouse publishes no employment type, so `employment_type` is empty there. `posted_at` is the date each vendor gives: when Greenhouse first published the job, when Lever created the posting (it can be years old), when Ashby published it, and only the day for Workable.

### How much it costs

You pay per result delivered to the default dataset. Errors and empty results are written to a separate `errors` dataset and are never charged.

| Plan tier | Price per 1,000 results |
|---|---|
| Free and Bronze | USD 2.00 |
| Silver and above | USD 1.70 |

Example: a run that delivers 1,000 results costs USD 2.00 on the Free and Bronze tiers and USD 1.70 on Silver and above, plus the platform's start event of USD 0.00005. If you set a maximum cost per run, the Actor stops before it would go over it and delivers nothing it cannot charge for.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `boards` | array | undefined | One board per line as vendor:slug, where the vendor is greenhouse, lever, ashby or workable. The slug is in the board's address, for example greenhouse:gitlab. Up to 500 entries per run, counted before duplicates are removed. Maximum results is shared by all boards; the default is 10, so raise it for a long list. |
| `keyword` | string | "" | Keep only jobs whose title contains this text, in any case and anywhere in the title, so engineer also keeps Engineering Manager. A phrase is matched as one piece of text; it is not a regular expression. It filters the boards you list; it does not search all boards. Leave empty for every job. |
| `posted_after` | string | "" | Date as YYYY-MM-DD, compared with posted_at in UTC. Lever gives the date a posting was created, which can be years ago for a job still open, so this keeps fewer Lever jobs than you may expect. Leave empty for every open job. |
| `new_since_last_run` | boolean | false | Deliver and charge only jobs this Actor has not delivered to you before. A job held back by Maximum results or your spending limit comes in the next run. Delivered jobs are remembered in a key-value store named ats-job-boards-scraper-state in your account. |
| `max_items` | integer | 10 | How many results to return at most, from 1 to 10000. |

### Output

Each result has these fields. Missing values are `null`, never a different type.

| Field | Type | Description |
|---|---|---|
| `item_type` | string | Always `job_post` |
| `source_id` | string | The vendor's job id with the vendor in front, for example greenhouse:8638232002 |
| `company` | string | Company name, or the board's slug where the vendor gives no name |
| `title` | string | Job title |
| `location` | string or null | Location as the vendor gives it. A Greenhouse placeholder (N/A, LOCATION, TBD) or missing location becomes the job's offices; a Greenhouse workplace type alone (Hybrid, Distributed, In-Office, Onsite) gets the offices in brackets, for example Hybrid (Austin, TX; New York, NY). Anything with Remote stays as given. |
| `department` | string or null | Department as published |
| `employment_type` | string or null | As the vendor writes it: FullTime or Intern (Ashby), Permanent, Full-time or Internship (Lever), full (Workable). Greenhouse publishes none, so it is empty there. |
| `posted_at` | string or null | ISO 8601 UTC. Greenhouse: first published (last updated when it gives no first date). Lever: when the posting was created, which can be years ago. Ashby: published. Workable: the publish day only, at 00:00 UTC. |
| `description_snippet` | string or null | The first 300 characters of the job text |
| `apply_url` | string | The job on the vendor's board |
| `ats_vendor` | string | greenhouse, lever, ashby or workable |
| `board_slug` | string | The board's slug |
| `source_url` | string | The record on the source site |
| `fetched_at` | string | When the record was fetched, ISO 8601 UTC |
| `actor_version` | string | The build that produced the record |

Example item:

```json
{
  "item_type": "job_post",
  "source_id": "<source_id>",
  "company": "<company>",
  "title": "<title>",
  "location": "<location>",
  "department": "<department>",
  "employment_type": "<employment_type>",
  "posted_at": "<posted_at>",
  "description_snippet": "<description_snippet>",
  "apply_url": "<apply_url>",
  "ats_vendor": "<ats_vendor>",
  "board_slug": "<board_slug>",
  "source_url": "<source_url>",
  "fetched_at": "2026-11-04T09:30:00Z",
  "actor_version": "0.4.1"
}
```

Free-text fields are cleaned before delivery: email addresses, phone numbers, @handles and person names introduced by words such as "contact", "recruiter", "founder" or "manager" are replaced with `[removed]`. The cleaning follows fixed rules, so a name written elsewhere in the text, or in lower case, can remain.

### Other Actors in this family

This Actor is part of a family of job and public-data scrapers built on the same core: one result per charge, a separate uncharged errors dataset, and no personal data. Links follow as the other Actors are published.

### FAQ and support

- **Is there personal data in the output?** No personal data by design: the output holds only facts about jobs and companies, never the author of a post, and contact details are removed from the text as described under Output.
- **Is the data accurate?** Accuracy is not guaranteed. The data is parsed from free text written by many people, and fields can be missing or wrong.
- **Who runs this Actor?** It is not affiliated with Greenhouse, Lever, Ashby and Workable.
- **What may I do with the data?** You are responsible for complying with the law and with the source's terms when you use the data.
- **How is the data collected?** The official API or open data is used where the source offers it. This Actor uses only the public JSON endpoints of Greenhouse, Lever, Ashby and Workable.
- **Something is broken.** Open an issue on the Issues tab with the run link and your input. Issues are answered by the automated maintainer.

# Changelog

This Actor's version history is a separate document: https://apify.com/plain-build/ats-job-boards-scraper/changelog.md

# Actor input Schema

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

One board per line as vendor:slug, where the vendor is greenhouse, lever, ashby or workable. The slug is in the board's address, for example greenhouse:gitlab. Up to 500 entries per run, counted before duplicates are removed. Maximum results is shared by all boards; the default is 10, so raise it for a long list.

## `keyword` (type: `string`):

Keep only jobs whose title contains this text, in any case and anywhere in the title, so engineer also keeps Engineering Manager. A phrase is matched as one piece of text; it is not a regular expression. It filters the boards you list; it does not search all boards. Leave empty for every job.

## `posted_after` (type: `string`):

Date as YYYY-MM-DD, compared with posted_at in UTC. Lever gives the date a posting was created, which can be years ago for a job still open, so this keeps fewer Lever jobs than you may expect. Leave empty for every open job.

## `new_since_last_run` (type: `boolean`):

Deliver and charge only jobs this Actor has not delivered to you before. A job held back by Maximum results or your spending limit comes in the next run. Delivered jobs are remembered in a key-value store named ats-job-boards-scraper-state in your account.

## `max_items` (type: `integer`):

How many results to return at most. You pay per result delivered.

## Actor input object example

```json
{
  "boards": [
    "greenhouse:gitlab",
    "greenhouse:stripe",
    "lever:spotify",
    "ashby:ramp",
    "workable:blueground"
  ],
  "keyword": "",
  "posted_after": "",
  "new_since_last_run": false,
  "max_items": 25
}
```

# Actor output Schema

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

One item per job post.

## `errors` (type: `string`):

Records that could not be delivered, and queries with no results. Not charged.

# 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:gitlab",
        "greenhouse:stripe",
        "lever:spotify",
        "ashby:ramp",
        "workable:blueground"
    ],
    "max_items": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("plain-build/ats-job-boards-scraper").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:gitlab",
        "greenhouse:stripe",
        "lever:spotify",
        "ashby:ramp",
        "workable:blueground",
    ],
    "max_items": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("plain-build/ats-job-boards-scraper").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:gitlab",
    "greenhouse:stripe",
    "lever:spotify",
    "ashby:ramp",
    "workable:blueground"
  ],
  "max_items": 25
}' |
apify call plain-build/ats-job-boards-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,plain-build/ats-job-boards-scraper"
        }
    }
}
```

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/Jkci5aRrcxfeWbe22/builds/4ApZRyJynd63CVBtm/openapi.json
