# Greenhouse Job Board Scraper (`vaulted/greenhouse-jobs-scraper`) Actor

Scrape all open jobs from any company hiring on Greenhouse. Give it company slugs and get title, location, department, office, full description and apply link as structured data.

- **URL**: https://apify.com/vaulted/greenhouse-jobs-scraper.md
- **Developed by:** [Vault](https://apify.com/vaulted) (community)
- **Categories:** Jobs, Agents, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Greenhouse Job Board Scraper do?

**This Actor extracts every open role from any company that hires through [Greenhouse](https://www.greenhouse.io/), one of the most widely used applicant tracking systems in tech.** Give it a list of company board slugs and it returns job title, company, location, department, office, posting date and a direct apply link as clean structured data.

Thousands of companies run their careers page on Greenhouse — Stripe, GitLab, Coinbase, Robinhood and many more. One run can pull **hundreds of roles per company**, and you can scrape as many companies as you like in a single run.

Results download as JSON, CSV, Excel or HTML, and are available through the Apify API. Schedule it to run daily and you have a continuously fresh hiring dataset.

### Why use this scraper?

- **Sales and lead intelligence** — a company opening ten engineering roles is a company with budget. Hiring activity is one of the strongest buying signals there is.
- **Recruitment and talent mapping** — see exactly what your competitors are hiring for, where, and in which departments.
- **Build a job board** — aggregate roles from hundreds of companies into your own niche site.
- **Market research** — track hiring volume by function and location over time.
- **Job hunting** — monitor every company you care about in one spreadsheet instead of checking dozens of careers pages.

### How to find a company's slug

Open the company's Greenhouse careers page. The slug is the last part of the URL:

```
https://job-boards.greenhouse.io/stripe   ->  slug is "stripe"
https://job-boards.greenhouse.io/gitlab   ->  slug is "gitlab"
```

Add as many slugs as you want to the **Company board slugs** field. If a company isn't on Greenhouse, the Actor logs a warning and carries on with the rest — a bad slug never breaks your run.

### How to use it

1. Enter one or more **company board slugs**.
2. Optionally set a **keyword** (for example `engineer`) or **location** (for example `London`) filter.
3. Turn on **Include full details** if you want descriptions, departments and offices.
4. Set **Maximum jobs** to cap the run size.
5. Click **Start**, then open the **Storage** tab to export.

### Input

| Field | Type | Description |
|---|---|---|
| `companies` | array | Greenhouse board slugs. Required. |
| `includeDetails` | boolean | Fetch full description, department and office. Default `false`. |
| `keyword` | string | Only return jobs whose title contains this text. |
| `location` | string | Only return jobs whose location contains this text. |
| `maxItems` | integer | Maximum jobs across all companies. Default `1000`. |

```json
{
    "companies": ["stripe", "gitlab", "coinbase"],
    "keyword": "engineer",
    "includeDetails": false,
    "maxItems": 500
}
```

### Output

```json
{
    "title": "Android BSP Engineer",
    "companySlug": "stripe",
    "companyName": "Stripe",
    "location": "Taipei, Taiwan",
    "department": "Engineering",
    "departments": ["Engineering"],
    "office": "APAC",
    "offices": ["APAC"],
    "url": "https://stripe.com/jobs/search?gh_jid=8074125",
    "jobId": 8074125,
    "requisitionId": "See Opening ID",
    "updatedAt": "2026-08-18T18:00:18-04:00",
    "firstPublished": "2026-07-20T21:43:12-04:00",
    "scrapedAt": "2026-08-25T03:17:21.586Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
|---|---|
| `title` | Job title. |
| `companySlug` / `companyName` | The board slug you supplied, and the company's own name. |
| `location` | Location string as published. |
| `department` / `departments` | Team the role sits in. **Requires Include full details.** |
| `office` / `offices` | Office the role is attached to. **Requires Include full details.** |
| `descriptionHtml` / `descriptionText` | Full job description as HTML and as plain text. **Requires Include full details.** |
| `url` | Direct apply link. |
| `jobId` / `requisitionId` | Greenhouse identifiers, useful for de-duplication. |
| `updatedAt` / `firstPublished` | When the posting was last changed and first published. |
| `scrapedAt` | ISO timestamp of capture. |

#### A note on Include full details

Greenhouse serves department, office and description only from its detailed endpoint, which returns roughly **12x more data**. Leaving the option off gives you a much faster, lighter run — but those three fields come back empty. Turn it on when you need them.

### How much does it cost?

Billed **per job returned**, so the cost tracks exactly what you get. A run that matches nothing costs nothing. Use **Maximum jobs** to put a hard ceiling on any run, and prefer keyword or location filters over scraping everything and filtering later.

### Tips

- Run on a daily schedule and diff against yesterday's dataset to catch brand-new postings the day they appear.
- Use `jobId` as your unique key when de-duplicating across runs.
- `firstPublished` tells you how long a role has been open — useful for spotting hard-to-fill positions.
- Leave **Include full details** off when scraping many companies at once, then re-run with it on for the shortlist you care about.

### FAQ, disclaimers, and support

**Where does the data come from?** Greenhouse's public job board endpoint — the same source that powers the embedded careers page on the company's own website. Nothing private or logged-in is accessed.

**Is this legal?** The Actor reads only publicly published job listings. You remain responsible for complying with applicable terms and data protection law in how you use the results.

**One of my companies returned nothing.** That company either isn't on Greenhouse or uses a different slug. Check the URL of their careers page — the slug is the final path segment. The run continues normally and logs which slugs were missing.

**Why are department and office empty?** Turn on **Include full details**. See the note above.

Need another ATS covered, or a custom variant? Open an issue on the **Issues** tab.

# Actor input Schema

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

Greenhouse board identifiers. For https://job-boards.greenhouse.io/stripe the slug is 'stripe'. Add as many as you like.

## `includeDetails` (type: `boolean`):

Fetch the full job description, department and office for every role. Greenhouse only returns these from its detailed endpoint, so leaving this off gives a much faster, lighter run but leaves those three fields empty.

## `keyword` (type: `string`):

Only return jobs whose title contains this text, for example 'engineer'.

## `location` (type: `string`):

Only return jobs whose location contains this text, for example 'London' or 'Remote'.

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

Stop after this many jobs across all companies.

## Actor input object example

```json
{
  "companies": [
    "stripe",
    "gitlab",
    "coinbase"
  ],
  "includeDetails": false,
  "maxItems": 1000
}
```

# Actor output Schema

## `results` (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": [
        "stripe",
        "gitlab",
        "coinbase"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vaulted/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",
        "coinbase",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vaulted/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",
    "coinbase"
  ]
}' |
apify call vaulted/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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