# ATS Jobs Search API: Greenhouse, Lever, Ashby (`scaleturn/ats-jobs-search`) Actor

Search open jobs by keyword across 19,630 company career sites on Greenhouse, Lever, Ashby, Recruitee and Personio. Filter by location, remote and posting date. Each job is read live from the employer's board, with full description and apply link. No login. $2 per 1,000 jobs.

- **URL**: https://apify.com/scaleturn/ats-jobs-search.md
- **Developed by:** [Sanjaya Maharjan](https://apify.com/scaleturn) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job returneds

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

This **ATS jobs search API** finds open jobs by keyword across the career sites of **19,630 companies** that hire through **Greenhouse, Lever, Ashby, Recruitee or Personio**, such as Discord, Spotify, Linear or Palantir. Type a job title such as `data engineer`, add a location, remote or posting-date filter, and get every matching job in one clean format: title, company, location, remote flag, salary where published, full description and apply link. Each job is read live from the employer's own job board during your run, so you never get a job that has closed. No login, API key, browser or proxy is needed.

*Not affiliated with or endorsed by Greenhouse, Lever, Ashby, Recruitee or Personio; the Actor uses the public job-board endpoints they publish for their customers' careers pages.*

### How to search jobs across company career sites

1. In **Job title keywords**, enter one or more titles, for example `data engineer` or `account executive`.
2. Optionally narrow the search with **Locations** (`Berlin`, `United Kingdom`), **Remote jobs only**, **Posted within the last N days**, **Applicant tracking systems** or **Companies**.
3. Set **Maximum jobs** and click **Start**. The matching jobs appear in the **Output** tab. Export them as JSON, CSV or Excel, or read them with the API.
4. For a daily feed, turn on **Only jobs not returned before** and schedule the Actor.

### What it does

- **One search, 19,630 company job boards.** A shared index of every open job on 19,630 company boards (16,828 of them with open jobs, 395,365 jobs in all, on 18 November 2026) is rebuilt from the vendors' public job-board APIs, so a search takes seconds instead of reading thousands of boards.
- **Live, never stale.** Matching jobs are re-read from the company's board during your run: closed jobs are dropped, jobs posted since the index was built are added, and descriptions are current.
- **One schema for five ATSs.** Title, company, location, remote flag, department, employment type, salary (where published), posting date, job and apply links, plain-text description, the company's board link and a stable job id.
- **Precise keyword matching.** Whole words, not substrings: `java` does not match "JavaScript". Accents and letter case are ignored, `engineer*` matches "Engineering", and **exclude keywords** remove what you do not want.
- **Saved searches.** With **Only jobs not returned before**, each run returns only new matches, so a scheduled run is a new-jobs feed. You never pay twice for the same job.
- **No duplicates.** A job is returned once per run, even when a company lists it on two boards.
- **Public job-board data only.** No login, no browser, no proxies, and no recruiter or hiring-manager contact data in the output.

### Use cases

- **Job boards and aggregators.** Fill a niche job board (for example remote data jobs in Europe) with fresh roles straight from employers' own boards, every day.
- **Recruiting and sales intelligence.** Find which companies are hiring for a role right now. A new posting is a buying signal for recruiters, staffing agencies and B2B sales teams.
- **AI agents.** One call answers "who is hiring a Rust engineer in Berlin?" with small, structured results (see "Use with AI agents" below).
- **Labour-market research.** Track openings, salary ranges and remote share by title, location or company.

### Coverage

The index is rebuilt from each vendor's public job-board API and checked board by board. Numbers from the refresh of 18 November 2026:

| ATS | Company boards indexed | Boards with open jobs | Open jobs |
|---|---:|---:|---:|
| Greenhouse | 6,500 | 5,555 | 191,948 |
| Personio | 4,094 | 3,540 | 31,860 |
| Ashby | 3,692 | 3,320 | 60,132 |
| Recruitee | 3,179 | 2,748 | 46,974 |
| Lever | 2,165 | 1,665 | 64,451 |
| **Total** | **19,630** | **16,828** | **395,365** |

Companies are found in Common Crawl's public web index and kept only while their board answers on the vendor's API; boards whose ATS-hosted pages are switched off are left out. Workable boards are not in the index.

### Input example

```json
{
    "keywords": ["data engineer", "analytics engineer"],
    "excludeKeywords": ["intern"],
    "locations": ["Berlin", "Remote"],
    "remoteOnly": false,
    "postedWithinDays": 30,
    "maxResults": 200,
    "includeDescription": true
}
```

| Field | Default | What it does |
|---|---|---|
| `keywords` | empty | Job title must match at least one keyword or phrase (rules below). |
| `excludeKeywords` | empty | Leave out jobs whose title matches any of these. |
| `locations` | empty | Location must match at least one of these words or phrases. |
| `remoteOnly` | `false` | Only jobs the ATS marks remote. |
| `postedWithinDays` | empty | Only jobs posted in the last N days. Jobs without a posting date are left out when this is set. |
| `ats` | all | Only these ATSs: `greenhouse`, `lever`, `ashby`, `recruitee`, `personio`. |
| `companies` | empty | Only these companies, by name (`Discord`) or board token (`discord`). |
| `maxResults` | `100` | Stop after this many jobs (up to 50,000). |
| `maxPerCompany` | empty | At most this many jobs from any one company, so a few large employers cannot fill the results. |
| `includeDescription` | `true` | Add the full plain-text description. |
| `onlyNew` | `false` | Return only jobs this saved search has not returned before. |
| `stateStoreName` | `ats-jobs-search-state` | Key-value store that remembers returned jobs; use one name per saved search. |

Set at least one of `keywords`, `locations`, `companies`, `remoteOnly` or `postedWithinDays`. A job is returned only if it passes every filter you set.

**Matching rules.** Keywords match the job title, ignoring letter case and accents, on whole words: `data engineer` matches "Senior Data Engineer, Platform" and "Data-Engineer (m/w/d)" but not "Data Engineering Lead". End a word with `*` to match its stems (`engineer*`). Several keywords are alternatives; the one that matched is returned in `matchedKeyword`. Locations follow the same whole-word rule on the job's location text.

### Output

One dataset item per job. Companies with the most recently posted matches are read first, so with a low **Maximum jobs** you get mostly recent jobs; within a company, jobs are newest first. A real item from a test run on 18 November 2026 (description shortened):

```json
{
    "id": "ashby:benchling:c97e5668-29ee-4810-b7cc-35331ac123f5",
    "ats": "ashby",
    "boardToken": "benchling",
    "company": "Benchling",
    "title": "Data Engineer",
    "location": "San Francisco, CA",
    "remote": false,
    "department": "Engineering",
    "employmentType": "Full-time",
    "salary": "$154K - $208K",
    "postedAt": "2026-11-18T01:41:03.029Z",
    "updatedAt": null,
    "jobUrl": "https://jobs.ashbyhq.com/benchling/c97e5668-29ee-4810-b7cc-35331ac123f5",
    "applyUrl": "https://jobs.ashbyhq.com/benchling/c97e5668-29ee-4810-b7cc-35331ac123f5/application",
    "description": "We are rebuilding biotech for the AI era.\n\nWhen a breakthrough is delayed, the world waits. ...",
    "boardUrl": "https://jobs.ashbyhq.com/benchling",
    "matchedKeyword": "data engineer"
}
```

| Field | Notes |
|---|---|
| `id` | Stable id, `ats:boardToken:atsJobId`. The same job keeps the same id from run to run. |
| `ats`, `boardToken`, `boardUrl` | Where the job came from, and the company's public job board. |
| `company` | Company name as the ATS publishes it. Lever, Ashby and Personio publish none in their job feeds, so the name is taken once from the company's public board page. |
| `title`, `location` | As published. Several locations are joined with `; `. |
| `remote` | `true` for remote jobs, from the ATS's own remote or workplace field. Greenhouse has none, so there it is `true` when the location mentions "remote". Hybrid is not remote. |
| `department`, `employmentType` | Where the ATS publishes them. |
| `salary` | The published pay range, for example `CAD 35-38 per-hour-wage` (Lever), `$240K - $320K` (Ashby), `EUR up to 6000 per month` (Recruitee), `EUR 14.50-22.50 per hour` (Personio). `null` when not published. |
| `postedAt`, `updatedAt` | ISO 8601 dates, where the ATS publishes them. |
| `jobUrl`, `applyUrl` | Job page and application page on the employer's board. |
| `description` | Plain text with line breaks and `- ` bullets, as written by the employer. `null` when descriptions are off. |
| `matchedKeyword` | The keyword that matched (`null` when you gave no keywords). |

#### Run report

Each run writes an `OUTPUT` record (the **Run report** output): when the index was built, how many jobs matched in it, how many company boards were read live and how many failed (with the error), jobs returned, duplicates removed, jobs that closed since the index was built and jobs added since, and whether the run's spending limit was reached. A board that fails is skipped, reported and never charged; the run carries on with the next boards.

### Saved searches and scheduling

1. Create a **task** with your keywords and filters, turn on **Only jobs not returned before**, and give it its own **state store name**, for example `rust-jobs-berlin`.
2. Add a **schedule**, for example once a day.
3. Each run returns only jobs not returned before. Send them on with a webhook or an integration (Slack, Google Sheets, Make, Zapier, n8n).

Jobs not delivered because a spending limit was reached are not marked as returned, so the next run delivers them. To start over, use a new state store name.

### Pricing

Pay per event, with Apify platform usage included:

- **USD 2.00 per 1,000 jobs returned** (USD 0.002 per job).
- Apify's Actor start fee of USD 0.00005 per GB of memory per run (USD 0.05 per 1,000 runs at 1 GB).

You pay only for jobs written to your dataset. Jobs left out by filters, duplicates, jobs already returned by the same saved search, and boards that fail cost nothing. Example: 500 matching jobs cost USD 1.00; a daily saved search that finds 20 new jobs costs USD 0.04 a day. Apify's USD 5 of free monthly usage covers about 2,500 jobs.

### Use via API

Run a search and get its jobs in one call (replace `YOUR_API_TOKEN`):

```bash
curl -X POST "https://api.apify.com/v2/acts/scaleturn~ats-jobs-search/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["product designer"], "remoteOnly": true, "maxResults": 50, "includeDescription": false}'
```

The Apify JavaScript and Python clients, webhooks, schedules and integrations work as with any Actor.

### Use with AI agents (MCP)

AI agents can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Add the server to your MCP client (Claude Desktop, Cursor, VS Code and others) and give it this Actor:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=scaleturn/ats-jobs-search",
            "headers": { "Authorization": "Bearer YOUR_API_TOKEN" }
        }
    }
}
```

Then ask in plain language, for example: *"Find remote staff data engineer jobs posted this week at companies on Greenhouse or Ashby, and list title, company and salary."* The agent fills in `keywords`, `remoteOnly`, `postedWithinDays` and `ats`. Tips for agents:

- Keep `maxResults` small (10 to 50) and set `includeDescription: false` for overviews; fetch descriptions only for the jobs you will read.
- Use `companies` to answer "is this company hiring for X?" in one call.
- The output is flat JSON with a stable `id`, so results can be cited and compared across calls.

### Speed

Measured on 18 November 2026 over the full index (19,630 boards, 395,365 jobs) from a single machine; your speed on the platform will differ. A search for `data engineer`, `product designer` and `account executive` with **Maximum jobs** 500 and **Maximum jobs per company** 5 matched 12,007 jobs on 3,419 boards, read 136 boards live and returned 500 jobs from 135 companies in 50 seconds, at a peak of 511 MB of memory. On the Apify platform at 1 GB the same search took 108 seconds. Smaller searches finish in seconds.

### Limits

- **Five ATSs.** Workday, iCIMS, Taleo, SmartRecruiters, Teamtailor, BambooHR and Workable boards are not in the index; neither are LinkedIn, Indeed or other job sites.
- **Companies come from a public web index.** A company whose board link has never appeared in Common Crawl is not in the index. The index is rebuilt regularly; new boards are added as new crawls are published.
- **Index rows are refreshed, not live.** Matching runs on the latest index, then each matching board is read live. A job posted after the index was built is found only when its board also holds an indexed match.
- **Keyword matching uses the job title.** Descriptions are not searched.
- **Recruitee** has announced that its Careers Site API will require a token from 10 February 2027; Recruitee boards may drop out of the index then.
- **Personio** companies are included only if they have switched on Personio's public job feed. Descriptions come in the language the company published them in, and the remote flag is read from the location text, as Personio's feed has no remote field.
- **Lever** asks automated readers to wait one second between requests, which the Actor does; searches that match many Lever boards take longer.
- **Boards with hosted job pages switched off are left out.** Some companies keep their ATS job feed but turn off the ATS-hosted job pages and show jobs only on their own site; their job links on the ATS would not open, so those boards are not in the index.
- **Jobs without a description are left out when descriptions are on.** A job whose employer published no description text is not output (and not charged); the run report counts them in `skippedNoDescription`. Turn descriptions off to get them.
- **Data is as published.** Fields the employer leaves empty are `null`. Descriptions may include contact details the employer chose to publish.

### FAQ

**How is this different from a LinkedIn or Indeed jobs scraper?** It reads each employer's own job board, the original posting, not a job site's copy. Jobs appear as soon as the employer posts them, closed jobs never appear, there are no promoted duplicates, and nothing needs a login, cookies or proxies.

**How is it different from scaleturn's Greenhouse, Lever, Ashby & Workable Jobs Scraper?** That Actor reads the companies you list. This one searches all 19,630 indexed companies by keyword.

**Is it legal to use this data?** The Actor reads public job-board endpoints that the ATS vendors publish so that their customers' open jobs can be shown on careers sites: Greenhouse documents its Job Board API as public, Lever's Postings API documentation says published jobs "may be scraped by third parties", Ashby documents its public job-posting API, Recruitee's Careers Site API answers without a token today (Recruitee has announced a token requirement from 10 February 2027), and Personio documents its XML job feed as needing no credentials. It respects each site's robots.txt and rate limits, reads job postings only and outputs no personal data about recruiters or hiring managers. How you use the data is your responsibility; this is not legal advice.

**Why is a company missing?** It uses an ATS not covered here, or its board has not appeared in the public web index yet. The companion Actor above reads any Greenhouse, Lever, Ashby or Workable board you name.

### How it is tested

- 55 unit and end-to-end tests on recorded responses from each ATS: keyword and location matching, remote and date filters, de-duplication, empty results, a failing board, output order with a slow board, the per-company cap, jobs without descriptions, saved searches, restarts and the spending limit (end-to-end with the Apify SDK's pay-per-event simulation).
- The refreshes of 18 November 2026 checked 30,928 candidate boards on the five ATSs; 19,630 answered with a valid job list and are in the index, 166 Lever, Ashby and Personio boards whose hosted pages answered 404 were left out, and 9 (0.03%) could not be checked for a reason other than "not a board".
- A three-title search on the full index returned 500 jobs from 135 companies, each with a title, company, job link and description, all ids unique, with no board failing. Searches limited to Lever and to Personio returned 20 jobs each, every one with a description and posting date. A sample of 35 job links across the five ATSs all opened (HTTP 200).

### Politeness

At most 4 requests at a time per ATS, one request a second to Lever (its robots.txt crawl delay) and to Personio (which rate-limits faster readers), timeouts, and retries with growing, randomised pauses on rate limits (HTTP 429) and server errors. If an ATS starts refusing requests, the Actor stops calling it for the rest of the run instead of pushing through. A search reads only the boards that hold matches. User agent: `ats-jobs-search/1.0`.

# Actor input Schema

## `keywords` (type: `array`):

Return jobs whose title matches at least one of these words or phrases. Matching ignores letter case and accents and works on whole words: 'data engineer' matches 'Senior Data Engineer' but not 'Data Engineering Lead'. End a word with \* to match its stems: 'engineer\*' also matches 'Engineering'.

## `excludeKeywords` (type: `array`):

Leave out jobs whose title matches any of these words or phrases, for example 'intern' or 'manager'. Same matching rules as the keywords.

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

Return only jobs whose location text matches at least one of these words or phrases, for example 'Berlin', 'United Kingdom' or 'Remote'. Leave empty for any location.

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

Return only jobs the ATS marks as remote (for Greenhouse, which has no such field: jobs whose location mentions 'remote').

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

Return only jobs posted in the last N days. Jobs without a posting date are left out when this is set.

## `ats` (type: `array`):

Search only these applicant tracking systems (ATSs). Leave empty for all.

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

Search only these companies: a company name as the ATS shows it (for example 'Discord') or a board token (the name in the board link, for example 'discord' in job-boards.greenhouse.io/discord). Not case-sensitive. Leave empty to search every company.

## `maxResults` (type: `integer`):

Stop after this many jobs. Companies with the most recently posted matches are read first. You pay only for jobs returned.

## `maxPerCompany` (type: `integer`):

Return at most this many jobs from any one company, so a few large employers cannot fill the results. Leave empty for no limit.

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

Adds the full plain-text job description to each job. Turn off for smaller, faster output.

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

Remembers the jobs this search has returned, in a named key-value store, and returns only jobs not returned by earlier runs. Use with a schedule for a daily new-jobs feed. The first run returns every match.

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

Name of the key-value store that remembers returned jobs when 'Only jobs not returned before' is on. Use a different name for each saved search.

## Actor input object example

```json
{
  "keywords": [
    "data engineer",
    "product designer"
  ],
  "remoteOnly": false,
  "maxResults": 100,
  "includeDescription": true,
  "onlyNew": false,
  "stateStoreName": "ats-jobs-search-state"
}
```

# Actor output Schema

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

One item per matching open job.

## `runReport` (type: `string`):

Index date, matches, boards read live and failed, duplicates removed, jobs closed since indexing.

# 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 = {
    "keywords": [
        "data engineer",
        "product designer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scaleturn/ats-jobs-search").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 = { "keywords": [
        "data engineer",
        "product designer",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scaleturn/ats-jobs-search").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 '{
  "keywords": [
    "data engineer",
    "product designer"
  ]
}' |
apify call scaleturn/ats-jobs-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scaleturn/ats-jobs-search"
        }
    }
}
```

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/VaDc7NAtLTwMZASUT/builds/By1Bzhjpf50hyEk4s/openapi.json
