# ATS Jobs Scraper: Greenhouse, Lever, Ashby, Workable | $2/1K (`mauve_bunch/ats-jobs-api`) Actor

Open jobs from Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee as JSON. Input: companies (name or URL), keywords, location, remote, postedWithinDays. Output: title, company, location, remote, salary, department, postedAt, applyUrl. $2 per 1,000 jobs. No proxy or API key.

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

## Pricing

from $1.60 / 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: Greenhouse, Lever, Ashby, Workable, SmartRecruiters & Recruitee

### Agent quick reference

- **Purpose:** Open jobs from Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee as JSON.
- **Price:** $2 per 1,000 jobs (pay per event; you pay only for items returned). Set `maxTotalChargeUsd` on the run to cap spend.
- **Call:** `POST https://api.apify.com/v2/acts/mauve_bunch~ats-jobs-api/run-sync-get-dataset-items?token=<APIFY_TOKEN>` with the JSON input below, or via the Apify MCP server (`call-actor`, Actor `mauve_bunch/ats-jobs-api`).
- **Minimal input:** `{"companies": ["greenhouse:airbnb", "ashby:ramp", "workable:huggingface"], "remoteOnly": false, "postedWithinDays": 0, "maxJobsPerCompany": 25, "maxJobsTotal": 500, "includeDescription": true, "onlyNew": false, "newJobsStoreName": "ats-jobs-seen"}`
- **Output:** one JSON object per item in the default dataset; a `SUMMARY` record in the key-value store has run counts.

> **Try it in one click:** press Start with the prefilled companies and you get fresh jobs from three companies in about 5 seconds. **$2 per 1,000 jobs**, no proxy, no API key.

**Get every open job from a company's career page as clean, normalized JSON.** Give the Actor a list of companies and it reads the public job boards that Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee publish for their customers' career pages. It auto-detects the applicant tracking system (ATS), applies your filters, and returns one consistent schema, no matter which ATS the company uses.

Use it to build job alerts, feed an AI agent with fresh openings, track competitor hiring, or enrich sales and recruiting workflows.

### What you get

- **Six ATS platforms, one schema.** Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee.
- **Auto-detect.** Paste a careers URL, `ats:slug` or only a company slug. Bare slugs are probed on all six systems and the board with the most openings wins.
- **Salary data when the employer publishes it** (Ashby, Lever, Greenhouse pay transparency, Recruitee): min, max, currency, period and the original text.
- **Remote / hybrid / on-site flags** where the ATS exposes them.
- **Full description as plain text**, ready for LLMs and embeddings (can be turned off to save time).
- **Only new jobs.** Turn on *Only jobs not seen in earlier runs* and schedule the Actor: each run returns just the postings that appeared since the last one.
- **Filters:** title/department keywords, exclude words, location, remote only, posted within N days.
- **Cheap and fast.** Plain HTTPS calls to public JSON endpoints, no browser, no proxies, no logins.

### How to use it

1. Open the Actor input and add companies. Examples that all work:
   - `https://boards.greenhouse.io/airbnb`
   - `https://jobs.lever.co/palantir`
   - `ashby:ramp`
   - `https://apply.workable.com/huggingface`
   - `smartrecruiters:BoschGroup`
   - `https://bunq.recruitee.com`
   - `stripe` (probes all six systems)
2. Optionally set keywords (for example `engineer`, `data`), a location (for example `Berlin`) or *Remote jobs only*.
3. Click **Start**. Results appear in the dataset as a table, JSON, CSV, Excel or via API.

#### Input example

```json
{
  "companies": ["greenhouse:airbnb", "ashby:ramp", "https://jobs.lever.co/palantir"],
  "keywords": ["engineer"],
  "excludeKeywords": ["intern"],
  "locationFilter": "United States",
  "maxJobsPerCompany": 50,
  "includeDescription": true,
  "onlyNew": false
}
```

#### Output example

```json
{
  "ats": "ashby",
  "companySlug": "ramp",
  "companyName": "ramp",
  "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": true,
  "workplaceType": "Hybrid",
  "employmentType": "FullTime",
  "salary": { "min": 211400, "max": 290600, "currency": "USD", "period": "1 YEAR", "text": "$211.4K – $290.6K • Offers Equity" },
  "postedAt": "2026-04-07T17:12:35.753Z",
  "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "descriptionText": "ABOUT RAMP ...",
  "scrapedAt": "2026-11-19T01:09:00.954Z"
}
```

Fields that an ATS does not provide are `null`. Some systems have no salary or `postedAt`, and Greenhouse has no employment type.

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Actor start | $0.0001 |
| Each job returned | $0.002 (volume discounts for paid Apify plans) |

You only pay for jobs that are actually returned. Companies that cannot be found cost nothing. Example: 100 companies with about 30 jobs each and a keyword filter that keeps 500 jobs costs about **$1.00**. Use *Max jobs per company* and *Max jobs in total* to cap spending, and Apify's per-run charge limit is respected.

### Monitoring new jobs

Create a Schedule (for example daily at 08:00), enable **Only jobs not seen in earlier runs**, and connect a webhook, Zapier, Make, n8n, Google Sheets or Slack integration. The Actor stores seen job IDs per company in a named key-value store (`ats-jobs-seen` by default). Use a different store name for each independent monitor. The first run returns all current jobs; after that you only get new postings.

### Use it from code

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/ats-jobs-api').call({
  companies: ['ashby:ramp', 'greenhouse:airbnb'],
  keywords: ['machine learning'],
  remoteOnly: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

The Actor also works through the Apify MCP server, so AI agents (Claude, Cursor, ChatGPT) can call it as a tool and receive structured jobs.

### Data sources and legality

The Actor calls the **public, unauthenticated job-board endpoints** that each ATS provides so employers can show openings on their own career sites:

- Greenhouse Job Board API (`boards-api.greenhouse.io`)
- Lever Postings API (`api.lever.co`)
- Ashby public job posting API (`api.ashbyhq.com`)
- Workable widget API (`apply.workable.com`)
- SmartRecruiters Posting API (`api.smartrecruiters.com`)
- Recruitee public offers API (`*.recruitee.com`)

It reads job postings only, which are published business information. It does not log in, bypass protections or collect applicant data. The Actor never returns recruiter names or email addresses. You are responsible for using the data in line with the employers' terms and applicable law (for example when you republish job ads, link back to the original `url`).

### Limits and tips

- The company must use one of the six supported systems. Custom career sites (Workday, iCIMS, Taleo, SuccessFactors) are not supported yet.
- A bare slug may exist on several systems. If the wrong board is chosen, use `ats:slug` or the careers URL.
- A few boards have no posting date. `postedWithinDays` skips jobs without a date.
- SmartRecruiters needs one extra request per returned job for the description.
- With *Only new jobs* and a low *Max jobs per company*, remaining new jobs come in the next run.

### FAQ

**Does it need proxies or an API key?** No.

**How fresh is the data?** Live: every run reads the boards as they are at that moment.

**Can I get jobs for hundreds of companies?** Yes. Companies are loaded three at a time and results stream into the dataset.

**Which output formats are available?** JSON, CSV, Excel, XML, HTML table, RSS, or the Apify API.

**Something is missing or wrong for a company.** Open an issue with the company URL; support for more ATS platforms is planned.

### Feedback

Found this useful? A quick review on the Store helps others find it. Issues or feature requests? Open an issue and I'll reply fast.

# Actor input Schema

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

One entry per company. Accepted formats: a careers URL (https://boards.greenhouse.io/airbnb, https://jobs.lever.co/palantir, https://jobs.ashbyhq.com/ramp, https://apply.workable.com/huggingface, https://careers.smartrecruiters.com/BoschGroup, https://bunq.recruitee.com), an explicit "ats:slug" such as "greenhouse:airbnb", or just the company slug, in which case all six systems are probed.

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

Keep only jobs whose title, department or team contains at least one of these words (case-insensitive). Leave empty to return everything.

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

Drop jobs whose title, department or team contains any of these words, e.g. "intern".

## `locationFilter` (type: `string`):

Keep only jobs with a location containing this text, e.g. "Berlin", "United States" or "Remote".

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

Return only jobs the employer marks as remote.

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

Keep only jobs posted or created within this many days. 0 disables the filter.

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

Newest jobs first. Lower this to control cost.

## `maxJobsTotal` (type: `integer`):

Hard cap for the whole run.

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

Adds the job description as plain text. Turn off for a smaller, faster output (SmartRecruiters needs one extra request per job).

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

Remember job IDs between runs (per company) and return only new postings. Ideal for scheduled monitoring. The first run returns all current jobs.

## `newJobsStoreName` (type: `string`):

Name of the key-value store used by "Only new jobs". Use different names to run independent monitors.

## Actor input object example

```json
{
  "companies": [
    "greenhouse:airbnb",
    "ashby:ramp",
    "workable:huggingface"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "locationFilter": "",
  "remoteOnly": false,
  "postedWithinDays": 0,
  "maxJobsPerCompany": 25,
  "maxJobsTotal": 500,
  "includeDescription": true,
  "onlyNew": false,
  "newJobsStoreName": "ats-jobs-seen"
}
```

# Actor output Schema

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

Dataset items: the jobs returned by the run (JSON, CSV, Excel, XML via the dataset API).

## `summary` (type: `string`):

Key-value store record SUMMARY with counts and per-input status for this run.

# 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": [
        "greenhouse:airbnb",
        "ashby:ramp",
        "workable:huggingface"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mauve_bunch/ats-jobs-api").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": [
        "greenhouse:airbnb",
        "ashby:ramp",
        "workable:huggingface",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mauve_bunch/ats-jobs-api").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": [
    "greenhouse:airbnb",
    "ashby:ramp",
    "workable:huggingface"
  ]
}' |
apify call mauve_bunch/ats-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/HOG9KOqOqQIycrGLk/builds/HEIaoQa9pVeY162rN/openapi.json
