# Greenhouse Jobs: Export Any Company's Job Board (`deepmine/greenhouse-jobs`) Actor

Export every open job from any company's Greenhouse job board: title, location, remote or hybrid, department, posting date, salary range when the company publishes it, full description and apply link. Paste board URLs or just company names. Lever and Ashby boards work too. No login.

- **URL**: https://apify.com/deepmine/greenhouse-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 $0.50 / 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

## Greenhouse Jobs: Export Any Company's Job Board

Paste Greenhouse job boards (`https://job-boards.greenhouse.io/duolingo`) or just company names, and get **every open job** as one clean row each: title, location, remote or hybrid, department, posting date, **salary range when the company publishes it**, full description and job link.

| 💼 Title | 🏢 Company | 📍 Location | 🏠 Workplace | 🗂️ Department | 💰 Salary | 📅 Posted |
|---|---|---|---|---|---|---|
| Staff Machine Learning Engineer, App Ads Modeling | Reddit | Remote - United States | Remote | Ads Engineering | USD 230,000 - 322,000 per year | 2026-09-25 |
| Software Engineer, Ingestion Platform | Reddit | Remote - United States | Remote | BE Platform | USD 164,200 - 229,900 per year | 2026-09-18 |
| Senior Creative, Social | Duolingo | New York, NY | – | Marketing and Communications | USD 142,800 - 193,200 per year | 2026-09-22 |

<sub>Collected 2026-09-28 with Reddit and Duolingo, 50 newest jobs each: 91 of the 100 jobs published a pay range.</sub>

**$0.90 per 1,000 jobs** on the Starter plan ($1.00 Free, $0.60 Scale, $0.50 Business). The prefilled run (100 jobs: 50 from each of 2 companies) costs about $0.09.

It reads Greenhouse's public job board API, the one each company's careers page uses. No browser and no login. Jobs come exactly as the company published them, read live on every run.

### What you can do with it

- **Salary as numbers:** `salaryMin`, `salaryMax`, currency and period next to the readable `salary`, with every pay zone listed. How many jobs publish pay depends on the company: 91 of 100 in the sample above, none on some boards.
- **Research pay** by role, team and city: the **💰 With Salary** list holds every job with a published pay range, ready for salary benchmarks.
- **Monitor hiring** at target accounts (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 job link.
- **Filter before you pay:** title words, locations (whole words or country codes), remote only, posted in the last N days. Jobs your filters drop cost nothing.
- **One format for every ATS:** Lever, Ashby, SmartRecruiters and Workday boards work in the same run, with the same fields.

### What to paste

| ATS | What to paste | Salary | Logo | Notes |
|---|---|---|---|---|
| Greenhouse | `https://job-boards.greenhouse.io/duolingo`, `boards.greenhouse.io/duolingo` or just `Duolingo` | 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` | from the description (most US jobs) | yes | Reads past Workday's 2,000-job limit, or only as far as the newest jobs you asked for. Descriptions take one extra request per job |

You can also paste:

- **Just the company name**, e.g. `Duolingo` or `Scale AI`. The name is tried on Greenhouse, Lever, Ashby and SmartRecruiters.
- **The company's own careers page**, e.g. `https://www.notion.com/careers`. The page is checked for a link to its job board.
- **`ats:board`** if you know it, e.g. `greenhouse:stripe`, `lever:palantir`.

### Input

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/reddit",
    "https://job-boards.greenhouse.io/duolingo",
    "Figma"
  ],
  "titleKeywords": ["engineer"],
  "locations": ["United States"],
  "remoteOnly": false,
  "postedWithinDays": 30,
  "maxJobsPerCompany": 100,
  "maxResults": 1000
}
```

| Field | What it does |
|---|---|
| `companies` | Greenhouse job board URLs or company names, one per line. Other job board URLs and careers pages work too. |
| `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), 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). The filters are under **🎛️ Filters** in the form, `includeHtml` under **🧾 Output**. |
| `includeDescription` | Full description as text (on by default). Workday's pay range is read from the description, so with it off Workday rows have no salary. Turning it off makes SmartRecruiters and Workday 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.

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 page (Greenhouse, Lever, Ashby, Workday). A stable image link that doesn't expire. Empty on SmartRecruiters 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)"). Many 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 gives only the day (`2026-09-27`). Lever gives 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). Empty when you apply on the job page itself (Greenhouse, Workday).
- `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` or `Workday`.
- `boardUrl`: the company's job board the job was read from.
- `jobId`: the job's id on its ATS.
- `companyInput`: the entry of your `companies` list that led to this job.
- `scrapedAt`: when this run read the job (UTC).

Example row (description shortened):

```json
{
  "companyLogo": "https://recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/000/004/762/original/200x75.png?1705381755",
  "title": "Staff Machine Learning Engineer, App Ads Modeling",
  "company": "Reddit",
  "location": "Remote - United States",
  "workplaceType": "Remote",
  "employmentType": "Full-time",
  "department": "Ads Engineering",
  "salary": "USD 230,000 - 322,000 per year",
  "salaryMin": 230000,
  "salaryMax": 322000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-09-25T01:13:27Z",
  "jobUrl": "https://job-boards.greenhouse.io/reddit/jobs/8187652",
  "applyUrl": null,
  "locations": ["Remote - United States"],
  "countryCode": "US",
  "description": "Reddit is a community of communities. It’s built on shared interests, passion, and trust...",
  "ats": "Greenhouse",
  "boardUrl": "https://job-boards.greenhouse.io/reddit",
  "jobId": "8187652",
  "companyInput": "https://job-boards.greenhouse.io/reddit",
  "scrapedAt": "2026-09-28T00:33:33Z"
}
```

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.

### Pricing

You pay per job delivered: $1.00 per 1,000 jobs on the Free plan, $0.90 on Starter, $0.60 on Scale and $0.50 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 (100 jobs) about $0.09; the default `maxResults` of 1,000 jobs $0.90; every job at 10 companies with 300 openings each (3,000 jobs) $2.70. `maxJobsPerCompany` and `maxResults` cap what a run can cost.

### FAQ

**Why do some jobs have no salary?** The company decides whether to publish a pay range on Greenhouse. Some publish it on every job, some only in the description text, some not at all.

**Do I need a proxy?** The default Apify datacenter proxy is all these APIs need. Residential and SERP proxies are replaced with datacenter; your own proxy URLs work too.

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

**Can I search all companies at once?** Not yet. This Actor reads the companies you list.

**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`):

Greenhouse board URLs (https://job-boards.greenhouse.io/reddit) or company names (Duolingo). Lever, Ashby, SmartRecruiters and Workday boards work too.

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

Each company's newest jobs, up to this many. You pay per job, so this caps the cost per company. 0 = every job.

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

Stop after this many jobs in total, delivered in the order of your inputs. You pay per job, so this caps the run's cost.

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

Adds the full description as plain text, at the same price. Workday pay ranges are read from it. Off is faster on Workday, SmartRecruiters, BambooHR and Rippling (one request less per job).

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

Keep jobs whose title contains any of these words or phrases, e.g. engineer, sales manager. Not case-sensitive. Empty = every job.

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

Keep jobs whose location names any of these, e.g. London, Germany. Two letters are a country code: US, GB, DE, CA (Canada). Empty = anywhere.

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

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

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

Keep jobs posted in the last N days, e.g. 7 for a weekly scheduled run. 0 = any date.

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

Adds descriptionHtml with the company's own formatting. Same price. Needs job descriptions on.

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

Leave as is: Apify datacenter proxies are all these job boards need. Residential and SERP proxies are replaced with datacenter (they cost more and add nothing here); your own proxy URLs work too.

## Actor input object example

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/reddit",
    "https://job-boards.greenhouse.io/duolingo"
  ],
  "maxJobsPerCompany": 50,
  "maxResults": 1000,
  "includeDescription": true,
  "remoteOnly": false,
  "postedWithinDays": 0,
  "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/reddit",
        "https://job-boards.greenhouse.io/duolingo"
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/greenhouse-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/reddit",
        "https://job-boards.greenhouse.io/duolingo",
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/greenhouse-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/reddit",
    "https://job-boards.greenhouse.io/duolingo"
  ],
  "maxJobsPerCompany": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/greenhouse-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/greenhouse-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/JmTtSR4l2VhfmUyio/builds/Mp1O4QE744uZa770J/openapi.json