# Career Site Jobs: Greenhouse, Lever, Workday (`deepmine/career-site-jobs`) Actor

Every open job from career sites on Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Workable, BambooHR, Recruitee, Personio, Teamtailor, Breezy HR and Rippling. Give board URLs or company names; get logo, title, location, remote, department, date, salary, description, apply link.

- **URL**: https://apify.com/deepmine/career-site-jobs.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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

## Career Site Jobs: Greenhouse, Lever, Workday, Workable and 8 more

Career page scraper: get every open job straight from company career sites. Give it company job board URLs, careers pages or just company names, and get one clean row per job with the same fields whichever of 12 hiring systems the company uses: company logo, title, location, remote or hybrid, department, job type, posting date, salary range, full description and the apply link.

| 💼 Title | 🏢 Company | 📍 Location | 🏠 Workplace | 🗂️ Department | 💰 Salary | 📅 Posted | ⚙️ ATS |
|---|---|---|---|---|---|---|---|
| Accountant | Airbnb | United States | Remote | Financial Planning and Analysis | USD 87,000 - 102,000 per year | 2026-09-25 | Greenhouse |
| Contract Operations | Palantir Technologies | Washington, D.C. | Hybrid | Legal | – | 2026-09-25 | Lever |
| Senior Software Program Manager - Datacenter Compute Server | NVIDIA | US, CA, Santa Clara | – | – | – | 2026-09-27 | Workday |

<sub>Collected 2026-09-27.</sub>

**$1.80 per 1,000 jobs** on the Starter plan ($2.00 Free, $1.50 Scale, $1.20 Business). The prefilled run (250 jobs: 50 from each of 5 companies) costs about $0.45.

It reads each ATS's own public job board API: Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Workable, BambooHR, Recruitee, Personio, Teamtailor, Breezy HR and Rippling. No browser and no login. Jobs come exactly as the company published them, read live on every run. It can also search every employer on Workable by keyword.

### What you can do with it

- **Monitor hiring** at a list of companies (competitors, customers, prospects) and see new roles every day.
- **Feed a job board or a job search app** with fresh, first-party postings that include salary, the company logo and the apply URL.
- **Build sales signals**: a company hiring for "Salesforce admin" or "data engineer" is a lead.
- **Research pay and the labor market**: the **💰 With Salary** list holds every job with a published pay range, ready for salary benchmarks.

### Supported career sites

| ATS | What to paste | Salary | Logo | Notes |
|---|---|---|---|---|
| Greenhouse | `https://job-boards.greenhouse.io/airbnb` or `boards.greenhouse.io/airbnb` | when the company publishes pay ranges | yes | Pay zones are listed one after another in `salary` |
| Lever | `https://jobs.lever.co/palantir` (EU: `jobs.eu.lever.co/...`) | when published | yes | |
| Ashby | `https://jobs.ashbyhq.com/notion` | when published | yes | |
| SmartRecruiters | `https://jobs.smartrecruiters.com/BoschGroup` | no | no | Descriptions take one extra request per job |
| Workday | `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` | no | yes | Reads past Workday's 2,000-job limit. Descriptions take one extra request per job |
| Workable | `https://apply.workable.com/huggingface/` | no | yes | Posting date is a day, not a time |
| BambooHR | `https://acme.bamboohr.com/careers` | when published | no | Descriptions, pay and dates take one extra request per job |
| Recruitee | `https://acme.recruitee.com/` | when published | yes | |
| Personio | `https://acme.jobs.personio.de/` | no | yes | Descriptions come in each job's own language |
| Teamtailor | `https://acme.teamtailor.com/jobs` (also `acme.na.teamtailor.com`) | no | yes | |
| Breezy HR | `https://acme.breezy.hr/` | when published | when set | Pay is the company's own text; min, max and period are read from it where it's clear |
| Rippling | `https://ats.rippling.com/acme/jobs` | when published | no | Descriptions, pay and dates take one extra request per job |

You can also paste:

- **The company's own careers page**, e.g. `https://www.notion.com/careers`. The page is checked for a link to its job board.
- **Just the company name**, e.g. `Duolingo` or `Scale AI`. The name is tried on Greenhouse, Lever, Ashby, SmartRecruiters and Workable. The other systems can't be found by name, so paste their URL.
- **`ats:board`** if you know it, e.g. `greenhouse:stripe`, `lever:palantir`, `workable:huggingface`, `personio:acme`, `workday:nvidia.wd5/NVIDIAExternalCareerSite`.

**Search every Workable employer:** put keywords in `searchTerms` (e.g. `data analyst`) and the Actor searches all companies hiring on Workable, not just the ones you list. `locations` goes to Workable's own location search, one search per place. A job two searches find is delivered once. A jobs.workable.com search link in `companies` works too.

### Input

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/airbnb",
    "https://jobs.lever.co/palantir",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "Duolingo"
  ],
  "titleKeywords": ["engineer"],
  "locations": ["United States"],
  "remoteOnly": false,
  "postedWithinDays": 14,
  "maxJobsPerCompany": 100,
  "maxResults": 1000
}
```

| Field | What it does |
|---|---|
| `companies` | Job board URLs, careers pages or company names, one per line. |
| `titleKeywords` | Keep jobs whose title contains any of these (not case-sensitive). |
| `locations` | Keep jobs whose location contains any of these as whole words (`India` doesn't match Indiana). A country name also matches the job's country. Two letters are a country code and match only the job's countries: `US`, `GB` (or `UK`), `DE`, `CA` (Canada, not California). A job's countries include every place its location names, so `UK` keeps "San Francisco, CA; London, UK", "Remote - UK" and "London". Two letters that aren't a country code (`NY`, `WA`) match as a word. |
| `remoteOnly` | Keep only jobs marked remote. |
| `maxJobsPerCompany` | Each company's newest jobs, up to this many (default 100; the form starts at 50), so one big company can't take all of `maxResults`. 0 = every job. You pay per job, so this caps the cost per company. |
| `maxResults` | Stop after this many jobs in total, which caps the run's cost. |
| `postedWithinDays` | Keep only jobs posted in the last N days (0 = any date). This and the options below are under **Advanced** in the form. |
| `searchTerms` | Keyword searches across every employer on Workable. Give only `searchTerms` to run searches only. A call with neither field runs the form's example companies. |
| `maxJobsPerSearch` | Each search's jobs in Workable's ranking (most relevant first), up to this many (default 100; 0 = all). With title keywords or other filters, a search stops after 10 pages in a row (200 results) where no job passes them: put the words in the search term instead. |
| `includeDescription` | Full description as text (on by default). Turning it off makes SmartRecruiters, Workday, BambooHR and Rippling faster. With a location or remote filter, Workday jobs whose list entry doesn't show the country or remote status are still checked, one request each. |
| `includeHtml` | Also the description with its original HTML formatting (`descriptionHtml`). |

### Output

One row per job. Rows come in the order of your companies list, each company's jobs newest first, then the Workable searches, each in Workable's ranking.

Two datasets, both with the same rows:

- **💼 All Jobs** (default dataset). Views: **📊 Overview** (🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 🏠 Workplace, 🗂️ Department, 💰 Salary, 📅 Posted, 🔗 Job Page) and **📝 Details** (💼 Title, 🏢 Company, 🕒 Job Type, 🗂️ Department, 🗺️ All Locations, 🌍 Country, ⚙️ ATS, 📋 Job Board, 🆔 Job ID, 🔗 Job Page). The separate apply link (`applyUrl`) is in the rows and the downloads.
- **💰 With Salary**: the delivered jobs that publish a pay range, in the same order, at no extra charge. View **💰 Salaries**: 🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 💰 Salary, 💰 Salary Min, 💰 Salary Max, 💱 Currency, ⏱️ Pay Period, 📅 Posted, 🔗 Job Page.

#### Output fields

In row order:

- `companyLogo`: the company logo from its job board (Greenhouse, Lever, Ashby, Workday, Workable, Recruitee, Personio, Teamtailor, and Breezy HR when set). A stable image link that doesn't expire. Empty on SmartRecruiters, BambooHR and Rippling, or when the board shows no logo.
- `title`: job title.
- `company`: company name as its job board shows it.
- `location`: the job's location as the company wrote it.
- `workplaceType`: `Remote`, `Hybrid` or `On-site` from the company's own field, or `Remote` when the location says so. Empty when the company doesn't say.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Internship`, `Temporary` or `Other` from the company's own field, else from the title when it says so ("Software Engineer Intern", "(12-month contract)"). Most Greenhouse boards publish no job type, so it's often empty there.
- `department`: department or team the company files the job under.
- `salary`: the published pay, e.g. `USD 87,000 - 102,000 per year`. When a posting lists several ranges (pay zones), each one is listed.
- `salaryMin`: the lowest pay across the published ranges, as a number.
- `salaryMax`: the highest pay across the published ranges, as a number.
- `salaryCurrency`: ISO currency code, e.g. `USD`.
- `salaryPeriod`: `year`, `month`, `week`, `day` or `hour`, from the posting's own wording. When the posting doesn't say, it comes from the amount (20,000 or more a year, 300 or less an hour) for USD, EUR, GBP, CAD, AUD, CHF, NZD and SGD. Otherwise it's empty.
- `postedAt`: when the job was published, in UTC (`2026-09-25T18:53:46Z`). Workday, Workable job boards and BambooHR give only the day (`2026-09-27`). Lever and Rippling give the date the posting was created.
- `jobUrl`: the job's page on the company's career site.
- `applyUrl`: a separate application page (Lever, Ashby, SmartRecruiters, Workable, Recruitee). Empty when you apply on the job page itself (Greenhouse, Workday and the others).
- `locations`: every place the job is offered, as a list.
- `countryCode`: ISO code of the job's country; for a job in several countries, the first one listed.
- `description`: the full job description as plain text, one line per paragraph, `•` for list items. Only with `includeDescription` (on by default).
- `descriptionHtml`: the description with the company's formatting. Only with `includeHtml`.
- `ats`: `Greenhouse`, `Lever`, `Ashby`, `SmartRecruiters`, `Workday`, `Workable`, `BambooHR`, `Recruitee`, `Personio`, `Teamtailor`, `Breezy HR` or `Rippling`.
- `boardUrl`: the company's job board the job was read from (for a Workable search, the company's page on jobs.workable.com).
- `jobId`: the job's id on its ATS.
- `companyInput`: the entry of your `companies` list or the search term that led to this job.
- `scrapedAt`: when this run read the job (UTC).

Example row (a Greenhouse job, description shortened):

```json
{
  "companyLogo": "https://s2-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/656/300/original/duo_logo.png?1625859636",
  "title": "Senior Creative, Social",
  "company": "Duolingo",
  "location": "New York, NY",
  "workplaceType": null,
  "employmentType": null,
  "department": "Marketing and Communications",
  "salary": "USD 142,800 - 193,200 per year",
  "salaryMin": 142800,
  "salaryMax": 193200,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-09-22T18:31:49Z",
  "jobUrl": "https://careers.duolingo.com/jobs/8810682002?gh_jid=8810682002",
  "applyUrl": null,
  "locations": ["New York, NY", "Pittsburgh, PA"],
  "countryCode": "US",
  "description": "Our mission at Duolingo is to develop the best education in the world...",
  "ats": "Greenhouse",
  "boardUrl": "https://job-boards.greenhouse.io/duolingo",
  "jobId": "8810682002",
  "companyInput": "Duolingo",
  "scrapedAt": "2026-09-27T19:21:07Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows, per company, which job board was found and how, how many jobs it lists, how many matched your filters and how many were delivered, plus any error.

### When something goes wrong

- A company that isn't found (a wrong name, a removed job board) is listed in the run summary and the status message. The run still delivers everything else.
- If a job board or a job's details can't be read after several retries on fresh IPs, the run ends as **failed** with the reason, so you notice. The jobs that were read are still in the dataset. A job whose details failed is left out and not charged.
- When `maxResults` is reached, the companies after that point get nothing; the run summary marks them as skipped. Raise `maxResults` or lower `maxJobsPerCompany` to reach more companies.
- SmartRecruiters answers the same for an unknown company and a company with no open jobs, so a wrong SmartRecruiters company id shows up as 0 jobs, with a note.

### Pricing

You pay per job delivered: $2.00 per 1,000 jobs on the Free plan, $1.80 on Starter, $1.50 on Scale and $1.20 on Business. Descriptions are included at the same price. Company lookups, pages that fail, jobs removed by your filters and the 💰 With Salary list cost nothing.

Examples on Starter: the prefilled run (250 jobs) about $0.45; the default `maxResults` of 1,000 jobs $1.80; every job at 10 companies with 300 openings each (3,000 jobs) $5.40. `maxJobsPerCompany` and `maxResults` cap what a run can cost.

### FAQ

**Do I need a proxy?** The default Apify datacenter proxy is all these APIs need.

**How fresh is the data?** Each run reads the job boards live; nothing comes from a cache or a database.

**How many jobs can a company have?** All of them: set `maxJobsPerCompany` to 0. Workday sites stop listing at 2,000 per search, so larger Workday sites are read category by category. If a part couldn't be read completely, the status message says so and the run summary shows how many jobs were read of how many Workday counts.

**Can I search all companies at once?** On Workable, yes: `searchTerms` searches every Workable employer by keyword. The other systems have no cross-company search, so this Actor reads the companies you list. Teamtailor's feed holds at most 5,000 jobs per company; a bigger board is marked as read in part.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily in Apify, and set `postedWithinDays` to 1 or 2 so each run brings only the latest postings.

### Feedback

Missing a career site, a field or a company it can't find? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

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

One per line. The best input is the company's job board URL on Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Workable, BambooHR, Recruitee, Personio, Teamtailor, Breezy HR or Rippling (e.g. https://jobs.lever.co/palantir, https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, https://apply.workable.com/huggingface). You can also give the company's own careers page (it's read for a link to its job board) or just the company name (tried on Greenhouse, Lever, Ashby, SmartRecruiters and Workable; the other systems need the URL). Looking up a company is free; you pay per job delivered.

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains any of these words or phrases (not case-sensitive), e.g. engineer, data, sales manager. Leave empty for every job. Jobs removed by a filter cost nothing.

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

Keep only jobs whose location contains any of these as whole words (not case-sensitive), e.g. London, New York, Germany. A country name also matches the job's country. Two letters are read as a country code and match only the job's countries (every place its location names): US, GB (or UK), DE, CA (Canada, not California). Two letters that aren't a country code (NY, WA) match as a word.

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

Keep only jobs the company marks as remote (or whose location says Remote).

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

Each company's newest jobs, up to this many, so one big company can't take all of Max results. You pay per job, so this caps the cost per company. 0 means every job. Default 100.

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

Stop after this many jobs in total. You pay per job, so this caps the run's cost. Companies are delivered in the order you list them.

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

Keep only jobs posted in the last N days. 0 means any date. Handy for a daily or weekly scheduled run.

## `searchTerms` (type: `array`):

Keyword searches across every employer on Workable (e.g. data analyst, nurse), besides the companies above. Location contains is sent to Workable's own location search, one search per place. Leave Companies empty to run searches only. You pay per job.

## `maxJobsPerSearch` (type: `integer`):

Each search's jobs in Workable's ranking (most relevant first), up to this many. You pay per job, so this caps the cost per search. 0 means every job it finds. Default 100.

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

The full job description as plain text. Same price either way. On SmartRecruiters, Workday, BambooHR and Rippling this takes one more request per job, so turning it off makes those faster. Workday lists don't show every job's country or whether it's remote, so with a location or remote filter those jobs are still checked one request each.

## `includeHtml` (type: `boolean`):

Adds descriptionHtml with the company's original formatting. Same price either way.

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

Apify datacenter proxies are the default and all these job boards need.

## Actor input object example

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/airbnb",
    "https://jobs.lever.co/palantir",
    "https://jobs.ashbyhq.com/notion",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "Duolingo"
  ],
  "remoteOnly": false,
  "maxJobsPerCompany": 50,
  "maxResults": 1000,
  "postedWithinDays": 0,
  "maxJobsPerSearch": 100,
  "includeDescription": true,
  "includeHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `withSalaryUrl` (type: `string`):

No description

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

No description

# 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/palantir",
        "https://jobs.ashbyhq.com/notion",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "Duolingo"
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/career-site-jobs").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/palantir",
        "https://jobs.ashbyhq.com/notion",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "Duolingo",
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/career-site-jobs").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/palantir",
    "https://jobs.ashbyhq.com/notion",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "Duolingo"
  ],
  "maxJobsPerCompany": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/career-site-jobs --silent --output-dataset

```

## MCP server setup

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

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/Zg54WocqvLkyB03hA/builds/qRgVkUTpG00tcCWci/openapi.json