# Career Site Jobs Search: 15,000 Greenhouse, Lever, Ashby Boards (`storesignal/ats-jobs-scraper`) Actor

Career site jobs search: live job postings from 15,000+ company career sites on Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee, or fetch the boards you list. Official public ATS APIs, one normalized record per job. Pay only for jobs returned.

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

## Pricing

Pay per event

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

## Career Site Jobs Search: ATS jobs from Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee

Give this Actor a list of companies and it returns one normalized record per open job, fetched live from the official public job-board APIs of six applicant tracking systems (ATS). It is built for job-board builders, recruiters, sales teams that use hiring as a buying signal, and people who automate their job search. There is no browser, no login, no proxy and no HTML scraping.

### What you get

- **One schema for six systems:** title, company, department, team, location(s), country, remote flag, workplace type, employment type, posting and update dates, job URL, apply URL.
- **Salary when the board publishes it:** structured min, max, currency and interval for Ashby, Lever and Recruitee. Otherwise `null`.
- **Description:** plain text by default, HTML optional.
- **Filters:** title keywords, excluded keywords, location keywords, remote only, posted within N days, and a per-company limit.
- **Missing values are `null`,** never guessed.

### Who it's for

1. **Job-board builders:** aggregate listings from many companies in one format.
2. **Sales and growth teams:** a company that is hiring for a role is a buying signal. Filter by title keyword and location.
3. **Recruiters and job seekers:** watch specific companies for new roles that match.

### Supported systems

| System | Example board URL | `ats:slug` form |
|---|---|---|
| Greenhouse | `https://boards.greenhouse.io/stripe` (also `job-boards.greenhouse.io`, `job-boards.eu.greenhouse.io`) | `greenhouse:stripe` |
| Lever | `https://jobs.lever.co/palantir` (also `jobs.eu.lever.co`) | `lever:palantir` |
| Ashby | `https://jobs.ashbyhq.com/ramp` | `ashby:ramp` |
| Workable | `https://apply.workable.com/starling-bank` | `workable:starling-bank` |
| SmartRecruiters | `https://jobs.smartrecruiters.com/BoschGroup` (also `careers.smartrecruiters.com`) | `smartrecruiters:BoschGroup` |
| Recruitee | `https://bunq.recruitee.com` | `recruitee:bunq` |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | string\[] | required unless `searchAllBoards` | Board URLs, `ats:slug` pairs, or bare slugs (see below). Duplicates are processed once. |
| `searchAllBoards` | boolean | false | Also search every company board in the bundled directory, after your `companies`. |
| `boardSystems` | string\[] | all | Restrict the bundled boards to these systems (`greenhouse`, `lever`, `ashby`, `workable`, `smartrecruiters`, `recruitee`). |
| `maxBoards` | integer | 0 | Take only the first N bundled boards (largest first) after the system filter. 0 means all. |
| `titleKeywords` | string\[] | none | Keep a job if its title contains any keyword (case-insensitive). |
| `excludeTitleKeywords` | string\[] | none | Drop a job if its title contains any of these. |
| `locationKeywords` | string\[] | none | Keep a job if its location, any of its locations, or its country contains any keyword. |
| `remoteOnly` | boolean | false | Keep only jobs where the board says remote. Jobs where it does not say are dropped. |
| `postedWithinDays` | integer | none | Keep only jobs posted in the last N days. Jobs without a posting date are dropped. |
| `includeDescription` | boolean | true | Fill `descriptionText`. For SmartRecruiters this costs one extra request per returned job. |
| `includeDescriptionHtml` | boolean | false | Also fill `descriptionHtml`. |
| `maxJobsPerCompany` | integer | 0 | Applied after filters. 0 means unlimited. |
| `maxConcurrency` | integer | 10 (30 with `searchAllBoards`) | Companies processed in parallel (1 to 50). At most 8 requests per system run at once. |

Each `companies` item is one of:

- a board URL as in the table above (scheme optional, extra path and query are ignored);
- `ats:slug`, for example `greenhouse:stripe`;
- a bare slug, for example `stripe`. The Actor tries Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee in that order and uses the first one that returns at least one job.

Slug case is preserved because SmartRecruiters identifiers are case-sensitive.

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/palantir",
    "https://jobs.ashbyhq.com/ramp",
    "workable:starling-bank"
  ],
  "titleKeywords": ["engineer"],
  "locationKeywords": ["remote", "london"],
  "maxJobsPerCompany": 50
}
```

### Search all known boards

Set `searchAllBoards` to search jobs across the company boards bundled with the Actor, not only the ones you list. The bundled directory holds 15,000+ company boards with open jobs (about 0.69 million jobs when it was built on 2026-11-16). Boards are appended after your own `companies` and de-duplicated. Combine it with keyword filters, and use `boardSystems` and `maxBoards` to keep a run small.

```json
{
  "searchAllBoards": true,
  "titleKeywords": ["data engineer"],
  "remoteOnly": true,
  "postedWithinDays": 7
}
```

The directory is a snapshot and ages: boards that no longer exist or have no open jobs are reported as `not_found` or `no_jobs`, and they are free. In this mode the `SUMMARY` record lists only companies that returned jobs or failed, plus a `byStatus` count in `totals`. Pay per returned job still applies, so set `maxJobsPerCompany` and filters to control cost.

### Output

One dataset item per job. A run also writes a `SUMMARY` record to the key-value store with one entry per input company (`ok`, `no_jobs`, `not_found`, `invalid_input` or `error`, jobs found and returned) and totals. A failure on one company never fails the run.

Record from a local test run (description shortened):

```json
{
  "ats": "ashby",
  "company": "ramp",
  "companyName": null,
  "jobId": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "title": "Software Engineer, Security, Cloud",
  "department": "Engineering",
  "team": "Backend",
  "location": "New York, NY (HQ)",
  "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
  "country": "USA",
  "remote": true,
  "workplaceType": "hybrid",
  "employmentType": "FullTime",
  "postedAt": "2026-04-07T17:12:35.753Z",
  "updatedAt": null,
  "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "salary": {
    "min": 211400,
    "max": 290600,
    "currency": "USD",
    "interval": "1 YEAR",
    "text": "$211.4K – $290.6K • Offers Equity"
  },
  "descriptionText": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams...",
  "descriptionHtml": null,
  "scrapedAt": "2026-11-15T10:30:00.000Z"
}
```

Fields are filled from what each system provides. For example, `country` is exactly what the system gives (a code or a name) and `remote` is `null` when the system does not say.

### Pricing

Pay per event: **$0.001 per job** (event `job-scraped`), which is $1 per 1,000 jobs. Only jobs written to the dataset are charged. Companies with no jobs, unknown companies and failed companies are free.

Runs with `searchAllBoards` that scan more than 500 bundled boards also pay a flat **$0.30 per run** (event `all-boards-search`), because the Actor reads every board live even when few jobs match. Scans of 500 boards or fewer (`maxBoards`) and runs on your own `companies` list have no flat fee. In one measured run a scan of the whole directory took 40 minutes; Workable boards are fetched slowly on purpose because that system rejects fast bursts, so use `boardSystems` to leave it out when you need speed (without Workable a scan takes about 25 minutes). If a system starts answering with HTTP 429 (rate limit) during a run, the Actor stops requesting its remaining boards and reports them as `error` in the `SUMMARY`; they are free.

### Guides

- [Who is hiring for RevOps right now? Turn 690,000 live job posts into a lead list](https://dev.to/storesignalhq/who-is-hiring-for-revops-right-now-turn-690000-live-job-posts-into-a-lead-list-47lb): a full scan with real numbers and a 40-line Python script that groups matching jobs by company.
- [6 public job-board APIs that need no key, and an open list of 15,647 companies that use them](https://dev.to/storesignalhq/6-public-job-board-apis-that-need-no-key-and-an-open-list-of-15647-companies-that-use-them-kga): the endpoints behind this Actor, system by system.

The bundled board directory is open data (CC BY 4.0): [github.com/storesignalhq/ats-job-boards](https://github.com/storesignalhq/ats-job-boards).

Long scans survive server migrations: the run continues where it stopped, and nothing is fetched or charged twice.

### Limitations

- **SmartRecruiters cannot report a missing company.** Its API answers with an empty list for any slug, so an unknown slug and an empty board look the same (`no_jobs`). Large boards need one request per 100 jobs, plus one per returned job for the description.
- **No structured salary for Greenhouse and Workable.** The field is `null` for those systems; pay ranges that appear inside the description text are not parsed.
- **Bare slugs can match a different company** that uses the same slug on another system. Prefer URLs or `ats:slug`.
- **Boards only.** The Actor reads the public job-board API of each system. Companies on other systems, or with a private board, are not supported and are reported as `not_found` or `invalid_input`.
- **Dates and text come from the system as published.** Workable gives a date without a time, which is stored as midnight UTC.
- Job counts reflect what the board lists at run time.

### FAQ

**Is it legal and ethical?** The Actor uses the official public job-board APIs that these systems provide so companies can embed their job listings on other sites. It needs no login and collects no personal data of candidates. You remain responsible for using the data in compliance with the rules that apply to you.

**Does it use a proxy or a browser?** No. It sends a small number of plain HTTPS requests with an identifying User-Agent, retries on temporary errors and never retries a 404.

**What is the difference between `remote` and `workplaceType`?** `remote` is true or false when the system says so, and `null` otherwise. `workplaceType` is `remote`, `hybrid`, `onsite` or `null`. Some systems flag a hybrid job as remote-friendly, so use `workplaceType` when you need the exact arrangement.

**What happens at my spending limit?** The Actor stops processing further companies, still writes the `SUMMARY`, and finishes successfully.

# Actor input Schema

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

Career-board URLs (for example https://boards.greenhouse.io/stripe), ats:slug pairs (for example greenhouse:stripe) or bare slugs (for example stripe, tried across all supported systems; the first one with jobs wins). Required unless Search all boards is on.

## `searchAllBoards` (type: `boolean`):

Also search every company board in the bundled directory (largest first), after the companies listed above. Combine with keyword filters. Scanning more than 500 bundled boards adds a flat $0.30 per run; a full scan takes about 40 minutes.

## `boardSystems` (type: `array`):

Restrict the bundled boards to these systems. Empty means all.

## `maxBoards` (type: `integer`):

Take only the first N bundled boards (largest first) after the system filter. 0 means all.

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

Keep a job only if its title contains any of these (case-insensitive).

## `excludeTitleKeywords` (type: `array`):

Drop a job if its title contains any of these (case-insensitive).

## `locationKeywords` (type: `array`):

Keep a job only if its location, any of its locations, or its country contains any of these (case-insensitive).

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

Keep only jobs the job board marks as remote. Jobs where the board does not say are dropped.

## `postedWithinDays` (type: `integer`):

Keep only jobs posted in the last N days. Jobs without a posting date are dropped when this is set.

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

Fill descriptionText. For SmartRecruiters this needs one extra request per returned job; turn it off to skip them.

## `includeDescriptionHtml` (type: `boolean`):

Also fill descriptionHtml. Requires the text description to be on.

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

Applied after the filters. 0 means unlimited.

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

Number of companies processed in parallel. Default 10, or 30 when Search all boards is on. At most 8 requests per system run at once.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/palantir",
    "https://jobs.ashbyhq.com/ramp",
    "workable:starling-bank"
  ],
  "searchAllBoards": false,
  "maxBoards": 0,
  "remoteOnly": false,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "maxJobsPerCompany": 25
}
```

# Actor output Schema

## `jobs` (type: `string`):

One record per open job: title, company, location, remote flag, dates, salary when published, description and apply URL.

# 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": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/palantir",
        "https://jobs.ashbyhq.com/ramp",
        "workable:starling-bank"
    ],
    "maxJobsPerCompany": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("storesignal/ats-jobs-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 = {
    "companies": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/palantir",
        "https://jobs.ashbyhq.com/ramp",
        "workable:starling-bank",
    ],
    "maxJobsPerCompany": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("storesignal/ats-jobs-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 '{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/palantir",
    "https://jobs.ashbyhq.com/ramp",
    "workable:starling-bank"
  ],
  "maxJobsPerCompany": 25
}' |
apify call storesignal/ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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