# Company Career Page Jobs Scraper: Greenhouse, Lever, Workday (`fetchwright/lever-jobs-scraper`) Actor

Company career page jobs: the job openings of the companies you name, live from their Lever, Greenhouse, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor boards: title, location, pay where published, link. Input: board links or names. $1.00 per 1,000 jobs on Free, $0.70 on Business.

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

## Pricing

from $0.70 / 1,000 jobs

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

### What does Company Career Page Jobs Scraper do?

**Company Career Page Jobs Scraper** returns the open jobs of the companies you name, read live from their own career-site job boards on Lever, Greenhouse, Ashby, Workable, Workday, Recruitee, Personio and Teamtailor, at **$1.00 per 1,000 jobs** on the Free plan ($0.70 to $0.90 on paid plans). You give it board links or company names, or a keyword to find boards by a web search; it reads those companies live from each company's own board during the run, not from a stored index of every employer's career site. A named watch, one run at a time, can return only the openings that are new since its last run, as a hiring signal. Each row gives the title, department, locations, remote flag, employment type, the pay range when the employer publishes it, the posting date and the apply link. A company name with no jobs found on Greenhouse, Lever, Ashby or Workable can also be looked for on Workday (within 20 web searches per run, shared with keyword searches; nothing charged for the lookup), and with descriptions on, supported English-language pay ranges may be extracted from Workday job descriptions.

#### Your first check

1. Open the example task [New jobs watch: daily only-new jobs at your companies](https://apify.com/fetchwright/lever-jobs-scraper/examples/new-jobs-daily-watch), or paste your own companies' career-board links (such as `https://jobs.lever.co/spotify`) or names.
2. Keep **Only new jobs** on, run once to get and remember today's openings, then schedule it daily (one run of the watch at a time): each later run returns only newly appearing jobs, including jobs that closed and reopened.
3. That task saves up to 300 jobs from 3 companies: at most **$0.30 on the Free plan** and **$0.21 on Business** ($1.00 / $0.70 per 1,000 jobs), plus Apify's start fee of $0.00005 per run; later daily runs (one run of the watch at a time) cost the new jobs plus that start fee.&#x20;

One job, as saved by a run on 15 November 2026 (abridged):

| title | location | workplaceType | department | postedAt |
| --- | --- | --- | --- | --- |
| Senior Director, Global Advertising Product Marketing | New York, NY | hybrid | Advertising | 2026-11-10 |

**Update 2026-11-15:** Optional Google Jobs search is available on paid plans. US only for now (non-US not measured).&#x20;

#### Google Jobs search

Select **Google Jobs** in **Systems to search**, enter **Find boards by keyword** terms such as `software engineer`, and optionally set **Location for the keyword search** to `Austin,Texas,United States`. The default search systems remain the career sites; Google Jobs is opt-in and paid plans only. Local runs and Free-plan runs show “Google Jobs search is available on paid Apify plans” and continue with the career-site work requested.&#x20;

Google Jobs: **US only for now** (non-US not measured). A supplied location must end in `United States`, `US` or `USA`; an empty location uses US results without a city preference. Google Jobs does **not provide job highlights, related links or a company logo** in this option. Its returned posting age is text, and the number collected is not Google's total.&#x20;

Google Jobs rows include `source: "google_jobs"`, `companyName`, `applyUrl`, `applyOptions`, `googleJobsUrl`, `postedText`, `employmentTypes`, `salaryText` when supplied, `benefits` (published labels) and `via`. Turn on **Include descriptions** to include description text. Career-site rows identify their system in `system`; runs selecting Google Jobs also include `source`. Within Google Jobs, results are deduplicated by Google `job_id`; up to 20 distinct application-link aliases per ID are retained in first-seen order across search terms and restarts (including application choices); later aliases are omitted. Watch memory remembers returned Google job IDs across runs, including when a company name changes.&#x20;

Google Jobs rows that may duplicate a career-site posting are **kept**, flagged in `possibleDuplicateOf` and **charged as separate rows**. The flag contains the career-site row's job URL when a retained Google application link equals that career row's job or apply URL in the same run, with company names equal after case and whitespace folding; otherwise it is `null`. URL comparison removes `utm_*` and tracking parameters (`gclid`, `dclid`, `fbclid`, `msclkid`, `gbraid`, `wbraid`, `mc_cid`, `mc_eid`, `gh_src`), fragments and trailing slashes. Scheme, path case and other query values remain significant. Titles and locations do not affect the flag. Shared and generic URLs can produce a flag; it is a possible overlap, not a confirmed duplicate. Both rows retain their own application choices. The summary reports `flaggedPossibleDuplicates` and repeated Google IDs skipped.&#x20;

To exclude flagged rows from exported data, filter `possibleDuplicateOf` is null (`possibleDuplicateOf == null`, or blank in CSV); saved rows remain charged. To avoid collecting these possible overlaps, do not select `google_jobs` together with career-site systems or list career-site boards in that Google Jobs run. Career-site rows are not skipped because of Google rows, and Google rows are not skipped because of career-site rows. Shared run job and charge caps still apply; company allowances are separate for career boards and Google company names.&#x20;

**Maximum jobs per company** (`maxJobsPerCompany`) limits career-site jobs **per canonical career board**: system plus lower-case board identity, with or without `google_jobs` selected. Different hiring entities on one board share its allowance; separate boards keep separate allowances even if their company names match. Personio's `.de` and `.com` addresses for the same company share one board allowance. Google Jobs has its own limit per company name Google writes, after case and whitespace folding. `Acme` and `Acme Inc.` have separate Google allowances; employer identity is not inferred. Google rows do not consume or block career-site allowances. An exhausted Google name does not take a slot from another eligible Google name. Leave empty for no per-company limit.&#x20;

The existing job price applies, with no separate Google Jobs fee: a saved row uses the existing job event once; repeated Google IDs are not saved or charged again. **Maximum jobs per run** and the run's **maximum charge** apply across both sources. Three consecutive Google Jobs failures stop further Google Jobs searches with partial status; career-site results can proceed. The search also stops on access refusal or exhausted search capacity.&#x20;

Google Jobs searches read up to the available row allowance (the smaller of the remaining job cap and charge allowance). The request allowance, including retries, is three times the row allowance divided by ten, rounded up; a search reaching it reports capped coverage. Buffered search data is capped at 8 MiB; reaching that cap is counted in the summary and stops collection. Search answers and a request in progress are saved with the run: a restart reuses recorded answers, and a request without a recorded answer stops further Google Jobs calls. Watch memory treats Google Jobs as partial search results, so it does not infer job closures from them.&#x20;

[![Company Career Page Jobs Scraper: open jobs live from the employer's own Lever, Greenhouse or Ashby board, $1.00 per 1,000 jobs on the Free plan](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-ats-hero-v1.png)](https://apify.com/fetchwright/lever-jobs-scraper)

Try a ready-made example: [every open job at Stripe (Greenhouse)](https://apify.com/fetchwright/lever-jobs-scraper/examples/greenhouse-jobs-api-stripe) · [OpenAI roles with pay ranges (Ashby)](https://apify.com/fetchwright/lever-jobs-scraper/examples/ashby-jobs-openai-pay-ranges) · [Spotify's open jobs (Lever)](https://apify.com/fetchwright/lever-jobs-scraper/examples/lever-jobs-spotify) · [a daily new-jobs watch](https://apify.com/fetchwright/lever-jobs-scraper/examples/new-jobs-daily-watch).

**Built for** recruiters and sourcers watching target companies, sales teams using hiring as a buying signal, job boards and newsletters that need direct-from-employer listings, market and salary researchers, and developers and AI agents that need live job data through an API. Try the prefilled example: it returns the 30 newest jobs at each of Airbnb, Spotify and Ramp.

| What you get | Details |
| --- | --- |
| 🏢 Name the companies | A job board link such as `https://jobs.ashbyhq.com/ramp` or `https://aaff.recruitee.com`, a name with its system such as `greenhouse:airbnb`, `personio:ottonova` or `teamtailor:pasqal`, a bare company name, looked up on Greenhouse, Lever, Ashby and Workable and, when none of them has its jobs, on Workday, or a keyword such as `data engineer` to find boards by a web search. There is no directory of every company: boards you do not name are found only by that search |
| 📋 One row per job | Title, department, team, locations, country, workplace type, remote flag, employment type, posted and updated dates, job and apply links |
| 💵 Pay when published | Minimum, maximum, currency and interval, with the range as written where the board gives it; on Workday, supported English-language ranges may be read from the job description when descriptions are on, on Recruitee from its own pay fields. This Actor does not return pay for Workable, Personio or Teamtailor |
| 🔎 Filters | Title keywords (in titles, or titles and descriptions) and excluded words, locations, departments, seniority, remote only, workplace (remote, hybrid, on-site), employment type, salary range, posted or updated since |
| 💰 A cost you set | A hard cap per run and per company, and the run's maximum charge checked before every row |
| 🔔 Only new jobs | With one run of the watch at a time, a named watch returns only jobs that appeared since its last run (older matches are not back-filled); an alert to Slack, Discord or a webhook when it finds some |
| 🧷 Safe watches | An answer that looks incomplete (no jobs, entries that are not jobs, repeated or missing IDs) never closes a watched job, and an answer that would close more than half of a board's remembered jobs (and more than 5) closes none until a second answer confirms it; closed jobs are listed free in `CLOSED_JOBS` |
| 🧾 A report per company | The run summary says, per company, how many jobs its board had, how many matched, were saved or left out, and why a company failed |
| 💾 Export anywhere | JSON, CSV, Excel, or through the API and MCP |

No account, login or key is needed: the Actor reads the public job boards the companies publish themselves.

### Why choose Company Career Page Jobs Scraper?

- **Live, not a copy.** Every run reads each company's board at the moment of the run (Ashby's answers can be up to a minute old), so a job closed this morning is not in your results and a job posted a few minutes ago is.
- **You never pay for more than you set.** Set **Maximum jobs per run**, **Maximum jobs per company**, or a maximum charge for the run in Apify: the run stops there and keeps what it saved.
- **Failures cost nothing and are explained.** A company without a board, a board that cannot be read, and jobs left out by your filters are not charged; the run summary lists each company with its reason.
- **Schedule it and get only new jobs, with one run of the watch at a time.** With **Only new jobs (watch)**, the first run returns up to your maximum of the newest matching jobs and remembers every job open on each board at that moment, also on boards it reads after your maximum is reached (read once, nothing saved or charged); with one run of the watch at a time, each later run returns only jobs that appeared after. Older matches are not back-filled. A board the watch has not read yet (because a run's maximum charge, its timeout or a failure stopped it first, or because you added the company later) gets its first read, up to your maximum, in the run that first reads it. With one run of the watch at a time, a job is not returned or charged again while it stays open on its board, also after you change the companies or filters of a named watch; a job that the employer closes and later reopens counts as new. Let one run finish before the next starts (Apify's schedule setting does this). Two runs of the same watch started within the same seconds can both proceed, and then the same job can be returned and charged in both.
- **Feed it from another Actor.** Give a dataset ID under **Companies from a dataset** and the Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor board links it recognizes are added to the company list.
- **No recruiter fields.** Recruiter, hiring-manager and contact fields are never returned, and e-mail addresses and phone numbers written in the usual formats are removed from descriptions. See [Does the output contain personal data?](#does-the-output-contain-personal-data)

#### What we measured

On 12 November 2026 at 05:21 UTC we read seven boards: Airbnb (207 open jobs) and Stripe (786) on Greenhouse, Palantir (303), Spotify (85) and Shield AI (665) on Lever, and OpenAI (821) and Ramp (176) on Ashby; at 08:42 UTC, Hugging Face (6) on Workable; at 09:31 UTC, on Workday, NVIDIA (which lists 2,000, the most a Workday site shows), Salesforce (1,573) and Adobe (256). Each board was read in 0.1 to 2.5 seconds; a Workday site answers 20 jobs at a time, in 1.1 to 2.0 seconds per list page. A pay range was published on 168 of Airbnb's 207 jobs, 554 of Shield AI's 665, 651 of OpenAI's 821 and 170 of Ramp's 176, and on none at Stripe, Palantir or Spotify.

Runs of this Actor on Apify the same day: the prefilled example saved 90 jobs, 30 from each board, in about 6 seconds; every open job at OpenAI with descriptions, 823 jobs, took 52 seconds at a peak of 117 MB of the default 512 MB of memory; a run with a maximum charge of $0.02 on a Starter-plan account ($0.90 per 1,000 jobs) stopped below its maximum, at $0.01985 for 22 jobs and the start event. A watch run twice on one board returned 40 jobs, then none, with all 85 jobs on the board skipped uncharged the second time. An alert from a run was delivered to a webhook receiver (HTTP 200); the Slack and Discord message formats are covered by automated tests only, not by a delivery into a live channel.

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

**$1.00 per 1,000 jobs on the Free plan, $0.70 to $0.90 on paid plans.** You pay per job saved, platform usage is included, and there is no monthly rental.

| Your Apify plan | Price per 1,000 jobs |
| --- | --- |
| Free | $1.00 |
| Starter (Bronze) | $0.90 |
| Scale (Silver) | $0.80 |
| Business (Gold) and above | $0.70 |

Every run also has Apify's start event, charged when the run starts, whatever it saves: $0.00005 for a run with up to 1 GB of memory (the default is 512 MB). Descriptions, pay ranges, alerts and filters are included in the price per job.

**Never charged** (only the run's start event applies): a company without a board, a board that refuses or fails, jobs left out by your filters or by your maximum per company, jobs a watch already saw (with one run of the watch at a time), a job found twice in one run, and anything a run did not reach because of your maximum, your maximum charge or the timeout. What was not finished is listed under `unfinishedTargets` and `failedTargets` in the `SUMMARY` record.

What typical jobs cost:

| Job | Jobs | Cost on Free | Cost on Gold |
| --- | --- | --- | --- |
| The prefilled example: 30 jobs at each of three companies | 90 | $0.09 | $0.06 |
| Every open job at one large employer | about 800 | about $0.80 | about $0.56 |
| 1,000 jobs across your target list | 1,000 | $1.00 | $0.70 |
| Daily watch on seven large employers, maximum 100 per run: the first run (the other open jobs on all seven boards are remembered, not charged) | 100 | $0.10 | $0.07 |
| The same watch afterwards | only jobs that appeared since the previous run, with one run of the watch at a time | see below | see below |

A watch's first run returns up to your maximum of the newest matching jobs and remembers the rest without charging them, on every board it reads; with one run of the watch at a time, later runs cost only the new jobs. How many appear depends on the companies. On the seven boards read on 12 November 2026, 887 of the 3,043 open jobs had been first posted from 13 October to 12 November. That counts only jobs still open on that day, so it is a lower bound on what those boards posted in 30 days, not a forecast; if they kept that pace, a daily watch on them would save at least 887 jobs a month, about $0.89 on Free. Apify's free plan includes $5 of credit each month, which is about **5,000 jobs** with this Actor.

#### How does the price compare?

Free-plan prices of the three actors with the most monthly users among the results of an Apify Store search for "lever jobs" on 12 November 2026, read from their public price cards that day and ordered by monthly users. Actors that search a job database rather than the companies' boards were not compared. We compared listings, prices and published input forms; we did not run them.

| Actor | Monthly users | Free-plan price per 1,000 jobs | Per run | Only-new monitoring | Alert to Slack or a webhook |
| --- | --- | --- | --- | --- | --- |
| **This Actor** | new | **$1.00** | $0.00005 | Yes | Yes |
| Most-used | 141 | $5.00 | none | Yes | Not in its input form |
| Second | 132 | $2.00 | none | Yes | Not in its input form |
| Third | 80 | $1.50 | $0.00005 | Yes | Not in its input form |

Counting each run's start fee, at these Free-plan prices of 12 November 2026 any run that saves at least one job costs less here than with each of the three. The two most-used also search companies you did not name; this Actor reads the companies you list. Prices change; check each listing before you decide.

### How do I scrape Lever, Greenhouse, Ashby, Workable and Workday jobs?

[![How to scrape Lever, Greenhouse and Ashby jobs in three steps: name the companies, run or schedule, export to CSV, Excel, JSON, API or Slack](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-ats-how-v1.png)](https://apify.com/fetchwright/lever-jobs-scraper)

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open the Actor and paste the companies' job board links, one per line. You find the link from the company's careers page: its jobs open on jobs.lever.co, job-boards.greenhouse.io or jobs.ashbyhq.com.
   A company name alone works too: it is looked up on Greenhouse, Lever, Ashby and Workable, and if it has no board there, or only boards with no open job, on Workday by one web search (free, at most 20 lookups per run). At most 100 bare names are read per run, and a Workday name that differs from the usual name is not found, so give the careers link.
3. Optionally add title keywords, locations, remote only and dates, and set **Maximum jobs per run**.
4. Click **Start**, or save it as a task and schedule it daily with **Only new jobs (watch)** on, with one run of the watch at a time (Apify's schedule setting can wait for the previous run).
5. Download the results as CSV, Excel or JSON, or fetch them through the API.

**Run it on a schedule.** For monitoring, run it daily as an only-new watch, with one run of the watch at a time. Apify's short video shows how to set up a schedule:

https://www.youtube.com/watch?v=1jI7WcVQmwM

### ⬇️ Input for Company Career Page Jobs Scraper

| Field | What it does |
| --- | --- |
| Companies | Job board links (`https://jobs.lever.co/spotify`, `https://job-boards.greenhouse.io/airbnb`, `https://jobs.ashbyhq.com/ramp`, `https://apply.workable.com/huggingface`, `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` (with or without a language such as `en-US`), also links to a single job; for Workable a link to one job counts only when the company is in it), `system:name` (`greenhouse:airbnb`, `workable:huggingface`; for Workday `workday:<tenant>.wd<N>/<site>`, such as `workday:nvidia.wd5/NVIDIAExternalCareerSite`), Recruitee, Personio and Teamtailor careers links (`https://aaff.recruitee.com`, `https://ottonova.jobs.personio.de` or `.jobs.personio.com`, `https://pasqal.teamtailor.com/jobs`, also links to a single job) or `recruitee:aaff`, `personio:ottonova` (`personio:ottonova.com` for a company on `.jobs.personio.com`), `teamtailor:pasqal`, or a bare name. A company's own careers domain (such as `careers.pasqal.com`) does not show which system it runs on, so give its Recruitee, Personio or Teamtailor link or `system:name`; a bare name is never looked up on these three. A bare name found on none of those four, or only as boards with no open job, is looked for on Workday by one web search: its careers site is read only when the site's company part is exactly the name (letters and digits, so `General Motors` finds `generalmotors`), its other Workday sites are listed under `alsoFoundOn`, at most 20 names per run are looked up this way, fewer when the keyword search below uses part of the run's 20 web searches (the rest show `lookup_limit` under `notChecked`), and nothing is charged for the search. When the search shows only the company's Workday address, the careers sites the company itself declares there are used: its one main external careers site is read when that is clear; otherwise the address and the declared sites are listed under `alsoFoundOn` and the company is reported `not_found` (a site is never guessed). A company whose Workday name differs from its usual name is not found this way; give its careers link. A bare name is looked up on all four systems, in lower case first; if it has a board on more than one (an old or unrelated board beside the current one), the board with the most open jobs is read and the others are listed under `alsoFoundOn` for that company in the `SUMMARY` record. A link or a system prefix is the sure way to get the board you mean, and costs one request; a bare name costs up to eight, so at most 100 bare names are read per run and the rest are reported as `bare_name_limit`, uncharged. The same board given twice is read once. |
| Maximum jobs per run | Hard cap for the run. Companies are read in your order, newest jobs first. Default 100, at most 100,000. |
| Maximum jobs per company | Per canonical career board; Google Jobs has separate limits per folded company name. Empty for no limit. |
| Find boards by keyword | Keywords such as `data engineer`, one per line: boards of companies you do not name are found by a web search for each keyword on each system below, and read. Only their jobs that match the keyword are saved; finding boards costs nothing. See [Finding boards by keyword](#finding-boards-by-keyword). |
| Location for the keyword search | A place such as `London`. It narrows the web search on Ashby, Workable and Workday, and on every system only jobs that state this place are saved from the boards found. Boards you list are not affected. |
| Systems to search | Any of `lever`, `greenhouse`, `ashby`, `workable`, `workday`; all five when empty. Each is one web search per keyword. |
| Title keywords | Every word of a line must appear in the title, at the start of a word (`engineer` also matches `Engineering`), in any order; any line matches. |
| Match keywords in | `title` (default) or `title_and_description`: a job also matches when its description contains a keyword line as written (its words next to each other, in that order, at the start of a word, ignoring case: `machine learning` matches `machine-learning`, not `a machine for learning`). The description is read from the board's own answer, so this works with descriptions off and costs no extra request. Workday job lists carry no description, so on Workday boards keywords are matched in titles only (`keywordsMatchedInTitlesOnly` for that company in the run summary). Exclude keywords always look at the title only. |
| Exclude title keywords | A job is left out when every word of a line appears in its title as a whole word (`intern` leaves out `Software Intern`, not `Internal Tools`). |
| Locations | One place per line; a line is one phrase, so `San Francisco, CA` means that place, not all of `CA`. Its words must appear as whole words in a location the employer states (`Berlin`, `United States`, `Remote`); a two-letter code such as `US` also matches the country a Lever board states. |
| Departments or teams | Part of the department or team name, such as `Engineering`. |
| Seniority | Any of `intern`, `junior`, `mid`, `senior`, `lead`, `principal`, `director`, `manager`: keeps jobs whose title states that level (see [How is seniority read?](#how-is-seniority-read)). A title that states no level is left out and counted as `no_seniority`, unless **Keep jobs whose title states no level** is on. |
| Remote jobs only | Jobs the source marks as remote (see `remoteStatedBy` below). |
| Workplace | Any of `remote`, `hybrid`, `onsite`. A job's workplace is the board's own `workplaceType`; a job with none stated counts as `remote` when the source marks it remote (`isRemote`). A job whose workplace is not stated is left out and counted as `no_workplace`, unless **Keep jobs whose workplace is not stated** is on. Many Greenhouse boards and every Workday list state no workplace type. `remote` on its own (without **Keep jobs whose workplace is not stated**) works as **Remote jobs only**, as in earlier versions, so saved tasks and watches keep their results: a job the source marks as remote is kept even when its stated workplace is hybrid. |
| Employment types | Types as the board writes them (`Full-time`, `Contract`, `Intern`), compared without case, spaces or punctuation (`full_time` = `FullTime`). These are read as one type: Full-time and Full Time Employee; Part-time and Part Time Employee; Intern and Internship; Contract and Contractor; Temporary and Temp. Any other type matches only itself (`Intern` does not match `Internal Only`; `Permanent` is not `Full-time`). A job whose board states no type is left out while this is set; most Greenhouse boards state none. |
| Minimum salary / Maximum salary / Salary currency | Keeps jobs whose published range reaches the minimum or starts at or below the maximum, compared in the job's own currency and interval with no conversion (an hourly range of 60 to 108 does not reach a minimum of 100000); the currency keeps one currency. A job without a published pay range is left out while any salary filter is set. |
| Posted in the last days / Posted on or after / Updated on or after | Date filters. Jobs without a stated date are left out while a posting-date filter is set; Lever, Ashby, Workable, Workday, Personio and Teamtailor state no update date, so their posting date is used. |
| Include the job description | Adds the full description. Off by default. On Workday it costs one extra request per saved job (the job's details), and also fills in all of the job's places, its country, its time type and the exact posting day. |
| Description format | `text` (default), `html` (the employer's formatting with scripts, styles, images and every attribute except link addresses removed) or `markdown` (headings, bold, lists and links). Every format comes from the same answer: no extra request, no extra charge. |
| Only new jobs (watch) | Turns a scheduled task into a watch: the first run returns up to your maximum of the newest matching jobs and remembers every job open on each board it reads, also those it reads after your maximum is reached (nothing saved or charged for them); with one run of the watch at a time, later runs return only jobs that appeared after. Older matches are not back-filled. A board the watch has not read yet (a company added later, or one a run's maximum charge, timeout or a failure kept it from) gets its first read, up to your maximum, in the run that first reads it. A job that closes and later reopens under the same ID is returned again. A job the watch returned that is gone from a board read to its end is listed once in the run's `CLOSED_JOBS` record, free (see below). |
| Watch name | Gives a watch its own memory, kept when you change its companies or filters: changing them never brings back a job the watch already saw (with one run of the watch at a time). |
| Send an alert to Slack, Discord or a webhook | Posts the count, the first three titles with company, location and link, and a link to all rows. |
| Companies from a dataset | A dataset ID; every Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor board link in its rows is read with the companies above. |

#### Finding boards by keyword

Without naming companies, give **Find boards by keyword**, for example `{"searchKeywords": ["product designer"], "searchLocation": "London"}`. For each keyword the Actor makes one web search per system, limited to that system's job boards, turns the results into boards (about 7 to 10 per search on 12 November 2026), and reads each board live like a board you listed. From those boards only jobs whose title matches the keyword are saved (or whose description does, with **Match keywords in** set to title and description), in the search location when one is given, and with every other filter applied; each row names its keyword in `foundByKeyword`. Finding boards is free: you pay per saved job, as for any board.

What to expect:

- **Found by a web search.** The boards are those the search engine has indexed for the keyword: about ten per system, not every company that has such a job. A board can be missed, and results change from day to day. For a complete list of a company's jobs, name the company.
- **Ashby, Workable and Workday results are job pages**, so the keyword and place mostly match: on 12 November 2026, the ten Ashby boards found for `product designer` in London listed 15 product designer jobs, 10 of them in London. **Lever and Greenhouse results are often board pages** matched anywhere on the page: the eight Lever boards found for `data engineer` with Berlin listed 7 data engineer jobs, none in Berlin. Jobs that do not match are left out and not charged.
- **At most 10 boards are read per keyword**, so the cost of reading boards stays in proportion to what you are charged: they are taken in turn from each system's results (the first of each system, then the second, and so on), each in the order the search gave. Boards beyond that are counted in the run summary (`boardsNotRead`), not read. A board already read for another keyword or that you listed does not count toward the 10.
- **At most 20 web searches per run**, Workday name lookups included: each keyword is one search per system, so 4 keywords on all five systems fill it. Searches beyond it are listed in the run summary (`search_limit`). If the web search asks for a verification or refuses, no further web search is made in that run, and the boards already found are still read. The same holds when the platform restarts a run while a web search was under way, or when the run cannot keep its record of the searches it made (`search_uncertain`): a search is never sent twice.
- **Workday sites** found by keyword are asked for each keyword that found them, and a job listed for several keywords is saved once. When a result shows only a Workday address without its careers site's name, the site's main careers site is read only when the site itself makes clear which one it is; otherwise the address is reported as `not_found` and nothing is guessed.
- **Watches** work as for named boards: a board found for the first time is read once to remember its open jobs, and, with one run of the watch at a time, later runs return only jobs that appear on it. A board a later search does not find is not read in that run.

```json
{
    "companies": ["https://jobs.lever.co/spotify", "greenhouse:airbnb", "https://jobs.ashbyhq.com/ramp"],
    "keywords": ["engineer", "data"],
    "excludeKeywords": ["intern"],
    "locations": ["United States", "Remote"],
    "maxJobsPerCompany": 50,
    "maxJobs": 200
}
```

### ⬆️ Output from Company Career Page Jobs Scraper

`requisitionId` is the employer's requisition ID where available, otherwise `null`. When the run finishes (complete, capped, stopped or with failed companies), each company entry in `SUMMARY.companies` includes `jobsOverview`; progress writes during the run, and the error record of a run that fails as a whole, leave it out, computed from rows saved in this run (including before a restart): `postings`, `postingsWithRequisitionId`, `distinctRequisitionIds` and `distinctTitles` (titles compared ignoring case and repeated whitespace; unstated titles are not counted). The two distinct counts can differ: one title can be posted under several requisition IDs, and some postings have no ID. `topDepartments` and `topLocations` each contain up to 5 `{name, count}` entries, counting a stated department and each distinct listed location per row; `newestPostings` contains up to 5 `{title, postedAt, url}` entries ordered by `postedAt`, excluding missing or invalid dates. Overview names and titles are limited to 500 characters, dates to 64 and URLs to 2,048.

[![One row per job: company, location, workplace and pay, from real jobs open on 12 November 2026](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-ats-output-v1.png)](https://apify.com/fetchwright/lever-jobs-scraper)

One row per job. A real job, as recorded from Ramp's Ashby board on 12 November 2026 and saved by this Actor's parser (description off):

```json
{
    "searchTarget": "https://jobs.ashbyhq.com/ramp",
    "system": "ashby",
    "boardToken": "ramp",
    "jobId": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "requisitionId": null,
    "jobKey": "ashby:ramp:34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "company": "ramp",
    "companyName": null,
    "title": "Security Engineer, Cloud",
    "seniority": null,
    "department": "Engineering",
    "team": "Backend",
    "location": "New York, NY (HQ)",
    "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
    "country": "USA",
    "workplaceType": "hybrid",
    "isRemote": true,
    "remoteStatedBy": "remote_flag",
    "employmentType": "FullTime",
    "salaryMin": 211400,
    "salaryMax": 290600,
    "salaryCurrency": "USD",
    "salaryInterval": "year",
    "salaryText": "$211.4K – $290.6K • Offers Equity",
    "salaryRangesStated": 1,
    "postedAt": "2026-04-07T17:12:35.753+00:00",
    "postedText": null,
    "updatedAt": null,
    "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
    "matchedKeywords": [],
    "foundByKeyword": null,
    "description": null,
    "descriptionStatus": "not_requested",
    "scrapedAt": "2026-11-12T05:21:38.000Z"
}
```

A Greenhouse job from Airbnb's board the same day, with the pay range from the employer's own pay block (selected fields):

```json
{
    "company": "Airbnb",
    "title": "Business Operations and Growth Lead - DACH & CEE",
    "seniority": "lead",
    "location": "Berlin, Germany",
    "workplaceType": "hybrid",
    "isRemote": false,
    "salaryMin": 114000,
    "salaryMax": 142000,
    "salaryCurrency": "EUR",
    "salaryText": "€114.000 — €142.000 EUR",
    "postedAt": "2026-11-06T04:52:49-05:00",
    "url": "https://careers.airbnb.com/positions/8357059?gh_jid=8357059"
}
```

When a source gives no value, `locations` uses an empty list and optional text fields use `null`. Google Jobs rows also use empty lists for unstated `applyOptions`, `employmentTypes` and `benefits`; these Google-specific fields are absent from career-site rows.  Values are as each system states them, so they differ by system:

- `isRemote` is `true` when the source marks the job as remote. `remoteStatedBy` says where that comes from: `remote_flag` (Ashby's own flag, which can be `true` on a hybrid job that allows remote work, as on the row above, or Workable's telecommuting flag), `workplace_type`, or `location_text` (the location says Remote, used only when the board states no workplace type).
- `country` is a two-letter code on Lever (`US`), a name on Ashby (`USA`, `United States`) and Workable (`France`), and `null` on Greenhouse. `employmentType` is written as the source writes it (`Full-time`, `FullTime`); most Greenhouse boards state none.
- `salaryInterval` is `null` for Greenhouse, whose pay block states no interval. `salaryRangesStated` counts the ranges a job states (for example one per zone); the row carries the first, or Ashby's own summary.
- `postedAt` is the first publication on Greenhouse, Ashby and Workable (a date without a time on Workable), and the creation time on Lever. `updatedAt` exists on Greenhouse and Recruitee only.
- Workday: the list states when a job was posted only relatively (`postedText`, such as `Posted 2 Days Ago`). `postedAt` is that counted back from the day of reading in UTC, so it is exact to the day for "Today", "Yesterday" and "N Days Ago"; `Posted 30+ Days Ago` gives no date (`postedAt` is `null`, `postedText` keeps the words). With descriptions on, `postedAt` is the posting day the job's details state (on the three sites we read it matched the counted day). A location such as `3 Locations` is a count, not a place, so `location` is empty unless descriptions are on. Workday publishes no pay field; with descriptions on, a pay range the employer writes in the description (such as "The U.S. pay range for this position is $229,000 - $369,600 annually") fills `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryInterval` and `salaryText`, but only when the description states exactly one range and it directly follows a statement of the job's pay (such as "pay range for this position is", "salary range:" or "base salary:"), both amounts in one of US dollars, euros, pounds or Canadian dollars, and no bonus, equity, commission, overtime or other kind of money named in the same sentence; amounts written with a plain "$" are read as US dollars only on jobs Workday places in the United States. A description with more than one different range (one per state, say), or with a range that does not meet these conditions, leaves the amounts empty and gives `salaryRangesStated` with the count of ranges. Workday also states no update time and no company display name: `company` is the tenant in the link, such as `nvidia`.
- Recruitee: `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryInterval` come from the pay range the employer publishes (`hour`, `month` or `year`; one end can be empty, as in "up to €18.50 per hour"); `workplaceType` from its remote, hybrid and on-site flags; `employmentType` is `Full-time` or `Part-time` (Recruitee's own type, without whether the contract is permanent or fixed-term); `companyName` is the company name Recruitee states; `updatedAt` is given.
- Personio: a company named on one Personio domain that Personio sends to the other (`.jobs.personio.de` and `.jobs.personio.com`) is read from the site that answers; both spellings are one board, the company itself (read and saved once, one maximum per company, one watch record, also across a restarted run; `boardToken` is the company's name, and `url` points to the site that answered). Personio publishes no pay, no workplace, no country and no job address in its feed: `url` and `applyUrl` are the job's page on the company's Personio careers site (`https://<company>.jobs.personio.de/job/<id>`). `companyName` is the hiring legal entity (such as `ottonova Technology Services GmbH`), `employmentType` the schedule (`full-time`, `part-time`, `full-or-part-time`), `postedAt` the creation time. The description is the job's named sections (in Markdown each becomes a heading).
- Teamtailor publishes no pay, no employment type and no update time. `workplaceType` and `isRemote` come from its remote status (`fully` is `remote`; a job with no remote option counts as not remote, `workplaceType` `null`); `team` is the role it states; `companyName` is the careers site's name; `url` is the job's page, usually on the company's own careers domain.
- Workable publishes no pay: on Workable jobs `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryInterval` and `salaryText` are always `null` and `updatedAt` is `null`. `workplaceType` is set only when Workable states it (it did on none of the jobs we read); `isRemote` comes from Workable's own remote flag.
- `matchedKeywords` lists the keywords the job matched, as you wrote them, in its title or (with **Match keywords in** `title_and_description`) its description, so you can check the filter on every row; it is empty when no keyword is set. Dates keep the time zone the source gives.
- `companyName` is the display name the source states (Greenhouse, such as `Airbnb`; Workable's account name, such as `Hugging Face`; Recruitee, Personio and Teamtailor as above) and `null` on Lever, Ashby and Workday, which state none. `company` is that name when given, otherwise the board name exactly as in the link (`ramp`, `shieldai`).
- `url` is the job page the board links to, often the company's own careers site; `jobKey` joins runs.

The dataset has three views: **Overview**, **Pay and work type**, and **Boards, dates and links**.

Example Google Jobs input:

```json
{
  "searchKeywords": ["software engineer"],
  "searchLocation": "Austin,Texas,United States",
  "searchSystems": ["google_jobs"],
  "maxJobs": 100,
  "includeDescription": true
}
```

#### The run summary

The `SUMMARY` record in the run's key-value store holds the run's `outcome` (`complete`, `partial` or `failed`; `running` while the run is saving, because the record is also written after every company, so a run stopped from outside still leaves one) and `coverage` (`complete`, `capped` or `partial`), and per company in `companies`: the system, `jobsOnBoard`, `matched`, `saved`, `filteredOut` by reason (`unlisted`, `keywords`, `excluded`, `location`, `department`, `seniority`, `no_seniority`, `remote`, `workplace`, `no_workplace`, `employment_type`, `no_employment_type`, `salary`, `no_salary`, `posted_date`, `updated_date`, `no_date`), for watches `skippedSeenBefore`, `watchFirstRead`, `notBackFilled` (matching jobs remembered at a first read, not returned) and `baselineOnly` (a board read after your maximum only to remember its jobs), `duplicatesSkipped`, `alsoFoundOn`, `notChecked` and `foundBy` (`web_search` when the Workday site was found by name) for a bare name, the requests and seconds it took, for Workday `listTotal` (the jobs the site states), `listPages`, `listComplete`, `listCapped` (the 2,000 the site shows at most), `listStoppedEarly`, `detailsRead`, `detailsUnavailable` and `droppedAfterDetails` (`descriptionStatus` `unavailable` on that row), for Teamtailor `listPages`, `listComplete`, `listCapped` and `contentSignal` (the uses the site's robots.txt states for its content, such as `search=yes, ai-train=no, ai-input=yes`), and its `status` (`complete`, `capped`, `partial`, `failed` or `not_read`) with a `reasonCode` and reason in words: `not_found`, `unsupported_board`, `invalid_target`, `bare_name_limit`, `same_board`, `robots_disallowed`, `robots_unreadable`, `bad_redirect`, `blocked`, `rate_limited`, `source_error`, `source_timeout`, `bad_data`, `too_large`, `max_jobs`, `max_jobs_per_company`, `max_charge`, `access_state_unsaved`, `aborted`, `lost_watch_lock`, `rejected_request`, `timeout` or `uncertain_write`. Boards found by keyword are listed in `companies` too, with `foundBy` `keyword_search` and `foundByKeyword`, and the `keywordSearch` block gives the location and systems searched, per keyword the searches made, `boardsFound`, `boardsYouListed` (found boards you had listed already), `boardsSelected` (chosen to be read, at most 10), `boardsRead` (actually read), `boardsLeftUnread` (chosen but not read because the run stopped first, for example at your maximum jobs; each company says why), `boardsNotRead` (beyond the 10 read per keyword) and `jobsSaved`, with `boardsFound` and `boardsRead` for the whole run (a board counts as read when it was asked itself: boards a service's earlier refusal closed are left unread; after a platform restart `boardsRead` counts only the boards requested after the restart, and `boardsLeftUnread` is the boards selected minus that count), and per search its `status`, `boardsFound` and, when not made, its `reasonCode` (`search_limit`, `blocked`, `search_uncertain`, `source_error`, `timeout`). It also lists `failedTargets` and `unfinishedTargets`, `sourceRefused` when a service refused the run, the watch's state for only-new runs (with `closedJobs`, the number of closed jobs listed), `inputNotes` (how your input was read), and `notification` with the alert's delivery status. The summary is saved before the alert is sent. Input that cannot run also leaves a `SUMMARY`, with `reasonCode` `invalid_input`, `unsupported_input` or `watch_busy`.

#### Closed jobs on a watch

On an only-new watch, a job the watch returned that is no longer on its board is listed once in the `CLOSED_JOBS` record of that run's key-value store: `changeType` `closed`, `jobKey`, `jobId`, `system`, `boardToken`, `company`, `title`, `url`, `searchTarget` and `closedDetectedAt`. It is not a dataset row, so it is never charged, and the alert does not include it. A job is listed closed only when its board was read to its end in that run: never from a board that failed, a Workday list that stops at the 2,000 jobs it shows, or a board whose saving stopped part-way (maximum charge, timeout, abort); such a board's job is listed by the next run that reads the board to its end. A board whose answer lists no job at all, when the watch remembers open jobs on it, reports no closures (`emptyAnswerNotClosed` and `closedJobs` 0 for that company in the run summary): an empty answer may be a fault, so an emptied board does not report closures, and its jobs are listed as closed only after a later read that lists jobs and not them. An answer that is not a complete feed is reported as `bad_data` and closes nothing either. On every system, an answer that would close more than half of the jobs the watch remembers on a board, and more than 5, closes none in that run (`closuresHeld` with the count, for that company in the run summary); they are listed as closed only when a later read confirms that they are gone. A job that a board lists without an identifier is not saved (it cannot be told apart from others), and an answer that holds any such job never closes or forgets a remembered job (`idlessJobs` with the count, for that company in the run summary); the jobs with an identifier are saved as usual. The same holds for an answer with an entry that is not a job (`malformedEntries`) and for a list in which an identifier comes back twice, such as pages that overlap (`repeatedIds`): only an answer whose every entry is a job with an identifier, read to its end with no repeats, can close jobs. Only jobs returned from version 0.1.15 on are tracked, and only jobs the watch returned, not every job on the board. If a run stops between listing a closed job and updating the watch's memory, the next run lists it again.

### Limits of Company Career Page Jobs Scraper

- **Which companies.** Only companies whose careers page uses Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor, and that you name or that a keyword search finds (Recruitee, Personio and Teamtailor are not searched by keyword). A company on another system (SmartRecruiters, BambooHR, its own site) is reported as `unsupported_board` or `not_found` and costs nothing. Recruitee, Personio and Teamtailor boards are read only from their link on the vendor's domain or `system:name`: a bare name is not looked up on them, and a company's own careers domain is not recognised. A Personio company whose feed the employer has switched off cannot be read. Boards on the EU instance of Greenhouse or Lever (addresses with `eu.greenhouse.io` or `jobs.eu.lever.co`) are not read yet. Up to 1,000 companies per run.
- **What the boards state.** Pay, employment type, workplace type and country are present only when the employer and the system state them. On 12 November 2026, Stripe, Palantir and Spotify published no pay on any job, and neither Greenhouse board we read stated an employment type.
- **Public jobs only.** Only jobs the employer has published on its public board. Internal and unlisted postings are not returned.
- **Descriptions** are the employer's text, as plain text, HTML or Markdown, cut at 50,000 characters (`descriptionStatus` `included_cut`; HTML is cut before its last unfinished tag, so its last element may be left open). Markdown is converted from the employer's HTML: tables become plain lines. A source that gives only plain text gives that text as paragraphs in HTML.
- **Keywords in descriptions** are not matched on Workday boards, whose job lists carry no description.
- **Workday** documents no public postings API: the Actor reads each careers site's own job list, as the careers page does, and only where the site's robots.txt allows it. A site is read only when its robots.txt, read conservatively (every Disallow for this Actor or for all agents counts, Allow lines do not), disallows no path the run would request: the careers page as linked, the job list and each job's details; otherwise the board, or that job's details, is skipped and costs nothing (`robots_disallowed`; `robots_unreadable` when the file cannot be read; a verification page served instead of the file counts as a refusal of the site). A Workday site shows at most 2,000 jobs, newest first: NVIDIA's list stopped there on 12 November 2026 (asking past it gave the first page again), so on a larger site only its 2,000 newest jobs are read. A watch on such a site remembers every job it has read and forgets none of them when they drop out of the 2,000 shown (a job missing from a list that stops at 2,000 may still be open), so a job that comes back into view is not returned again; an older job it has never seen that comes into view, because newer jobs closed, is returned as new. Pages hold 20 jobs and the Actor asks each site about once a second, so 2,000 jobs take about 100 requests and two minutes. Without a watch, paging stops once the run has the matching jobs it can save; a watch reads the whole list, because it remembers every open job. With descriptions on, filters on what a job's details state (locations, remote only, employment types, salary, dates) are checked after the details are read, and every filter is checked again before a job is saved, so nothing left out is saved or charged; such a run reads the whole list and can read details of jobs that are then left out (each one extra request, no charge; counted as `droppedAfterDetails`). In the run summary, `jobsOnBoard` is the number of jobs read and `listTotal` the number the site states.
- **Workable** publishes no pay range and no update time, and its posting dates have no time of day; a salary filter leaves every Workable job out.
- **Personio and Teamtailor** publish no pay range, so a salary filter leaves all their jobs out.
- **Teamtailor** careers sites are read only where their robots.txt allows it. The file is read on the company's own careers domain, where Teamtailor sends it (only to a public web address over HTTPS, never to a verification or bot-check service; any other redirect is treated as a refusal and the board is not read), and the board is read only when every job in its feed links to that same careers domain: a feed that links elsewhere, or a Teamtailor site that lists no job, is treated as a refusal, nothing is saved or charged and a watch closes nothing, and the board is skipped (`robots_disallowed`, `robots_unreadable`; nothing charged) when it disallows the job feed or the careers pages for this Actor or for all agents. The Teamtailor sites we read on 12 November 2026 state `ai-train=no` in robots.txt: their employers do not want their content used to train AI models. Their rows are for search, monitoring and analysis, not for model training; the run summary reports each site's statement under `contentSignal`. A Teamtailor list is read 100 jobs per request, and at most 2,000 jobs per site (`listCapped`).
- **Large boards.** The largest board we read, OpenAI's on Ashby, was 821 jobs and 14.4 MB. A board larger than an eighth of the run's memory (64 MB at the default 512 MB) is reported as `too_large` and costs nothing, and that service is not asked again in the run (on Greenhouse, Lever, Ashby and Workable this skips the rest of that system's companies in the run; on Workday, Recruitee, Personio and Teamtailor each company's site is its own).
- **When a service limits or refuses a run.** If a service asks the run to slow down, it waits at most twice in the whole run; after that, or after any refusal, that service is not asked again in the run, also if the platform restarts the run, and its remaining companies are reported as failed. If the record of a refusal or a pause cannot be saved with the run, the run ends at once, asks no job board and no web search anything more, and says so (`stoppedBy` `access_state_unsaved`, `accessStateNotSaved` in the run summary). On Workday, Recruitee, Personio and Teamtailor this holds per company site. Other services are still read. Nothing is charged for what was not read.
- **Bare names.** At most 100 per run; use links or `system:name` for longer lists.
- **A watch's first run** of a board does not back-fill: matching jobs beyond your maximum that are already on the board are remembered and never returned. A watch run that reaches your maximum still reads each board it has not read before, once, to remember its jobs; boards it never reaches because of the maximum charge, the timeout or a failure get their first read in a later run.
- **Salary filters** compare numbers in the job's own currency and interval, with no conversion, and leave out jobs without a published pay range. A watch remembers every job open on each of its boards, with no size limit.
- **Restarts and failed saves.** If the platform restarts a run, the jobs it already saved are kept and are not saved or charged again, and the maximums still hold. If saving a job reports an error, the Actor reads the dataset back before going on: a job found there counts once; otherwise the run stops (`uncertain_write`) rather than risk saving it twice, and a watch's next run settles it.

### Who uses Company Career Page Jobs Scraper, and for what?

#### 🎯 Recruiters and sourcers

Watch the companies you hire from: a daily run with only-new monitoring, with one run of the watch at a time, tells you who just opened which role, where and at what pay.

#### 💼 Sales teams: hiring as a buying signal

A company opening five data-engineering roles is building a data team. List your target accounts, filter on departments, and get a Slack alert when they post.

#### 📰 Job boards and newsletters

Direct-from-employer listings with apply links and pay, refreshed on your schedule, joined across runs on `jobKey`.

#### 📊 Salary and market research

Pay ranges by title, location and company, with the employer's own text beside the parsed numbers.

#### 🤖 AI-agent builders: use it in Claude, ChatGPT or Cursor through MCP

Add this address as a custom connector (MCP server) in your AI app, sign in to Apify when the browser opens, and the Actor appears as a tool the assistant can call:

```
https://mcp.apify.com?tools=fetchwright/lever-jobs-scraper
```

Ask the agent "list the remote engineering jobs Spotify, Airbnb and Ramp posted this week, with pay" and it can call this Actor directly through the [Apify MCP server](https://mcp.apify.com).

### Use it as a Greenhouse, Lever, Ashby, Workable and Workday jobs API (Python, Node.js, curl)

A ready-made Python example for Google Jobs search (paid plans, US): keyword and location in, listings with apply links out as CSV: [github.com/Fetchwright/google-jobs-api](https://github.com/Fetchwright/google-jobs-api).

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("fetchwright/lever-jobs-scraper").call(run_input={
    "companies": ["https://jobs.lever.co/spotify", "greenhouse:airbnb"],
    "keywords": ["engineer"],
    "maxJobs": 200,
})
dataset_id = run["defaultDatasetId"] if isinstance(run, dict) else run.default_dataset_id  # apify-client 2 returns a dict
for job in client.dataset(dataset_id).iterate_items():
    print(job["company"], job["title"], job["location"], job["salaryMin"], job["salaryMax"])
```

Node.js:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('fetchwright/lever-jobs-scraper').call({
    companies: ['https://jobs.ashbyhq.com/ramp'],
    remoteOnly: true,
    postedWithinDays: 7,
    maxJobs: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]?.title);
```

curl, waiting for the run and returning the rows:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetchwright~lever-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["greenhouse:airbnb"], "locations": ["Berlin"], "maxJobs": 50}'
```

### Use it in a pipeline: hiring signals in a Clay table

Runs are billed to your own Apify account at your plan's prices, wherever you start them. Clay connects to Apify with your own Apify account ("Bring Your Own Account").

1. In Apify Console, create a task for `fetchwright/lever-jobs-scraper` with the companies you sell to and the roles that signal a need, for example:
   ```json
   { "companies": ["https://jobs.ashbyhq.com/ramp", "greenhouse:airbnb"], "keywords": ["data engineer", "revops"], "postedWithinDays": 7, "onlyNew": true, "watchName": "weekly-signals" }
   ```
2. In Clay, either add Apify's **Import data from Apify Actor** as a source to bring a run's jobs into a table, or use the **Run Apify Actor** enrichment on an existing table of companies, which puts each row's result in a cell. In both, pick this Actor and supply the input above.
3. Use the columns `companyName`, `title`, `seniority`, `location`, `postedAt` and `url` to score accounts or write the first line of an outreach message.

With `onlyNew`, each run of the Actor returns only jobs the watch has not returned before, with one run of the watch at a time and none is stopped before it saves its memory. Checked on 13 November 2026 against Clay's own pages for its Apify integration, which describe picking an Actor, giving its input and running it; the input fields and output columns are this Actor's own. Not run in a live Clay account, so tell us on the Issues tab if a step fails.

### ❓ FAQ about Company Career Page Jobs Scraper

#### Is there a Google Jobs API or a job scraper API?

Google's Cloud Talent Solution job search API searches jobs you upload yourself; it does not return Google Jobs results. This Actor works as a job scraper API: name companies (or, on paid plans in the US, search Google Jobs by keyword) and get the open jobs back as JSON from Python, Node.js or one HTTP call (see [the API section](#use-it-as-a-greenhouse-lever-ashby-workable-and-workday-jobs-api-python-nodejs-curl)).

#### Why use this instead of the careers pages?

Careers pages show jobs one company at a time, in different layouts. This Actor returns the jobs of all the companies you name as one table with the same columns, on a schedule, only the new ones if you like (with one run of the watch at a time), and through an API.

#### How fresh is the data?

Every run reads each board at that moment (Ashby's answers can be up to a minute old): a job is in the results as soon as the employer publishes it, and gone as soon as they close it. `postedAt` is when the job was published (on Lever, when it was created), `scrapedAt` when the row was saved.

#### How much does a run cost?

$1.00 per 1,000 jobs on the Free plan, less on paid plans, plus Apify's start event of $0.00005 per run with up to 1 GB of memory. See the tables above.

#### Can a run cost more than I set?

Not for the jobs. **Maximum jobs per run** is a hard cap, and the Actor checks the run's maximum charge in Apify before saving every row and stops there, keeping what it saved. A run that stops at your maximum charge succeeds, says so in its status message and lists what it did not finish in the `SUMMARY` record.

#### How fast is it?

On 12 November 2026 on Apify, 90 jobs from three companies took about 6 seconds, and every open job of one large employer with descriptions, 823 jobs, took 52 seconds at a peak of 117 MB of memory. A long company list takes about a second per company on top of that, less when the companies are spread over several systems: each system is paced on its own, and on Workday, Recruitee, Personio and Teamtailor each company's site is.

#### Why did a company return no jobs, or fail?

Look up the company in `companies` in the `SUMMARY` record. `not_found` can mean no public board was found under that name on the system you gave (for a bare name: none on Greenhouse, Lever, Ashby or Workable, and no Workday site whose company part is exactly the name). It can also mean a Workday address was found but its careers site could not be identified. Open the company's careers page, click a job, and paste the board link from the address bar. `unsupported_board` means the link is not on a system this Actor reads (Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio, Teamtailor). `complete` with `saved` 0 means the board was read and your filters left every job out; `filteredOut` says which filter.

#### How do I check that my filters worked?

Every row has `matchedKeywords`, the keywords it matched. The `SUMMARY` record in the run's key-value store says, for each company, how many jobs its board listed (`jobsOnBoard`), how many passed your filters (`matched`), how many were saved (`saved`), and how many each filter left out (`filteredOut`, by reason, such as `keywords`, `posted_date` or `salary`). A board that listed fewer jobs than you expected shows it there, with its `status` and a reason when it failed.

#### How is seniority read?

From the job title only, by fixed rules, so the same title always gets the same value; never from the description or from years of experience, and never guessed. A title that states no level (`Software Engineer`, `Data Scientist`) gets `null`. Only the start of a title (its first 600 characters, and of those the first 300 once runs of spaces are collapsed to one) is read, and fixed rules can misread an unusual title, so check the `title` column when a filter result matters. The values:

- `intern`: Intern, Internship, Co-op, Apprentice; Werkstudent, Praktikant, Praktikum, Ausbildung; Stagiaire, Alternant(e); Stagiair; and Stage only in French or Dutch phrasing (`Stage PPI Juriste H/F`, `Stage de fin d'études`, `en stage`, `stage bij`) or a Dutch compound (`Meewerkstage`, `Afstudeerstage`), never a theatre or film job (`Stage Manager`, `Stage-Manager`, `Stage / Sound Technician`, `Soundstage`) or an English compound (`Early-stage`, `Late-stage`). Stagiaire, Stagiair and Alternant(e) are always `intern`, whatever follows.
- `junior`: Junior, Jr, Entry-level, Graduate, New Grad, Trainee; Berufseinsteiger, Absolvent; Débutant, Jeune diplômé; Nyexaminerad.
- `mid`: Mid, Mid-level, Intermediate, Medior, Confirmé, and a Roman II right after a job word (`Engineer II`; not `Solvency II`). Other numbers (I, III) are not read: employers' ladders differ.
- `senior`: Senior, Sr, Snr.
- `lead`: Lead, Leader, Team Lead; Teamleiter, Teamleider, Teamledare, Chef or Cheffe d'équipe; and Head before a job word (`Head Chef`, `Head Coach`), the head of a team at its level.
- `principal`: Principal, Distinguished, and Staff before an engineering or product word (`Staff Engineer`; not `Staff Accountant` or `Staff Nurse`).
- `director`: Director, VP, Vice President, Chief, Head of (`Head of Finance`, `Department Head`), Managing Director; Geschäftsführer, Leiter, Leitung, Abteilungsleiter; Directeur, Directrice; Hoofd; VD (Swedish); School Principal.
- `manager`: Manager, Responsable, Projektleiter, Chef or Cheffe de projet; every Swedish title ending in -chef (`Enhetschef`, `Försäljningschef`, `IT-chef`, `Ekonomichef`; not `Souschef`) and `Chef för`, only when no other level is stated: `Engineering Manager` is `manager`, `Senior Product Manager` is `senior`.

When a title states two levels, one value is given: an internship is always `intern`, then director, principal, lead, senior, mid and junior in that order (`Sr / Staff Machine Learning Engineer` is `principal`, `Senior Director` is `director`). An assistant does not take the level of the person or role assisted: only words before "Assistant" (or Assistenz, Assistante) count, so `Assistant Manager`, `Assistant to the Director` and `Executive Assistant to the CEO` are `null`, and `Senior Executive Assistant` is `senior`. Words that only look like a level are not read as one: the elderly-care phrases `Senior Living`, `Senior Care`, `Senior Citizens`, `Senior Housing` (`Senior Community Manager` stays `senior`), the sales phrases `Lead Generation Specialist` and `Lead Development Representative` (`Lead Development Engineer` stays `lead`), `Head Office Administrator`, `Mid-Market Account Executive`, `Junior High Teacher`, `Graduate Recruiter`, `Internal Auditor`, `Stage Manager`. Across the 133 different job titles of every board recorded for our tests, each title gets one value or none; some uses of a word will still differ from what an employer meant, which is why the rules are listed here.

Only the start of a title (its first 600 characters, and of those the first 300 once runs of spaces are collapsed to one) is read for its level.

#### How does a watch decide what is new?

On its first run a watch returns up to your maximum of the newest matching jobs and remembers every job open on each board at that moment, matching or not; older matches are not back-filled, also when that first run was cut short by its maximum charge, its timeout, an abort or an error: on every board it read, what it did not save is not returned later (run once without the watch if you need the full list). When a run reaches your maximum, it still reads each board it has not read before, once, only to remember its jobs (nothing saved or charged). A board no run has read yet, because the maximum charge, the timeout or a failure stopped a run before it, gets its first read, up to your maximum, in the run that first reads it. With one run of the watch at a time, every later run returns only jobs that were not on the board at the previous complete read. If a later run stops at your maximum, the new jobs it did not save stay new for the next run. A job that closes is forgotten, so if it reopens under the same ID it is returned again; if the watch had returned it, its closing is listed once, free, in that run's `CLOSED_JOBS` record. Changing the filters of a named watch brings back no older job; adding a company gives that company a first run of its own.

#### Why is a job marked remote although it says hybrid?

On Ashby boards `isRemote` is the employer's own remote flag, which can be on for a hybrid job that also allows remote work. `workplaceType` keeps the stated arrangement, and `remoteStatedBy` says where the flag came from.

#### Coming from another job-board actor?

Paste your existing input: common field names of other Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio and Teamtailor actors are read as this Actor's own, and the run log and the `inputNotes` of the run summary say how each was read.

| Their field | Read as |
| --- | --- |
| `companyUrls`, `startUrls`, `urls`, `{ "ats": ..., "company": ... }` items | `companies` |
| `titleKeyword`, `titleKeywords` | `keywords` |
| `locationKeyword`, `location` | `locations` |
| `maxItems`, `maxResults` | `maxJobs` (at the default of 100, the smaller of the two is used) |
| `maxItemsPerCompany`, `maxPerCompany` | `maxJobsPerCompany` (0 means no limit) |
| `postedInLastDays` | `postedWithinDays` |
| `includeDescriptions` | `includeDescription` |
| `onlyNewSinceLastRun`, `sinceLastRun`, `onlyNewOrChanged` set to true | `onlyNew` (a changed job is not returned again) |
| `stateKey` | `watchName` |
| `seniority`, `experience_levels`, `experienceLevels`, `seniorityLevels` | `seniorities` (values such as `entry`, `mid_level`, `staff`, `executive` are read as ours) |
| `employmentTypes`, `minSalary`, `salaryCurrency` | the same fields here |
| `remote: "remote_only"` | `remoteOnly` |
| `workplaceTypes`, `work_models`, `remote: "onsite_only"` | `workplaceTypes` |
| `keywordScope`, `keywordsInDescription` or `search_description` set to true | `keywordScope` (`title_and_description`) |
| `descriptionFormat`, `description_format`, `descriptionType` | `descriptionFormat` |
| `searchAllCompanies: true` with `keywords` (and `atsPlatforms`) | `searchKeywords` (and `searchSystems`): boards are found by a web search for each keyword, not from a directory |

Options this Actor does not offer (a search across all companies without keywords, preset company lists, application questions, hiring reports) stop the run at once with a message, before any request, so no job is charged (the start event still applies).

#### Is it legal to scrape Lever, Greenhouse, Ashby, Workable and Workday job boards?

The Actor reads only jobs that employers have published on their public boards, with no login. Lever's own documentation says: "Note that all job postings in the `published` state are publicly viewable. These jobs may be scraped by third parties." Greenhouse's documentation says: "Job Board data is publicly available, so authentication is not required". Ashby documents its public job postings for employers' careers pages and states no permission or prohibition for third parties. Workable's API reference describes the address this Actor reads as one that "Returns a collection of the public jobs for an account", with no credentials; Workable's terms bind its customers and state no permission or prohibition for third parties. Workday documents no public postings API; the Actor reads a Workday careers site only where that site's robots.txt allows it, at about one request a second, and stops at any refusal. Recruitee's terms say its careers site "is intended, among other things, to provide the public with a list of job opportunities", and its documentation describes the public careers-site interface as the way "to display a list of job offers"; the Actor reads each company's job feed (`/api/feeds/offers.xml`, listed in Recruitee's help centre), which Recruitee's documentation says is not covered by the token its careers-site API needs from 10 February 2027. Personio documents the public job feed of a company's careers site in its API reference ("the job positions XML feed from the Company Career Site"). Teamtailor's guide to its careers-site job feed says "all of the data is publicly available"; the Actor reads a Teamtailor site only where its robots.txt allows it. None of the eight states a licence for the data, and the Teamtailor sites we read state in robots.txt that their content is not for AI training. Apify's overview of the topic is in [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) This is not legal advice.

#### Does the output contain personal data?

Rows are about jobs, not people. Recruiter, hiring-manager, owner and contact fields that a system may carry are never read or returned. The job description is the employer's own text, returned when you switch it on, with e-mail addresses and phone numbers in the usual formats replaced by `[e-mail removed]` and `[phone removed]` (an unusual spelling of a number can remain; a long reference number can be removed with them); in HTML and Markdown, a link whose address holds an e-mail address or a phone number keeps its text but loses the address; apply through the apply link instead. It can still contain a contact person's name that the employer chose to publish. That an employer publishes them does not end data-protection duties such as those of the GDPR: when you store or use this data, you decide why and how it is used, and you are responsible for having a lawful basis, for how long you keep it, and for its deletion, including the copies in your datasets, exports and alert channels.

#### Can I download the results as CSV, Excel or Google Sheets?

Yes. Each run's results are an Apify dataset, which you can export from the run's Storage tab or through the API as JSON, CSV, Excel (XLSX), XML, HTML or RSS. For Google Sheets, import the CSV or Excel file, or connect the run through a pipeline as described above.

#### Can I use it with the API or other tools?

Yes. Like every Apify Actor it can be run through the Apify API, scheduled, and connected to Zapier, Make, n8n, Slack and Google Sheets. See the examples above and the API tab on this page.

#### Something is wrong or a field is missing. Where do I report it?

Open an issue on the Issues tab of this page.

### Start reading job boards

Open the Actor and click **Start** on the prefilled example, then paste your own companies. Apify's free plan credit covers about **5,000 jobs** a month.

This Actor is not affiliated with, endorsed by or sponsored by Lever, Greenhouse, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor, or by any company whose jobs it returns.

### More from Fetchwright

- [TED Tenders Scraper](https://apify.com/fetchwright/ted-tenders-scraper): EU public procurement notices by keyword, CPV code, country and date, with buyer, value, deadline and winners, and an only-new watch with alerts.
- [Google Ads Transparency Scraper](https://apify.com/fetchwright/google-ads-transparency-scraper): the ads Google publishes for the advertisers you choose, with ad text, dates and impressions, and a new-ads-only mode for competitor monitoring.
- [Microsoft Ads Library Scraper](https://apify.com/fetchwright/microsoft-ads-library-scraper): Bing ads shown in the EEA, with dates, impressions and the share per country.
- [Google AI Overview Tracker](https://apify.com/fetchwright/google-ai-overviews-ai-mode-scraper): what Google's AI answers for a query, the pages it cites, and whether your brand is mentioned.
- [Telegram Channel Scraper](https://apify.com/fetchwright/telegram-channel-scraper): posts from public Telegram channels with no account, cashtags and engagement rates, and keyword alerts.

# Changelog

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

# Actor input Schema

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

The companies whose open jobs you want, one per line: a job board link such as **https://jobs.lever.co/spotify**, **https://job-boards.greenhouse.io/airbnb**, **https://jobs.ashbyhq.com/ramp**, **https://apply.workable.com/huggingface**, **https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite**, **https://aaff.recruitee.com**, **https://ottonova.jobs.personio.de** or **https://pasqal.teamtailor.com/jobs**, or a board name with its system such as **greenhouse:airbnb**, **recruitee:aaff**, **personio:ottonova**, **teamtailor:pasqal** or **workday:nvidia.wd5/NVIDIAExternalCareerSite**. Recruitee, Personio and Teamtailor boards are read by link or system:name only. A bare name such as **ramp** is looked up on Greenhouse, Lever, Ashby and Workable and the board with the most open jobs is read; a name found on none of them (or only as empty boards) is looked for on Workday, such as **Boeing**, with nothing charged for the lookup (up to 20 per run). At most 100 bare names per run. A company without a board costs nothing. Leave it empty to find boards by keyword only (below).

## `maxJobs` (type: `integer`):

A hard cap: the run never saves more than this many jobs, for example **100**. You pay per job saved ($1.00 per 1,000 on the Free plan), so this caps the cost of a run. Companies are read in the order you list them, newest jobs first. Default: 100.

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

Optional, for example **30**, newest first. Career-site jobs are limited per canonical career board (system plus lower-case board identity), with or without google_jobs selected. Different hiring entities on one board share its allowance; separate boards keep separate allowances even with the same company name. Personio .de and .com addresses for the same company share one board allowance. Google Jobs has a separate allowance per company name Google writes, with case and whitespace folded; Acme and Acme Inc. stay separate. Google rows do not consume or block career-board allowances. Default empty: no per-company limit. Jobs left out by it are not charged.

## `searchKeywords` (type: `array`):

Optional. Find job boards of companies you do not name: for each keyword, one per line, for example **data engineer** or **product designer**, a web search on each system below finds boards that list such jobs, and those boards are read. Only their jobs that match the keyword are saved (each row says which in foundByKeyword); finding boards costs nothing. Results are the boards the search engine has indexed for the keyword, so boards can be missed; at most 10 boards are read per keyword. At most 20 web searches per run (keywords times systems). With google_jobs selected, these are also the Google Jobs search terms (for example software engineer); default empty. Google Jobs is US only for now and paid plans only.

## `searchLocation` (type: `string`):

Optional. A place such as **London** or **Germany**. It narrows the web search on Ashby, Workable and Workday, and on every system only jobs that state this place are saved from boards found by keyword. Boards you list above are not affected (use Locations below for them). For Google Jobs use a US city, state and country, for example Austin,Texas,United States; empty uses US results without a city preference. Google Jobs: US only for now (non-US not measured), paid plans only.

## `searchSystems` (type: `array`):

Optional. Empty searches the five career-site systems, for example Lever and Greenhouse. Select google_jobs explicitly to search Google Jobs with the keywords above: US only for now (non-US not measured), paid plans only, at the same job price. Google Jobs does not provide job highlights, related links or a company logo. Repeated Google Jobs IDs are deduplicated within a run and remembered across watch runs. Up to 20 distinct application-link aliases per ID are retained in first-seen order across search terms and restarts; later aliases are omitted. Google Jobs rows that may duplicate a career-site posting are kept, flagged in possibleDuplicateOf and charged as separate rows. The flag requires a retained application link matching a career row job or apply URL in the same run and equal company names after case and whitespace folding; tracking parameters, fragments and trailing slashes are ignored. Filter possibleDuplicateOf is null to exclude flagged rows from exports (saved rows remain charged), or do not select google_jobs together with career-site systems or list career-site boards in that Google Jobs run.

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

Optional. Keep only jobs whose title contains any of these, one per line, for example **engineer** or **data analyst**. Every word of a line must appear in the title, in any order, at the start of a word, ignoring case. Jobs left out are not saved and not charged. Each saved row lists the keywords it matched (matchedKeywords).

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

Where the title keywords above are looked for. **Job title and description** also keeps a job whose description contains a keyword line as written (its words next to each other, in that order, at the start of a word, ignoring case), whether or not you include descriptions in the rows. Workday job lists carry no description, so on Workday boards keywords are matched in titles only, and the run summary says so for that company. Exclude keywords always look at the title only. Default: Job title only.

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

Optional. Leave out jobs whose title contains any of these, one per line, for example **senior** or **internship**. Every word of a line must appear in the title as a whole word: **intern** leaves out Software Intern, not Internal Tools Engineer. Jobs left out are not charged.

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

Optional. Keep only jobs in any of these places, one per line, for example **Berlin**, **San Francisco, CA** or **Remote**. A line is one phrase (a comma does not split it); its words must appear as whole words in a location the employer states, ignoring case. A two-letter code such as **US** also matches the country Lever states. Jobs left out are not charged.

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

Optional. Keep only jobs whose department or team contains any of these, one per line, for example **Engineering** or **Sales**. Ignoring case. Jobs left out are not charged.

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

Optional. Keep only jobs whose title states one of these levels, for example **Senior** and **Lead**. The level is read from the job title only, by fixed rules (each row has it in seniority); a title that states no level, such as Software Engineer, is left out and counted as no_seniority unless you keep it below. Jobs left out are not charged.

## `keepUnknownSeniority` (type: `boolean`):

With a seniority filter, also keep jobs whose title states no level (seniority null), for example Software Engineer or Data Scientist. Off by default.

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

Keep only jobs the source marks as remote (isRemote true): Ashby's remote flag, a workplace type of remote, or, where the board states no workplace type, a location that says Remote, for example **US - Remote**. Jobs left out are not charged. Default: off.

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

Optional. Keep only jobs whose workplace is one of these, for example **Hybrid** and **On-site**. The workplace is the board's own workplace type (workplaceType); a job with none stated counts as Remote when the source marks it remote (isRemote). Jobs whose workplace is not stated are left out and counted as no_workplace in the run summary, unless you keep them below. Many Greenhouse boards and every Workday list state no workplace type. Jobs left out are not charged.

## `keepUnstatedWorkplace` (type: `boolean`):

With a workplace filter set, also keeps jobs whose board states no workplace type and does not mark them remote, for example **most Greenhouse jobs**. Off by default: such jobs are left out and counted as no_workplace. Jobs that state another workplace are still left out.

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

Optional. Keep only jobs whose employment type, as the board states it, is one of these, one per line, for example **Full-time**, **Part-time**, **Contract** or **Intern**. Case, spaces and punctuation are ignored, and these are read as one type: Full-time and Full Time Employee; Part-time and Part Time Employee; Intern and Internship; Contract and Contractor; Temporary and Temp. Any other type matches only itself (Intern does not match Internal Only; Permanent is not Full-time). Most Greenhouse boards state no type, so their jobs are left out while this is set. Jobs left out are not charged.

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

Optional. Keep only jobs whose published pay range reaches at least this amount, for example **120000**. Compared in the job's own currency and interval (a year, an hour), with no conversion; add Salary currency to keep one currency. Jobs without a published pay range are left out while a salary filter is set, and are not charged.

## `maxSalary` (type: `integer`):

Optional. Keep only jobs whose published pay range starts at or below this amount, for example **90000**. Compared in the job's own currency and interval, with no conversion. Jobs without a published pay range are left out while a salary filter is set, and are not charged.

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

Optional. Keep only jobs whose published pay range is in this currency, a three-letter code such as **USD**, **EUR** or **GBP**. Jobs without a published pay range are left out while it is set, and are not charged.

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

Optional, for scheduled runs: only jobs first published on or after the date this many days before the run, for example **7**. Jobs whose board states no posting date are left out while this is set. When a start date is also set, the later of the two applies.

## `postedSince` (type: `string`):

Optional date the job was first published, for example **2026-11-01**. Jobs whose board states no posting date are left out while this is set. Leave empty for no lower bound.

## `updatedSince` (type: `string`):

Optional date of the job's last update, for example **2026-11-01**. Greenhouse and Recruitee state an update date; when no update date is stated, the posting date is used. Jobs with neither date are left out while this is set. Leave empty for no lower bound.

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

Adds the full job description as the employer published it, as plain text, HTML or Markdown (see Description format), for example **the responsibilities and requirements**. Off by default, for smaller rows. No extra charge. On Workday boards it costs one extra request per saved job (no extra charge) and also gives every place, the country, the time type and the exact posting day.

## `descriptionFormat` (type: `string`):

How the description is written when descriptions are included: **Plain text** (as before), **HTML** (the employer's formatting, with scripts, styles, images and every attribute except link addresses removed) or **Markdown** (headings, bold, lists and links). The same response is read in every format: no extra request and no extra charge. Has no effect while descriptions are off. Default: Plain text.

## `onlyNew` (type: `boolean`):

For scheduled monitoring, for example a daily run on your target companies. The first run returns up to your maximum of the newest matching jobs and remembers every job open on each board it reads, also boards read after your maximum is reached (nothing saved or charged for them); with one run of the watch at a time, each later run returns only jobs that appeared after. Older matches are not back-filled. A job the watch returned that has gone from a board read to its end is listed once, free, in the run's CLOSED_JOBS record, not as a row. A board the watch has not read yet gets its first read, up to your maximum, in the run that first reads it. Run a watch one at a time: two runs started in the same seconds can both return and charge the same job. Default: off.

## `watchName` (type: `string`):

Optional. Give a watch its own memory, for example **ai-labs-engineering**. A named watch keeps its memory when you change its companies or filters (a company you add gets a first run of its own). For a schedule, turn on Apify's setting not to start a new run while the previous one is running. Without a name, each saved task keeps one memory per set of companies and filters, and API runs share one per set.

## `notifyWebhookUrl` (type: `string`):

Optional. Paste a Slack or Discord incoming-webhook address, or any https:// address that accepts JSON, for example **https://hooks.slack.com/services/...**. When the run saves jobs, a short message is posted there: the count, the first three titles with company, location and link, and a link to all rows. No extra charge.

## `notifyWhenNothingFound` (type: `boolean`):

Also post the alert when the run saved no jobs, for example to confirm that a scheduled check ran. Off by default, so a quiet run sends nothing.

## `companiesFromDataset` (type: `string`):

Optional. The ID of a dataset in your account, for example **the output of another Actor** that lists companies, such as aBcD1234eFgH5678. The Greenhouse, Lever, Ashby, Workable, Workday, Recruitee, Personio or Teamtailor board links it recognizes in its rows (up to 5,000 rows) are added to the company list, together with the companies above.

## Actor input object example

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/airbnb",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/ramp"
  ],
  "maxJobs": 100,
  "maxJobsPerCompany": 30,
  "keywordScope": "title",
  "keepUnknownSeniority": false,
  "remoteOnly": false,
  "keepUnstatedWorkplace": false,
  "includeDescription": false,
  "descriptionFormat": "text",
  "onlyNew": false,
  "notifyWhenNothingFound": false
}
```

# Actor output Schema

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

One item per job: company, title, department, location, remote flag, employment type, pay range when published, posted date, job and apply links, and the description when asked for.

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

The run's outcome and coverage, and per company what was read, saved, filtered, failed and why, plus the alert's delivery status. With Google Jobs selected, includes availability, collected and saved counts, flaggedPossibleDuplicates (saved Google rows whose retained application link equals a saved career job/apply URL in the same run after tracking parameters, fragments and trailing slashes are removed, with company names equal after case and whitespace folding; titles and locations do not affect the flag), duplicatesSkipped (repeated Google IDs), and partial or capped search status.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "https://job-boards.greenhouse.io/airbnb",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/ramp"
    ],
    "maxJobs": 100,
    "maxJobsPerCompany": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchwright/lever-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": [
        "https://job-boards.greenhouse.io/airbnb",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/ramp",
    ],
    "maxJobs": 100,
    "maxJobsPerCompany": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("fetchwright/lever-jobs-scraper").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/airbnb",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/ramp"
  ],
  "maxJobs": 100,
  "maxJobsPerCompany": 30
}' |
apify call fetchwright/lever-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/iRJTQNoe4KJLbD5cF/builds/M3DOxdWjSom2n2Be7/openapi.json
