# ATS Job Scraper: Greenhouse, Lever, Ashby, Workable (`built_for_more/ats-jobs-direct`) Actor

Every open job from companies' own hiring boards on Greenhouse, Lever, Ashby, Workable and Recruitee. Paste board links, careers pages, domains or company names and get clean jobs with salaries, locations and full descriptions. Monitor mode returns only new postings.

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

## Pricing

from $3.00 / 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.

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 Direct

Get every open job from a company's own hiring board. Give the actor a list of companies and it returns one clean record per job: title, locations, countries, workplace type, salary when the posting states one, posting date, the full description and the link to apply.

It reads the public job-board data that companies' careers pages are already built on. There is no login, no browser automation and no personal data.

### Who it's for

- **Recruiters and sourcers** who want a tidy list of what target companies are hiring for.
- **Job-board and aggregator builders** who need a steady feed of direct-from-employer postings.
- **Market and hiring-signal researchers** tracking which companies hire for which roles, where, and at what pay.
- **Job seekers** who want an alert when certain companies post certain roles.

### Supported systems

| System | Example board link |
|---|---|
| Greenhouse | `https://boards.greenhouse.io/discord` |
| Lever | `https://jobs.lever.co/palantir` |
| Ashby | `https://jobs.ashbyhq.com/linear` |
| Workable | `https://apply.workable.com/huggingface/` |
| Recruitee | `https://<company>.recruitee.com` |

**Not supported:** Workday, iCIMS, Taleo, LinkedIn, Indeed and SmartRecruiters (its site asks automated tools to stay away, so the actor does not read it). A company that uses one of these only (or a custom careers site) will not return jobs. A SmartRecruiters link is reported as not supported for that line, and the run carries on with the rest.

### How to list companies

Put one company per line in **Companies**. Each line can be any of these:

| Form | Example |
|---|---|
| Job-board link | `https://jobs.lever.co/palantir` |
| Link to a single job on a board | any job page on a supported board |
| Careers page | `https://stripe.com/jobs` |
| Website domain | `linear.app` |
| Company name | `Hugging Face` |
| System and slug | `lever:palantir` |

A board link or `system:slug` is the most reliable, because there is nothing to guess. A careers page is read for links to a supported board. If the page shows none, the actor guesses from the company name or the page's domain, trying the same board names on all five systems. A guess is accepted only when the board states the same company name you entered, ignoring endings such as Inc, Ltd or Technologies (boards that state no name are accepted). If nothing matches, that line is reported as not found rather than returning another company's jobs. When more than one board matches, the one that looks most like the company is used and the others are mentioned in the run's summary. Two lines that point at the same board are listed once.

#### Finding a board slug

The slug is the company's name as it appears in the board address:

- `boards.greenhouse.io/discord` or `job-boards.greenhouse.io/discord` - slug `discord`
- `jobs.lever.co/palantir` - slug `palantir`
- `jobs.ashbyhq.com/linear` - slug `linear`
- `apply.workable.com/huggingface` - slug `huggingface`
- `acme.recruitee.com` - slug `acme`

To find it: open the company's careers page, click any "Apply" button and look at the address of the page you land on. If it sits on one of the domains above, paste that link (or write `system:slug`). Pasting the careers page itself also works in most cases.

### Input

| Field | Type | What it does |
|---|---|---|
| `companies` (required) | list of text | One company per line, in any form above. |
| `keywords` | list of text | Keep jobs whose title contains any of these. Case is ignored and a word start is enough: "engineer" also finds "Engineering". Empty keeps every job. |
| `keywordsInDescription` | checkbox, default off | Also keep jobs whose description contains a keyword, not just the title. |
| `excludeKeywords` | list of text | Drop jobs whose title contains any of these, for example Senior, Intern or Manager. |
| `locations` | list of text | Keep jobs matching any of these: a city, country, US state, Canadian province or region such as Europe, EMEA or Remote. See below. |
| `remoteOnly` | checkbox, default off | Keep only jobs whose workplace type is `remote`. Hybrid jobs are left out. |
| `postedWithinDays` | integer, default 0 | Keep jobs posted in the last N days. Where a board gives no posting date, the last-updated date is used. 0 means any time. |
| `onlyNew` | checkbox, default off | Monitor mode: return each job only once. See below. |
| `monitorId` | text | Optional name for the history that `onlyNew` keeps. Letters, numbers and dashes. |
| `descriptionFormat` | `markdown` (default), `text`, `html`, `none` | How the description is returned. `html` is as published; `none` gives smaller output. |
| `maxJobsPerCompany` | integer, default 0 | Newest jobs first. 0 means no limit. |
| `maxJobs` | integer, default 0 | Stop after this many jobs across all companies. 0 means no limit. |

Example input:

```json
{
  "companies": [
    "https://boards.greenhouse.io/discord",
    "https://jobs.ashbyhq.com/linear",
    "Hugging Face"
  ],
  "keywords": ["engineer"],
  "excludeKeywords": ["intern"],
  "locations": ["Germany", "Remote"],
  "postedWithinDays": 14
}
```

### Filters

Leave every filter empty to get all open jobs. All filters combine: a job must pass every one you set. Jobs that are filtered out are never charged.

- **Keywords** match at the start of a word in the title (and in the description if you turn that option on). A job matches if it contains any one keyword.
- **Exclude keywords** apply to the title and win over everything else.
- **Locations** match the location text and the countries, regions and states the actor works out from it. A job listed as "Austin, TX" matches `United States`, `Texas` and `North America`. `US`, `USA` and `United States` are treated as the same, as are `UK` and `United Kingdom`. Jobs with no location at all are left out when you set this filter.
- **Remote only** relies on the workplace type the board gives. A job whose type is unknown is not counted as remote.
- **Posted within** needs a date. A job with neither a posting date nor an update date is left out when this is set.

### Monitor mode (only new jobs)

Turn on `onlyNew` and the actor remembers which jobs it has already returned, per company board, in a storage of your own Apify account. The first run returns every current match (use `postedWithinDays` or `maxJobs` to keep that first batch small). Every later run returns only jobs that were not there before. Jobs that have left the board are forgotten, and a board not checked for 60 days starts fresh.

To schedule it:

1. Fill in the input and save it as a **Task**.
2. Open the task's **Schedules** and set how often to run, for example once a day.
3. Read the new jobs from each run's dataset, or send them on with a webhook or integration (see below).

A saved task keeps its own history automatically. When you start runs through the API instead, set the same `monitorId` on each run so they share one history. A different `monitorId` keeps two feeds apart. Without a task or `monitorId`, the history is tied to the exact companies and filters you entered, so changing them starts a new history.

### Output

One dataset item per job. Fields:

```json
{
  "title": "Senior Backend Engineer",
  "company": "Example Co",
  "location": "Austin, TX",
  "locations": ["Austin, TX", "Remote - US"],
  "countries": ["US"],
  "workplaceType": "hybrid",
  "isRemote": false,
  "department": "Engineering",
  "team": "Payments",
  "employmentType": "full-time",
  "salary": {
    "min": 150000,
    "max": 190000,
    "currency": "USD",
    "interval": "year",
    "source": "ats"
  },
  "salaryText": "USD 150,000-190,000 per year",
  "postedAt": "2026-11-10T14:02:11Z",
  "updatedAt": "2026-11-14T09:30:00Z",
  "url": "https://job-boards.greenhouse.io/examplecompany/jobs/1234567",
  "applyUrl": "https://job-boards.greenhouse.io/examplecompany/jobs/1234567",
  "description": "## About the role\n\nYou will build ...",
  "ats": "greenhouse",
  "jobId": "1234567",
  "companySlug": "examplecompany",
  "boardUrl": "https://job-boards.greenhouse.io/examplecompany",
  "input": "https://boards.greenhouse.io/examplecompany",
  "scrapedAt": "2026-11-17T02:35:15Z"
}
```

Notes on the fields:

- Any field a board does not provide is `null` (or an empty list). Boards differ in what they publish, so expect gaps, especially in `team`, `employmentType` and `salary`.
- `workplaceType` is `remote`, `hybrid`, `onsite` or `null`. `isRemote` is `null` when the type is unknown.
- `salary` is filled from the board's structured pay data when it has any (`"source": "ats"`), and otherwise only from an explicit pay range with a currency in the description (`"source": "description"`). Anything vague is left empty rather than guessed. `interval` can be `null`.
- `postedAt` and `updatedAt` are UTC timestamps.
- `input` is the line you entered that led to this job; `scrapedAt` is when it was read.
- `location` is the first entry of `locations`.

The run's key-value store also holds a `SUMMARY` record: for each line you entered, which board it resolved to and how, how many jobs were on the board, how many matched, how many were returned, and any error or note.

### Pricing

Pay per result: you are charged per job returned; see the Pricing tab for the current price. You are charged for each job that is stored in the dataset, and for nothing else. Jobs removed by your filters, jobs skipped by monitor mode and companies that fail are not charged.

**Spending limit.** Set a maximum cost per run when you start it. The actor stops storing jobs when the next one would go past that limit, and the run ends with a message saying it stopped at your maximum. If the limit is lower than the price of one job, nothing is fetched. `maxJobs` works the same way as a plain job-count cap.

### Limits and caveats

- **Only public postings.** The actor reads what companies publish on their public boards. It does not log in, and it does not collect applicant or recruiter personal data.
- **Only the five supported systems.** Workday, iCIMS, Taleo, SmartRecruiters, LinkedIn and Indeed are not read.
- **Countries: unknown beats wrong.** `countries` is worked out from the board's own country field first, then from country, state and province names in the location text, then from a table of cities companies commonly hire in. If none of that is conclusive, `countries` is left empty rather than guessed, so a location filter can miss a job whose location is unusual or vague.
- **Company-name matching can be wrong.** A bare name or domain is a best guess. Pasting the board link removes the guesswork.
- **What you get is what the board lists.** If a company has closed a job but not yet removed it, or a board shows no dates, the actor cannot know.
- **Salary is often missing** because many postings do not state pay.
- **Big boards take longer**, since each company is read in full before filters apply.

### FAQ

**Does it find jobs on LinkedIn or Indeed?**
No. It reads company-owned boards on the five supported systems only.

**A company returned nothing. Why?**
Either it uses an unsupported system, the name could not be matched to a board, or the board has no open jobs. If every line you entered is not found, the run still finishes successfully with a message and no charge. Check the `SUMMARY` record in the key-value store for the reason, and try pasting the board link directly.

**Am I charged if a run fails or finds nothing?**
You are charged only for jobs stored in the dataset. No jobs, no charge.

**How do I get a daily feed of new postings?**
Save your input as a task with `onlyNew` on and put it on a schedule. See "Monitor mode" above.

**Can I get the descriptions as plain text or HTML?**
Yes. Set `descriptionFormat` to `text` or `html`, or to `none` if you only need the structured fields.

**Why is `countries` empty for a job that has a location?**
The location text was not specific enough to place the job with confidence, for example only "Remote" or an unfamiliar town. The `location` text is still there.

**Will the first monitor run be large?**
It returns every current match. Add `postedWithinDays` or `maxJobs` to the first run if you want a smaller starting batch.

### Integrations and API

Everything on Apify is available programmatically:

- **API:** start runs and read the dataset through the Apify API or the official JavaScript and Python clients. Pass the same input fields as above.
- **Webhooks:** call your own endpoint when a run succeeds, then fetch the new dataset items.
- **Zapier, Make and similar tools:** use the Apify integration to trigger the actor on a schedule and send the jobs to a spreadsheet, Slack, email or a database.
- **Export:** download the dataset as JSON, CSV, Excel, XML or HTML.

### Feedback

If a company's board is not read correctly, open an issue in the actor's Issues tab with the line you entered and what you expected.

# Actor input Schema

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

One company per line, in any of these forms: a job-board link (https://boards.greenhouse.io/discord, https://jobs.lever.co/palantir, https://jobs.ashbyhq.com/linear), a link to any one job on the board, a careers page (https://stripe.com/jobs), a website domain (linear.app), a company name (Hugging Face) or ats:slug (lever:palantir). Supported systems: Greenhouse, Lever, Ashby, Workable and Recruitee.

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

Keep jobs whose title contains any of these. Case doesn't matter and a word start is enough: 'engineer' also finds 'Engineering'. Leave empty to keep every job.

## `keywordsInDescription` (type: `boolean`):

Also keep jobs whose description, not just the title, contains a keyword.

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

Drop jobs whose title contains any of these, for example Senior, Intern or Manager.

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

Keep jobs whose location matches any of these, for example London, Germany, California, Europe, EMEA or Remote. Countries, US states, Canadian provinces and regions also match jobs listed by city or state code when the actor can tell where they are: a job in "Austin, TX" matches United States, Texas and North America. US, USA and United States count as the same, as do UK and United Kingdom. Jobs that list no location are left out when this is set.

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

Keep only jobs marked as remote (workplaceType 'remote'). Hybrid jobs are left out.

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

Keep jobs posted in the last N days. Where a board gives no posting date, the last-updated date is used. 0 means any time.

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

Return each job only once. The first run returns every current match (limit it with Posted within or Max jobs); later runs return only jobs that are new since. Save this input as a task and schedule it for a daily feed of new postings.

## `monitorId` (type: `string`):

Optional name for the history that Only new jobs keeps. A saved task keeps its own history automatically. Set this when you start runs through the API, so they share one history, or to keep two histories apart. Letters, numbers and dashes.

## `descriptionFormat` (type: `string`):

How each job's full description is returned.

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

Newest jobs first. 0 means no limit.

## `maxJobs` (type: `integer`):

Stop after this many jobs across all companies. 0 means no limit. Your maximum cost per run also caps the total.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/discord",
    "https://jobs.ashbyhq.com/linear",
    "https://apply.workable.com/huggingface/"
  ],
  "keywordsInDescription": false,
  "remoteOnly": false,
  "postedWithinDays": 0,
  "onlyNew": false,
  "descriptionFormat": "markdown",
  "maxJobsPerCompany": 0,
  "maxJobs": 0
}
```

# Actor output Schema

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

All job postings found in this run (JSON, CSV or Excel via the format parameter).

# 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/discord",
        "https://jobs.ashbyhq.com/linear",
        "https://apply.workable.com/huggingface/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("built_for_more/ats-jobs-direct").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/discord",
        "https://jobs.ashbyhq.com/linear",
        "https://apply.workable.com/huggingface/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("built_for_more/ats-jobs-direct").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/discord",
    "https://jobs.ashbyhq.com/linear",
    "https://apply.workable.com/huggingface/"
  ]
}' |
apify call built_for_more/ats-jobs-direct --silent --output-dataset

```

## MCP server setup

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

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/BPMO7hOtFmNNAb9Kl/builds/VcGOdsvITPcr4SFT0/openapi.json
