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).
• 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/<token>, https://job-boards.greenhouse.io/<token>, embed URLs (...embed/job_board?for=<token>), greenhouse:<token>	Job Board API	Pay ranges when the company publishes them; otherwise ranges stated in the description
Lever	https://jobs.lever.co/<site>, https://jobs.eu.lever.co/<site>, lever:<site>	Postings API (global and EU hosts)	salaryRange when published; otherwise ranges stated in the description
Ashby	https://jobs.ashbyhq.com/<board>, ashby:<board>	Job Postings API	Compensation when the company shows it on postings; otherwise ranges stated in the description
Workable	https://apply.workable.com/<account>, https://<account>.workable.com, workable:<account>	Public account endpoint documented in Workable's help center	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). 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):

{
  "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:

{
  "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:

{
  "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):

{
  "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):

{
  "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.
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 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=<APIFY_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). 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. 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.