# Greenhouse, Lever, Ashby & Workable Jobs API: New Jobs Feed (`wisekit/ats-job-feed`) Actor

Open jobs from Greenhouse, Lever, Ashby, Workable, Recruitee, Teamtailor and Personio boards: one row per job with title, location, remote or hybrid, seniority, salary when published, dates and apply link. New and closed jobs since the last run. $1 per 1,000 jobs; failed boards free.

- **URL**: https://apify.com/wisekit/ats-job-feed.md
- **Developed by:** [Wisekit](https://apify.com/wisekit) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job rows

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

## Greenhouse, Lever, Ashby & Workable Jobs API: New Jobs Feed

Turn a list of companies into one clean job feed: every open job on their Greenhouse, Lever, Ashby, Workable, Recruitee, Teamtailor or Personio job board (Workday too, where the site allows automated reads), in the same fields whatever the ATS, with new and closed jobs since your last run. **$0.001 per job row plus $0.002 per board read; boards that can't be read are free.** Try the free demo first: tick "Free demo" and click Start.

> Reads only the public job-board APIs and feeds that these ATSs publish so employers can show their jobs on other sites. Read-only: it never submits applications. Descriptions are as published by the employer, with email addresses and phone numbers removed. Not affiliated with or endorsed by Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Teamtailor or Personio. Names are used only to describe compatibility.

### Example output

One row per job, in the same fields whatever the ATS (fictional company from the free demo; full field list below):

```json
{
  "type": "job",
  "provider": "ashby",
  "company": "demo-coffee",
  "title": "Data Analyst",
  "location": "Remote",
  "workplaceType": "remote",
  "postedAt": "2026-11-14T09:00:00.000Z",
  "salaryMin": 80000,
  "salaryMax": 105000,
  "salaryCurrency": "USD",
  "jobUrl": "https://jobs.demo-coffee.example/c-103",
  "changeType": "new"
}
```

### What does ATS Job Feed do?

- Reads the open jobs of up to 100 companies per run from eight ATSs: Greenhouse, Lever (US and EU), Ashby, Workable, Workday, Recruitee, Teamtailor and Personio.
- Gives one row per job with the same fields for every ATS: title, department, team, locations, remote flag and workplace type (remote, hybrid, on-site), seniority (from the title, or the employer's experience level on Recruitee and Personio), employment type, posted date, pay range when the employer publishes it (in the API or in the description), job link and apply link.
- Adds the description as plain text and HTML (on by default, can be turned off).
- Filters by keywords in the title (and words to exclude), location, department, remote only, seniority, posting date (last N days) or pay range shown, so you pay only for the jobs you want.
- With a monitor name, marks each job `new`, `unchanged` or `closed` since the last run, and can output only the changes.

### Who uses it

- **Recruiters and sourcers:** watch target companies for new roles in their niche every morning.
- **Job boards and newsletters:** fill a niche board (remote design jobs, climate jobs, AI jobs) from employers' own boards.
- **Sales and market-intelligence teams:** hiring is a buying signal; see which accounts are hiring for which teams.
- **Investors and analysts:** track hiring at portfolio or competitor companies over time, including closed roles.
- **Job seekers and career coaches:** one list of matching roles across many companies, checked daily.

### How to get jobs from Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Teamtailor and Personio boards

1. Find each company's careers page and copy the job-board URL, for example `https://boards.greenhouse.io/yourcompany`, `https://jobs.lever.co/yourcompany`, `https://jobs.ashbyhq.com/yourcompany`, `https://apply.workable.com/yourcompany`, `https://yourcompany.recruitee.com`, `https://yourcompany.teamtailor.com`, `https://yourcompany.jobs.personio.de` (or `.jobs.personio.com`) or a Workday careers site such as `https://yourcompany.wd5.myworkdayjobs.com/SiteName`. You can also type `greenhouse:yourcompany`. A Teamtailor careers site on the company's own domain works as `teamtailor:careers.yourcompany.com`; a Workday site also as `workday:yourcompany.wd5/SiteName`.
2. Paste one per line into **Companies**.
3. Optional: add keywords, a location, remote only or a department; set a monitor name if you'll run it again.
4. Click **Start**. Rows appear in the **Jobs** table; **Jobs with descriptions** shows every field.
5. Download as JSON, CSV or Excel, or send the rows to Google Sheets, Slack or a webhook.

### Input

| Field | Default | Notes |
|---|---|---|
| `companies` | (required) | Job-board URLs or `provider:board` (greenhouse, lever, lever-eu, ashby, workable, recruitee, teamtailor, personio, workday). Up to 100 companies per run (5 on the Apify free plan). |
| `keywords` | empty | Only jobs whose title, department or team contains one of these words. |
| `excludeKeywords` | empty | Leave out jobs whose title contains one of these words, e.g. `intern`. |
| `locationContains` | empty | Only jobs whose location contains one of these, e.g. `London`, `Remote`. |
| `remoteOnly` | `false` | Only jobs marked remote. Hybrid is not remote. |
| `departments` | empty | Only jobs whose department or team contains one of these. |
| `seniority` | empty | Only jobs at these levels: `intern`, `junior`, `mid`, `senior`, `staff`, `lead`, `manager`, `director`, `executive` (read from the title, or the employer's experience level on Recruitee and Personio; jobs with neither are left out). |
| `postedWithinDays` | empty | Only jobs first published in the last N days (1 to 3650). Jobs without a published date are left out. |
| `onlyWithSalary` | `false` | Only jobs that show a pay range (needs `includeDescription` for ranges written in Greenhouse and Workable descriptions). |
| `monitorName` | empty | Name a monitor to get `new`, `unchanged` and `closed` jobs on later runs. |
| `onlyChanges` | `false` | With a monitor, output only new and closed jobs after the first run. |
| `includeDescription` | `true` | Description as plain text and HTML. Also needed to find pay ranges written in Greenhouse and Workable descriptions. |
| `maxJobsPerCompany` | `1000` | 1 to 10,000 job rows per company, after filters (100 on the Apify free plan). |
| `demoMode` | `false` | Free sample output from two fictional companies. No requests, no charge. |

Example input:

```json
{
  "companies": ["https://boards.greenhouse.io/yourcompany", "lever:anothercompany", "ashby:thirdcompany"],
  "keywords": ["engineer", "designer"],
  "remoteOnly": true,
  "monitorName": "remote-tech-roles",
  "onlyChanges": true
}
```

### What data do you get?

| Field | What it is |
|---|---|
| `provider`, `company`, `companyName` | The ATS, the board name, and the company name when the ATS publishes it |
| `jobId`, `title` | The posting's id on the ATS and its title |
| `department`, `team` | As the employer set them |
| `location`, `locations` | Locations as written by the employer (one string, and a list) |
| `remote`, `workplaceType` | `true` for remote jobs, `false` for hybrid or on-site, `null` when unknown; `remote`, `hybrid` or `onsite`, from the ATS's workplace field (Lever, Ashby, Recruitee, Teamtailor, and Workday sites that publish one) or from "remote", "hybrid" or "on-site" in the location or title (Greenhouse, Workable, Personio) |
| `seniority` | `intern`, `junior`, `mid`, `senior`, `staff`, `lead`, `manager`, `director` or `executive`, read from words in the title ("Senior", "Staff", "Head of", "VP", "Engineer II"), or, when the title has none, from the experience level the employer set on Recruitee or Personio; `null` when neither gives one |
| `employmentType` | Full-time, Part-time, Contract, Internship, Temporary or the ATS's own wording |
| `postedAt`, `updatedAt` | First published and last updated (ISO 8601) when the ATS provides them |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryInterval`, `salarySource` | Pay range when the employer publishes one: `salarySource` `structured` (the ATS's salary field: Ashby, Lever, Recruitee, Personio) or `description` (Greenhouse's pay-transparency block, or a labelled range such as "Salary: $113,672 - $144,750/yr" in the description; only with `includeDescription`). When a description range states no period, `salaryInterval` is guessed from the size for USD, CAD, AUD, NZD, GBP, EUR and CHF (500 or less: hour; 15,000 or more: year), otherwise left `null` |
| `jobUrl`, `applyUrl` | The posting page and where to apply |
| `descriptionText`, `descriptionHtml` | The description, with email addresses and phone numbers removed |
| `changeType`, `firstSeenAt`, `monitorName` | With a monitor: `baseline`, `new`, `unchanged` or `closed`, and when the monitor first saw the job |
| `type`, `status`, `message`, `retryable` | `job` rows, or a `company` row that says why a company gave no jobs |
| `input`, `checkedAt`, `demo` | What you typed, when the board was read, and whether the row is demo data |

Example row (fictional company, description shortened):

```json
{
  "type": "job",
  "status": "ok",
  "provider": "ashby",
  "company": "demo-coffee",
  "jobId": "c-103",
  "title": "Data Analyst",
  "department": "Finance",
  "location": "Remote",
  "remote": true,
  "workplaceType": "remote",
  "employmentType": "Full-time",
  "postedAt": "2026-11-14T09:00:00.000Z",
  "salaryText": "$80K - $105K",
  "salaryMin": 80000,
  "salaryMax": 105000,
  "salaryCurrency": "USD",
  "salaryInterval": "year",
  "jobUrl": "https://jobs.demo-coffee.example/c-103",
  "applyUrl": "https://jobs.demo-coffee.example/c-103/application",
  "descriptionText": "Join Demo Coffee as Data Analyst.\n\n• Roast, taste, ship.",
  "changeType": "new",
  "firstSeenAt": "2026-11-17T08:00:00.000Z"
}
```

The Output tab has three views: **Jobs** (key fields), **Board status** (status, note and retry flag of each company row) and **Jobs with descriptions** (every field). The key-value store holds `PROBLEMS`, a short JSON list of only the companies that gave no result and why (empty when every board was read), and `SUMMARY` with the counts.

Not every ATS publishes every field: Greenhouse has no remote flag, employment type or structured salary on its board API (remote is `true` when the location or title says "remote", otherwise `null`); Lever has no update date; Workable and Teamtailor have no salary field; Teamtailor has no employment type; on Personio the apply link is the job page. Workday rows have title, locations, posted date, job link and, on sites that publish them, remote type and time type; they have no department, salary or description (only the job list is read, never each job's page). Workday shows dates as "Posted 3 Days Ago", so `postedAt` is that day; "30+ Days Ago" gives `null`.

### How much does it cost to get job postings?

**$0.001 per job row** (pay per event `job`): each job row output, including baseline, new, unchanged and closed rows.
**$0.002 per board read** (pay per event `company-read`): one per job board read, per started 1,000 open jobs on the board or per started 20 seconds of reading time, whichever is more.

No start fee. Free: boards that don't exist, refuse the request, are rate limited, fail or whose site's robots.txt doesn't allow reading the feed (`board_not_found`, `blocked`, `blocked_by_robots`, `rate_limited`, `error`), `invalid_input`, `excluded_by_request` and the `skipped_*` statuses. Rows that explain why a company gave no jobs are never charged. Your maximum charge per run is respected, counting boards still being read.

| Example | Cost |
|---|---|
| 3 companies, 10 jobs each (the prefilled input) | 30 × $0.001 + 3 × $0.002 = **$0.036** |
| 20 companies, about 100 matching jobs each | 2,000 × $0.001 + 20 × $0.002 = **$2.04** |
| Daily monitor of 20 companies with `onlyChanges`, about 15 new or closed jobs a day | 15 × $0.001 + 20 × $0.002 = **$0.055 a day** |

Filters cost nothing: jobs that don't match are neither output nor charged. On the Apify free plan you can read 5 companies and 100 jobs per company per run.

Why it costs less than most job feeds: you pay per job row and per board read, with no monthly rental and no start fee, and you bring your own company list instead of paying for a pre-built database. The board APIs and feeds are public, so there are no proxy or data-licence costs to pass on.

On Recruitee, Teamtailor, Personio and Workday each request counts as at least 1 second of reading time (the polite pace is one request per second), so one board read covers up to 20 requests. Each board takes one request for its robots.txt, plus one for the feed on Recruitee and Personio, one per 100 jobs on Teamtailor, or one per 20 jobs on Workday (a 1,000-job Workday site is about 51 requests, so 3 board reads).

### How do I see only new and closed jobs?

Set a **monitor name** (for example `remote-tech-roles`) and tick **Only output new and closed jobs**. The first run saves every open job as the baseline and outputs it (`changeType: "baseline"`). Each later run with the same name outputs only jobs that are new on the board or gone from it (`closed`). The state is kept in a key-value store named `ats-job-feed-<name>` in your own Apify account.

- New jobs come first, then closed jobs, then the rest, so `maxJobsPerCompany` and your maximum charge cut unchanged jobs before changes. Changes cut by either are reported on a later run, not lost.
- A board that suddenly shows no jobs is read a second time before its jobs are called closed.
- Changing the filters later doesn't bring back jobs that were already seen.

### Get new jobs every morning (schedule recipe)

1. Fill in your companies, filters and a monitor name, tick **Only output new and closed jobs**, and click **Save as a new task**.
2. Add a **Schedule** to the task, for example every day at 07:00. Personio's own guidance is to sync its job feed about once an hour, so keep schedules that include Personio boards hourly or slower.
3. Under the task's **Integrations**, add Slack, email, Google Sheets or a webhook on "Run succeeded", so the new jobs go where your team works.

### Use it in n8n

1. Add an **HTTP Request** node. Method `POST`, URL `https://api.apify.com/v2/acts/wisekit~ats-job-feed/run-sync-get-dataset-items`.
2. **Authentication:** Generic credential type → Header Auth, with name `Authorization` and value `Bearer <your Apify API token>`.
3. **Body:** JSON, for example:

```json
{
  "companies": ["greenhouse:yourcompany", "lever:anothercompany"],
  "keywords": ["engineer"],
  "monitorName": "n8n-daily",
  "onlyChanges": true,
  "includeDescription": false
}
```

4. Each result row comes back as one n8n item, ready for Slack, Google Sheets, a database or an IF node. Keep rows where `type` is `job`; with a monitor, `changeType` is `new` or `closed`. Put a Schedule Trigger in front (for example every day at 07:00) for a morning feed. Free demo input: `{"companies": ["demo"], "demoMode": true}`.

The call waits for the run to finish, for up to 5 minutes. For longer runs, start the run with `POST https://api.apify.com/v2/acts/wisekit~ats-job-feed/runs` and read the dataset when it finishes, or use n8n's Apify node. To try the flow without spending anything, send the free demo input first.

### Use it from an AI agent or the API

Only `companies` is required. Python (`pip install "apify-client>=3"`):

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("wisekit/ats-job-feed").call(run_input={
    "companies": ["greenhouse:yourcompany", "lever:anothercompany"],
    "keywords": ["engineer"],
    "includeDescription": False,
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    if row["type"] == "job":
        print(row["company"], row["title"], row["location"], row["jobUrl"])
```

**AI agents (MCP):** add Apify's MCP server to Claude Desktop, Claude Code, Cursor or another MCP client with this Actor as a tool:

```json
{
  "mcpServers": {
    "apify-ats-job-feed": {
      "url": "https://mcp.apify.com?tools=wisekit/ats-job-feed",
      "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
    }
  }
}
```

Prompts to try: "Run the ATS job feed in demo mode and summarise the new and closed jobs." (free) or "Get the remote engineering jobs at greenhouse:yourcompany and lever:anothercompany, without descriptions, and list them by company." The run's status message gives the result in one line, for example "Read 3/3 job boards: 458 open jobs, 30 job rows output."

### How it reads job boards

- Only these public read endpoints: Greenhouse `boards-api.greenhouse.io/v1/boards/{board}/jobs`, Lever `api.lever.co/v0/postings/{board}` (or `api.eu.lever.co`), Ashby `api.ashbyhq.com/posting-api/job-board/{board}`, Workable `apply.workable.com/api/v1/widget/accounts/{board}`, Recruitee `{board}.recruitee.com/api/offers/` (the careers-site API), Teamtailor `{site}/jobs.rss` (the jobs RSS feed, 100 jobs per page) Personio `{board}.jobs.personio.de/xml` (the XML job feed) and Workday `{tenant}.wdN.myworkdayjobs.com/wday/cxs/{tenant}/{site}/jobs` (the job search that the careers site itself uses, 20 jobs per page). Greenhouse's embed pages are never used.
- For Recruitee, Teamtailor, Personio and Workday, the site's `robots.txt` is read once per site per run before the feed. If it doesn't allow the feed path, the board is not read and comes back as `blocked_by_robots` (free). Teamtailor jobs under `/jobs/internal/` are skipped. On Workday both the careers path and the job-search path must be allowed. If `robots.txt` can't be read (server error or a bot check), the board is not read either (`blocked` or `error`, free).
- Bot checks are never worked around: a site that answers with a challenge page comes back as `blocked` (free) and gets no more requests in that run. On Workday, an HTTP 401 or 403, or a "too many requests" answer without a short wait time, also stops that site for the run (free).
- One request at a time per ATS host, at least 1 second apart (for Recruitee, Teamtailor and Personio, one queue per ATS across all company sites; for Workday, one request per second per site and at most two per second across all Workday sites). When a host answers "too many requests" (HTTP 429) it is paused for the time it asks; after 3 such answers in one run it is left alone, and its remaining companies come back as `rate_limited` (free; run them again later). If a host fails 4 times in a row (timeouts or server errors), its remaining companies come back as `error` (free, retryable) instead of waiting on an outage.
- Every request carries an honest User-Agent, `WisekitAtsJobFeed/1.0`, that names this Actor. No proxies, no IP rotation, no logins, no cookies.

### What it never does

- Never submits applications or sends anything to an ATS: read-only GET requests. The one exception is Workday's job search, which only answers a POST: the Actor sends the same search the careers page sends (no filters, no search text, 20 jobs per page) and nothing else.
- Never outputs the application inbox address that Recruitee publishes with each job, or Teamtailor's street address and postcode.
- Never outputs recruiter or hiring-manager names, internal ids, custom fields (Greenhouse "metadata") or anything outside the field list above.
- Removes email addresses and phone numbers from descriptions (`[email removed]`, `[phone removed]`), and the name in labelled contact lines such as "Recruiter: ..." or "Reach out to ... at ..." (`[name removed]`). Other names written inside the employer's own text can't be removed reliably; descriptions are as published by the employer.
- Strips scripts, frames, embedded objects, event handlers and `javascript:` links from `descriptionHtml`, so the HTML is safer to show on your own site.
- Keeps no copy of your results and shares nothing between users; monitor state lives only in your account.

### Limits

- Bring your own company list: the Actor reads the boards you give it; it has no built-in index of companies.
- EU-hosted Greenhouse boards (`job-boards.eu.greenhouse.io`) are not supported yet and come back as `invalid_input`.
- Many Workday careers sites sit behind a bot check that answers automated requests with a challenge page. Those sites come back as `blocked` and are free; the Actor never tries to get past them. In our tests on 18 Nov 2026 the large Workday sites we tried did this, so expect some Workday boards to give no rows.
- Up to 100 companies and 10,000 job rows per company per run; boards with more than 10,000 open jobs are read up to 10,000 and closed jobs aren't checked for them.
- Read times, measured on 17 Nov 2026 on 15 public boards: up to about 1 second per board on the Apify platform (OpenAI's 841-job Ashby board, 14 MB with descriptions, took 0.2 to 0.4 s); a run with 14 large boards and 3,587 job rows with descriptions took about 20 to 45 seconds in a local test. Boards share one polite queue per ATS, so many boards on the same ATS take at least 1 second each.

### FAQ

**Is it legal to read job boards this way?** It reads only the job-board APIs that each ATS publishes without a login so employers' jobs can appear on other sites; Lever's documentation says published postings "may be scraped by third parties". Descriptions are the employers' text; use them in line with the employer's rights, and check the laws and terms that apply to your use. This is not legal advice.

**How do I find a company's board name?** Open the company's careers page and click a job: the URL shows the ATS and the board name, for example `jobs.lever.co/yourcompany/...`. Paste that URL as it is.

**Why is `remote` null for Greenhouse jobs?** Greenhouse's board API has no remote field. The Actor sets `true` when the location or title says "remote", `false` with `workplaceType` `hybrid` or `onsite` when it says "hybrid" or "on-site", and leaves it `null` otherwise, rather than guessing.

**Why is there no salary for some jobs?** Many employers publish no pay range. Ashby, Lever, Recruitee and Personio pay ranges come from the ATS's salary field (only when the employer chose to show it). For Greenhouse and Workable the Actor looks in the description: Greenhouse's pay-transparency block, or a range right after a word such as "Salary", "Pay", "Base pay" or "Compensation" (`salarySource` `description`). This needs `includeDescription` on. Ranges written any other way are not picked up and stay in the description. On a board checked on 18 Nov 2026, 165 of 202 Greenhouse jobs had a pay range found this way.

**How is seniority worked out?** From words in the job title: "Intern", "Junior"/"Graduate"/"Associate"/"I", "II", "Senior"/"III", "Staff"/"Principal", "Lead", "Manager", "Director"/"Head of", "VP"/"Chief". When the title has none, Recruitee's and Personio's experience level is used when the employer set one (for example Personio "student" becomes `intern`, "entry-level" becomes `junior`). It is a quick label for filtering; `null` means neither gave a level.

**What does a `company` row with status `ok` mean?** The board was read (and the board read charged) but gave no job rows: no open jobs, no jobs matching your filters, or no new or closed jobs since the last run. The `message` says which.

**Can I use it to train AI models?** It is built as a feed for job boards, CRMs, alerts and agents. Some ATSs (for example Workable and Teamtailor) signal that their content should not be used for AI training; respect the employer's and ATS's terms.

### Status values

Job rows have `status` `ok`. A `company` row says why a company gave no job rows: `ok` (read, but no open jobs, no matching jobs or no changes), `board_not_found`, `blocked`, `blocked_by_robots`, `rate_limited`, `error`, `invalid_input`, `excluded_by_request`, `skipped_max_charge`, `skipped_plan_limit` or `skipped_run_limit`. Only job rows and board reads are charged; `retryable` is `true` when running the company again later may work.

### Employers and ATS providers

If you are an employer or an ATS and don't want a board read by this Actor, open an issue on this Actor's Issues tab. The board (or provider) is added to an exclusion list (`excluded_by_request`) and gets no further requests. This covers every ATS above, including Recruitee, Teamtailor, Personio and Workday sites (a Workday company is excluded across all of its careers sites). Sites can also disallow their feed path in `robots.txt` (Recruitee, Teamtailor, Personio, Workday), which the Actor checks on every run.

### Other Wisekit Actors

- [AI Visibility Tracker: ChatGPT, Perplexity, Gemini & Claude](https://apify.com/wisekit/ai-search-visibility-tracker): see whether AI assistants recommend a brand or its competitors.
- [Tech Stack Detector: CMS, Analytics, Hosting & Email Provider](https://apify.com/wisekit/tech-stack-detector): CMS, analytics, hosting and email provider for a list of websites.
- [Shopify Price & Stock Monitor: Competitor Change Alerts](https://apify.com/wisekit/product-price-monitor): competitors' prices, stock, and new and removed products since your last run.
- [Shopify Store Lead Qualifier: Country, Prices & Emails](https://apify.com/wisekit/store-qualifier): Shopify or not, country, catalogue size, price band and generic public contact emails for a list of store domains.
- [Domain Availability & Expiry Checker: Bulk RDAP Lookup](https://apify.com/wisekit/domain-lookup): registration status, expiry date, registrar and DNS for a list of domains.
- [Company Contact Page & Social Links Finder](https://apify.com/wisekit/contact-finder): a company's contact page and social profile links from its website.
- [Website Screenshot & PDF: Full Page, Mobile, Dark Mode](https://apify.com/wisekit/website-screenshot): full-page, mobile or dark-mode screenshots and PDFs of web pages.

### Feedback and support

Found a bug, or want another ATS or field? Open an issue on the **Issues** tab; we aim to reply within 24 hours. Ratings and reviews, good or bad, help other people find the Actor and help us improve it.

### Changelog

- 0.3 (18 Nov 2026): Workday, Recruitee, Teamtailor and Personio boards, with salary, remote type and experience level where they publish them; robots.txt checked once per site for these (new free status `blocked_by_robots`); bot-check pages are never worked around. Same prices.
- 0.2 (18 Nov 2026): `seniority` (from the title), `salarySource` and pay ranges found in Greenhouse and Workable descriptions, `workplaceType` hybrid/on-site from the location text; new filters `excludeKeywords`, `seniority`, `postedWithinDays` and `onlyWithSalary`. Same prices.
- 0.1.4 (17 Nov 2026): labelled contact names removed from descriptions; more phone formats removed (area code in brackets, two-group national numbers, 00 international); unsafe HTML stripped from `descriptionHtml`; a "Board status" view and a `PROBLEMS` record listing only the companies that gave no result; an ATS host that keeps failing is skipped for the rest of the run (free).
- 0.1 (17 Nov 2026): first version. Greenhouse, Lever (US and EU), Ashby and Workable; filters; monitor with new and closed jobs; free demo.

# Actor input Schema

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

Required. One company per line, as a public job-board URL (boards.greenhouse.io/x, job-boards.greenhouse.io/x, jobs.lever.co/x, jobs.eu.lever.co/x, jobs.ashbyhq.com/x, apply.workable.com/x, x.recruitee.com, x.teamtailor.com, x.jobs.personio.de, x.jobs.personio.com or a Workday careers site such as x.wd5.myworkdayjobs.com/SiteName) or as "provider:board" with provider greenhouse, lever, lever-eu, ashby, workable, recruitee, teamtailor, personio or workday (for example "greenhouse:yourcompany"; a Teamtailor careers site on its own domain: "teamtailor:careers.yourcompany.com"; Workday: "workday:yourcompany.wd5/SiteName"). The board name is the part after the domain in the careers-page URL (for Recruitee, Teamtailor and Personio, the part before the domain). Up to 100 companies per run (5 on the Apify free plan). Duplicates are merged. Boards that don't exist, refuse the request or fail are reported and free. Cost: $0.002 per board read (per started 1,000 open jobs or 20 s of reading) + $0.001 per job row output. Agent example: {"companies":\["greenhouse:yourcompany","lever:yourcompany"]}.

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

Optional. Only output jobs whose title, department or team contains at least one of these words (not case-sensitive), e.g. "engineer", "designer". Leave empty for all jobs. No extra cost: you only pay for rows that are output.

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

Optional. Leave out jobs whose title contains any of these words (not case-sensitive), e.g. "intern", "contract". Checked after the keyword filter. No extra cost: you only pay for rows that are output.

## `locationContains` (type: `array`):

Optional. Only output jobs whose location text contains at least one of these, e.g. "London", "Germany", "Remote". Matched against the location as the employer wrote it. No extra cost.

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

Only output jobs marked as remote: the provider's remote or workplace field says remote, or, where the provider has no such field (Greenhouse, Personio), the location or title says "remote". Hybrid jobs are not remote. No extra cost. Default off.

## `departments` (type: `array`):

Optional. Only output jobs whose department or team contains at least one of these, e.g. "Engineering", "Sales". No extra cost.

## `seniority` (type: `array`):

Optional. Only output jobs at these levels. The level is read from words in the job title (for example "Senior", "Staff", "Head of", "Intern", "Engineer II"), or, when the title has none, from the experience level the employer set on Recruitee and Personio; a job with neither has seniority null and is left out when this filter is set. Levels: intern, junior, mid, senior, staff, lead, manager, director, executive. No extra cost.

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

Optional. Only output jobs first published in the last N days (1 to 3650), e.g. 7 for last week. Jobs whose board publishes no date are left out when this is set. Leave empty or 0 for all dates. No extra cost.

## `onlyWithSalary` (type: `boolean`):

Only output jobs that show a pay range: from the provider's salary field (Lever, Ashby, Recruitee, Personio) or found in the description (Greenhouse pay-transparency block, or a labelled range such as "Salary: $120,000 - $150,000"). Pay ranges in descriptions are only found when "Include job descriptions" is on. No extra cost. Default off.

## `monitorName` (type: `string`):

Optional. Give the monitor any name, e.g. "design-roles", and use the same name on every run (for example on a daily schedule). The first run saves every open job as the baseline (changeType "baseline"); later runs mark jobs "new", "unchanged" or "closed" (gone from the board since the last run). The state lives in a key-value store named "ats-job-feed-<name>" in your own Apify account. Leave empty for a one-off snapshot. No extra cost.

## `onlyChanges` (type: `boolean`):

Only with a monitor name, on runs after the first: output only new and closed jobs, so unchanged jobs are neither output nor charged (the board read, $0.002 per started 1,000 open jobs or per started 20 s of reading, still applies). The first run of a monitor outputs every job as the baseline. Default off.

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

Add each job's description as plain text (descriptionText) and HTML (descriptionHtml), as published by the employer, with email addresses and phone numbers removed. Also needed to find pay ranges written in Greenhouse and Workable descriptions (salarySource "description"). Turn off for much smaller rows and faster reads of Greenhouse and Workable boards. Workday rows never have a description. No extra cost. Default on.

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

The most job rows output per company (1 to 10,000), after filters. Default 1,000. Each job row is $0.001, so this caps the cost: 1,000 jobs = $1.00 per company plus the board read. With a monitor, new and closed jobs come first; changes cut by this cap are reported on a later run. Apify free-plan accounts are limited to 100 jobs per company.

## `demoMode` (type: `boolean`):

Tick to see sample output for free: two fictional companies read twice, with new, closed and unchanged jobs, salary and a description with an email address and phone number removed. No job board is contacted and nothing is charged; other fields except onlyChanges and includeDescription are ignored. Rows have "demo": true. Agent example: {"companies":\["demo"],"demoMode":true}.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/airbnb",
    "lever:spotify",
    "https://jobs.ashbyhq.com/notion"
  ],
  "remoteOnly": false,
  "onlyWithSalary": false,
  "onlyChanges": false,
  "includeDescription": true,
  "maxJobsPerCompany": 10,
  "demoMode": false
}
```

# Actor output Schema

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

One row per job: ATS, company, title, department, location, remote flag, employment type, posted date, salary when published, change since the last run, job link.

## `details` (type: `string`):

Every field, including the plain-text description and the apply link.

## `status` (type: `string`):

Status, note and retry flag for every company row (job rows show status ok).

## `problems` (type: `string`):

Only the companies that gave no result and why (not found, refused, rate limited, error, invalid input, skipped); free. An empty list means every board was read.

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

Counts only: boards read, jobs per board, rows output, new and closed jobs, requests per API host.

# 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/airbnb",
        "lever:spotify",
        "https://jobs.ashbyhq.com/notion"
    ],
    "maxJobsPerCompany": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("wisekit/ats-job-feed").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/airbnb",
        "lever:spotify",
        "https://jobs.ashbyhq.com/notion",
    ],
    "maxJobsPerCompany": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("wisekit/ats-job-feed").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/airbnb",
    "lever:spotify",
    "https://jobs.ashbyhq.com/notion"
  ],
  "maxJobsPerCompany": 10
}' |
apify call wisekit/ats-job-feed --silent --output-dataset

```

## MCP server setup

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

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/1RTXBiurlFCkejfei/builds/76k0OHCIO1dClu0Qp/openapi.json
