# ATS Jobs Scraper: Greenhouse, Lever, Ashby, Workday (Lite) (`cleanyield/ats-jobs-scraper-lite`) Actor

Returns one row per live job posting from Greenhouse, Lever, Ashby, Workday and 15 more hiring systems: title, location, date, apply URL, salary when posted. Lite: no per-result charge, max 25 jobs per run. Full version (no limit, monitor, alerts): https://apify.com/cleanyield/ats-jobs-scraper

- **URL**: https://apify.com/cleanyield/ats-jobs-scraper-lite.md
- **Developed by:** [Clean Yield](https://apify.com/cleanyield) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 Scraper: Greenhouse, Lever, Ashby, Workday & More

> **Lite version** of [ATS Jobs Scraper: Greenhouse, Lever, Ashby, Workday & More](https://apify.com/cleanyield/ats-jobs-scraper), with no per-result charge: up to **25 results per run**, no monitor mode or alerts.
> Need more results, scheduled monitoring and alerts? Use the [full version](https://apify.com/cleanyield/ats-jobs-scraper) — you only pay for valid, complete results.

![Real results table from an Apify run of the pre-filled form: open jobs at OpenAI, Airbnb and Ramp with location, workplace type and posted salary](https://cleanyield-data.github.io/img/ats-jobs.png)

**For recruiters, sales teams and analysts: type company names and get every open job from their careers pages, with location, remote status, posting date and salary when posted.**

### How to use the ATS jobs scraper

1. Type company names, websites or job board URLs in **Companies** (for example `stripe`, `figma.com` or `ashby:ramp`).
2. Click **Start**. Optional filters: keywords, location, remote, department, posted within N days, salary.
3. Get one row per open job with title, location, remote or hybrid, posting date, apply link and the salary when the company posts it. Download it as JSON, CSV or Excel, or read it through the API.

▶️ **Click Start: the form is pre-filled with OpenAI, Airbnb and Ramp and finishes in ~5 seconds** (US jobs, filtered to the ones that post a salary).

![Animation built from a real run: the public Apify Store page (real screenshot), then the input of the pre-filled form, Start and the results of that run (rendered from the real run data, not screenshots of Apify Console)](https://cleanyield-data.github.io/img/ats-jobs-run.gif)

### What does the ATS Jobs Scraper do?

- **Recruiters:** see every new role at the companies you place candidates into, the day it opens, with the salary when it is posted.
- **Sales teams:** know which accounts are building the team you sell to right now (new sales, engineering or data roles are a buying signal you can quote in the first line).
- **Market and investment research:** hiring volume, locations and posted pay across a sector or a portfolio, read live from each company's own job board.

Every row is read when the run starts, straight from the company's careers page, so you only get jobs that are open now and belong to that company.

#### Example: what the pre-filled demo returns

Real output of the pre-filled demo, run on Apify on 2026-11-09 (24 jobs in 4 seconds; the demo asks only for jobs that post a salary, so all 24 have one):

| Company | Job title | Location | Workplace | Salary (annual, USD) | Posted |
|---|---|---|---|---|---|
| OpenAI | Senior Counsel, Commercial (Health and Life Sciences) | San Francisco | hybrid | $330,000 – $366,000 | 2026-11-09 |
| Airbnb | Senior Enablement Manager - API | United States | remote | $132,000 – $155,000 | 2026-11-09 |
| OpenAI | Account Director, Higher Education | San Francisco | hybrid | $305,000 – $352,000 | 2026-11-09 |
| Ramp | Manager, Account Executive, Strategic | Remote (US) | remote | $520,000 – $620,000 | 2026-11-07 |
| Ramp | Lead Counsel, Employment | New York, NY (HQ) | hybrid | $228,000 – $313,000 | 2026-11-06 |

One item from that run (shortened):

```json
{
  "jobId": "ashby:openai:6fc25168-bc4c-47a0-8601-583dfaf7fcbd",
  "ats": "ashby",
  "company": "OpenAI",
  "title": "Applied AI Engineer, Enterprise - Healthcare Life Sciences (HLS)",
  "department": "Go To Market",
  "employmentType": "full_time",
  "location": "San Francisco",
  "countryCode": "US",
  "allLocations": ["San Francisco", "New York City", "US - Remote"],
  "workplaceType": "hybrid",
  "salaryMin": 251000,
  "salaryMax": 278000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salarySource": "ats",
  "postedAt": "2026-11-06T22:33:48.426Z",
  "applyUrl": "https://jobs.ashbyhq.com/openai/6fc25168-bc4c-47a0-8601-583dfaf7fcbd/application",
  "companyDomain": "openai.com"
}
```

### Three ready-to-run examples

1. Click **Start**: the form is already filled in (OpenAI, Airbnb and Ramp, US jobs with a posted salary) and finishes in about 5 seconds.
2. Or open the **JSON** tab of the input, paste one of the inputs below and click **Start**.

#### 🧑‍💼 Recruiting: senior engineering roles opened in the last 14 days at 8 companies (US)

```json
{"companies": ["stripe", "figma", "databricks", "notion", "ramp", "anthropic", "airbnb", "scale ai"], "keywords": ["engineer"], "seniorities": ["senior", "lead"], "locations": ["United States"], "postedWithinDays": 14, "onlyWithSalary": false, "maxJobsPerCompany": 10}
```

Run on Apify on 2026-11-10: 23 jobs in 8 seconds (Anthropic 8, Databricks 6, Airbnb 6, Stripe 1, Ramp 1, Scale AI 1), 22 of them with a posted salary.

#### 📈 Sales: which accounts opened Sales roles in the last 14 days

```json
{"companies": ["airbnb", "ramp", "notion", "figma", "scale ai", "perplexity", "harvey", "cohere"], "departments": ["Sales"], "postedWithinDays": 14, "locations": [], "onlyWithSalary": false, "maxJobsPerCompany": 10}
```

With the full version this input returned 33 jobs on 2026-11-10 (Ramp 10, Notion 10, Airbnb 4, Figma 4, Scale AI 3, Perplexity 2). This Lite version returns the first 25; the [full version](https://apify.com/cleanyield/ats-jobs-scraper) returns them all and adds a hiring score and a "why now" line per company (Pro mode).

#### 📊 Market: posted pay for US software engineers at 12 AI and tech companies

```json
{"companies": ["openai", "anthropic", "scale ai", "databricks", "perplexity", "ramp", "notion", "figma", "stripe", "airbnb", "harvey", "cohere"], "keywords": ["software engineer"], "locations": ["United States"], "onlyWithSalary": true, "maxJobsPerCompany": 10}
```

With the full version this input returned 120 jobs on 2026-11-10 (the 10 newest per company, all with a posted salary). This Lite version returns the first 25; the [full version](https://apify.com/cleanyield/ats-jobs-scraper) returns all 120 and can be scheduled weekly with monitor mode.

### Which ATS it covers

| Hiring system (ATS) | What you can type | Notes |
|---|---|---|
| Greenhouse | company name, website, board URL or `greenhouse:<token>` | salary from Greenhouse pay ranges |
| Lever (US and EU) | company name, website, board URL or `lever:<token>` | salary ranges when posted |
| Ashby | company name, website, board URL or `ashby:<token>` | compensation tiers |
| Workday | the company website (e.g. `zoom.us`, `sanofi.com`; a Workday site the website does not link is used only when it names the website's exact domain, otherwise the company is reported as not found, free) or the board URL (e.g. `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`) | exact posting date read from each job page |
| Recruitee | company name, website or board URL | salary fields when posted |
| Personio | company name, website or board URL | |
| Teamtailor | company name, website or board URL | |
| Oracle Recruiting Cloud | the company website (e.g. `emerson.com`) or the site URL (`https://<tenant>.fa.<dc>.oraclecloud.com/hcmUI/CandidateExperience/en/sites/<site>`) | large retail, healthcare and industrial employers (Dollar General, Honeywell, Next, Mayo Clinic); salary when the post states it |
| Eightfold | the company website (e.g. `bostonscientific.com`) or the careers URL (`https://<company>.eightfold.ai/careers`, also on the company's own domain like `jobs.twilio.com/careers`) | Boston Scientific, Lockheed Martin, Bayer, Vale |
| Phenom | the company website (e.g. `lowes.com`) or the careers portal URL (`https://talent.lowes.com/us/en/search-results`) | Lowe's, TJX, CVS Health, Roche; newest jobs first |
| iCIMS | the company website (e.g. `atlassian.com`) or the iCIMS site URL (`https://<site>.icims.com/jobs`) | Atlassian; read from the site's sitemap and the job data each job page publishes, up to the 200 newest jobs per run; sites whose robots.txt asks robots to stay out are not read |
| SAP SuccessFactors (Career Site Builder) | the company website (e.g. `vestas.com`, `cemex.com`) or the careers site URL | Volvo Group, Novo Nordisk, PACCAR, Grifols; up to the 500 newest jobs. Old-style `careerN.successfactors.*` portals ask robots to stay out and are not read |
| Jibe (iCIMS career sites) | the company website (e.g. `costco.com`, `docusign.com`) or the careers site URL | Costco, Ulta Beauty, Booking.com, Schneider Electric, REI; up to 1,000 newest jobs |
| Radancy / TalentBrew | the company website (e.g. `ikea.com`, `ford.com`) or the careers site URL | UnitedHealth Group, Walgreens, Kaiser Permanente, Intuit; up to the 200 newest jobs per run (one page per job) |
| Deel, BambooHR, Breezy HR, Gem, Gupy | company website, board URL (`jobs.deel.com/<company>`, `<company>.bamboohr.com/careers`, `<company>.breezy.hr`, `jobs.gem.com/<company>`, `<company>.gupy.io`) or a bare name (Deel, BambooHR, Breezy) | Deel, Konfio, Embraer, sennder, Retool, Creditas |
| Company career site with schema.org job data | the company website (e.g. `lidl.com`, `gm.com`, `mercedes-benz.com`) | when the company's own careers site (its domain or a subdomain, never a job board) publishes each job for Google (JobPosting) in its sitemap; up to the 200 newest jobs per run |

#### How many companies it covers: two numbers

- **Fixed sample of 286 well-known companies** (mostly mid-size and large: Fortune 500, scale-ups, healthcare, industry and retail in the US, Europe and Latin America): it finds and reads the job board of **72.7%** (208 companies; version 1.1.53, 2026-11-11). We re-run this same list after every change, so the number is comparable over time: 39% → 47% (2026-11-10, Oracle, Eightfold, Phenom) → 55% → 71.7% (2026-11-11, SuccessFactors, Jibe, iCIMS, Radancy, Deel, BambooHR, Breezy, Gem, Gupy) → 72.7% (generic reader for career sites with schema.org JobPosting). Each company is checked with a real run from its website; a company that only worked from our own network and not from Apify is not counted.
- **Broader random sample of 1,000 companies** (drawn from Wikidata and Y Combinator, without picking the ones we already read: small, mid-size and large, US, Europe and Latin America; version 1.1.48, 2026-11-11): it reads **27.2%** of the 874 whose website responded, and **40.1%** of the 594 where a careers page or hiring system was found. By segment: about 55% of US mid-size and large companies, but 9.8% of small companies, 18% in Europe and 14.5% in Latin America (small companies rarely use a known hiring system, and many European and Latin American companies use local systems or their own HTML pages).

In short: it works best for mid-size and large companies, above all in the US. For small companies and for Europe and Latin America, expect a lower hit rate. Companies it can't read are listed as "not found" in the COMPANIES record and are not charged.

Not covered yet: SmartRecruiters (its API asks robots to stay out, so we do not read it), Taleo, Avature, Workable, old-style SuccessFactors portals and career sites that load jobs only with JavaScript. Companies on those systems are reported as "not found" in the COMPANIES record and are free. Need one of them? Open an issue.

### Use cases

- **Recruiting agencies**: watch the 200 companies you place candidates at and get every new role each morning.
- **Niche job boards**: feed your board with fresh postings from a curated list of employers, with salary and remote flags already normalized.
- **Sales intelligence ("is hiring" signal)**: know which accounts are opening engineering, data or sales roles this week (HIRING_SIGNALS), straight into Clay or your CRM.
- **Investors and analysts**: track open roles, departments and new locations of portfolio companies over time.
- **Job seekers and communities**: alerts for remote roles above a salary at your dream companies.

Get every open job posting of the companies you choose — a live **job postings API** straight from their career pages, read from the official public job board feeds of **Greenhouse, Lever, Ashby, Workday, Oracle Recruiting Cloud, Eightfold, Phenom, SuccessFactors, iCIMS (and its Jibe sites), Radancy, Recruitee, Personio, Teamtailor, Deel, BambooHR, Breezy, Gem and Gupy**, in one clean schema: structured salary (also as annual USD), city/region/ISO country, remote/hybrid/onsite, normalized employment type, seniority, years of experience, visa sponsorship, company website, domain and logo, exact ISO dates and the full description. Give it a company name, a website or a board URL — it finds the job board for you. Built for recruiting agencies, niche job boards, sales teams using "is hiring" as a buying signal, and investors tracking headcount. Also works as a **Greenhouse jobs scraper**, a **Lever postings API**, an **Ashby job board scraper**, a **Workday jobs scraper**, an **Oracle Recruiting Cloud (Oracle HCM) jobs scraper**, an **Eightfold jobs scraper**, a **Phenom careers site scraper**, a **SuccessFactors jobs scraper**, an **iCIMS jobs scraper**, a **Recruitee / Personio / Teamtailor / BambooHR / Breezy jobs API** and a **company careers page monitor**.

### Why use this ATS jobs scraper?

- ✅ **Only live, real job postings**: reads each company's career page when the run starts, so there is no indexing delay and **no expired jobs or other companies' jobs** (0 wrong rows in our head-to-head test of 2026-11-05, vs 11% in a typical job database).
- 🧩 **19 ATS, one schema, one Actor**: Greenhouse, Lever (incl. EU), Ashby, Workday, Oracle Recruiting Cloud, Eightfold, Phenom, SuccessFactors, iCIMS, Jibe, Radancy, Recruitee, Personio, Teamtailor, Deel, BambooHR, Breezy, Gem and Gupy — mix them in the same run and get the same fields for all. A posting listed on two boards of the same company is returned (and charged) once.
- 🌐 **Just give the website**: `figma.com`, `bunq.com` or `notion.so` is enough — the Actor follows the company's Careers link to its job board (or tries the name on each ATS). No need to know which ATS a company uses.
- 🧾 **Values from the source, not AI-guessed**: salary, department and apply URL come straight from the ATS fields; seniority, years and visa use fixed rules and stay `null` when the posting does not say it. Every job says where each value came from (`fieldSources`: hiring-system field, title or description), how sure it is (`salaryConfidence`, `seniorityConfidence`) and, for visa, the exact sentence (`visaEvidence`).
- 📏 **Exact limits and a clear report**: `maxResults` and `maxJobsPerCompany` return exactly what you ask (no hidden cap), and every company you send gets a status in COMPANIES (found, no open jobs, not found) — not-found companies are free.
- 💰 **Structured salary**: min/max, ISO currency, period, annualized values and **annual USD** (`salaryAnnualMinUsd`/`MaxUsd`, exchange rate of the day) from Greenhouse pay ranges, Lever salary ranges, Ashby compensation tiers and Recruitee salary fields (60% of 10,334 real jobs in our fixed test set have a salary, measured 2026-11-10: 47% straight from the ATS, 13% from an explicit range in the job text, all flagged with `salarySource`).
- 🧹 **Clean, normalized output**: same fields for every ATS, exact ISO 8601 publication dates (Workday's "Posted 3 days ago" is replaced by the real date from the job page), ISO country codes (96% of jobs), US/Canada state codes, `workplaceType` remote/hybrid/onsite, employment type normalized (`full_time`, `contract`, `internship`…) — also read from explicit phrases like "this full-time position" when the ATS has no field —, company domain on every job, stable `jobId`, deduplicated.
- 🔍 **Just type a name**: "Stripe", a website, a board URL, a careers page (the Actor finds the ATS link inside) or a token like `ashby:ramp`. Not-found companies are reported clearly and are free.
- 🎯 **Filters that work**: posted within N days or after an exact date (`postedAfter`), seniority (intern … executive), max years of experience (great for freshers), only jobs with salary, only jobs that sponsor visas, exclude countries — all read from the posting itself, never guessed.
- 🚀 **Pro mode (one checkbox)**: company hiring score 0–100, "hiring is accelerating" flag, a factual **"why now"** line for sales outreach, hiring trend since your first run, technologies mentioned and a one-sentence AI insight per job.
- 🔁 **Built for monitoring (full version only)**: schedule it and get only **new or changed** jobs, plus **closed jobs with the date they disappeared** (`closedAt`) and when you first saw them (`firstSeenAt`), with Slack/webhook alerts and a per-company hiring summary.
- ⚡ **Fast**: 87 live jobs from 4 companies in ~2.5 s end to end (measured 2026-11-06); 3,200 jobs from 8 big employers in ~9 s. Sync mode for Clay, n8n and Make.
- 🔌 **Drop-in replacement**: accepts the input field names of popular career-site job APIs and can return their output field names (`outputFormat: "leader-compatible"`). See "Migrating from other scrapers".
- 🤖 **AI-agent ready**: pay-per-result only (no usage fees), works through MCP without an Apify account.

#### This Actor vs typical alternatives

Measured head-to-head: the most-used job database in the Store, run on Apify on 2026-11-05 for 4 companies from our fixed test set (PostHog on Ashby, Outreach on Lever, Discord on Greenhouse, Linear on Ashby), against this Actor (version 1.2, re-measured on 2026-11-06 with the same input). Ground truth: each company's live public job board. Our full test set (101 real inputs) is in "Measured quality".

| Same 4 companies, same time | Typical alternative (job database, measured) | This Actor |
|---|---|---|
| Open jobs returned (all jobs on the live boards) | 63 of 85 (74%) — 0 of 8 at PostHog, 20 of 31 at Linear | **100% (85 of 85; 87 of 87 on 6/11)** |
| Rows that are wrong (closed jobs, or another company's jobs) | 8 of 71 (11%) | **0** |
| Salary matches the job post (38 comparable jobs) | 34 / 38 (AI-extracted) | **38 / 38 (ATS field / post text)** |
| Department filled | 0% | **100%** |
| Employment type / company domain filled | 100% / 100% (AI-guessed / derived) | **100% / 100% (ATS field or the post's own words)** |
| Work arrangement / experience / visa filled | **100% / 100% / 100% (AI-guessed)** | 86% / 80% / 0% (only when the post states it) |
| Useful fields filled (14 fields × every live job) | 62% | **86%** |
| Run time | **3 s (pre-indexed database)** | ~2.5 s locally, ~4 s on Apify (read live) |
| Cost per 1,000 useful jobs (Free plan) | USD 15 (list USD 12 + USD 0.01 per run) | **No per-result charge in this Lite version** (up to 25 jobs per run) · [full version](https://apify.com/cleanyield/ats-jobs-scraper): USD 2 per 1,000 today, USD 5 from Nov 24, 2026 |
| Your own list of companies (names, websites, URLs, careers pages) | partial (only indexed companies) | **✓, with clear not-found report (free)** |
| Monitor mode (only new/changed/closed, with closing date) + Slack/webhook | ✗ (time windows only) | [Full version](https://apify.com/cleanyield/ats-jobs-scraper) only |
| Annual salary in USD for any currency (when the job posts a salary) | ✗ | **✓ (rate of the day)** |
| Hiring score, "why now", trend per company | ✗ | **✓ (Pro mode)** |

#### Measured quality

We publish our own numbers, measured on a **fixed test set of 101 real inputs** (`testset/cases.json`: all 10 ATS, names, websites, URLs, filters, job sites and not-found cases) that every new version must pass before release (last run: 2026-11-10):

| Metric | Target | Measured |
|---|---|---|
| Successful runs | ≥ 99% | **100% (101/101)** |
| Items with every required field | ≥ 98% | **100% (10,446 items)** |
| Key fields correct vs the source | ≥ 99% | **100% (513/513 checks)** |

Independent check of the three newest systems on 2026-11-10: 80 jobs from 20 companies on Oracle Recruiting Cloud, Eightfold and Phenom compared one by one with the live portal, with title, location, posting date and link matching in 80 of 80. On Phenom a few jobs can be missed when paging (259 of 268 at Philips, 226 of 234 at Chewy).

Field coverage on 3,203 jobs from 8 large employers: country 97%, seniority 27% (only when the title says it), years of experience 57%, visa sponsorship stated 21%, company logo 100%, company website 59%, technologies 56% (Pro), language 100%. Salary: 57% of 8,955 jobs (44% from the ATS, 13% from an explicit range in the text). Every change is listed in [changelog](https://apify.com/cleanyield/ats-jobs-scraper/changelog).

### What data can you get from Greenhouse, Lever, Ashby, Workday, Recruitee, Personio and Teamtailor?

> **New: ATS-specific fields (one checkbox, no extra cost).** Turn on `includeAtsFields` to also get what only each ATS publishes: Greenhouse requisition ID, department path, offices and every pay range; Lever commitment, level and the requirement lists as bullets; Ashby compensation tiers with equity, commission and bonus; Workday requisition ID, exact posting date and time type.

| Field | Example | Source |
|---|---|---|
| `jobId` | `greenhouse:anthropic:5473216008` (stable: `<ats>:<token>:<id>`) | This Actor |
| `ats` / `company` / `companyToken` | `greenhouse` / `Anthropic` / `anthropic` (`ats`: greenhouse, lever, ashby, workday, recruitee, personio, teamtailor) | ATS board |
| `title`, `department`, `team` | `Scaled Account Manager, Beneficial Deployments`, `Sales` | ATS field |
| `employmentType` / `employmentTypeRaw` | `full_time` / `FullTime` | ATS field, or read from the title or text |
| `location`, `city`, `region`, `countryCode`, `allLocations` | `San Francisco, CA \| New York City, NY`, `San Francisco`, `CA`, `US`, `[...]` | ATS field; city, region and country deduced from it |
| `isRemote`, `workplaceType` | `false`, `onsite` | ATS field, or deduced from the location text |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | `222800`, `290000`, `USD`, `year` | ATS pay field, or an explicit range read from the text (`salarySource`) |
| `salaryAnnualMin`, `salaryAnnualMax`, `salaryText`, `salarySource` | `222800`, `290000`, `Annual Salary: USD 222,800–290,000`, `ats` | Deduced from the salary (annualized) |
| `salaryAnnualMinUsd`, `salaryAnnualMaxUsd` | `190908`, `241443` for a EUR 170,000–215,000 job (exchange rate of the run's day; same value when already USD) | Deduced: exchange rate of the run's day |
| `postedAt`, `updatedAt` | `2026-11-04T20:52:41.000Z` | ATS field (Workday: read from each job page) |
| `url`, `applyUrl`, `boardUrl` | job page, application page, company board | ATS |
| `descriptionText` / `descriptionHtml` | full description as clean text and/or HTML | ATS |
| `seniority` | `intern`, `entry`, `mid`, `senior`, `lead`, `director`, `executive` — from the title; `null` if the title does not say | Read from the title, or an ATS level field |
| `experienceYearsMin` | `5` from "5+ years of experience"; `null` if not stated | Read from the text, or an ATS field |
| `visaSponsorship` | `true` ("we sponsor visas"), `false` ("unable to sponsor"), `null` (not mentioned) | Read from the text |
| `visaEvidence` | the sentence behind `visaSponsorship`: `"We offer visa sponsorship for this role."` | The job text (exact sentence) |
| `fieldSources` | where each value comes from: `ats` (a field of the hiring system), `title` (read from the title) or `text` (read from the description), for `salary`, `employmentType`, `seniority`, `experienceYearsMin` and `visaSponsorship` | This Actor |
| `salaryConfidence`, `seniorityConfidence` | `high` (hiring-system field or explicit word like "Senior") / `medium` (salary read from the text, level number like "Engineer III") | This Actor (fixed rules) |
| `descriptionLanguage` | `en`, `es`, `de`, `fr`, `pt`, `it`, `nl` | Deduced from the text |
| `allCities`, `allCountryCodes` | every city and ISO country of the job: `["New York", "San Francisco"]`, `["US", "CA"]` | Deduced from the ATS locations |
| `companyWebsite`, `companyDomain`, `companyLogoUrl` | `https://ramp.com`, `ramp.com`, logo URL — from the company's own board, or the domain its own posts link to when it matches the company name | ATS board, or the domain the company's posts link to |
| **Pro mode:** `companyHiringScore`, `companyHiringAccelerating`, `companyOpenJobs`, `companyJobsPostedLast30Days`, `companyTrend`, `whyNow`, `techStack`, `insight` | `78`, `false`, `169`, `54`, trend since your first run, `"Ramp posted 54 new jobs in the last 30 days (169 open), most in Sales (22)."`, `["TypeScript", "React"]`, AI sentence | Deduced from the company's open jobs with fixed rules; `insight` written by AI |
| **With "Add company details":** `companyDetails` | email, phone, LinkedIn, X, country, website technologies | The company's own website |
| `changeType`, `changedFields` | monitor mode: `new` / `changed` (+ which fields) / `closed` | This run (monitor) |
| `closedAt`, `firstSeenAt` | monitor mode: when the job disappeared from the board, and when your monitor first saw it | This run (monitor history) |

**Source**: *ATS* = a field the company's hiring system publishes; *read from the title / text* = found in the job title or description with fixed rules, no AI; *deduced* = worked out from those values. Every job repeats this in `fieldSources`, with `salaryConfidence`, `seniorityConfidence` and, for visa, the exact sentence in `visaEvidence`.

### How much does it cost to scrape Greenhouse, Lever, Ashby and Workday jobs?

> **This Lite version has no per-result charge** (up to 25 results per run; only Apify's platform usage applies). The prices below are for the [full version](https://apify.com/cleanyield/ats-jobs-scraper).

Pay per result (pay per event), with no subscription or platform usage fees. Failed, incomplete or not-found results are free.

| What | Price (Free plan) |
|---|---|
| Each job returned | USD 0.002 (USD 2 per 1,000) today · USD 0.005 (USD 5 per 1,000) from Nov 24, 2026 |
| Each watched company checked in monitor mode | USD 0.004 |
| Run start | USD 0.005 |
| **Pro mode**: each job with hiring score, why now, trend, tech stack and AI insight (on top of the job price) | USD 0.005 |
| **Add company details**: each company with useful website data | USD 0.01 |

| Example | Cost today | From Nov 24, 2026 |
|---|---|---|
| 100 jobs | USD 0.21 | USD 0.51 |
| 1,000 jobs | USD 2.01 | USD 5.01 |
| 10,000 jobs | USD 20.01 | USD 50.01 |
| Monitor 50 companies daily, ~30 new jobs/day | ≈ USD 0.27/day (≈ USD 8/month) | ≈ USD 0.36/day (≈ USD 11/month) |

Apify subscribers get a lower price per job (tiers on the Pricing tab). Set **Maximum cost per run** and the Actor stops exactly there; set **Max jobs per company** to cap big employers.

**No surprises**: before the first request, the log tells you the price and the most this run can cost (e.g. "this run will cost at most USD 0.13 (60 results + extra events)"). Pro mode on 1,000 jobs = USD 7.01 in total today (USD 10.01 from Nov 24, 2026); still well below the USD 12 per 1,000 of typical job databases.

> **Switching from another job scraper or job postings API? Paste your current input as is.** Common field names (`organizationSearch`, `domainFilter`, `titleSearch`, `locationSearch`, `limit`, `timeRange`, `datePostedAfter`…) are translated automatically, and `outputFormat: "leader-compatible"` keeps the output field names your integration already reads. Full list in [Migrating from other scrapers](#migrating-from-other-scrapers).
>
> | Typical field | Here |
> |---|---|
> | company / organization / domain | `companies` (name, domain, board URL or careers page) |
> | title search / exclude | `keywords` / `excludeKeywords` |
> | location / exclude location | `locations` / `excludeLocations` |
> | limit | `maxResults` (exact, no hidden cap) |
> | time range / posted after | `postedWithinDays` / `postedAfter` (exact date) |
> | salary min / max / currency | `salaryMin` / `salaryMax` / `salaryCurrency` (from the ATS, not AI) |

### Limits

- **19 hiring systems**: Greenhouse, Lever, Ashby, Workday, Oracle Recruiting Cloud, Eightfold, Phenom, SuccessFactors, iCIMS, Jibe, Radancy, Recruitee, Personio, Teamtailor, Deel, BambooHR, Breezy, Gem and Gupy, plus career sites that publish schema.org job data. SmartRecruiters, Taleo, Avature and Workable are not covered yet; those companies come back as "not found" and are free. Workday, Oracle Recruiting Cloud, Phenom, SuccessFactors, iCIMS, Jibe and Radancy need the board URL or the company website (a bare name is not enough). Oracle Recruiting Cloud reads up to the 2,000 newest jobs per site, Eightfold and Jibe up to 1,000, Phenom and SuccessFactors up to 500, iCIMS, Radancy and schema.org career sites up to 200 per run. Some career sites ask in their robots.txt for a pause of several seconds between requests (Crawl-delay); we respect it, so those sites return fewer jobs per run, and the run message says how many were read and why. When the company also has a public job board on Greenhouse, Lever or Ashby that we can confirm as its own, that board is used instead.
- **Coverage depends on the company**: it reads 72.7% of our fixed sample of 286 well-known companies, but on a broader random sample of 1,000 companies it reads 40.1% of those with a careers page it could find (27.2% of all reachable ones), and less for small companies, Europe and Latin America (see [How many companies it covers](#how-many-companies-it-covers-two-numbers)).
- **Salary only when the company posts it**: 60% of 10,334 jobs in our fixed test set (2026-11-10). Seniority comes only when the title or the hiring system states it (27% of 3,203 jobs from 8 large employers) and visa sponsorship only when the post says it (21%).
- **Jobs open right now.** Closed jobs, with `closedAt`, appear only in monitor mode and only for jobs it saw in an earlier run.
- **No recruiter names or emails.**
- **Never charged:** companies not found and failed requests. The full version has a USD 0.005 start fee per run, and **Maximum cost per run** stops it exactly there.

### FAQ

#### Is it legal to scrape Greenhouse, Lever, Ashby, Workday, Oracle, Eightfold, Phenom, Recruitee, Personio and Teamtailor job boards?

The Actor only reads the job board feeds these ATS publish for exactly this purpose: Greenhouse says job board data "is publicly available, so authentication is not required"; Lever says published postings "may be scraped by third parties"; Ashby documents its public job posting API; Recruitee documents its public careers-site API; Personio publishes an XML feed of open positions for company websites and job portals; Teamtailor career sites publish an RSS feed; Workday, Oracle Recruiting Cloud and Eightfold career sites are read through the same public, login-free requests their own job pages make, and Phenom portals publish the jobs inside their public pages. SuccessFactors, iCIMS, Radancy, Deel and other career sites through their public search pages, sitemaps and the job data (schema.org JobPosting) they publish for Google; Jibe, BambooHR, Breezy, Gem and Gupy through the public JSON their own job pages use. Every request follows the site's robots.txt: paths it asks robots to skip are never requested (for example SuccessFactors' feed, UnitedHealth's search pages or old-style SuccessFactors portals), and its Crawl-delay is respected; on sites that ask for long waits, a run reads at most about 2 minutes of pages and says the list is partial. A company whose website asks robots not to read it comes back as not found, free. It never bypasses logins, captchas or blocks. It only collects what the company publishes in the posting (recruiter names are not extracted).

#### What happens if a company is not found or a request fails?

Not-found companies are listed in the **COMPANIES** record with a clear message (and a hint: paste the board URL or use a prefixed token) and **cost nothing**. Failed requests are retried automatically; if they still fail, the company is skipped and **you are not charged**. Every run stores a `RUN_STATS` record (successes, failures by reason).

#### Which companies are supported?

Any company with a public Greenhouse, Lever (including EU-hosted), Ashby, Workday, Oracle Recruiting Cloud, Eightfold, Phenom, Recruitee, Personio or Teamtailor job board. Workday, Oracle Recruiting Cloud, Eightfold and Phenom need the site URL or the company website (e.g. `emerson.com`, `bostonscientific.com`, `lowes.com`); the others work with a bare name too. ATS that block automated access or ask the robots to stay out are not covered; those companies come back as `notFound` for free.

#### A name exists on two ATS. Which one is used?

Greenhouse and Ashby are tried first (the board with more open jobs wins), then Lever, then Recruitee, Personio and Teamtailor; boards with no open jobs lose to boards with jobs. Alternatives are listed in COMPANIES. Use a prefixed token (`greenhouse:ramp`) to force one. If you list two boards of the same company, a posting that appears on both is returned once.

#### Why is `employmentType` sometimes null?

Greenhouse and Teamtailor feeds do not always publish an employment type. We fill it when the company adds it as a field, when the title says it (intern, contract, part-time) or when the post says it explicitly ("the base salary range for this full-time position…") — we never guess.

#### Will the output format change?

No. The output schema is stable and versioned (`schemaVersion: 3` since 1.2.0); fields are only added, never renamed, and every change is in [changelog](https://apify.com/cleanyield/ats-jobs-scraper/changelog).

#### Is any of this AI-generated?

Only the optional `insight` sentence in Pro mode (Claude Haiku, using only the job's data). Salary, seniority, years of experience, visa sponsorship and the hiring score come from the ATS or from explicit text in the posting, with fixed rules — when the posting does not say, the field is `null`.

#### Can I keep my company list between runs?

Yes: set **Saved list name** once. Next runs (and schedules) use the saved companies plus any you add.

#### Can I send the jobs to Google Sheets?

Yes: use the Make template "New jobs → Google Sheets" or the n8n "Is this company hiring? → Google Sheets" template in `templates/`, or Apify's Google Sheets integration on the dataset. Slack and webhooks are built in (monitor mode).

#### Is this an official Greenhouse, Lever, Ashby, Workday, Oracle, Eightfold, Phenom, Recruitee, Personio or Teamtailor product?

No. Not affiliated with or endorsed by any of them. The names are used only to describe where the public job data comes from.

#### Is there a free version or a free trial?

This Lite version has no per-result charge: up to 25 results per run, and only Apify's platform usage applies. For more results, monitor mode and alerts, the [full version](https://apify.com/cleanyield/ats-jobs-scraper) charges only for valid, complete results, and the monthly credit of Apify's free plan works there too.

### Related Actors: if you use this, you'll also like…

- [Company Enrichment from Website: Emails, Phones & Tech](https://apify.com/cleanyield/company-enrichment-from-website) — found who is hiring? Get the company's emails, phones, social profiles and tech stack from its website, to reach out.

Every Clean Yield Actor has the same rules: one clean row per result, you only pay for valid results, and a Lite version with no per-result charge to try it first. All of them: [apify.com/cleanyield](https://apify.com/cleanyield).

### Support

Found a bug or need a feature? Open an issue in the **Issues** tab: we usually answer within 12 hours. Need a custom version (another source, extra fields, a different output format)? Describe it in an issue and we will tell you if we can build it.

Did this Actor help you? A short review on its Apify page helps other users find it (and tells us what to improve).

### Technical documentation

Everything below is reference: a complete output item, monitor mode, Pro mode, hiring signals, every input field, migration from other tools, use inside your own Actor, code examples and AI agents.

### Output example

Real item from a run on 2026-11-06 (description shortened here; EUR salary also converted to annual USD):

```json
{
  "jobId": "greenhouse:anthropic:5471118008",
  "ats": "greenhouse",
  "company": "Anthropic",
  "companyToken": "anthropic",
  "atsJobId": "5471118008",
  "title": "Business Recruiter",
  "department": "People",
  "team": null,
  "employmentType": null,
  "employmentTypeRaw": null,
  "location": "Dublin, IE",
  "city": "Dublin",
  "region": null,
  "countryCode": "IE",
  "allLocations": [
    "Dublin, IE"
  ],
  "isRemote": false,
  "workplaceType": "onsite",
  "salaryMin": 170000,
  "salaryMax": 215000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salaryAnnualMin": 170000,
  "salaryAnnualMax": 215000,
  "salaryText": "Annual Salary: EUR 170,000–215,000",
  "salarySource": "ats",
  "salaryAnnualMinUsd": 190908,
  "salaryAnnualMaxUsd": 241443,
  "postedAt": "2026-11-04T18:40:55.000Z",
  "updatedAt": "2026-11-04T20:30:04.000Z",
  "url": "https://job-boards.greenhouse.io/anthropic/jobs/5471118008",
  "applyUrl": "https://job-boards.greenhouse.io/anthropic/jobs/5471118008",
  "boardUrl": "https://job-boards.greenhouse.io/anthropic",
  "descriptionText": "About Anthropic\n\nAnthropic’s mission is to create reliable, interpretable, and steerable AI systems. We want AI to be sa […]",
  "descriptionHtml": null,
  "seniority": null,
  "experienceYearsMin": 4,
  "visaSponsorship": true,
  "descriptionLanguage": "en",
  "allCities": [
    "Dublin"
  ],
  "allCountryCodes": [
    "IE"
  ],
  "companyWebsite": "https://www.anthropic.com/jobs",
  "companyDomain": "anthropic.com",
  "companyLogoUrl": "https://s8-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/040/300/original/2025-04-07-greenhouse.png?1744052732",
  "techStack": null,
  "companyHiringScore": null,
  "companyHiringAccelerating": null,
  "companyOpenJobs": null,
  "companyJobsPostedLast30Days": null,
  "companyTrend": null,
  "whyNow": null,
  "insight": null,
  "companyDetails": null,
  "closedAt": null,
  "firstSeenAt": null,
  "scrapedAt": "2026-11-06T04:48:23.036Z",
  "schemaVersion": 3
}
```

With **Pro mode** the same job also carries (real values from 2026-11-04):

```json
{
  "companyHiringScore": 80,
  "companyHiringAccelerating": false,
  "companyOpenJobs": 682,
  "companyJobsPostedLast30Days": 194,
  "companyTrend": null,
  "whyNow": "Anthropic posted 194 new jobs in the last 30 days (682 open), most in Sales (34).",
  "techStack": [],
  "insight": "One-sentence conclusion written only from this job's data (needs the AI to be configured)."
}
```

### Schedule it: monitor job openings and get only what changed

> 🔒 **Full version only.** Not included in this Lite version: [open the full version](https://apify.com/cleanyield/ats-jobs-scraper).

1. Turn on **Monitor mode** (optionally give it a **Monitor state name**, e.g. `my-watchlist-daily`).
2. Optional: **First run: save baseline only** to be alerted only about jobs posted from now on.
3. Add a **Slack webhook** or a **webhook URL** (Zapier, Make, n8n — use it to send emails too).
4. Open **Schedules** → **Create schedule** → daily or weekly → select this Actor with your input.

Each run compares every company with its own previous state and outputs only new or changed jobs (`changeType`: `new` or `changed`, with `changedFields` such as `salaryMax` or `location`). Turn on **Also report closed jobs** to get `closed` items too. A company that fails to load in one run never "closes" its jobs, and you can add companies to the list without resetting the others.

### Pro mode: hiring score, "why now" and trend

> 🔒 **Full version only.** Not included in this Lite version: [open the full version](https://apify.com/cleanyield/ats-jobs-scraper).

Tick **Pro mode** and every job gets company-level hiring intelligence that no single snapshot gives you:

- **`companyHiringScore` (0–100)** — easy to sort. 40 points for volume (open jobs, log scale, 300+ = full), 35 for freshness (share of openings posted in the last 30 days, 50%+ = full), 15 for breadth (departments with new openings, 5+ = full), 10 for growth since your first run (neutral 5 until there is history).
- **`companyHiringAccelerating`** — `true` when at least 5 jobs and 40% of the openings were posted in the last 30 days, or open jobs grew 20%+ (and by 3+) since your first run.
- **`whyNow`** — one factual line for outreach: *"Ramp posted 54 new jobs in the last 30 days (169 open), most in Sales (22)."*
- **`companyTrend`** — open jobs then vs now since your first Pro run (up to 90 days). History is stored in **your** account (key-value store `ats-jobs-history`) and grows with every run.
- **`techStack`** — technologies named in the job (about 70: Python, Go, React, AWS, Snowflake, Salesforce…), fixed dictionary, no guessing.
- **`insight`** — one sentence written by AI (Claude Haiku) **only from the job's data**, e.g. what stands out about pay, seniority or the company's hiring burst.

Runs without Pro end with an honest line saying what Pro would have added (e.g. "2 companies accelerating their hiring"). No tricks: the default run stays cheap.

**Add company details** (separate checkbox): reads each hiring company's own website once and adds `companyDetails` (primary email and phone, LinkedIn and X, country, website technologies). Companies without useful data are free.

Every run also saves a free **dashboard page** (`DASHBOARD` in the key-value store): open jobs by company, hiring score, departments, countries, seniority and the highest-paying jobs. Its link is in the `SUMMARY` record.

### Hiring signals per company (monitor mode)

> 🔒 **Full version only.** Not included in this Lite version: [open the full version](https://apify.com/cleanyield/ats-jobs-scraper).

Every monitor run stores **HIRING_SIGNALS** in the key-value store and sends it with your alert: for each watched company, open jobs, how many were opened/changed/closed since the last run, new jobs by department and **new locations** (e.g. "Ramp (ashby): 4 new · 169 open · Engineering +3 · new locations: Miami, FL"). That is a change over time that a single snapshot — or passing one JSON through your own AI model — cannot give you. Included at no extra cost.

### Input example and configuration

#### Input example (JSON)

```json
{
  "companies": ["anthropic", "https://jobs.lever.co/spotify", "jobs.ashbyhq.com/ramp"],
  "maxJobsPerCompany": 20,
  "includeDescription": "text"
}
```

#### Configuration: all input fields

| Field | Description |
|---|---|
| `companies` | One per line: name (Stripe), website (figma.com), job board URL (job-boards.greenhouse.io/x, jobs.lever.co/x, jobs.eu.lever.co/x, jobs.ashbyhq.com/x, x.recruitee.com, x.jobs.personio.de, x.teamtailor.com, tenant.wd5.myworkdayjobs.com/site, tenant.fa.dc.oraclecloud.com/hcmUI/CandidateExperience/en/sites/site, x.eightfold.ai/careers, a Phenom portal like careers.x.com/us/en/search-results), careers page URL, or prefixed token (`greenhouse:x`, `lever:x`, `lever-eu:x`, `ashby:x`, `recruitee:x`, `personio:x`, `teamtailor:x`). Bare names are tried on Greenhouse and Ashby, then Lever, then Recruitee, Personio and Teamtailor; Workday, Oracle Recruiting Cloud, Eightfold and Phenom need the site URL or the company website. |
| `maxJobsPerCompany` | Max jobs per company after filters, newest first. 0 = all. |
| `maxResults` | Max jobs in total for the run. 0 = no limit. |
| `keywords` / `keywordScope` / `excludeKeywords` | Title words to keep (or title + description) and title words to drop. |
| `locations` | City, state code, country name or ISO code, or `remote`; matches every location of the job. |
| `workplaceTypes` | `remote`, `hybrid`, `onsite`. |
| `departments` | Text contained in the department or team. |
| `employmentTypes` | `full_time`, `part_time`, `contract`, `internship`, `temporary`, `other`. |
| `postedWithinDays` | Only jobs published in the last N days. |
| `postedAfter` | Only jobs published on or after an exact date or time (`2026-10-01`, `2026-10-01T09:00:00Z`) or a relative time (`48 hours`, `7 days`). |
| `minSalary` / `salaryCurrency` / `includeJobsWithoutSalary` | Minimum annual salary in a currency (compared in that currency; use `salaryAnnualMinUsd` in the output to compare across currencies). |
| `onlyWithSalary` | Only jobs that publish a salary. |
| `excludeLocations` | Drop jobs whose locations are ALL in these places (e.g. `India`). |
| `seniorities` | `intern`, `entry`, `mid`, `senior`, `lead`, `director`, `executive` (from the title). |
| `maxExperienceYears` | Drop jobs asking for more than N years (jobs that do not say are kept). |
| `onlyVisaSponsorship` | Only jobs that explicitly say they sponsor visas. |
| `outputFormat` | `standard` or `leader-compatible` (field names of popular career-site job APIs). |
| `savedListName`, `saveList` | Remember your company list between runs. |
| `proMode` | Pro mode (see above). |
| `enrichCompanies` | Add company details from each company's website. |
| `includeDescription` | `text` (default), `html`, `both` or `none`. |
| `monitorMode`, `monitorStateName`, `includeClosedJobs`, `skipExistingOnFirstRun` | Monitor mode (see "Schedule it"). |
| `notifyWebhookUrl`, `notifySlackWebhookUrl` | Alerts when monitor mode finds changes. |

Every run also stores **COMPANIES** in the key-value store: one line per input company with status (`found`, `notFound`, `duplicate`, `error`), detected ATS, token, board URL, open jobs and a readable message — free.

### Migrating from other scrapers

Already using a career-site job API? Paste your input as it is: these field names are translated automatically (our own fields win if you send both), and `outputFormat: "leader-compatible"` returns the same output names, so your integration keeps working.

| Their input | Here |
|---|---|
| `organizationSearch`, `domainFilter` | `companies` (names, domains, board URLs) |
| `titleSearch` / `titleExclusionSearch` | `keywords` / `excludeKeywords` |
| `descriptionSearch` | `keywords` + `keywordScope: titleAndDescription` |
| `locationSearch` / `locationExclusionSearch` | `locations` / `excludeLocations` |
| `limit` | `maxResults` |
| `timeRange` (`24h`, `7d`, `6m`) | `postedWithinDays` (1, 7, 183) |
| `datePostedAfter`, `posted_after`, `postedSince` | `postedAfter` (exact date) |
| `aiWorkArrangementFilter` | `workplaceTypes` |
| `aiEmploymentTypeFilter` | `employmentTypes` |
| `aiExperienceLevelFilter` (`0-2`, `2-5`, `5-10`) | `maxExperienceYears` |
| `hasSalary` / `aiVisaSponsorshipFilter` | `onlyWithSalary` / `onlyVisaSponsorship` |
| `includeCompanyDetails` | `enrichCompanies` |

| Their output | Here (standard) |
|---|---|
| `id`, `title`, `organization`, `url` | `jobId`, `title`, `company`, `url` |
| `organization_url`, `organization_logo`, `domain_derived` | `companyWebsite`, `companyLogoUrl`, `companyDomain` |
| `date_posted`, `date_modified` | `postedAt`, `updatedAt` |
| `locations_alt`, `cities_derived`, `countries_derived` | `allLocations`, `allCities`, `allCountryCodes` |
| `ai_salary_min_value` / `max_value` / `currency` / `unit_text` | `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` (from the ATS, not AI) |
| `ai_work_arrangement`, `ai_employment_type` | `workplaceType`, `employmentType` |
| `ai_experience_level`, `ai_visa_sponsorship`, `ai_key_skills`, `ai_job_language` | `experienceYearsMin`, `visaSponsorship`, `techStack` (Pro), `descriptionLanguage` |
| `description_text`, `description_html`, `source` | `descriptionText`, `descriptionHtml`, `ats` |

Not available here (by design): LinkedIn company data (headcount, industry), recruiter names and emails (personal data), AI summaries of responsibilities, and ATS that do not publish an open feed or that block automated access.

### For developers: use it inside your own Actor

Building an Actor, an agent tool or a pipeline that needs job data? Call this one:

- **Fast and synchronous**: one company in 2–6 s through `run-sync-get-dataset-items`.
- **Stable schema**: every item has `schemaVersion`; fields are only added, never renamed ([changelog](https://apify.com/cleanyield/ats-jobs-scraper/changelog)).
- **Clear price**: pay per valid job only, no usage fees; the Actor stops at your `maxTotalChargeUsd`.
- **Clear failures**: not-found companies are free and explained in `COMPANIES`; a run where no board could be read fails loudly instead of returning an empty dataset.

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const { items } = await client
    .actor('cleanyield/ats-jobs-scraper')
    .call({ companies: ['stripe', 'ashby:ramp'], seniorities: ['senior'], includeDescription: 'none' }, { maxTotalChargeUsd: 1 })
    .then((run) => client.dataset(run.defaultDatasetId).listItems());
```

### Usage examples: API, Python, JavaScript and integrations

Bulk input is fine: up to 5,000 companies per run, with polite per-host pacing (Lever is read 1 request/second as its robots.txt asks; Workday jobs are read with a few requests at a time), retries and your budget cap.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("cleanyield/ats-jobs-scraper").call(run_input={
    "companies": ["anthropic", "https://jobs.lever.co/spotify", "ashby:ramp"],
    "keywords": ["engineer"],
    "workplaceTypes": ["remote", "hybrid"],
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["company"], job["title"], job["salaryText"], job["url"])
```

#### JavaScript

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('cleanyield/ats-jobs-scraper').call({
    companies: ['anthropic', 'https://jobs.lever.co/spotify', 'ashby:ramp'],
    minSalary: 150000,
    salaryCurrency: 'USD',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((j) => `${j.company}: ${j.title} (${j.salaryText})`));
```

#### Sync mode (Clay, n8n, Make, HTTP)

One HTTP call returns the jobs directly (typically 2–6 s for one company):

```
POST https://api.apify.com/v2/acts/cleanyield~ats-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
Content-Type: application/json

{ "companies": ["stripe"], "maxJobsPerCompany": 50, "includeDescription": "none" }
```

#### n8n and Make

Ready-made templates in this Actor's repository folder `templates/`: **n8n** "New jobs at watched companies → Slack (daily)", **n8n** "Is this company hiring? → Google Sheets", **Make** "New jobs → Google Sheets", **Clay** "Is this company hiring?" HTTP column. Or use the official Apify node/app → **Run an Actor** → `cleanyield/ats-jobs-scraper`.

### Use with AI agents / MCP

This Actor charges only per result (no usage fees), so AI agents can run and pay for it through the [Apify MCP server](https://mcp.apify.com) without an Apify account.

Example requests to your assistant:

> "Which of these companies are hiring remote data engineers in the US right now, and what do they pay? Stripe, Ramp, Notion, Datadog, Spotify."

> "Find entry-level or intern engineering jobs that sponsor visas at OpenAI, Anthropic and Ramp."

> "Which of my 50 target accounts are accelerating their hiring this month? Use Pro mode and give me the 'why now' line for each."

Tips for agents: pass company names, board URLs or domains in `companies`; use `includeDescription: "none"` for short answers; every filter has a plain-English description in the input schema; `COMPANIES` explains companies that were not found.

# Changelog

This Actor's version history is a separate document: https://apify.com/cleanyield/ats-jobs-scraper-lite/changelog.md

# Actor input Schema

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

One company per line. Accepted: a company name (Stripe, Scale AI), the company website (figma.com — the Actor follows its Careers link to the job board), a job board URL (https://job-boards.greenhouse.io/anthropic, https://jobs.lever.co/spotify, https://jobs.eu.lever.co/<company>, https://jobs.ashbyhq.com/ramp, https://bunq.recruitee.com, https://<company>.jobs.personio.de, https://<company>.teamtailor.com, https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, https://<tenant>.fa.<dc>.oraclecloud.com/hcmUI/CandidateExperience/en/sites/<site>, https://<company>.eightfold.ai/careers, a Phenom careers portal such as https://talent.lowes.com/us/en/search-results), the company's own careers page (https://www.figma.com/careers), or a prefixed token (greenhouse:stripe, lever:palantir, lever-eu:<company>, ashby:openai, recruitee:bunq, personio:<company>, teamtailor:<company>). For a bare name the Actor tries Greenhouse and Ashby first, then Lever, then Recruitee, Personio and Teamtailor. Workday, Oracle Recruiting Cloud, Eightfold and Phenom sites need their URL or the company website (emerson.com, bostonscientific.com, lowes.com). Example: \["anthropic", "https://jobs.lever.co/spotify", "ashby:ramp"]. Can be left empty when you use a saved list (see "Saved list name").

## `savedListName` (type: `string`):

Give your company list a name (e.g. "my-target-accounts") and the Actor remembers it: next runs and schedules use the saved companies plus any you add here. Stored in your own Apify account (key-value store "saved-lists"). Leave empty to use only the companies above.

## `saveList` (type: `boolean`):

With a saved list name: add the companies of this run to the saved list. Turn off to use the saved list without changing it.

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

Maximum jobs returned per company after filters, newest first. 0 = all open jobs. Use it to cap cost on big employers (some have 800+ open jobs). Example: 50.

## `maxResults` (type: `integer`):

Stop after this many jobs in total across all companies. 0 = no limit. You pay only for jobs actually returned. Example: 1000.

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

Keep only jobs whose title contains at least one of these words or phrases (case-insensitive; 'engineer' also matches 'Engineering'; words of 3 letters or less like 'AI' or 'QA' match whole words only). Leave empty for all jobs. Example: \["engineer", "data scientist"].

## `keywordScope` (type: `string`):

Where to look for the keywords: only the job title (precise, default) or the title and the full description (broader, e.g. to find every job that mentions 'Kubernetes').

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

Drop jobs whose title contains any of these words. Example: \["intern", "senior director"].

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

Keep jobs in any of these places: a city (London), a US state or region code (CA), a country name or ISO code (Germany, DE, United States) or the word 'remote'. Matches the main location and every additional location of the job. Example: \["United States", "London", "remote"].

## `excludeLocations` (type: `array`):

City, state code, country name or ISO code, or "remote". A job is dropped only when ALL its locations match (a job in "London | Remote US" stays if you exclude UK). Example: \["India"].

## `workplaceTypes` (type: `array`):

Keep only remote, hybrid and/or on-site jobs. Jobs whose ATS does not say the workplace type (and whose location does not mention it) are excluded when this filter is set. Example: \["remote"].

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

Keep jobs whose department or team contains any of these texts (case-insensitive). Example: \["engineering", "sales"].

## `employmentTypes` (type: `array`):

Keep only these employment types (normalized across ATS): full_time, part_time, contract, internship, temporary, other. Jobs with unknown type are excluded when this filter is set. Example: \["full_time"].

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

Keep only jobs published in the last N days (by the ATS publish date). 0 = any date. Example: 7.

## `postedAfter` (type: `string`):

Keep only jobs published on or after this exact date or time (ISO 8601, e.g. 2026-10-01 or 2026-10-01T09:00:00Z), or a relative time like "48 hours" or "7 days". Jobs without a publish date are left out. Empty = any date.

## `minSalary` (type: `integer`):

Keep only jobs whose published salary range reaches at least this amount per year (hourly and monthly pay are annualized). Compared in the currency below, without conversion. Jobs without a published salary are excluded unless you tick the next option. 0 = no salary filter. Example: 150000.

## `salaryCurrency` (type: `string`):

ISO 4217 currency of the minimum salary (USD, EUR, GBP, CAD…). Only jobs paid in this currency pass the salary filter. Example: USD.

## `includeJobsWithoutSalary` (type: `boolean`):

With a minimum salary set: also keep jobs that do not publish a salary.

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

Keep only jobs that publish a salary (structured from the ATS or an explicit range in the job text).

## `seniorities` (type: `array`):

Keep only these levels, read from the job title: intern, entry (junior, new grad, I), mid (II, intermediate), senior (senior, III), lead (staff, principal, lead), director (director, head of), executive (VP, chief). Titles without a level are excluded when this filter is set. Example: \["intern", "entry"] for students and freshers.

## `maxExperienceYears` (type: `integer`):

Drop jobs that ask for MORE than N years of experience (read from phrases like "5+ years of experience"). Jobs that do not say are kept. Example: 2 for freshers and early-career.

## `onlyVisaSponsorship` (type: `boolean`):

Keep only jobs whose text explicitly says visa sponsorship is offered ("we sponsor visas", "visa sponsorship is available").

## `includeDescription` (type: `string`):

Include the full job description as clean plain text (default, best for AI and spreadsheets), as the original HTML, both, or none (smaller output).

## `outputFormat` (type: `string`):

standard = this Actor's fields (recommended). leader-compatible = the field names used by the most popular career-site job APIs on the Store (title, organization, date_posted, locations_alt, countries_derived, ai_salary_min_value, ai_work_arrangement, description_text…) so you can switch without changing your integration. Values still come from the ATS, not from AI.

## `includeAtsFields` (type: `boolean`):

Also return the fields only each ATS publishes (no extra cost): Greenhouse requisition ID, department path, offices, every pay range and custom fields; Lever commitment, level and the posting's requirement lists as bullets; Ashby compensation tiers with equity, commission and bonus, and secondary locations; Workday requisition ID, exact posting date, time type and hiring entity. Off = the standard fields only (same output as before).

## `proxyConfiguration` (type: `object`):

Not needed: these ATS publish their job board feeds openly, so the Actor connects directly (cheaper and faster). Only enable a proxy if your network requires one. Example: {"useApifyProxy": false}.

## Actor input object example

```json
{
  "companies": [
    "anthropic",
    "https://jobs.lever.co/spotify",
    "ashby:ramp"
  ],
  "savedListName": "my-target-accounts",
  "saveList": true,
  "maxJobsPerCompany": 50,
  "maxResults": 1000,
  "keywords": [
    "engineer",
    "product manager"
  ],
  "keywordScope": "title",
  "excludeKeywords": [
    "intern"
  ],
  "locations": [
    "United States",
    "London"
  ],
  "excludeLocations": [
    "India"
  ],
  "workplaceTypes": [
    "remote"
  ],
  "departments": [
    "engineering"
  ],
  "employmentTypes": [
    "full_time"
  ],
  "postedWithinDays": 7,
  "postedAfter": "2026-10-01",
  "minSalary": 150000,
  "salaryCurrency": "USD",
  "includeJobsWithoutSalary": false,
  "onlyWithSalary": true,
  "seniorities": [
    "senior",
    "lead"
  ],
  "maxExperienceYears": 2,
  "onlyVisaSponsorship": false,
  "includeDescription": "text",
  "outputFormat": "standard",
  "includeAtsFields": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All valid results of this run (only these are charged). JSON, CSV or Excel from the dataset.

## `runStats` (type: `string`):

RUN_STATS: results saved, failures by reason (not charged), retries and success rate.

## `dashboard` (type: `string`):

DASHBOARD: a shareable HTML page with charts and rankings for this run.

# 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": [
        "openai",
        "airbnb",
        "https://jobs.ashbyhq.com/ramp"
    ],
    "maxJobsPerCompany": 8,
    "locations": [
        "United States"
    ],
    "onlyWithSalary": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cleanyield/ats-jobs-scraper-lite").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": [
        "openai",
        "airbnb",
        "https://jobs.ashbyhq.com/ramp",
    ],
    "maxJobsPerCompany": 8,
    "locations": ["United States"],
    "onlyWithSalary": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("cleanyield/ats-jobs-scraper-lite").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": [
    "openai",
    "airbnb",
    "https://jobs.ashbyhq.com/ramp"
  ],
  "maxJobsPerCompany": 8,
  "locations": [
    "United States"
  ],
  "onlyWithSalary": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call cleanyield/ats-jobs-scraper-lite --silent --output-dataset

```

## MCP server setup

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

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/EQidXOUtz5fD99Xuh/builds/QP9AyCNj0AkbzYccK/openapi.json
