# Greenhouse Jobs Scraper - Company Career Boards to JSON (`studio-amba/greenhouse-jobs-scraper`) Actor

Scrape job postings from any company's Greenhouse career board. Enter a board token like 'adyen' or 'doctolib' and get every open position: department, office, location, remote flag, salary when listed, and full description text. Fast official JSON API, no login or cookies required.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Greenhouse Jobs Scraper

Scrape job postings from any company's Greenhouse career board — enter a board token like `adyen` or `doctolib` and get every open position as clean, structured JSON.

### Why use this actor?

Thousands of companies (Adyen, Doctolib, GitLab, N26, HelloFresh, SumUp, Monzo, Celonis and many more) run their careers page on Greenhouse, one of the most widely used applicant tracking systems. This actor pulls their full job board through Greenhouse's official public JSON API — no HTML parsing, no brittle selectors, no login, no cookies.

Typical use cases:

- **Recruiting & sourcing** — monitor competitors' open roles, spot hiring sprees and freezes
- **Sales intelligence** — companies hiring for a role often buy tools for that role; job postings are buying signals
- **Job aggregators** — feed fresh postings from hundreds of company boards into your job site
- **Market research** — track salaries, remote policies, and demand for specific skills
- **Talent mapping** — see which departments and offices a company is growing

Because the data comes from a stable JSON API rather than scraped HTML, runs are fast (one request per company board) and the output stays consistent.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `boardTokens` | Array | No | Greenhouse board tokens — the company slug in `job-boards.greenhouse.io/{token}`. Defaults to a set of verified European tech companies. |
| `careerPageUrls` | Array | No | Alternative: paste Greenhouse career board URLs and the token is derived automatically. |
| `contentFlag` | Boolean | No | Include the full job description text (HTML-stripped). Default: `true`. |
| `maxItemsPerBoard` | Integer | No | Maximum postings per company board. Default: `200`. |
| `locationFilter` | String | No | Only return jobs whose location or office contains this text, e.g. `"Amsterdam"` or `"Remote"`. |
| `proxyConfiguration` | Object | No | Proxy settings. Datacenter proxies are sufficient — the API is public. |

#### How do I find a company's board token?

Open the company's careers page and look at the URL of an individual job posting. It looks like `https://job-boards.greenhouse.io/{token}/jobs/123456` — the `{token}` part is what you need. You can also just paste that URL into `careerPageUrls` and the actor extracts the token for you.

Verified working examples (June 2026): `adyen`, `doctolib`, `celonis`, `n26`, `gitlab`, `sumup`, `hellofresh`, `contentful`, `monzo`, `getyourguide`, `trivago`.

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `company` | String | `"Adyen"` |
| `boardToken` | String | `"adyen"` |
| `jobId` | Integer | `7436701` |
| `positionName` | String | `"Account Manager"` |
| `department` | String | `"Account Management"` |
| `departments` | Array | `["Account Management"]` |
| `office` | String | `"Amsterdam"` |
| `location` | String | `"Amsterdam"` |
| `remote` | Boolean | `false` |
| `salary` | String | `"£78,000 - £110,000"` (when listed) |
| `contentText` | String | Full job description, plain text |
| `requisitionId` | String | `"JR_3740"` |
| `jobLanguage` | String | `"en"` |
| `firstPublished` | String | `"2026-01-15T08:53:34-05:00"` |
| `updatedAt` | String | `"2026-06-08T02:57:37-04:00"` |
| `url` | String | Direct application URL |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
    "company": "Adyen",
    "boardToken": "adyen",
    "jobId": 7436701,
    "positionName": "Account Manager",
    "department": "Account Management",
    "departments": ["Account Management"],
    "office": "Amsterdam",
    "location": "Amsterdam",
    "remote": false,
    "salary": "",
    "contentText": "This is Adyen\n\nAdyen provides payments, data, and financial products in a single solution for customers like Meta, Uber, H&M, and Microsoft...",
    "requisitionId": "JR_3740",
    "jobLanguage": "en",
    "firstPublished": "2026-01-15T08:53:34-05:00",
    "updatedAt": "2026-06-08T02:57:37-04:00",
    "url": "https://job-boards.greenhouse.io/adyen/jobs/7436701",
    "scrapedAt": "2026-06-11T12:09:41.146Z"
}
````

### How to scrape Greenhouse jobs data

1. **Create a free Apify account** and open this actor.
2. **Enter board tokens** for the companies you want to track (e.g. `adyen`, `gitlab`), or paste their Greenhouse careers URLs. Leave it empty to try the verified defaults.
3. **Optionally filter by location** — e.g. `"Berlin"` or `"Remote"` — and set `maxItemsPerBoard`.
4. **Run the actor.** One company board takes a few seconds; the entire board is fetched in a single API call.
5. **Export your data** as JSON, CSV, or Excel from the dataset tab, or connect via the Apify API to feed your own systems.

To monitor hiring activity over time, schedule the actor to run daily or weekly and compare `jobId` sets between runs — new IDs are new openings, missing IDs are closed roles.

### Salary data

Greenhouse does not have a structured salary field, but many companies (especially UK-based ones, where pay transparency is common) include pay ranges in the description. The actor extracts these with a best-effort parser that looks for ranges like `£78,000 - £110,000` or `€77.000 - €94.000` near salary-related wording. Expect salary coverage to vary by company — Monzo lists ranges on most roles, Adyen on none.

### Cost estimate

One request per company board, regardless of how many jobs it has. Scraping 10 company boards (~1,000 postings) uses well under **0.01 compute units** — effectively the only cost is the per-result fee. This makes it one of the cheapest ways to build a multi-company jobs dataset.

### Limitations

- Only works for companies that use Greenhouse as their ATS. For companies on Lever, Workday, or SmartRecruiters you need a different scraper.
- The board token must be exact — `spotify` and `klarna` for example do not expose public Greenhouse boards.
- Salary extraction is best-effort; not all companies publish pay ranges.
- Data comes from the public Greenhouse board API and may change without notice. Respect the website's terms of service and use the data responsibly.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

## `boardTokens` (type: `array`):

Greenhouse board tokens — the company slug in job-boards.greenhouse.io/{token}. Examples: 'adyen', 'doctolib', 'celonis', 'n26', 'gitlab', 'sumup', 'hellofresh'. Defaults to a few verified European tech companies if empty.

## `careerPageUrls` (type: `array`):

Alternative to board tokens: paste Greenhouse career board URLs (e.g. https://job-boards.greenhouse.io/adyen or https://boards.greenhouse.io/doctolib). The board token is derived automatically.

## `contentFlag` (type: `boolean`):

Fetch the full job description text for every posting (HTML-stripped). Disable for a faster, lighter run with only structural fields.

## `maxItemsPerBoard` (type: `integer`):

Maximum number of job postings to return per company board.

## `locationFilter` (type: `string`):

Only return jobs whose location or office contains this text (case-insensitive). Examples: 'Amsterdam', 'Berlin', 'Paris', 'Remote'. Leave empty for all locations.

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

Proxy settings. The Greenhouse board API is public and has no anti-bot — any Apify proxy works.

## Actor input object example

```json
{
  "boardTokens": [
    "adyen",
    "doctolib",
    "celonis",
    "n26"
  ],
  "contentFlag": true,
  "maxItemsPerBoard": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "boardTokens": [
        "adyen",
        "doctolib",
        "celonis",
        "n26"
    ],
    "contentFlag": true,
    "maxItemsPerBoard": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "boardTokens": [
        "adyen",
        "doctolib",
        "celonis",
        "n26",
    ],
    "contentFlag": True,
    "maxItemsPerBoard": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/greenhouse-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "boardTokens": [
    "adyen",
    "doctolib",
    "celonis",
    "n26"
  ],
  "contentFlag": true,
  "maxItemsPerBoard": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/greenhouse-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Jobs Scraper - Company Career Boards to JSON",
        "description": "Scrape job postings from any company's Greenhouse career board. Enter a board token like 'adyen' or 'doctolib' and get every open position: department, office, location, remote flag, salary when listed, and full description text. Fast official JSON API, no login or cookies required.",
        "version": "0.1",
        "x-build-id": "02mzpHQgDb6LkbT7D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~greenhouse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~greenhouse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~greenhouse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "boardTokens": {
                        "title": "Board Tokens",
                        "type": "array",
                        "description": "Greenhouse board tokens — the company slug in job-boards.greenhouse.io/{token}. Examples: 'adyen', 'doctolib', 'celonis', 'n26', 'gitlab', 'sumup', 'hellofresh'. Defaults to a few verified European tech companies if empty.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "careerPageUrls": {
                        "title": "Career Page URLs",
                        "type": "array",
                        "description": "Alternative to board tokens: paste Greenhouse career board URLs (e.g. https://job-boards.greenhouse.io/adyen or https://boards.greenhouse.io/doctolib). The board token is derived automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "contentFlag": {
                        "title": "Include Full Job Descriptions",
                        "type": "boolean",
                        "description": "Fetch the full job description text for every posting (HTML-stripped). Disable for a faster, lighter run with only structural fields.",
                        "default": true
                    },
                    "maxItemsPerBoard": {
                        "title": "Max Items Per Board",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job postings to return per company board.",
                        "default": 200
                    },
                    "locationFilter": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Only return jobs whose location or office contains this text (case-insensitive). Examples: 'Amsterdam', 'Berlin', 'Paris', 'Remote'. Leave empty for all locations."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. The Greenhouse board API is public and has no anti-bot — any Apify proxy works.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
