# Greenhouse Jobs Scraper: Live Boards, Pay, New-Job Alerts (`fetchwright/greenhouse-jobs-scraper`) Actor

Greenhouse jobs live from each company's own board, $1.00 per 1,000 jobs: pay range and pay written in the description, seniority, an only-new watch with Slack or webhook alerts. Input: Greenhouse board links or names. $0.70 per 1,000 jobs on Business.

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

## Pricing

from $0.70 / 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

### What does Greenhouse Jobs Scraper do?

**Greenhouse Jobs Scraper** returns the open jobs of the companies you name, read live from their Greenhouse job boards during the run, at **$1.00 per 1,000 jobs** on the Free plan ($0.70 to $0.90 on paid plans). Give it Greenhouse board links such as `https://job-boards.greenhouse.io/airbnb` or board names such as `stripe`. Each row gives the title, department, locations, remote flag, the pay range when the employer publishes it, pay written in the description, the level read from the title, the posting and update dates and the job link. A named watch, run on a schedule one run at a time, returns only the jobs that are new since its last run and can post them to Slack, Discord or a webhook.

It is for recruiters and sourcers who track target companies, sales teams who use hiring as a buying signal, job boards and newsletters that need fresh postings, and salary researchers.

**Measured** in a read of the full boards on 12 November 2026: Airbnb's Greenhouse board listed 207 open jobs and published a pay range on 168 of them; Stripe's listed 786 with no pay range on any. Each board answered in under a second (0.58 s and 0.73 s).&#x20;

#### Your first check

1. Keep the prefilled boards (Airbnb and Stripe) or paste your own Greenhouse links or board names.
2. Run it. The prefilled run saves up to 30 jobs per company, at most 60 jobs: **$0.06 on the Free plan**, $0.042 on Business, plus Apify's start fee of $0.00005.&#x20;
3. For monitoring, turn on **Only new jobs (watch)** and schedule the task daily: the first run returns up to your maximum of the newest jobs and remembers the rest; with one run of the watch at a time, later runs return only jobs that appeared since.&#x20;

### Why choose Greenhouse Jobs Scraper?

- **Live from the board, not a stored copy.** Every run reads each company's board at the time of the run, so a job closed this morning is not in your results and one posted a minute ago is.
- **Pay, two ways.** The pay range from the employer's own pay block (`salaryMin`, `salaryMax`, `salaryCurrency`, `salaryText`), and, for jobs without one, pay written in the description (`payFromText`), with descriptions on or off, at no extra charge.&#x20;
- **An only-new watch with alerts built in.** Schedule it; each run returns only new jobs, lists jobs that closed in a free `CLOSED_JOBS` record, and can post a short message to a Slack or Discord incoming webhook or any https:// address.&#x20;
- **You never pay for more than you set.** **Maximum jobs per run**, **Maximum jobs per company** and the run's maximum charge in Apify all hold; the run stops there and keeps what it saved.
- **Failures cost nothing and are explained.** A company without a Greenhouse board, a board that cannot be read and jobs left out by your filters are not charged; the run summary lists each company with its reason.
- **No recruiter fields.** Recruiter, hiring-manager and contact fields are never returned, and e-mail addresses and phone numbers written in the usual formats are removed from descriptions.

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

**$1.00 per 1,000 jobs on the Free plan, $0.70 to $0.90 on paid plans.** You pay per job saved; platform usage is included and there is no monthly rental.

| Your Apify plan | Price per 1,000 jobs |
| --- | --- |
| Free | $1.00 |
| Starter (Bronze) | $0.90 |
| Scale (Silver) | $0.80 |
| Business (Gold) and above | $0.70 |

Every run also has Apify's start event, charged when the run starts: $0.00005 for a run with up to 1 GB of memory (the default is 512 MB). Descriptions, pay, alerts and filters are included in the price per job.

**Never charged** (only the start event applies): a company without a Greenhouse board, a board that refuses or fails, jobs left out by your filters or your maximum per company, jobs a watch already returned (with one run of the watch at a time), a job found twice in one run, a run stopped before any request because its input lists a board of another system or asks for a keyword search on the Free plan, and anything a run did not reach because of your maximum, your maximum charge or the timeout.

| Job | Jobs | Cost on Free | Cost on Gold |
| --- | --- | --- | --- |
| The prefilled example: up to 30 jobs at each of two companies | 60 | $0.06 | $0.042 |
| Every open job at Airbnb on 12 November 2026 | 207 | $0.21 | $0.14 |
| 1,000 jobs across your target list | 1,000 | $1.00 | $0.70 |
| Daily watch, maximum 100 per run: the first run (the other open jobs are remembered, not charged) | 100 | $0.10 | $0.07 |
| The same watch afterwards | only the jobs that appeared since the previous run | per job | per job |

Apify's free plan includes $5 of credit each month, about **5,000 jobs** with this Actor.

#### How does the price compare?

Prices of the three actors at the top of an Apify Store search for "greenhouse jobs" on 17 November 2026, read from their public price cards that day. We compared listings, prices and published input forms; we did not run them. Prices change; check each listing before you decide.

| Actor | Monthly users | Free plan, per 1,000 jobs | Business plan, per 1,000 jobs | Reads the board live | Only-new watch | Alert to Slack or a webhook |
| --- | --- | --- | --- | --- | --- | --- |
| **This Actor** | new | **$1.00** | **$0.70** | Yes | Yes | Yes |
| First result | 135 | $2.00 | $1.20 | No (a job database) | Not in its input form | Not in its input form |
| Second result | 31 | $4.00 | $1.30 | No (a job database) | Not in its input form | Not in its input form |
| Third result | 16 | $1.00, descriptions extra | $0.90, descriptions extra | Yes | By date filter | Not in its input form |

### How do I scrape Greenhouse jobs?

1. Find the company's careers page. If its job links go to `job-boards.greenhouse.io/<name>` or `boards.greenhouse.io/<name>`, paste that link, or just the `<name>`.
2. Set **Maximum jobs per run** and, if you like, **Maximum jobs per company**, title keywords, locations, departments, seniority, salary or date filters.
3. Run it, and download the rows as JSON, CSV or Excel, or read them through the API.
4. To monitor, turn on **Only new jobs (watch)**, give the watch a name, add a Slack webhook under **Send an alert**, and schedule the task daily or weekly in Apify (with the setting that does not start a run while the previous one is running). A daily watch costs the new jobs it finds plus $0.00005 per run.

A board name with capitals or spaces is read in lower case without spaces: `Scale AI` is the board `scaleai`. A link to a Lever, Ashby, Workday or other board stops the run before any request, with nothing charged; [Company Career Page Jobs Scraper](https://apify.com/fetchwright/lever-jobs-scraper) reads those with the same rows.&#x20;

### ⬇️ Input for Greenhouse Jobs Scraper

```json
{
    "companies": ["https://job-boards.greenhouse.io/airbnb", "stripe"],
    "maxJobs": 200,
    "maxJobsPerCompany": 100,
    "keywords": ["engineer", "data"],
    "locations": ["United States", "Remote"],
    "onlyNew": true,
    "watchName": "greenhouse-engineering",
    "notifyWebhookUrl": "https://hooks.slack.com/services/..."
}
```

| Field | What it does |
| --- | --- |
| Greenhouse boards | Board links or names, one per line. Up to 1,000 per run. |
| Maximum jobs per run / per company | Caps on rows saved, newest first. They cap the cost. |
| Find boards by keyword | Optional, paid Apify plans only: a web search finds Greenhouse boards with matching jobs (up to 10 boards per keyword, 5 keywords per run); only matching jobs are saved. On the Free plan a run with keywords stops before any request, with nothing charged. |
| Title keywords, Exclude title keywords, Match keywords in | Keep or leave out jobs by words in the title, or in the title and description. |
| Locations, Departments, Seniority, Remote, Workplace, Employment types | Filters on what the board states. |
| Minimum / Maximum salary, Salary currency | Compared with the published pay range in its own currency, no conversion. |
| Posted in the last days, Posted on or after, Updated on or after | Date filters on Greenhouse's first-published and updated dates. |
| Include the job description, Description format | The description as text, HTML or Markdown; no extra charge. |
| Only new jobs (watch), Watch name, Send an alert | Monitoring: only new jobs per run, and a message when it saves jobs. |
| Companies from a dataset | A dataset ID: the Greenhouse board links in its rows are added. |

Field names of other Greenhouse actors (`urls`, `startUrls`, `companyUrls`, `titleKeywords`, `maxItems` and others) are read as ours, so a saved input from another actor usually runs unchanged.

### ⬆️ Output from Greenhouse Jobs Scraper

One row per saved job. The dataset has three views: **Overview**, **Pay and work type**, and **Boards, dates and links**. An abridged row from the recorded Airbnb board:

```json
{
    "searchTarget": "https://job-boards.greenhouse.io/airbnb",
    "system": "greenhouse",
    "boardToken": "airbnb",
    "jobId": "8374941",
    "jobKey": "greenhouse:airbnb:8374941",
    "company": "Airbnb",
    "title": "Engineering Manager, Marketing Technology",
    "seniority": "manager",
    "department": "Software Engineering",
    "location": "United States - Remote",
    "workplaceType": "remote",
    "isRemote": true,
    "salaryMin": 212000,
    "salaryMax": 265000,
    "salaryCurrency": "USD",
    "salaryText": "$212,000 — $265,000 USD",
    "payFromText": null,
    "postedAt": "2026-11-10T16:22:38-05:00",
    "updatedAt": "2026-11-11T20:11:05-05:00",
    "url": "https://careers.airbnb.com/positions/8374941?gh_jid=8374941",
    "descriptionStatus": "not_requested",
    "scrapedAt": "2026-11-12T05:30:00.000Z"
}
```

Fields as the board states them: `title`, `department`, `location`, `locations`, `workplaceType` (where the board has a workplace field), `isRemote` with `remoteStatedBy`, `employmentType` (most Greenhouse boards state none), `salaryMin` to `salaryText` and `salaryRangesStated` from the employer's pay block (Greenhouse states no pay interval), `postedAt` (first published), `updatedAt`, `requisitionId`, `url` and `applyUrl`. Added by the Actor: `seniority` (from the title by fixed rules), `payFromText` (pay written in the description, for jobs without a pay block: a list of `{min, max, currency, period, location, sentence, source}`), `matchedKeywords`, `foundByKeyword`, `description` and `descriptionStatus`, `jobKey`, `searchTarget` and `scrapedAt`.

#### The run summary

If Apify does not let this Actor open the watch memory store `ats-jobs-watch` because another actor in your account made a store of the same name (under Apify's limited permissions an actor may open only the named stores it made), the run is not stopped: nothing was read from that store, so the watch follows its first-run rule once, and from then on its memory is kept in `ats-jobs-watch-<this Actor's ID>` instead, unless the other store is later deleted, in which case the next run starts a new memory under the usual name (its first-run rule applies once), and the `SUMMARY` record says so under `storeNotes`. The Lever, Greenhouse and Workday listings use the same store name, so this happens when one of the others ran a watch in your account first.

Each run writes a `SUMMARY` record in its key-value store: the outcome and coverage, and per company the jobs on the board, matched, saved, left out by each filter, skipped as seen by the watch, and why a company failed, plus `requests`, `requestsBySource`, `peakRequestsPerMinute` and the alert's delivery status. On a watch, jobs that closed are listed once, free, in `CLOSED_JOBS`.

### Limits of Greenhouse Jobs Scraper

- **Greenhouse boards only.** Companies on Lever, Ashby, Workday and other systems are read by [Company Career Page Jobs Scraper](https://apify.com/fetchwright/lever-jobs-scraper). Boards on Greenhouse's EU instance (`job-boards.eu.greenhouse.io`) are not read yet.
- **Public jobs only.** Internal and unlisted postings are not returned.
- **What the board states.** Pay, employment type and workplace type are present only when the employer publishes them; most Greenhouse boards state no employment or workplace type, so those filters leave their jobs out.
- **Pay from the description** reads supported English-language ranges; a description that states several different ranges lists them all without picking one.
- **Keyword search** is for paid Apify plans, up to 5 keywords per run, and finds the boards the search engine has indexed for the keyword, so boards can be missed.
- **A watch's memory belongs to this Actor.** A watch with the same name in Workday Jobs Scraper or Company Career Page Jobs Scraper keeps its own memory and runs independently.
- **A watch's first run** does not back-fill: matching jobs beyond your maximum are remembered and not returned later.
- **Run a watch one at a time:** two runs of the same watch started within the same seconds can both return and charge the same job.

### Use it as a Greenhouse jobs API (Python, Node.js, curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/fetchwright~greenhouse-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["airbnb", "stripe"], "maxJobs": 50}'
```

The same call works from the Apify Python and JavaScript clients, Make, Zapier, n8n and Google Sheets through Apify's integrations.

#### Use it in Claude, ChatGPT or Cursor through MCP

Add `https://mcp.apify.com?tools=fetchwright/greenhouse-jobs-scraper` as an MCP server, then ask the agent "list the remote engineering jobs Airbnb and Stripe posted on Greenhouse this week, with pay" and it can call this Actor directly through the [Apify MCP server](https://mcp.apify.com).

### ❓ FAQ about Greenhouse Jobs Scraper

#### Is there an official Greenhouse jobs API?

Greenhouse publishes a public Job Board API for each company's board. This Actor reads it for you across many companies, adds pay from descriptions, filters, a watch and alerts, and returns one row format.

#### How fresh is the data?

As fresh as the board: each run reads every board at the time of the run.

#### How much does a run cost?

$1.00 per 1,000 jobs saved on the Free plan, $0.70 on Business, plus $0.00005 per run. Set **Maximum jobs per run** or a maximum charge to cap it.

#### How fast is it?

A board is one request; the boards we read on 12 November 2026 answered in under a second each. Boards are read at most about once a second, so 100 companies take about two minutes or more.

#### Why did a company return no jobs, or fail?

The run summary says why per company: no Greenhouse board under that name (`not_found`), a board of another kind of address (`unsupported_board`), every job left out by your filters (with counts per filter), or a refusal by the service. None of these is charged.

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

The Actor reads job postings that employers publish on their public Greenhouse boards for anyone to read, through Greenhouse's public board API, at a polite pace. It returns no personal data fields. You are responsible for how you use the data; check the rules that apply to you, and consult a lawyer if unsure.

#### Does the output contain personal data?

No recruiter, hiring-manager or contact fields are returned, and e-mail addresses and phone numbers written in the usual formats are removed from descriptions.

#### Can I download the results as CSV, Excel or Google Sheets?

Yes: from the run's dataset in Apify, or through the API and Apify's Google Sheets integration.

### Start reading Greenhouse boards

Paste your target companies' Greenhouse links, set a maximum, and run it; turn on the watch and a schedule to get only new jobs every day.

### More from Fetchwright

- [Company Career Page Jobs Scraper](https://apify.com/fetchwright/lever-jobs-scraper): the same rows from Lever, Greenhouse, Ashby, Workable, Workday, Recruitee, Personio and Teamtailor in one run.
- [Workday Jobs Scraper](https://apify.com/fetchwright/workday-jobs-scraper): open jobs from companies' Workday careers sites.

# Changelog

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

# Actor input Schema

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

The companies whose open Greenhouse jobs you want, one per line: the board link, such as **https://job-boards.greenhouse.io/airbnb** (boards.greenhouse.io and embed links work too), or the board name, such as **stripe** or **greenhouse:stripe**. A name written with spaces or capitals, such as Scale AI, is read as the board name scaleai. A board of another system (Lever, Ashby, Workday and others) stops the run before any request, with nothing charged: read those with Company Career Page Jobs Scraper. A company without a Greenhouse board costs nothing. Leave it empty to find boards by keyword only (below).

## `maxJobs` (type: `integer`):

A hard cap: the run never saves more than this many jobs, for example **100**. You pay per job saved ($1.00 per 1,000 on the Free plan), so this caps the cost of a run. Companies are read in the order you list them, newest jobs first. Default: 100.

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

Optional, for example **30**: at most this many jobs per board, newest first. Default empty: no per-company limit. Jobs left out by it are not charged.

## `searchKeywords` (type: `array`):

Optional. Find Greenhouse boards of companies you do not name: for each keyword, one per line, for example **data engineer** or **product designer**, a web search finds Greenhouse boards that list such jobs, and those boards are read. Only their jobs that match the keyword are saved (each row says which in foundByKeyword); finding boards costs nothing. Results are the boards the search engine has indexed for the keyword, so boards can be missed; at most 10 boards are read per keyword. Paid Apify plans only: each keyword is a web search, so on the Free plan a run with keywords stops before any request, with nothing charged. At most 5 keywords per run.

## `searchLocation` (type: `string`):

Optional. A place such as **London** or **Germany**: from boards found by keyword, only jobs that state this place are saved. Boards you list above are not affected (use Locations below for them).

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

Optional. Keep only jobs whose title contains any of these, one per line, for example **engineer** or **data analyst**. Every word of a line must appear in the title, in any order, at the start of a word, ignoring case. Jobs left out are not saved and not charged. Each saved row lists the keywords it matched (matchedKeywords).

## `keywordScope` (type: `string`):

Where the title keywords above are looked for. **Job title and description** also keeps a job whose description contains a keyword line as written (its words next to each other, in that order, at the start of a word, ignoring case), whether or not you include descriptions in the rows. Exclude keywords always look at the title only. Default: Job title only.

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

Optional. Leave out jobs whose title contains any of these, one per line, for example **senior** or **internship**. Every word of a line must appear in the title as a whole word: **intern** leaves out Software Intern, not Internal Tools Engineer. Jobs left out are not charged.

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

Optional. Keep only jobs in any of these places, one per line, for example **Berlin**, **San Francisco, CA** or **Remote**. A line is one phrase (a comma does not split it); its words must appear as whole words in a location the employer states, ignoring case. A two-letter code such as **US** also matches the country Lever states. Jobs left out are not charged.

## `departments` (type: `array`):

Optional. Keep only jobs whose department or team contains any of these, one per line, for example **Engineering** or **Sales**. Ignoring case. Jobs left out are not charged.

## `seniorities` (type: `array`):

Optional. Keep only jobs whose title states one of these levels, for example **Senior** and **Lead**. The level is read from the job title by fixed rules (each row has it in seniority); a job whose title states no level, such as Software Engineer, is left out and counted as no_seniority unless you keep it below. Jobs left out are not charged.

## `keepUnknownSeniority` (type: `boolean`):

With a seniority filter, also keep jobs whose title states no level (seniority null), for example Software Engineer or Data Scientist. Off by default.

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

Keep only jobs marked remote (isRemote true): a workplace type of remote where the board states one in its custom fields, or, where it states none (most Greenhouse boards), a location that says Remote, for example **Remote - US**. Jobs left out are not charged. Default: off.

## `workplaceTypes` (type: `array`):

Optional. Keep only jobs whose workplace is one of these, for example **Hybrid** and **On-site**. The workplace is the board's own workplace field where it has one (workplaceType); a job with none stated counts as Remote when its location says Remote. Most Greenhouse boards state no workplace type: such jobs are left out and counted as no_workplace in the run summary, unless you keep them below. Jobs left out are not charged.

## `keepUnstatedWorkplace` (type: `boolean`):

With a workplace filter set, also keeps jobs whose board states no workplace type and does not mark them remote, for example **most Greenhouse jobs**. Off by default: such jobs are left out and counted as no_workplace. Jobs that state another workplace are still left out.

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

Optional. Keep only jobs whose employment type, as the board states it, is one of these, one per line, for example **Full-time**, **Part-time**, **Contract** or **Intern**. Case, spaces and punctuation are ignored, and these are read as one type: Full-time and Full Time Employee; Part-time and Part Time Employee; Intern and Internship; Contract and Contractor; Temporary and Temp. Any other type matches only itself (Intern does not match Internal Only; Permanent is not Full-time). Most Greenhouse boards state no employment type, so their jobs are left out while this is set. Jobs left out are not charged.

## `minSalary` (type: `integer`):

Optional. Keep only jobs whose published pay range reaches at least this amount, for example **120000**. Compared in the job's own currency and interval (a year, an hour), with no conversion; add Salary currency to keep one currency. Jobs without a published pay range are left out while a salary filter is set, and are not charged.

## `maxSalary` (type: `integer`):

Optional. Keep only jobs whose published pay range starts at or below this amount, for example **90000**. Compared in the job's own currency and interval, with no conversion. Jobs without a published pay range are left out while a salary filter is set, and are not charged.

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

Optional. Keep only jobs whose published pay range is in this currency, a three-letter code such as **USD**, **EUR** or **GBP**. Jobs without a published pay range are left out while it is set, and are not charged.

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

Optional, for scheduled runs: only jobs first published on or after the date this many days before the run, for example **7**. Jobs whose board states no posting date are left out while this is set. When a start date is also set, the later of the two applies.

## `postedSince` (type: `string`):

Optional date the job was first published, for example **2026-11-01**. Jobs whose board states no posting date are left out while this is set. Leave empty for no lower bound.

## `updatedSince` (type: `string`):

Optional date of the job's last update on Greenhouse, for example **2026-11-01**. Jobs with no update date and no posting date are left out while this is set. Leave empty for no lower bound.

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

Adds the full job description as the employer published it, as plain text, HTML or Markdown (see Description format), for example **the responsibilities and requirements**. Off by default, for smaller rows. No extra request and no extra charge: pay written in the description (payFromText) is read with descriptions off too.

## `descriptionFormat` (type: `string`):

How the description is written when descriptions are included: **Plain text** (as before), **HTML** (the employer's formatting, with scripts, styles, images and every attribute except link addresses removed) or **Markdown** (headings, bold, lists and links). The same response is read in every format: no extra request and no extra charge. Has no effect while descriptions are off. Default: Plain text.

## `onlyNew` (type: `boolean`):

For scheduled monitoring, for example a daily run on your target companies. The first run returns up to your maximum of the newest matching jobs and remembers every job open on each board it reads, also boards read after your maximum is reached (nothing saved or charged for them); with one run of the watch at a time, each later run returns only jobs that appeared after. Older matches are not back-filled. A job the watch returned that has gone from a board read to its end is listed once, free, in the run's CLOSED_JOBS record, not as a row. A board the watch has not read yet gets its first read, up to your maximum, in the run that first reads it. Run a watch one at a time: two runs started in the same seconds can both return and charge the same job. Default: off.

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

Optional. Give a watch its own memory, for example **ai-labs-engineering**. A named watch keeps its memory when you change its companies or filters (a company you add gets a first run of its own). For a schedule, turn on Apify's setting not to start a new run while the previous one is running. Without a name, each saved task keeps one memory per set of companies and filters, and API runs share one per set. The memory belongs to this Actor: a watch of the same name in our other job Actors keeps its own.

## `notifyWebhookUrl` (type: `string`):

Optional. Paste a Slack or Discord incoming-webhook address, or any https:// address that accepts JSON, for example **https://hooks.slack.com/services/...**. When the run saves jobs, a short message is posted there: the count, the first three titles with company, location and link, and a link to all rows. No extra charge.

## `notifyWhenNothingFound` (type: `boolean`):

Also post the alert when the run saved no jobs, for example to confirm that a scheduled check ran. Off by default, so a quiet run sends nothing.

## `companiesFromDataset` (type: `string`):

Optional. The ID of a dataset in your account, for example **the output of another Actor** that lists companies, such as aBcD1234eFgH5678. The Greenhouse board links it recognizes in its rows (up to 5,000 rows) are added to the companies above; values of other job-board systems are left out.

## Actor input object example

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/airbnb",
    "https://job-boards.greenhouse.io/stripe"
  ],
  "maxJobs": 100,
  "maxJobsPerCompany": 30,
  "keywordScope": "title",
  "keepUnknownSeniority": false,
  "remoteOnly": false,
  "keepUnstatedWorkplace": false,
  "includeDescription": false,
  "descriptionFormat": "text",
  "onlyNew": false,
  "notifyWhenNothingFound": false
}
```

# Actor output Schema

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

One item per job: company, title, department, location, remote flag, employment type, pay range when published, posted date, job and apply links, and the description when asked for.

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

The run's outcome and coverage, and per company what was read, saved, filtered, failed and why, plus the alert's delivery status.

# 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/airbnb",
        "https://job-boards.greenhouse.io/stripe"
    ],
    "maxJobs": 100,
    "maxJobsPerCompany": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchwright/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": [
        "https://job-boards.greenhouse.io/airbnb",
        "https://job-boards.greenhouse.io/stripe",
    ],
    "maxJobs": 100,
    "maxJobsPerCompany": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("fetchwright/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": [
    "https://job-boards.greenhouse.io/airbnb",
    "https://job-boards.greenhouse.io/stripe"
  ],
  "maxJobs": 100,
  "maxJobsPerCompany": 30
}' |
apify call fetchwright/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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