# ATS Jobs API: Greenhouse, Lever, Ashby & more (`deftcell/ats-jobs-api`) Actor Get public job postings from Greenhouse, Lever, Ashby, and Workable boards in one normalized schema: locations, remote flag, salary ranges, dates, apply links, and clean descriptions. Give board URLs, careers pages, or domains. Incremental mode returns only new jobs for daily feeds. - **URL**: https://apify.com/deftcell/ats-jobs-api.md - **Developed by:** [Ervin Amaya](https://apify.com/deftcell) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.05 / 1,000 job delivereds 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 API: Greenhouse, Lever, Ashby & more Get every public job posting from a company's **Greenhouse, Lever, Ashby, or Workable** job board in **one normalized schema**: title, department, team, employment type, locations, remote flag, salary range, dates, apply link, and a clean plain-text description. Give it board URLs, careers-page URLs, bare domains, or `ats:token` pairs. Turn on **incremental mode** and each scheduled run returns only jobs you have not received before, which makes it a ready-made daily job feed for job boards, recruiting tools, market research, and AI agents. **Built and maintained by an AI agent operated by Elite Tech Global LLC (Deftcell).** Issues are monitored and answered by the same AI-assisted team. ### What it does - **One schema for four ATSs.** Greenhouse, Lever, Ashby, and Workable data is mapped to the same fields, so you can mix companies freely. - **Auto-detection.** Pass `https://example.com/careers` or `example.com` and the Actor finds the company's ATS board from that page (see [How auto-detection works](#how-auto-detection-works)). - **Salaries, parsed carefully.** Structured pay fields come first (Greenhouse pay ranges, Lever salary ranges, Ashby compensation). If none exist, a salary *range* is taken from the description only when it is clearly stated next to words like "salary", "base", or "pay". Every salary says where it came from (`salarySource`) and shows the wording it was read from (`salaryText`). - **Remote and workplace flags.** `workplaceType` is `remote`, `hybrid`, `onsite`, or `null` when unknown. `isRemote` is `true` for fully remote jobs and for jobs that list a remote option. - **Filters.** Keywords, locations, remote only, and "posted within N days". Filtered-out jobs are not charged. - **Incremental mode** for daily feeds, with one memory per feed name (`feedName`). - **Polite and reliable.** Uses only public job-board APIs, at most 5 requests in flight, robots.txt Crawl-delay honoured, retries with exponential backoff on 429/5xx, timeouts on every request. ### Supported ATSs | ATS | Accepted inputs | Source | Salary data | |---|---|---|---| | Greenhouse | `https://boards.greenhouse.io/`, `https://job-boards.greenhouse.io/`, embed URLs (`...embed/job_board?for=`), `greenhouse:` | [Job Board API](https://developers.greenhouse.io/job-board.html) | Pay ranges when the company publishes them; otherwise ranges stated in the description | | Lever | `https://jobs.lever.co/`, `https://jobs.eu.lever.co/`, `lever:` | [Postings API](https://github.com/lever/postings-api) (global and EU hosts) | `salaryRange` when published; otherwise ranges stated in the description | | Ashby | `https://jobs.ashbyhq.com/`, `ashby:` | [Job Postings API](https://developers.ashbyhq.com/docs/public-job-posting-api) | Compensation when the company shows it on postings; otherwise ranges stated in the description | | Workable | `https://apply.workable.com/`, `https://.workable.com`, `workable:` | Public account endpoint documented in [Workable's help center](https://help.workable.com/hc/en-us/articles/115012771647-Using-the-Workable-API-to-create-a-careers-page) | Ranges stated in the description | **Not supported, on purpose:** - **SmartRecruiters.** Its Posting API is documented as public, but `api.smartrecruiters.com/robots.txt` disallows every user agent except LinkedInBot (checked 2026-10-02). This Actor respects robots.txt, so SmartRecruiters inputs are reported as `unsupported_ats` and never fetched. - **Recruitee.** Its Careers Site API now requires a token that the company creates inside its own Recruitee account, and calls without it are being switched off ([Recruitee docs](https://docs.recruitee.com/reference/authentication-1)). There is no open endpoint for third parties, so Recruitee inputs are reported as `unsupported_ats`. ### Input examples **Board URLs (the simplest and most exact input):** ```json { "companies": [ "https://job-boards.greenhouse.io/figma", "https://jobs.lever.co/spotify", "https://jobs.ashbyhq.com/linear", "https://apply.workable.com/huggingface/" ] } ``` **Mixed forms: shorthand, objects, careers pages, and domains:** ```json { "companies": [ "greenhouse:gitlab", "lever:palantir", { "ats": "ashby", "token": "notion", "companyName": "Notion" }, "https://ramp.com/careers", "figma.com" ], "maxJobsPerCompany": 100 } ``` **Filtered search: remote or US engineering jobs from the last two weeks:** ```json { "companies": ["greenhouse:gitlab", "lever:spotify", "ashby:linear"], "keywords": ["engineer", "developer"], "locations": ["United States", "Remote"], "postedWithinDays": 14 } ``` **Daily feed of new jobs only (pair it with an Apify schedule):** ```json { "companies": ["greenhouse:figma", "lever:zoox", "ashby:ramp", "workable:flosum"], "incremental": true, "feedName": "daily-design-tools-feed" } ``` #### Input fields | Field | Type | Default | Description | |---|---|---|---| | `companies` | array (required) | – | Board URLs, careers-page URLs, domains, `"ats:token"` strings, or `{ "ats", "token", "companyName" }` objects. Up to 10,000 per run. | | `keywords` | string\[] | `[]` | Keep jobs whose title, department, or team contains any keyword. Whole words, case-insensitive; `engineer` also matches "Engineers" and "Engineering". | | `keywordsInDescription` | boolean | `false` | Also search the description text. | | `locations` | string\[] | `[]` | Keep jobs matching any location: city, region, country, or `Remote`. `US`/`USA`/`United States` and `UK`/`United Kingdom` are treated as the same place, and US jobs written as "City, ST" count as United States. | | `remoteOnly` | boolean | `false` | Keep only jobs with `isRemote: true`. | | `postedWithinDays` | integer | none | Keep jobs whose `postedAt` (or `updatedAt` when no posting date exists) is within this many days. | | `maxJobsPerCompany` | integer | none | Deliver at most this many jobs per company, newest first. | | `includeDescriptionHtml` | boolean | `false` | Add the original description HTML (`descriptionHtml`). Plain text is always included. | | `incremental` | boolean | `false` | Deliver only jobs not delivered by earlier runs with the same `feedName`. | | `feedName` | string | `"default"` | Name of the feed whose memory is used. The older name `incrementalKey` still works. | ### Output One dataset item per job. Example (a real posting, description shortened): ```json { "id": "5c4d01f94730ce8c132385ef", "ats": "lever", "companyToken": "zoox", "companyName": null, "atsJobId": "2ff4b934-b823-4d33-a0c2-3372389aeef7", "title": "Senior Software Engineer - Pipeline Infrastructure & Integration", "department": "Software", "team": "Software Systems", "employmentType": "FULL_TIME", "employmentTypeRaw": "Full-time", "locations": ["Foster City, CA"], "isRemote": false, "workplaceType": "hybrid", "salaryMin": 219000, "salaryMax": 315000, "salaryCurrency": "USD", "salaryPeriod": "YEAR", "salarySource": "ats", "salaryText": "219,000–315,000 USD per year", "postedAt": "2026-09-08T16:15:09.821Z", "updatedAt": null, "applyUrl": "https://jobs.lever.co/zoox/2ff4b934-b823-4d33-a0c2-3372389aeef7/apply", "jobUrl": "https://jobs.lever.co/zoox/2ff4b934-b823-4d33-a0c2-3372389aeef7", "descriptionText": "The Software Systems Engineering team is responsible for defining SW development processes and ensuring that all safety-critical software meets a high safety bar for production vehicles.\n\nIn this role, you will design and implement methodologies, tools, and …", "companyInput": "lever:zoox", "scrapedAt": "2026-10-02T21:23:32.159Z" } ``` | Field | Meaning | |---|---| | `id` | Stable ID: a hash of ATS + company token + ATS job ID. The same job keeps the same ID across runs, so you can de-duplicate or upsert on it. | | `ats`, `companyToken`, `atsJobId` | Where the job came from. | | `companyName` | From the ATS when it provides one (Greenhouse, Workable) or from your input object; otherwise `null`. | | `title`, `department`, `team` | As published. Greenhouse has no team field, so `team` is `null` there. | | `employmentType` | `FULL_TIME`, `PART_TIME`, `CONTRACT`, `INTERN`, `TEMPORARY`, `OTHER`, or `null`. `employmentTypeRaw` keeps the published wording. | | `locations` | Location strings as published, split into a list. Locations a Workable company marks hidden are left out. | | `isRemote`, `workplaceType` | See [What it does](#what-it-does). | | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Numbers in the stated currency (ISO 4217). Period is `YEAR`, `MONTH`, `WEEK`, `DAY`, `HOUR`, or `null` if unclear. When a Greenhouse posting lists several pay zones in the same currency, the range spans all of them (the zones are listed in `salaryText`). | | `salarySource`, `salaryText` | `ats` (structured field) or `description` (clearly stated range in the text), plus the wording it came from. | | `postedAt`, `updatedAt` | ISO 8601 UTC. `postedAt` is the first-published date (Ashby reports the last-published date). `updatedAt` is `null` where the ATS does not provide it. | | `applyUrl`, `jobUrl` | Application link and job page. Greenhouse uses one URL for both. | | `descriptionText` | Plain text with paragraphs and `- ` bullets. Personal e-mail addresses are replaced with `[email removed]`. | | `descriptionHtml` | Only when `includeDescriptionHtml` is on. | | `companyInput` | The `companies` entry that produced the job. | | `scrapedAt` | When the board was read. | The **Overview** tab of the dataset shows company, title, locations, workplace, type, salary, posted date, and job link. Export as JSON, CSV, Excel, or through the API. #### Run summary Each run also saves `RUN_SUMMARY` in its key-value store: one record per input with `status`, the board it resolved to, how it was detected, and job counts (fetched, matched, new, delivered). Statuses: `ok`, `no_jobs`, `no_matching_jobs`, `no_new_jobs`, `duplicate`, `board_not_found`, `not_detected`, `robots_disallowed`, `unsupported_ats`, `invalid_input`, `error`, `partial_charge_limit`, `skipped_charge_limit`. Problems never stop the other companies from being processed. (`RUN_STATE` in the same store is internal; it lets a run resume without duplicates if Apify moves it to another server.) ### Incremental mode for daily feeds 1. Set `incremental: true` and pick a `feedName`, such as `"daily-feed"`. 2. Create an [Apify schedule](https://docs.apify.com/platform/schedules) that runs the Actor (or a saved task) every day. 3. The **first run delivers every matching job.** Later runs deliver only jobs that no earlier run with the same key delivered. How it works: - Delivered job IDs are stored per company in a named key-value store in your Apify account, `ats-jobs-api-incremental`. Named stores persist between runs. - A job counts as "seen" only once it has actually been delivered. Jobs cut off by `maxJobsPerCompany`, by a filter, or by your maximum charge stay "new" and come in a later run. - Different keys are fully independent, so one Actor can power several feeds. - IDs of jobs that disappear from a board are forgotten after 180 days. - Do not run two incremental runs with the same key at the same time; they could both deliver the same new jobs. - To start a feed over, use a new `feedName`. ### Filters - **Keywords** match the title, department, and team (plus the description with `keywordsInDescription`). Any keyword is enough. - **Locations** match any listed location string, the country the ATS reports (Lever, Ashby, Workable), and "Remote" for remote jobs. - **Remote only** keeps `isRemote: true` jobs. - **Posted within N days** uses `postedAt` (or `updatedAt`); jobs with no date are excluded while this filter is on. All filters are applied before charging. You pay only for delivered jobs. ### How auto-detection works For a careers-page URL or a domain, the Actor: 1. Checks the site's robots.txt for its user agent, `DeftcellJobsAPI/1.0 (+https://apify.com/deftcell)`. If robots.txt does not allow the page, the page is not fetched (`robots_disallowed`). 2. Fetches **only that one page**, following its redirects (at most 5). It never follows links or crawls the site. A redirect straight to an ATS board is used directly. 3. Looks for ATS links and embeds in the HTML, including script embeds and URLs inside inline JSON. The most frequent board wins; others are listed in `RUN_SUMMARY` as `otherBoardsFound`. 4. If the page shows no ATS, it tries the domain name as a board name on Greenhouse and Workable, the two ATSs whose public API reports the company name. The guess is accepted only if that board has open jobs **and** its company name matches the domain (`detectedVia: "domain-name-match"`). For exact results, pass the ATS board URL. Pages that load their job list only with JavaScript from another domain may not reveal their ATS. ### Pricing Pay per event: - **About $0.0015 per job delivered** (the `job` event, one per dataset item). 1,000 jobs cost about $1.50. - Apify's small automatic start event (`apify-actor-start`) per run. Final prices are shown on the Actor's pricing tab. Jobs removed by filters, jobs already delivered in incremental mode, and companies that fail are never charged. If you set a **maximum charge per run**, the Actor stops delivering when that budget is reached and records what was left out in `RUN_SUMMARY`. ### For AI agents and MCP clients - **Smallest useful input:** `{"companies": ["greenhouse:figma"], "maxJobsPerCompany": 20}`. - **API (synchronous, returns the dataset items):** `POST https://api.apify.com/v2/actors/deftcell~ats-jobs-api/run-sync-get-dataset-items?token=&maxTotalChargeUsd=1` with the input JSON as the body. Use `maxTotalChargeUsd` to cap spend. - **MCP:** add `https://mcp.apify.com?tools=deftcell/ats-jobs-api` to your MCP client (see [Apify MCP docs](https://docs.apify.com/integrations/mcp)). The dataset schema documents every output field, so agents can read the field meanings before calling. - Prefer exact inputs (`ats:token` or board URLs) over domains when you know them; they need no page fetch. - Use `id` to de-duplicate, `salarySource` to judge salary reliability, and `RUN_SUMMARY` to see why a company returned nothing. ### Limits - Up to 10,000 companies per run; companies are processed 5 at a time. - Workable's public endpoint has no structured salary or workplace data beyond a remote flag, so those fields are filled only from the posting text. - Lever and Ashby APIs do not return the company name; pass `{"ats", "token", "companyName"}` if you need it. - Descriptions are the company's own text. Structured person fields are never output, and personal e-mail addresses are removed, but names written inside a description stay as published. - Salary parsing from text takes the first clearly stated range and skips anything ambiguous (single figures, funding amounts, stipends, bonuses). - Workable's robots.txt states content-use preferences (search and AI input allowed, AI training not). Respect them in how you use the data. ### FAQ **Why did a company return no jobs?** Check `RUN_SUMMARY`. `not_detected` means no supported ATS was found from the page you gave; pass the board URL instead. `board_not_found` means the ATS has no public board with that name. `no_jobs` means the board exists but has no open jobs. **Is the salary always the base salary?** It is the range the company publishes. Structured fields are usually base pay. Text ranges come from sentences that mention salary, base, or pay; read `salaryText` to see the wording. **Will the same job appear twice?** Not within one run, even when two inputs point to the same board (`duplicate`). Across normal runs, yes, unless you use incremental mode or de-duplicate on `id`. **Can it scrape LinkedIn, Indeed, or company sites in general?** No. It reads only the public job-board APIs of the supported ATSs, plus the single careers page you give it for detection. **What about SmartRecruiters or Recruitee?** See [Supported ATSs](#supported-atss). They are recognised and reported, but not fetched. ### Data source and compliance - Jobs come only from the **public job-board APIs** that Greenhouse, Lever, Ashby, and Workable document so that companies can publish their openings on careers sites and job boards. These endpoints need no login or API key. No data is taken from behind a login. - The output contains **job postings, not people.** The Actor never outputs recruiter, hiring-manager, or contact fields, and it removes personal e-mail addresses from descriptions. Role mailboxes such as `careers@` or `accommodations@` stay, because applicants need them. - **robots.txt is respected** for every host the Actor contacts, including Crawl-delay. Careers-page detection reads only the one page you supply. - Requests are rate-limited (at most 5 in flight, a minimum gap per host), retried with backoff on 429/5xx, and identified by the user agent `DeftcellJobsAPI/1.0 (+https://apify.com/deftcell)`. - You are responsible for how you use the data, including the hiring companies' terms, applicable privacy law, and any content preferences a source publishes. - Not affiliated with or endorsed by Greenhouse, Lever, Ashby, or Workable. Their names only describe where the data comes from. ### Support Open an issue on the Actor's **Issues** tab with your run ID and what you expected. **Built and maintained by an AI agent operated by Elite Tech Global LLC (Deftcell).** Issues are monitored and answered by the same AI-assisted team. # Actor input Schema ## `companies` (type: `array`): One entry per company. Accepted forms: - ATS board URL: https://job-boards.greenhouse.io/figma, https://jobs.lever.co/spotify, https://jobs.ashbyhq.com/linear, https://apply.workable.com/huggingface - Careers page or domain: https://example.com/careers or example.com (the Actor fetches that one page, respecting robots.txt, and looks for an ATS link or embed) - Shorthand: "greenhouse:figma", "lever:spotify", "ashby:linear", "workable:huggingface" - Object: {"ats": "greenhouse", "token": "figma", "companyName": "Figma"} ## `keywords` (type: `array`): Keep jobs whose title, department, or team contains any of these words or phrases (case-insensitive, whole words; "engineer" also matches "Engineering"). Leave empty to keep all jobs. ## `keywordsInDescription` (type: `boolean`): When on, keywords also match the job description text (useful for skills such as "Kubernetes"). ## `locations` (type: `array`): Keep jobs whose location matches any entry, for example "London", "United States", "Germany", or "Remote". "US" and "UK" also match their full names, and US jobs listed as "City, ST" count as United States. ## `remoteOnly` (type: `boolean`): Keep only jobs the ATS or the posting marks as remote. ## `postedWithinDays` (type: `integer`): Keep only jobs first published within this many days (uses the posting date from the ATS). Leave empty for no limit. ## `maxJobsPerCompany` (type: `integer`): Deliver at most this many jobs per company, newest first. Leave empty for all jobs. ## `includeDescriptionHtml` (type: `boolean`): Add the original description HTML in `descriptionHtml`. Plain text (`descriptionText`) is always included. ## `incremental` (type: `boolean`): When on, each run delivers only jobs that earlier runs with the same feed name have not delivered yet. The first run delivers everything that matches. Ideal for scheduled daily feeds. ## `feedName` (type: `string`): Name of the feed whose memory to use, such as `daily-design-jobs`. Use a different name for each separate feed or schedule. Leave empty to use the feed named `default`. (Formerly `incrementalKey`, which still works.) ## Actor input object example ```json { "companies": [ "https://job-boards.greenhouse.io/figma", "lever:spotify", { "ats": "ashby", "token": "linear", "companyName": "Linear" }, "https://apply.workable.com/huggingface/" ], "keywordsInDescription": false, "remoteOnly": false, "maxJobsPerCompany": 50, "includeDescriptionHtml": false, "incremental": false } ``` # Actor output Schema ## `jobs` (type: `string`): Normalized job postings (one item per job) in the default dataset. ## `runSummary` (type: `string`): Per-company status, detection method and job counts (RUN\_SUMMARY record). # 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": [ "https://job-boards.greenhouse.io/figma", "https://jobs.lever.co/spotify", "https://jobs.ashbyhq.com/linear", "https://apply.workable.com/huggingface/" ], "maxJobsPerCompany": 50 }; // Run the Actor and wait for it to finish const run = await client.actor("deftcell/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "companies": [ "https://job-boards.greenhouse.io/figma", "https://jobs.lever.co/spotify", "https://jobs.ashbyhq.com/linear", "https://apply.workable.com/huggingface/", ], "maxJobsPerCompany": 50, } # Run the Actor and wait for it to finish run = client.actor("deftcell/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": [ "https://job-boards.greenhouse.io/figma", "https://jobs.lever.co/spotify", "https://jobs.ashbyhq.com/linear", "https://apply.workable.com/huggingface/" ], "maxJobsPerCompany": 50 }' | apify call deftcell/ats-jobs-api --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,deftcell/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 ` 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/mG2tPQLIzKCoM37NO/builds/Wat5EhcxnialsQQne/openapi.json