# Greenhouse Jobs Scraper (`deriverge/greenhouse-jobs-scraper`) Actor

Job listings from any Greenhouse board with title, department, locations and the pay range the company publishes, read live when you run it. Give it board links, board tokens or company domains, or leave the list empty to search more than 180,000 open Greenhouse jobs in our daily index.

- **URL**: https://apify.com/deriverge/greenhouse-jobs-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 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 Scraper

Greenhouse Jobs Scraper returns every open job on the Greenhouse boards you give it, one row per job: title, department, locations, posting and update dates, the apply link and the pay range when the company publishes one. Paste a board link such as `https://job-boards.greenhouse.io/gitlab` and click **Start**, or leave the list empty to search more than 180,000 open Greenhouse jobs from our daily index (29 September 2026). Greenhouse boards publish no employment type, workplace type or team, so those fields stay empty. It costs $1.50 per 1,000 jobs on the Free plan ($0.75 on Business), and the $5 of monthly credit in Apify's Free plan covers about 3,300 jobs.

### What data does it return?

| Field | Description |
|---|---|
| `title`, `department` | Title as posted and the first department the job is filed under, `Product Security` in the sample. |
| `companyName`, `company` | Company name from the board (`GitLab`) and the board token from the link (`gitlab`). |
| `locations`, `countries` | Greenhouse gives one location text per job, and it can name several places: `Remote, Canada; Remote, Israel; Remote, United Kingdom; Remote, United States` becomes `CA`, `IL`, `GB` and `US`. |
| `salaryText` | Pay range from the board's pay transparency data with the label the company gave it, such as `203,200 - 275,000 USD (United States Salary Range)`. Several ranges are joined with a semicolon. |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | The same range as numbers. With descriptions on, a range written only in the ad is read too. |
| `salaryYearlyMin`, `salaryYearlyMax` | Pay per year (hourly × 2,080, monthly × 12), for comparing hourly and salaried jobs. |
| `postedAt`, `updatedAt` | When the job was first published and when it last changed, as ISO 8601 timestamps. |
| `language` | Language code Greenhouse stores with the job (`en`), present even without descriptions. |
| `url`, `applyUrl` | The link Greenhouse gives for the job. Some companies point it at their own careers page with a `gh_jid` parameter, as Stripe does: `https://stripe.com/jobs/search?gh_jid=8145117`. |
| `seniority`, `jobCategory`, `workArrangement` | Read from the title, department, location and description: `lead`, `it-security` and `remote` for the sample job. |
| `employmentTypes` | Types named in the title, such as `contract` or `internship`; for most jobs the list is empty. |
| `skills`, `experienceYearsMin`, `educationLevel`, `visaSponsorship` | Read from the description when it is on: `GitLab`, `Go`, `Python`, `TypeScript`, `Rust` and `10` years for the sample job. |
| `description` | The ad as plain text. Greenhouse sends it in the same response as the job list. |
| `key`, `jobId`, `input`, `reference`, `firstSeenAt` | A key such as `greenhouse:gitlab:8731718002`, the Greenhouse job ID, your input as typed, your own label and the time this run read the job. |

### How to scrape Greenhouse jobs

1. Put one Greenhouse board per line into **Career sites**. Links on `job-boards.greenhouse.io` and `boards.greenhouse.io` work, including their EU versions and embed links that carry the token after `?for=`. The bare token (`gitlab`) or a company domain (`gitlab.com`) works as well.
2. To follow only some roles, set **Title keywords**, which also match the department, or **Countries** and **Locations**. The job filters cover seniority, job category, work arrangement and pay.
3. Turn on **Include the full job description** to get the ad text, the skills and years of experience it asks for, and pay that is written only in the text.
4. Click **Start**. The **Output** tab lists the jobs for download in CSV, Excel or JSON. A matching API input:

```json
{
  "companies": ["https://job-boards.greenhouse.io/gitlab", "stripe"],
  "keywords": ["security"],
  "hasSalary": true,
  "includeDescription": true,
  "maxJobsPerCompany": 25
}
```

### Example output

One row from a run on 30 September 2026 over GitLab's board with **Title keywords** set to `security`, **Only jobs with a salary** and descriptions on; `description` is trimmed to its opening two sentences.

```json
{
  "key": "greenhouse:gitlab:8731718002",
  "ats": "greenhouse",
  "company": "gitlab",
  "companyName": "GitLab",
  "jobId": "8731718002",
  "title": "Principal Security Researcher",
  "locations": [
    "Remote, Canada; Remote, Israel; Remote, United Kingdom; Remote, United States"
  ],
  "remote": true,
  "department": "Product Security",
  "team": null,
  "employmentType": null,
  "workplaceType": null,
  "salaryText": "203,200 - 275,000 USD (United States Salary Range)",
  "postedAt": "2026-09-05T17:47:29.000Z",
  "updatedAt": "2026-09-29T14:38:50.000Z",
  "url": "https://job-boards.greenhouse.io/gitlab/jobs/8731718002",
  "applyUrl": "https://job-boards.greenhouse.io/gitlab/jobs/8731718002",
  "description": "GitLab is the intelligent orchestration platform for DevSecOps. GitLab enables organizations to increase developer productivity, improve operational efficiency, reduce security and compliance risk, and accelerate digital transformation. …",
  "language": "en",
  "reference": null,
  "input": "https://job-boards.greenhouse.io/gitlab",
  "firstSeenAt": "2026-09-30T00:43:34.320Z",
  "seniority": "lead",
  "jobCategory": "it-security",
  "employmentTypes": [],
  "workArrangement": "remote",
  "countries": [
    "CA",
    "IL",
    "GB",
    "US"
  ],
  "salaryMin": 203200,
  "salaryMax": 275000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryYearlyMin": 203200,
  "salaryYearlyMax": 275000,
  "visaSponsorship": null,
  "skills": [
    "GitLab",
    "Go",
    "Python",
    "TypeScript",
    "Rust"
  ],
  "experienceYearsMin": 10,
  "experienceYearsMax": null,
  "educationLevel": null
}
```

### How much does it cost to scrape Greenhouse jobs?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 jobs | $1.50 | $1.20 | $0.975 | $0.75 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

A board with 200 open jobs costs $0.30 on the Free plan and $0.15 on Business, whether or not you add descriptions. Jobs your filters remove, jobs the new-only mode skips and companies that turn out to use another system are not charged.

### Limits

- On 29 September 2026, about one Greenhouse job in five in our index had a pay range in its board data. The others get pay numbers only when the description states a range and descriptions are on.
- With no workplace field to go on, `workArrangement` relies on words in the location, title and description, such as `Remote` or `Hybrid`.
- Only the first department of a job is kept.
- A company can run several Greenhouse boards, for example one per region or brand. Add each board on its own line.
- Greenhouse keeps internal job postings off the public board, so they are not returned.

### Searching all Greenhouse jobs

With **Career sites** empty, the actor searches the Greenhouse part of our daily index, where every board is re-read each day. The filters work the same way, except that title keywords match only the title. Results come newest first, up to **Maximum jobs (index search)**, 1,000 when empty; a search that returned 955 jobs finished in about 9 seconds. Index rows name the company in `company` and the token in `companySlug`, and have no `input` or `reference`. Turning on the description re-reads each job on its board, which also drops jobs closed since the last build.

### FAQ

#### Is it legal to scrape Greenhouse job boards?

Greenhouse job boards are public pages that companies publish to recruit, and the actor reads them through Greenhouse's Job Board API, which serves those same pages. It collects the job ads only, with no candidate or employee data. It is up to you to use the results lawfully.

#### What is a Greenhouse board token?

The name after the host in the board link: in `https://job-boards.greenhouse.io/gitlab` it is `gitlab`. If you only know the company's website, enter its domain. The actor looks for a Greenhouse link on the company's careers page and, failing that, for a board whose data contains the domain or whose name matches it.

#### How do I track new Greenhouse jobs every day?

Turn on **Return only jobs posted since the last run**, set a **Watch name** and schedule the run daily. Each run returns the jobs that were not on the boards the time before, and the `CHANGES` record also counts closed and retitled jobs. Jobs a run leaves out because of **Maximum jobs per company** or its maximum cost are not marked as seen, so the following run returns them.

### Related scrapers

- [Career Site Jobs Scraper](https://apify.com/deriverge/greenhouse-lever-workday-jobs-scraper)
- [Career Site and ATS Jobs API](https://apify.com/deriverge/career-site-jobs-search)
- [Lever Jobs Scraper](https://apify.com/deriverge/lever-jobs-scraper)
- [Ashby Jobs Scraper](https://apify.com/deriverge/ashby-jobs-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

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

# Actor input Schema

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

One entry per company: the Greenhouse board identifier, the Greenhouse URL, or just the company domain (stripe.com), which the actor resolves to the right board before it scrapes. Inputs pointing at another applicant tracking system are skipped and listed in the run summary. Leave this empty to search every open Greenhouse job in our daily index instead, by keywords, country, seniority and the other filters below.

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

Keep only jobs whose title, department or team contains at least one of these words, case-insensitive. In the daily index search, when Career sites is left empty, only the title is matched. Leave empty to keep everything.

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

Drop jobs whose title, department or team contains any of these words. In the daily index search, when Career sites is left empty, the title and the company name are checked instead.

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

Keep only jobs whose location contains one of these strings, for example "London", "United States", "Remote".

## `countries` (type: `array`):

Keep only jobs in these countries: English names or two-letter codes, for example United States, Germany, UK or DE. Read from the job location, so "Austin, TX" counts as United States.

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

Keep only jobs the ATS marks as remote or whose location says remote.

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

Drop jobs older than this many days when the ATS provides a posting date. Leave empty for no limit.

## `seniority` (type: `array`):

Read from the job title in English, German, French, Spanish and more. Titles without a level count as mid.

## `categories` (type: `array`):

Read from the job title (and the department when the title says nothing), for example software, healthcare, sales or logistics. Jobs whose title fits no category are left out when this filter is on.

## `workArrangement` (type: `array`):

From the workplace field, the location and clear sentences in the description. Jobs with a place and no remote or hybrid mention count as on-site.

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

Only jobs whose employment field or title states one of these types.

## `hasSalary` (type: `boolean`):

Only jobs that state pay, from the salary field or a pay range in the description (turn on the description to catch more).

## `minYearlySalary` (type: `integer`):

Only jobs whose pay, converted to a year (hourly × 2,080, monthly × 12), reaches this amount in the currency below, for example 120000.

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

Currency of the minimum yearly salary: USD, EUR, GBP, CAD, AUD and so on.

## `visaSponsorship` (type: `boolean`):

Only jobs whose description says the company sponsors visas. Reads the description.

## `descriptionKeywords` (type: `array`):

Only jobs whose title or description contains any of these, for example "python" or "SAP". Reads the description.

## `excludeDescriptionKeywords` (type: `array`):

Drop jobs whose title or description contains any of these, for example "security clearance".

## `skills` (type: `array`):

Only jobs that ask for all of these skills, for example Python, AWS or Salesforce. Known tools, languages and certifications match their other spellings (golang, k8s, postgres); anything else is matched as a whole word in the title or description.

## `maxYearsOfExperience` (type: `integer`):

Leave out jobs whose description asks for more years of experience than this, for example 2 for junior roles. Jobs that do not state years are kept.

## `languages` (type: `array`):

Only jobs written in these languages, as two-letter codes or names, for example en or English to find English-language jobs in Germany. Detected from the description.

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

Adds the job description as plain text. Costs one extra request per job on SmartRecruiters, Workable, Workday and BambooHR, so runs take longer there.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only jobs that were not in the previous snapshot. Schedule the task daily and you get a hiring-signal feed: every new opening, once, the day it appears. Closed jobs are counted in the CHANGES record.

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

Name of the snapshot used by the new-only mode, for example "competitors". Runs from a saved task get a snapshot automatically even without a name.

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

Caps the number of jobs returned per career site. Leave empty for all.

## `maxItems` (type: `integer`):

Cap on jobs returned when Career sites is empty and the daily index is searched, newest first; empty means 1,000.

## Actor input object example

```json
{
  "companies": [
    "stripe",
    "gitlab.com"
  ],
  "remoteOnly": false,
  "hasSalary": false,
  "salaryCurrency": "USD",
  "visaSponsorship": false,
  "includeDescription": false,
  "newOnly": false,
  "maxJobsPerCompany": 25
}
```

# Actor output Schema

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

One row per job with the unified schema: title, locations, remote, department, employment type, salary text where the ATS provides it, posting date, links and optional description.

## `changes` (type: `string`):

New, closed and retitled jobs compared with the previous snapshot of the same watch name or task.

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

Per-company counts, skipped inputs with reasons, and totals.

# 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": [
        "stripe",
        "gitlab.com"
    ],
    "maxJobsPerCompany": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/greenhouse-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": [
        "stripe",
        "gitlab.com",
    ],
    "maxJobsPerCompany": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("deriverge/greenhouse-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": [
    "stripe",
    "gitlab.com"
  ],
  "maxJobsPerCompany": 25
}' |
apify call deriverge/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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