# ATS Jobs Scraper: Greenhouse, Lever, Ashby, Workday & More (`apimy/ats-jobs-scraper`) Actor

ATS jobs scraper for company career sites: Greenhouse, Lever, Ashby, Workday, Workable, SmartRecruiters, Recruitee. Give company names or careers URLs, get every open job: title, location, remote, salary, date, description, apply link. No API key.

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

## Pricing

from $1.20 / 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

**ATS Jobs Scraper** downloads every open job from company career sites that run on **Greenhouse, Lever, Ashby, Workday, Workable, SmartRecruiters and Recruitee**. Type company names (`Stripe`, `notion.so`) or paste careers URLs, press Start, and get one row per job in the same format for every system: title, department, location, remote / hybrid / on-site, salary when the company publishes it, publish date, full description, job and apply links, and recruiter emails written in the posting. No login, no API key, no browser. Export JSON, CSV or Excel, schedule it, or call it from the API.

### Tested head-to-head — 16 Nov 2026

We ran this Actor and five other ATS job scrapers from Apify Store on the same request: Stripe (Greenhouse) and Notion (Ashby), 10 jobs each, with full descriptions.

| | This Actor | The other five |
|---|---|---|
| Rows delivered | 20 of 20 | 20 of 20 (one added 2 paid summary rows) |
| Price of that run, Free plan | $0.048 | $0.022 – $0.10 (three of five cost more) |
| Fields per job | 35, same set for every system | 6 – 32 |
| Company found from a name or domain | yes | 3 of 5 |
| Systems covered | 7, including Workday | 3 – 12 |
| Run time | 4 – 5 s | 2 – 26 s |

Two of the five are cheaper per row: one returns 6 fields per job, the other fills 57% of its columns and charges for summary rows. Everything in this table is from our own runs on that date; prices and results of other Actors change.

### What does the ATS jobs scraper do?

An applicant-tracking system (ATS) is the software behind a company's careers page. Each of the seven systems below serves its job boards through a public JSON endpoint — the same one the careers page itself reads. This Actor calls that endpoint for every company in your list and turns the answers into one clean table.

| System | How you name the company | Found from a bare name? |
|---|---|---|
| Greenhouse | `Stripe`, `greenhouse:stripe`, `https://job-boards.greenhouse.io/anthropic` | yes |
| Lever | `Spotify`, `lever:spotify`, `https://jobs.lever.co/palantir` | yes |
| Ashby | `notion.so`, `ashby:openai`, `https://jobs.ashbyhq.com/ramp` | yes |
| Workable | `workable:starling-bank`, `https://apply.workable.com/netguru` | yes |
| SmartRecruiters | `smartrecruiters:BoschGroup`, `https://jobs.smartrecruiters.com/Visa` | yes |
| Recruitee | `bunq`, `https://bunq.recruitee.com` | yes |
| Workday | `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` | no — always the careers URL |

- **You do not need to know which ATS a company uses.** Give a name or a domain: the Actor asks the six slug-based systems in parallel whether they have a board with that name and reads the one that answers. The row tells you which system it was (`source`) and what you typed (`companyQuery`).
- **Whole boards in seconds.** A Greenhouse, Lever, Ashby or Recruitee board is one request, however many jobs it has. Seven companies on six systems, five jobs each, took 8 seconds in our test (16 Nov 2026).
- **Filters applied for you:** title keywords, locations, remote / hybrid / on-site, posted within a day / week / month or after a fixed date. Jobs come newest first, so a per-company cap keeps the freshest ones.
- **One row shape for every system.** A field a system does not have is `null`, never missing, so your CSV columns and code do not depend on which ATS a company uses.
- **Nothing silently disappears.** A company that could not be found gets its own free error row saying so; a run where the filters left nothing gets a free row explaining which filter to widen.

**What it does not do:** it does not search the whole job market by keyword — you give the companies. It reads public career sites only: no applicant data, nothing behind a login. A company whose careers page is custom-built (not on one of the seven systems) is reported as "no job board found".

### What data does it return?

| Field | Example |
|---|---|
| `source`, `board`, `company` | greenhouse · gitlab · GitLab |
| `id`, `url`, `applyUrl` | 8937862002 · https://job-boards.greenhouse.io/gitlab/jobs/8937862002 |
| `title`, `department` | Senior Engagement Manager · Practice Management |
| `location`, `allLocations`, `city`, `region`, `country`, `countryCode` | London, England, United Kingdom · GB |
| `isRemote`, `workplaceType` | true · remote / hybrid / onsite |
| `employmentType`, `jobTypes`, `experienceLevel` | fulltime · Mid-Senior Level |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText` | 95200 · 160800 · USD · year |
| `postedAt`, `updatedAt`, `postedText` | 2026-11-13T17:01:40.108Z · last change (Greenhouse, Recruitee) · "Posted 2 Days Ago" (Workday) |
| `description`, `descriptionHtml` | full text and HTML |
| `emails`, `phones`, `companyDomain` | addresses written in the posting · domain from the apply link when it is the company's own site |
| `hiringEntity`, `companyQuery`, `scrapedAt` | legal entity (Workday) · what you typed · run time |

Honest notes on the data, checked on live boards on 16 Nov 2026:

- **Salary** is filled only when the company publishes it in a structured way: Ashby and Lever compensation fields, Recruitee salary, and Greenhouse's pay-transparency block. Loose numbers in a description are never turned into a salary. In our 30-job demo sample 2 rows had a salary.
- **Workplace**: Ashby, Lever, Workable, SmartRecruiters, Recruitee and Workday state it; Greenhouse has no such field, so there a job counts as remote when its location says "Remote".
- **Company name**: Workday does not give a display name, so `company` is the tenant name from the address ("Adobe", "Nvidia") and `hiringEntity` holds the legal entity.
- **Workday limits**: Workday itself never lists more than 2,000 jobs per career site, and its list shows only "Posted 30+ Days Ago" for old jobs — the exact date comes from each job page (one request per job, only for the jobs you keep).
- **A bare name can match the wrong company** when two companies share a slug on different systems. The Actor reads the board with the most open jobs and writes the alternatives to the log; paste the careers URL or use `system:slug` to be exact.

### How much does it cost to scrape ATS jobs?

**$2.40 per 1,000 jobs** ($0.0024 per job row) on the Free plan, going down to **$1.20 per 1,000** on Gold and higher Apify plans. No fee per run, per company or per request. Error rows (company not found, a board that did not answer), the "nothing matched" explanation and the run-summary notice are free. Jobs removed by your filters are not charged — you pay only for job rows in the dataset.

Example: 20 companies × 100 open jobs = 2,000 rows = $4.80 on the Free plan. Filter to "engineer" + "remote" and you pay only for those rows.

### How to scrape jobs from Greenhouse, Lever, Ashby and Workday

1. Open the **Input** tab.
2. Put companies into **🏢 Companies**, one per line: a name (`Stripe`), a domain (`notion.so`), a careers URL, or `system:slug`. For Workday paste the careers URL.
3. Optional: add **Title keywords**, **Locations**, **Workplace** and **Posted within**.
4. Press **Start**, then download the results from the **Output** tab, or read them through the API.

An empty API call works too: with no companies, the Actor returns a demo — the 10 newest jobs each from GitLab (Greenhouse), Notion (Ashby) and Palantir (Lever).

### ⬇️ Input

```json
{
    "companies": ["Stripe", "notion.so", "https://jobs.lever.co/spotify", "https://adobe.wd5.myworkdayjobs.com/external_experienced"],
    "titleKeywords": ["engineer"],
    "workplace": "remote",
    "postedWithin": "month",
    "maxJobsPerCompany": 50
}
```

| Field | Default | What it does |
|---|---|---|
| `companies` | demo | Names, domains, careers URLs or `system:slug`, one per line |
| `titleKeywords` | all jobs | Keep jobs whose title or department contains one of these words |
| `locations` | any | Keep jobs whose location contains one of these texts (`London`, `Germany`, `Remote`) |
| `workplace` | any | `remote`, `hybrid` or `onsite` |
| `postedWithin` / `postedAfter` | any time | `day`, `3days`, `week`, `month` — or a fixed `YYYY-MM-DD` date for daily schedules |
| `maxJobsPerCompany` | every job | Cap per company after filters, newest first |
| `maxItems` | 100000 | Stop after this many rows in total |
| `includeDescription` | true | Turn off for a lighter and faster export (no request per job on Workday, Workable, SmartRecruiters) |
| `includeContacts` | true | Emails and phones written in the posting — free |

### ⬆️ Output

```json
{
    "type": "job",
    "source": "ashby",
    "board": "notion",
    "company": "Notion",
    "id": "7a044182-7787-47cd-b8eb-18ebf5642ed4",
    "title": "Forward Deployed Architect",
    "department": "Sales",
    "location": "London, United Kingdom",
    "city": "London",
    "country": "United Kingdom",
    "isRemote": false,
    "workplaceType": null,
    "employmentType": "fulltime",
    "salaryMin": null,
    "salaryMax": null,
    "postedAt": "2026-11-13T17:01:40.108Z",
    "url": "https://jobs.ashbyhq.com/notion/7a044182-7787-47cd-b8eb-18ebf5642ed4",
    "applyUrl": "https://jobs.ashbyhq.com/notion/7a044182-7787-47cd-b8eb-18ebf5642ed4/application",
    "description": "WHO WE ARE\n\nNotion is the collaborative AI workspace…",
    "emails": [],
    "companyQuery": "notion.so",
    "scrapedAt": "2026-11-16T02:47:30.924Z"
}
```

Rows with `type` other than `job` are free service rows: `error` (a company that was not found, with the reason) and `notice` (run summary). Filter them out with `type == "job"`.

### Use cases

- **Hiring-signal lead lists**: which of your target accounts opened sales, security or data roles this week — hiring is a budget signal.
- **Job boards and aggregators**: a daily feed of fresh jobs straight from the employers' systems, with `postedAfter` set to yesterday.
- **Recruiting and talent intelligence**: track open roles, locations and published salary ranges of competitors.
- **Job seekers and AI agents**: watch a list of dream companies for new remote roles; the Actor works as a tool through the Apify MCP server.

### Run it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/apimy~ats-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["Stripe", "ashby:openai"], "titleKeywords": ["engineer"], "maxJobsPerCompany": 25}'
```

### FAQ

**Is it legal to scrape ATS job boards?** The Actor reads public job postings that companies publish for candidates, through the same public endpoints their careers pages use. It collects no applicant or private data. Recruiter emails appear only when the company wrote them in the posting; handle personal data according to GDPR and your local rules.

**Which ATS does a company use?** You do not need to know: give the name. If nothing is found, open the company's careers page and paste its URL — the address usually shows the system (`boards.greenhouse.io`, `jobs.lever.co`, `myworkdayjobs.com`).

**Why did a company return an error row?** Its careers site is not on one of the seven systems, the slug differs from the company name, or it is a Workday site given without the URL. The row says which; it is free.

**How do I get only new jobs every day?** Schedule the Actor and set `postedWithin` to `day` (or `postedAfter` to a date). You pay only for the new rows.

**A field is null — is that a bug?** Usually the system does not have it (Greenhouse has no workplace field, most companies publish no salary). If a value is visible on the careers page and missing in the row, open an issue on the Issues tab with the company and job link — we fix those quickly.

# Actor input Schema

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

One company per line, in any of three forms. <b>A name or domain</b> (<code>Stripe</code>, <code>notion.so</code>): the Actor asks Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee which of them has a board with that name and reads it. <b>A careers URL</b> (<code>https://job-boards.greenhouse.io/anthropic</code>, <code>https://jobs.lever.co/spotify</code>, <code>https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite</code>) — Workday companies are always given by URL. <b>system:slug</b> (<code>ashby:openai</code>, <code>smartrecruiters:BoschGroup</code>) when you know the system. Every open job of each company is returned, newest first, then the filters below are applied. Empty = a demo: 10 newest jobs each from GitLab, Notion and Palantir.

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

Keep only jobs whose title or department contains one of these words (case-insensitive): <code>engineer</code>, <code>sales</code>, <code>product manager</code>. Empty = all jobs.

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

Keep only jobs whose location contains one of these texts (case-insensitive): <code>London</code>, <code>United States</code>, <code>Remote</code>, <code>Germany</code>. Matched against the location as the company wrote it. Empty = any location.

## `workplace` (type: `string`):

Remote, hybrid or on-site. Ashby, Lever, Workable, SmartRecruiters, Recruitee and Workday say it themselves; Greenhouse has no such field, so there a job counts as remote when its location says "Remote" and hybrid when it says "Hybrid".

## `postedWithin` (type: `string`):

Drop jobs published earlier than this. Uses the publish date the system gives (Workday lists say only "Posted 30+ Days Ago" for old jobs — the exact date is read from the job page).

## `postedAfter` (type: `string`):

<code>YYYY-MM-DD</code>. Use instead of "Posted within" for a fixed date (handy for daily schedules).

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

Cap per company after the filters, newest first. Leave empty for every matching job (big boards have 500–5,000 open roles; Workday itself never lists more than 2,000 per site); the form starts at 20 so a first try stays cheap.

## `maxItems` (type: `integer`):

Stop after this many job rows in total.

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

Description as plain text and HTML. Turn off for a lighter and faster export with titles, locations and links only: Workday, Workable and SmartRecruiters then need no request per job (on Greenhouse the salary range, which lives in the description, is skipped too).

## `includeContacts` (type: `boolean`):

Recruiter emails and phone numbers written in the job description, plus the company domain from the apply link. Free.

## `concurrency` (type: `integer`):

How many companies are read at once.

## `proxyConfiguration` (type: `object`):

Not needed: the public job-board APIs answer direct requests. If a board ever refuses, that one request is retried through Apify Proxy automatically.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "notion.so",
    "https://jobs.lever.co/spotify",
    "https://adobe.wd5.myworkdayjobs.com/external_experienced"
  ],
  "workplace": "any",
  "postedWithin": "any",
  "maxJobsPerCompany": 20,
  "maxItems": 100000,
  "includeDescription": true,
  "includeContacts": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per job: source, title, company, company website and size, location, remote/hybrid, job type, salary as numbers, posting date, description, apply link, skills, emails and phones found in the posting.

## `runSummary` (type: `string`):

JSON counters for the run: rows delivered, filtered out, errors and request statistics.

# 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",
        "notion.so",
        "https://jobs.lever.co/spotify",
        "https://adobe.wd5.myworkdayjobs.com/external_experienced"
    ],
    "maxJobsPerCompany": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apimy/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": [
        "Stripe",
        "notion.so",
        "https://jobs.lever.co/spotify",
        "https://adobe.wd5.myworkdayjobs.com/external_experienced",
    ],
    "maxJobsPerCompany": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("apimy/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": [
    "Stripe",
    "notion.so",
    "https://jobs.lever.co/spotify",
    "https://adobe.wd5.myworkdayjobs.com/external_experienced"
  ],
  "maxJobsPerCompany": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call apimy/ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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