# ATS Job Feeds: Greenhouse, Lever, Ashby, Workable & more (`datafeed/ats-job-feeds`) Actor Jobs from public endpoints of Greenhouse, Lever, Ashby, Personio, Workable and Recruitee (until 2027-02-10). Not Workday, SmartRecruiters, Teamtailor. Monitor mode: new, changed, closed jobs, days open, hiring velocity. Recruiter names, e-mails, phones removed. - **URL**: https://apify.com/datafeed/ats-job-feeds.md - **Developed by:** [Benjamin Cojocaru](https://apify.com/datafeed) (community) - **Categories:** Jobs, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per event 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 Job Feeds: Greenhouse, Lever, Ashby, Personio, Workable, Recruitee Give it company job boards (or just company domains). It reads the **public job-board endpoints** of Greenhouse, Lever, Ashby, Personio, Workable and Recruitee (official, documented APIs, except Workable's unofficial careers-widget endpoint; **Recruitee is read only until 2027-02-10**, see below) and returns one clean job schema. Schedule it in **monitor mode** and it returns only what changed since the last run: **new jobs, changed jobs (title, location, salary, remote) and closed jobs with the date they disappeared and how many days they were open** (time to fill). It also keeps a per-company posting history, your hiring-velocity signal. **Price:** `job-returned` $0.003 per new, changed, closed (monitor) or open (snapshot) job row; `company-checked-unchanged` $0.001 when a monitored company has nothing new; `board-discovered` $0.003 (discover mode only) per company whose board was found and validated. Failed boards, detection misses and store errors are free. Watching 100 companies daily with about 3 changes each a week costs about $7/month (the first check of each company is a baseline at $0.001 unless you turn on `emitBaseline`; the free `baseline_summary` row, see "First run", is not charged). Job data comes only from the ATS endpoints, never from scraped HTML; for a bare company domain the Actor reads at most 3 pages of the company's own site just to find the board link. No search engines, no LinkedIn or Indeed, no logins, no proxies. robots.txt is honoured on every host, with a polite per-host delay. ### Input ```json { "companies": [ "greenhouse:gitlab", "https://jobs.lever.co/palantir", "https://jobs.ashbyhq.com/ashby", "personio.jobs.personio.de", "workable:blueground", "recruitee:bunq", {"domain": "acme.com", "label": "Acme"} ], "mode": "monitor", "keywords": ["engineer", "data"], "locations": ["Germany", "Remote"], "remoteOnly": false, "postedSinceDays": 0 } ``` | Field | What it does | |---|---| | `companies` | Up to 200. `ats:board` (`greenhouse`, `lever`, `lever-eu`, `ashby`, `personio`, `workable`, `recruitee`), a board URL, or a company domain. Workday, SmartRecruiters and Teamtailor entries give a free `unsupported_ats` error row. | | `mode` | `monitor` (default): only new / changed / closed jobs since the last run. `snapshot`: every matching open job. `discover`: one row per company with the board found for it (see below), no job rows. | | `keywords`, `excludeKeywords`, `keywordsIn` | Any-word match in the title (default) or title + description. Case-insensitive. | | `locations`, `departments` | Any-word match in any location / in the department or team. | | `remoteOnly` | Only jobs marked remote (hybrid is not remote). | | `postedSinceDays` | Only jobs posted in the last N days (0 = off). | | `maxDescriptionChars` | Markdown description cap (default 4,000; 0 = no description). | | `maxJobsPerCompany` | Row (and charge) cap per company per run. In monitor mode the rest come on the next run. | | `emitBaseline` | Monitor: return every open job as `new` (`baseline: true`) on a company's first check. **Default off**: the first check stores the baseline for one `company-checked-unchanged` ($0.001) and returns one free `baseline_summary` row. On, 100 companies x 150 jobs = 15,000 rows, about $22.50 once. | | `includeChanged`, `includeClosed` | Monitor: return changed / closed jobs (default on). | | `closeAfterMissedChecks` | Consecutive checks a job must be missing before it counts as closed (default 2; the closing date is the first missed check). | | `emitCompanyStats` | One free stats row per company (always in the `SUMMARY` record anyway). | | `monitorStoreName` | Named key-value store with the history (default `ats-job-feeds`). One schedule per store. | **Domain auto-detection.** For `acme.com` the Actor first reads the company's own site: `https://acme.com/` and, if that page links to no job board, up to 2 careers pages it links to on the same domain (`/careers`, `/jobs`, `/join-us`, `/karriere`, ...). Redirects are followed only while they stay on `acme.com` or its sub-domains; a redirect to another domain ends the site check without contacting that domain. Every supported board URL in those pages counts (links, iframes, Greenhouse embed scripts, URLs inside page JSON); boards whose token matches the domain (`acme`, `acmeinc`, `acme-labs`) are tried first. A linked board is `detectionVerified: true` only when its token or the API's company name matches the domain (or its job URLs are on the domain); a link to someone else's board (partner, portfolio, customer page) is used but marked `false` (another company's name) or `null`. If the site links to no supported board, the Actor guesses the board token (`acme`; for `acme-labs.co.uk` also `acmelabs`) and asks Greenhouse, Lever, Ashby, Personio, Workable and Recruitee once each, in that order (`slug-guess`): the first board **with jobs** wins; an existing but empty board is used only if nothing else answers. For guesses `detectionVerified` is `true`/`false` when the API's company name (Greenhouse, Personio, Workable, Recruitee) or job URLs can be compared, `null` otherwise (Lever, Ashby). At most 3 site pages + 12 guesses per domain. No search engine is ever queried. A site that links only to Workday, SmartRecruiters or Teamtailor gets a free `unsupported_ats` error naming it. Hits are cached in the monitor store for 30 days, misses for 7 days. **Discover mode** (`"mode": "discover"`) runs only that detection for a list of domains and returns one row per company: `{status: "discovered", company, domain, ats, board, boardUrl, endpoint, method: "site-link"|"slug-guess"|"given", foundOn, detectionVerified, charged, openJobs}`. One `board-discovered` is charged, after the row is stored, only for boards you gave (`given`) or boards with `detectionVerified: true`. Unverified finds are returned free with `charged: false`, and so are misses (`not_detected`, `unsupported_ats`) and errors. Feed the results into monitor mode as `ats:board` entries. **First run (monitor mode).** The first check of a company only stores its open jobs as the baseline, so it returns no job rows. To show that the run worked, it returns one free row with `status: "baseline_summary"`: `company`, `storedJobs` (open jobs stored), `matchingFilters` (how many match your keywords and filters), `sample` (the first 5 matching jobs: title, location, URL), `message`, `nextStep` and `charged: false`. It has no `jobId`, is never a charged event and is not a job row; the only charge is the one `company-checked-unchanged` ($0.001) per company. The run's status message reads "Baseline stored for N of M companies". The second run with no change returns no rows (one `company-checked-unchanged` per company); changes appear as `new`, `changed` and `closed`. With `emitBaseline` on there is no `baseline_summary` row, the jobs themselves are returned. Filters decide which rows you get and pay for. In monitor mode every job of the company is still tracked, so the history and counts are company-wide. ### Output (one row per job) ```json { "status": "closed", "jobId": "greenhouse:gitlab:8860302002", "ats": "greenhouse", "board": "gitlab", "company": "GitLab", "title": "Account Executive - France", "location": "Remote, France", "locations": ["Remote, France", "France"], "remote": true, "workplaceType": "remote", "department": "EMEA - Commercial", "team": null, "employmentType": null, "salary": null, "postedAt": "2026-10-02T15:31:50Z", "updatedAt": "2026-10-02T15:31:50Z", "applyUrl": "https://job-boards.greenhouse.io/gitlab/jobs/8860302002", "jobUrl": "https://job-boards.greenhouse.io/gitlab/jobs/8860302002", "source": {"ats": "greenhouse", "endpoint": "https://boards-api.greenhouse.io/v1/boards/gitlab/jobs?content=true"}, "description": "GitLab is the intelligent orchestration platform ...", "descriptionTruncated": true, "privacyRedactions": 0, "firstSeenAt": "2026-10-14T08:00:00Z", "changes": [], "closedAt": "2026-10-24T08:00:00Z", "daysOpen": 22, "checkedAt": "2026-10-24T08:00:00Z", "error": null } ``` - `status`: `baseline_summary` (free, first monitor check only, see "First run"), `new`, `changed` (with `changes: [{field, before, after}]` for title, locations, salary, remote), `closed`, `open` (snapshot), `error` (free), `company` (free stats row). - `remote`: `true`/`false`, or `null` when the board does not say. `salary` is filled only when the board publishes it: Lever `salaryRange`, Ashby compensation, and Greenhouse pay ranges rendered into the post. Personio feeds carry no salary. - Closed rows carry what the monitor remembered (title, locations, department, salary text, posted / first-seen date). `daysOpen` counts from the posting date (else the first time the Actor saw the job) to `closedAt`, the first check where the job was missing. - `SUMMARY` record: per company `openJobs`, `new30d` / `closed30d` / `new90d` / `closed90d`, `netChange30d` / `netChange90d`, `medianDaysOpenOfClosed`, `trackedSince`, plus counts and warnings. **Run-summary row (free).** When a run produces no other row (for example a monitor run where nothing changed, or a run stopped at once by your maximum charge or the run timeout), the Actor adds one row `{"type": "run_summary", "status": "run_summary", "message": "...", "stopReason": ..., "warnings": [...], "summary": {...}}` (`summary` is the same as the `SUMMARY` record), so the dataset is never empty. It is never charged. Skip it with `type != "run_summary"`. ### Privacy: no personal data - ATS fields that name people (Greenhouse custom `metadata` such as "Hiring Manager", hiring-team data) are never read. - In descriptions, departments, locations and salary text: e-mail addresses (also `name (at) domain (dot) com`), phone numbers (international, US incl. space-only and 1-800, German `089 / 123 456 78`), LinkedIn / Calendly / WhatsApp / Telegram profile links and mailto/tel links are removed. So are names after a cue: strong cues ("I'm", "my name is", "Recruiter:", "Hiring Manager -", "Ansprechpartner(in):") take one capitalised word; weak cues ("contact", "reach out to", "report to") need two words or an honorific (Dr., Mr., Ms., Frau, Herr). Hyphenated surnames and a comma after the cue are handled. Words like products and companies ("contact Google Cloud") and roles are never treated as names. Job titles only lose e-mails, phones and links, never words. Each removal is replaced by a marker such as `[email removed]` and counted in `privacyRedactions`. - **Limit:** this is a heuristic. A name with no cue ("Abhik and Benji, our founders") is not detected. Founders and executives named in a company's public job text may remain. ### Monitor mode, how it works Each company has its own records in the named key-value store: `state--` (one compact entry per open job: title, locations, salary text, remote, department and dates, never descriptions), `history--` (daily open/new/closed/changed counts for 400 days, plus the last 500 closed jobs with days open), and a `LOCK` while a run is active. - A job counts as closed after it has been missing from `closeAfterMissedChecks` (default 2) consecutive successful answers. ATS APIs can briefly serve stale or partial lists, so a single missing check is treated as possibly a glitch. A board that fails to load (timeout, 5xx, robots) closes nothing. Whatever the setting, at least two checks are needed when a board goes empty (`board_empty_unconfirmed`), shrinks by 30 % or more and at least 5 jobs (`board_shrink_unconfirmed`), or is a multi-page Lever board (`multi_page_board`). `closedAt` is still the first missed check. This lowers false closures but cannot rule them out. - A job that disappears and comes back within `closeAfterMissedChecks` is neither new nor closed. - Billing order: the state record is saved first, then the rows are pushed and charged. If the state save fails, nothing is pushed or charged and the same changes come next run. If the history record fails to save twice in a row, that company is checked for free until a save works again (`SUMMARY.chargingPaused`). - The state size is checked before any charge (1.5 MB cap, `state_too_large`, free). - When your maximum charge or `maxJobsPerCompany` cuts a company short, the rows not delivered are rolled back in the state (a new job is "not seen yet", a closed job keeps its closing date) and come on the next run. Nothing is lost or charged twice (`deferred` in SUMMARY). A company is not started at all when not even one row fits. - Use **one schedule per `monitorStoreName`**. A second run on the same store while one is active stops with `store_locked` (a crashed run's lock expires after 3 hours). The lock is best effort: the key-value store has no atomic compare-and-set, so two runs started in the same second can both proceed. A run removes the lock only if it is still its own. - If a delivery is interrupted (the platform refuses a row), the undelivered rows are rolled back and the state is saved again, so they come next run. Baseline jobs deferred by the row cap stay marked `baseline: true` and are never counted as new hires in the history. ### Sources and their terms Public endpoints that need no login or key: Greenhouse, Lever, Ashby, Personio and Recruitee (official, documented; Recruitee only until 2027-02-10) and one unofficial endpoint (Workable's careers widget). All six are enabled by default; nothing needs switching on. Details, terms, robots.txt and rate-limit notes are in `SOURCES.md`. | ATS | Endpoint | Notes | |---|---|---| | Greenhouse | `boards-api.greenhouse.io/v1/boards/{board}/jobs?content=true` | "Job Board data is publicly available"; one request per board | | Lever | `api.lever.co/v0/postings/{board}?mode=json` (EU: `api.eu.lever.co`) | published postings "may be scraped by third parties"; 100 per page; robots Crawl-delay 1 | | Ashby | `api.ashbyhq.com/posting-api/job-board/{board}?includeCompensation=true` | public posting API for job boards | | Personio | `{board}.jobs.personio.de/xml` | documented open-positions XML feed; parsed with defusedxml | | Workable | `apply.workable.com/api/v1/widget/accounts/{board}?details=true` | **unofficial widget endpoint**: the careers-widget endpoint Workable gives customers to embed jobs, no formal API reference. Workable's terms have no clause against automated access; robots.txt allows all | | Recruitee | `{board}.recruitee.com/api/offers/` | public Careers Site API; the job's reply-to mailbox, screening questions and custom fields are never read | Live check on 2026-10-14 (one request per endpoint, robots.txt first, User-Agent `DataFeedBot`): Workable (Blueground) and Recruitee (bunq) answered public JSON without login. Not included: **Workday** (`*.myworkdayjobs.com`). Its JSON list works without login, but Workday's site terms (https://workday.com/en-us/legal/site-terms.html, section 2) ban "robots or similar data gathering or extraction methods designed to scrape" and their "Sites" include "the Workday APIs", so it is disabled. The adapter stays in the code, switched off. **SmartRecruiters**: robots.txt of `api.smartrecruiters.com` allows only LinkedInBot. **Teamtailor**: its JSON API needs the company's own key. iCIMS, Taleo, SuccessFactors: no public JSON. **Recruitee:** Recruitee announced that from 2027-02-10 the Careers Site API needs a company token. From that date the Actor stops calling it (checked in the code before any request) and Recruitee boards get a free `unsupported_ats` error row; domain auto-detection no longer finds Recruitee boards either. While you still list Recruitee boards, `SUMMARY.warnings` says how many days remain, and after the date that the platform is no longer read. ### Limits - Board responses over 10 MB are refused (`too_large`). That is roughly 1,000+ Greenhouse jobs with full descriptions; `maxDescriptionChars` does not reduce the download. Lever is paged and allows up to 5,000 postings. A board whose monitor state exceeds 1.5 MB (several thousand jobs) gets a free `state_too_large` row: run that board in `snapshot` mode instead. - Greenhouse EU boards (`job-boards.eu.greenhouse.io`) are not supported yet. - Slug guessing uses the domain name only; site-link detection reads at most 3 pages of the company's own site (robots.txt honoured) and does not run JavaScript, so boards injected only by script at runtime are missed. - Recruitee and Workable boards on a company's own career domain (e.g. `careers.acme.com` served by Recruitee) are not recognised from links; give `recruitee:acme` instead. - Salaries are as published. No currency conversion, no salary parsing from free text (except Greenhouse's pay-range block, which understands US and EU separators, K suffixes and C$/A$/S$/NZ$). When an amount is ambiguous, `min`/`max` stay null and only `text` is filled. - `employmentType` is not exposed by the Greenhouse Job Board API (null). ### Acceptable use The Actor reads job postings that companies publish for anyone to read through their ATS's public API. It outputs company-level job data only, never applicant or recruiter data. You are responsible for how you use the data, including the ATS terms and applicable law such as the GDPR. # Actor input Schema ## `companies` (type: `array`): One per line: a board token with its ATS (`greenhouse:gitlab`, `lever:palantir`, `lever-eu:acme`, `ashby:ashby`, `personio:acme`, `workable:acme`, `recruitee:acme`), a board URL (boards.greenhouse.io/x, jobs.lever.co/x, jobs.ashbyhq.com/x, x.jobs.personio.de, apply.workable.com/x, x.recruitee.com), or a company domain (`acme.com`): the board is then found from links on the company's own site (home page and up to 2 careers pages on the same domain), else by one request per ATS per name guess. Max 200. ## `mode` (type: `string`): Monitor keeps a per-company history in a named key-value store and returns only what changed (the first check of a company stores a baseline and returns one free `baseline_summary` row, not the jobs, unless 'Return all jobs on the first run' is on). ## `keywords` (type: `array`): Keep jobs whose title (or title + description, see below) contains any of these words. Case-insensitive. ## `excludeKeywords` (type: `array`): Drop jobs containing any of these words. ## `keywordsIn` (type: `string`): Where keywords are matched. ## `locations` (type: `array`): Keep jobs where any location contains one of these, e.g. `Berlin`, `Germany`, `Remote`. ## `departments` (type: `array`): Keep jobs whose department or team contains one of these. ## `remoteOnly` (type: `boolean`): Only jobs the board marks as remote (or whose location says remote). Hybrid is not remote. ## `postedSinceDays` (type: `integer`): 0 = no date filter. Jobs without a posting date are dropped when this is set. ## `maxDescriptionChars` (type: `integer`): Markdown characters per description; 0 = no description. ## `maxJobsPerCompany` (type: `integer`): Caps the rows (and charges) per company per run. Monitor mode: the rest are delivered on the next run. ## `emitBaseline` (type: `boolean`): Monitor mode: off (default) = a company's first check only stores the baseline, returns one free `baseline_summary` row (counts, a sample and the next step) and costs one 'company-checked-unchanged' event (about $0.001); later runs return only new, changed and closed jobs. On = every open job is returned as `new` (with `baseline: true`) on the first check and charged as `job-returned`: e.g. 100 companies x 150 open jobs = 15,000 rows, about $45 at $0.003. ## `includeChanged` (type: `boolean`): Title, location, salary or remote flag changed. ## `includeClosed` (type: `boolean`): Jobs that disappeared from the board, with `closedAt` and `daysOpen` (time to fill). ## `closeAfterMissedChecks` (type: `integer`): Consecutive checks a job must be missing before it counts as closed (default 2, so a one-off glitch never closes a job). The closing date is always the first missed check. Boards that empty, drop by 30 %+ (and 5+ jobs) or are multi-page Lever boards always need at least 2. ## `emitCompanyStats` (type: `boolean`): Free row with open jobs, new/closed in 30 and 90 days, net change and median days open of closed jobs. Always in the SUMMARY record too. ## `monitorStoreName` (type: `string`): Named key-value store holding the history. Use one schedule per store name. ## `personioLanguage` (type: `string`): Language requested from Personio feeds. ## `perHostDelayMs` (type: `integer`): Politeness delay; robots.txt Crawl-delay is honoured when larger. ## `timeoutSecs` (type: `integer`): Per request. ## Actor input object example ```json { "companies": [ "greenhouse:gitlab", "ashby:ashby" ], "mode": "monitor", "keywordsIn": "title", "remoteOnly": false, "postedSinceDays": 0, "maxDescriptionChars": 4000, "maxJobsPerCompany": 2000, "emitBaseline": false, "includeChanged": true, "includeClosed": true, "closeAfterMissedChecks": 2, "emitCompanyStats": false, "monitorStoreName": "ats-job-feeds", "personioLanguage": "en", "perHostDelayMs": 1500, "timeoutSecs": 30 } ``` # Actor output Schema ## `results` (type: `string`): One row per result (see the dataset schema for fields). ## `summary` (type: `string`): SUMMARY record: counts, warnings, stop reason and what was charged. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "companies": [ "greenhouse:gitlab", "ashby:ashby" ] }; // Run the Actor and wait for it to finish const run = await client.actor("datafeed/ats-job-feeds").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "companies": [ "greenhouse:gitlab", "ashby:ashby", ] } # Run the Actor and wait for it to finish run = client.actor("datafeed/ats-job-feeds").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:gitlab", "ashby:ashby" ] }' | apify call datafeed/ats-job-feeds --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,datafeed/ats-job-feeds" } } } ``` 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 ` 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/qpLdKfW877XExwHfP/builds/bon06ib82WGjcNigt/openapi.json