# Greenhouse Jobs Scraper — Live Board Data (`b2b_leads/greenhouse-boards-real-time-data-scraper`) Actor

Live job openings from any company career board on Greenhouse: board listings, keyword search, full descriptions, departments, offices, and direct job links. Results stream to your dataset in real time — ready for recruiters, sourcing, and AI workflows.

- **URL**: https://apify.com/b2b_leads/greenhouse-boards-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.

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 Boards Real-Time Data

Live job openings from any company career board powered by Greenhouse — keyword search across boards, full job descriptions, departments, offices, posting dates, and direct job links, streamed to your dataset in real time.

> **Free trial:** runs on the free Apify plan return a 2-result sample per run. Upgrade to a paid plan for unlimited exports.

### Who is this for?

- **Recruiters & sourcers** building talent pipelines from live openings
- **Job-board operators** aggregating fresh postings across companies
- **Sales & lead-gen teams** tracking hiring signals (growth, new offices, new departments)
- **Market researchers** studying hiring trends by company, department, or location
- **AI agents & automations** that need structured, current job data on demand

### Use cases

1. Monitor engineering hiring across a watchlist of companies.
2. Track new postings daily for a sourcing pipeline.
3. Enrich company records with open roles, departments, and offices.
4. Feed fresh job data into a job board, newsletter, or alert bot.
5. Research which departments and locations a company is growing.
6. Power AI agents that answer "who is hiring for X?" with current data.

### Features

| Checkbox | What it does |
|---|---|
| 💼 Board jobs (default on) | Search live openings across one or more company boards by keyword, location, department, and date posted. |
| Enrich with full details | Adds the full job description, departments, offices, and posting dates to each row. Adds a little extra time per record. Off = fast cards from the board listing. |
| 🔗 Job links | Collect structured data from individual Greenhouse job page URLs. |
| ⚙️ Output & delivery | Streaming dataset output, JSON/Slack webhooks, max-items cap. |
| 🌐 Connection | Residential US connection recommended for reliable, high-volume runs. |

### Input reference

| Field | Type | Default | Example |
|---|---|---|---|
| `enableBoardJobs` | boolean | `true` | Primary discovery — keep on. |
| `boardTokens` | string\[] | `["airbnb"]` | Company boards, e.g. `["airbnb", "stripe", "figma"]` (from `boards.greenhouse.io/BOARD`). |
| `jobKeywords` | string\[] | `["engineer"]` | `["engineer", "designer", "support"]`. Empty = all openings. |
| `jobLocation` | string | `""` | e.g. `"New York"`, `"Remote"`, `"London"`. |
| `jobDepartment` | string | `""` | e.g. `"Engineering"`, `"Design"`. |
| `jobDatePosted` | select | `"any"` | `any` / `month` / `week` / `day`. |
| `jobsPerBoard` | integer | `10` | Max jobs per board/keyword combination (1–200). |
| `searchFetchFullDetails` | boolean | `false` | Enrich each row in place (`detailsFetched: true`). |
| `enableScrapeByUrl` | boolean | `false` | Enable job-links mode. |
| `jobUrls` | string\[] | `[]` | e.g. `["https://boards.greenhouse.io/airbnb/jobs/8184174"]`. |
| `webhookUrl` | string | `""` | Optional HTTPS endpoint for real-time POSTs. |
| `webhookFormat` | select | `"json"` | `json` (full record) or `slack` (compact message). |
| `proxyConfiguration` | proxy | Residential US | Apify proxy settings. |

Tip: find a company's board name from its careers page — Greenhouse boards live at `boards.greenhouse.io/BOARD` (e.g. `boards.greenhouse.io/airbnb`).

### Output fields

Each dataset row is one job posting. Every discovered posting is exported — results are enriched in place, never filtered out.

| Field | Example |
|---|---|
| `featureType` | `board_job` / `scrape_by_url` |
| `jobId` | `8184174` |
| `boardToken` | `airbnb` |
| `title` | `Account Manager` |
| `company` / `companyUrl` | `Airbnb` / `https://boards.greenhouse.io/airbnb` |
| `location` | `London, United Kingdom` |
| `departments` / `offices` | `["Supply"]` / `["London"]` |
| `jobUrl` / `applyUrl` | Board job link / application link |
| `descriptionText` / `descriptionHtml` | Full description (with enrich on) |
| `postedAt` / `updatedAt` | ISO-8601 timestamps |
| `detailsFetched` | `true` when enriched |
| `searchQuery` / `searchBoard` / `position` | Search context |
| `scrapedAt` | Collection timestamp |

### Webhooks

Set `webhookUrl` to receive a real-time POST per job in addition to the dataset write. `json` sends the full row; `slack` sends a compact incoming-webhook message with title, company, location, department, and link. Delivery failures never stop the run.

### MCP / AI-agent usage

Pair with the Apify MCP server: your agent can start this Actor and read the dataset. Example question: *"Find current engineering openings at Airbnb and Stripe in New York, with full descriptions."*

### FAQ

- **Which connection should I use?** Residential US works best for consistent, high-volume runs.
- **What does the free trial include?** 2 results per run on the free plan; paid plans are uncapped.
- **How fresh is the data?** Every run collects current live board listings — no cached dumps.
- **Do partial rows get dropped?** No. Every discovered posting is exported; enrichment only adds fields.
- **Why is a board empty?** Check the board name (`boards.greenhouse.io/BOARD`) — unknown boards return no rows.

# Actor input Schema

## `enableBoardJobs` (type: `boolean`):

Collect live job openings from Greenhouse company boards. Enabled by default.

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

Company board names as they appear in boards.greenhouse.io URLs (e.g. airbnb for boards.greenhouse.io/airbnb). One search runs per board.

## `jobKeywords` (type: `array`):

Search terms matched against job title, department, office, location, and description (e.g. engineer, designer, support). Empty = all openings on the selected boards.

## `jobLocation` (type: `string`):

Optional filter on the job location (e.g. New York, Remote, London). Partial match.

## `jobDepartment` (type: `string`):

Optional filter on the department (e.g. Engineering, Design, Sales). Partial match.

## `jobDatePosted` (type: `string`):

Only return jobs posted within this window.

## `jobsPerBoard` (type: `integer`):

Maximum jobs to return per board/keyword combination (1-200). Default 10 for fast demo runs.

## `searchFetchFullDetails` (type: `boolean`):

Adds full job description, departments, offices, and posting dates to each row. Adds a little extra time per record. Off = fast cards from the board listing.

## `enableScrapeByUrl` (type: `boolean`):

Collect structured data from individual Greenhouse job page URLs.

## `jobUrls` (type: `array`):

Greenhouse job page URLs (https://boards.greenhouse.io/airbnb/jobs/8184174) to collect.

## `webhookUrl` (type: `string`):

Optional HTTPS endpoint. Each record is always saved to the dataset — the webhook sends an additional real-time POST per job (CRM, Slack, Zapier, Make, custom pipelines).

## `webhookFormat` (type: `string`):

json = full job record. slack = compact Slack incoming-webhook message.

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

Apify proxy configuration. Residential US proxy is recommended for consistent results on large runs.

## Actor input object example

```json
{
  "enableBoardJobs": true,
  "boardTokens": [
    "airbnb",
    "stripe",
    "figma"
  ],
  "jobKeywords": [
    "engineer",
    "designer",
    "support"
  ],
  "jobLocation": "",
  "jobDepartment": "",
  "jobDatePosted": "any",
  "jobsPerBoard": 10,
  "searchFetchFullDetails": false,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every job field from this run.

## `overview` (type: `string`):

Core job fields table view.

## `full` (type: `string`):

All job fields including descriptions.

# 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 = {
    "enableBoardJobs": true,
    "boardTokens": [
        "airbnb",
        "stripe",
        "figma"
    ],
    "jobKeywords": [
        "engineer",
        "designer",
        "support"
    ],
    "jobLocation": "",
    "jobDepartment": "",
    "jobDatePosted": "any",
    "jobsPerBoard": 10,
    "searchFetchFullDetails": false,
    "enableScrapeByUrl": false,
    "jobUrls": [],
    "webhookUrl": "",
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/greenhouse-boards-real-time-data-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 = {
    "enableBoardJobs": True,
    "boardTokens": [
        "airbnb",
        "stripe",
        "figma",
    ],
    "jobKeywords": [
        "engineer",
        "designer",
        "support",
    ],
    "jobLocation": "",
    "jobDepartment": "",
    "jobDatePosted": "any",
    "jobsPerBoard": 10,
    "searchFetchFullDetails": False,
    "enableScrapeByUrl": False,
    "jobUrls": [],
    "webhookUrl": "",
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/greenhouse-boards-real-time-data-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 '{
  "enableBoardJobs": true,
  "boardTokens": [
    "airbnb",
    "stripe",
    "figma"
  ],
  "jobKeywords": [
    "engineer",
    "designer",
    "support"
  ],
  "jobLocation": "",
  "jobDepartment": "",
  "jobDatePosted": "any",
  "jobsPerBoard": 10,
  "searchFetchFullDetails": false,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/greenhouse-boards-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/greenhouse-boards-real-time-data-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/9ZOFzReklXc7dkVdw/builds/sCTiZwWvMkQLBPAhA/openapi.json