# ATS Job Scraper - Greenhouse, Lever, Workday, Ashby & More (`lukehunter/greenhouse-job-alerts`) Actor

Scrape and watch Greenhouse, Lever, Workday, Ashby, Workable, BambooHR, Personio, Breezy and Teamtailor job boards in one run, with normalized salary, employment type and country fields plus new-job alerts for $0.003/job.

- **URL**: https://apify.com/lukehunter/greenhouse-job-alerts.md
- **Developed by:** [Luke Hunter](https://apify.com/lukehunter) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 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.

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

## ATS Job Scraper - Greenhouse, Lever, Workday, Ashby & More

**For recruiters, job-board operators, hiring-market researchers and automation builders who watch company careers pages.** One run scrapes many **Greenhouse, Lever, Workday, Ashby, Workable, BambooHR, Personio, Breezy and Teamtailor** job boards through public careers-site JSON/XML endpoints and returns one normalized schema, including source-backed salary, employment type and country fields where available. Use it as a one-off scraper, or enable `onlyNewSinceLastRun` and schedule it for new-job alerts.

**$0.003 per delivered job — 1,000 jobs = $3**

No login, proxy, cookie, browser automation, customer API key or User-Agent rotation is used. Invalid or blocked companies are isolated in per-company status and never charged.

### Supported platforms

| Platform | Input examples | Source route | Status |
|---|---|---|---|
| Greenhouse | `airbnb`, `greenhouse:stripe`, `https://boards.greenhouse.io/airbnb` | `boards-api.greenhouse.io/v1/boards/{token}` | Supported; unprefixed tokens stay Greenhouse. |
| Lever | `lever:netflix`, `https://jobs.lever.co/netflix` | `api.lever.co/v0/postings/{site}?mode=json` | Supported. |
| Workday | `workday:acme.wd5/External_Careers`, `https://acme.wd5.myworkdayjobs.com/en-US/External_Careers` | `POST .../wday/cxs/{tenant}/{site}/jobs` | Supported; 20-item offset pagination, 2,000-job company cap. |
| Ashby | `ashby:openai`, `https://jobs.ashbyhq.com/openai` | `api.ashbyhq.com/posting-api/job-board/{name}` | Supported. |
| Workable | `workable:huggingface`, `https://apply.workable.com/huggingface` | `apply.workable.com/api/v1/widget/accounts/{account}` | Supported. |
| BambooHR | `bamboohr:acme`, `https://acme.bamboohr.com/careers` | `https://{company}.bamboohr.com/careers/list` | Supported; observed careers-page JSON endpoint. |
| Personio | `personio:acme`, `https://acme.jobs.personio.de/` | `https://{company}.jobs.personio.de/xml` | Supported; documented XML careers feed. `.personio.com` careers URLs are also detected. |
| Breezy HR | `breezy:acme`, `https://acme.breezy.hr/` | `https://{company}.breezy.hr/json` | Supported; observed public careers JSON endpoint. |
| SmartRecruiters | `smartrecruiters:Visa` | Posting API | **Skipped.** API-host robots.txt disallows this crawler. |
| Recruitee | `recruitee:acme` | Careers Site API | **Skipped.** Current access contract requires authentication. |
| Teamtailor | `teamtailor:acme`, `https://acme.teamtailor.com/` | `https://{company}.teamtailor.com/jobs.rss?offset=N&per_page=M` | Supported; Teamtailor documents a public careers-site RSS feed. |

### Quick start

Existing Greenhouse inputs remain unchanged:

```json
{
  "companies": ["airbnb", "stripe"],
  "maxItems": 20
}
```

A mixed-ATS run can use prefixes and careers URLs together:

```json
{
  "companies": [
    "greenhouse:airbnb",
    "https://jobs.lever.co/netflix",
    "https://acme.wd5.myworkdayjobs.com/en-US/External_Careers",
    "https://jobs.ashbyhq.com/openai",
    "https://apply.workable.com/huggingface",
    "bamboohr:acme",
    "personio:acme",
    "breezy:acme",
    "teamtailor:acme"
  ],
  "keywords": ["engineer", "developer"],
  "excludeKeywords": ["manager"],
  "locationContains": "London",
  "departments": ["Engineering"],
  "remoteOnly": false,
  "salaryOnly": false,
  "postedWithinDays": 14,
  "includeDescription": false,
  "maxItems": 50
}
```

URL auto-detection supports Greenhouse, Lever, Workday (including an optional locale segment such as `/en-US/`), Ashby, Workable, BambooHR, Personio, Breezy and Teamtailor careers URLs. Duplicate `platform+company` inputs are removed before requests start.

### Job alerts: only new jobs since the last run

Set `onlyNewSinceLastRun` to `true` and run on an Apify Schedule. The first successful run creates the baseline; later runs return only unseen matching identities. Seen identity is `atsPlatform + sourceBoard + jobId`, so equal IDs on different ATSes or companies do not collide.

The watch key includes normalized platform+company pairs and all matching filters, including `salaryOnly`. `maxItems`, `stateStoreName`, `includeDescription` and the alert toggle do not change watch identity. The legacy default state-store name remains `greenhouse-job-alerts-seen-jobs`.

### Get new job alerts in Discord, Telegram, Slack, Teams, Google Chat, your phone (ntfy/Pushover) or any app (webhook)

Want a **Greenhouse, Lever, Workday or Ashby job alert** in Discord, Telegram or on your phone instead of checking a dataset? Add one or more destinations in the Actor's **Notifications (optional)** section and each run sends the jobs it delivered. It is a **monitor that notifies you**: it only reads public careers-site feeds, and it never applies to a job, contacts a recruiter or logs in to any careers site.

| Channel | Fill in | What you get |
|---|---|---|
| Discord | `discordWebhookUrl` | One card per job, 10 per message |
| Telegram | `telegramBotToken` + `telegramChatId` | Up to 10 jobs per message, one line each |
| Slack | `slackWebhookUrl` | Block Kit message, up to 10 jobs per message |
| Mattermost, Rocket.Chat | `slackCompatibleWebhookUrl` | Slack-style incoming webhook: a Markdown list (these apps do not render Slack Block Kit) |
| Microsoft Teams | `teamsWebhookUrl` | Adaptive Card from a Teams Workflows webhook, up to 10 jobs per card |
| Google Chat | `googleChatWebhookUrl` | Card in a space, up to 10 jobs per message |
| ntfy (phone push, no account) | `ntfyTopic` (optional `ntfyServer`, `ntfyToken`) | A push per job, up to 10, then one "...and N more" |
| Pushover (phone push) | `pushoverUserKey` + `pushoverAppToken` | A push per job, up to 10, then one "...and N more" |
| Any app: Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant | `webhookUrl` | One JSON POST per run with every delivered row |

Fill in as many as you like; each channel works on its own and a failing one never stops the others.

#### Setup, channel by channel

- **Discord (1 minute):** Server Settings → Integrations → Webhooks → New Webhook → pick the channel → **Copy Webhook URL**.
- **Telegram (2 minutes):** chat with **@BotFather**, send `/newbot`, paste the token into `telegramBotToken`. Add the bot to the chat or channel (administrator for a channel; for a chat with yourself press **Start** on the bot). `telegramChatId` is a numeric id (`123456789`, or `-1001234567890` for a group or channel) or a public `@channelusername`.
- **Slack:** at api.slack.com/apps create an app (**From scratch**) → **Incoming Webhooks** → switch it on → **Add New Webhook to Workspace** → pick the channel → copy the `https://hooks.slack.com/services/...` URL.
- **Mattermost or Rocket.Chat:** create an **incoming webhook** in the app and paste its public `https://` URL into `slackCompatibleWebhookUrl`. It must be reachable from the internet: localhost, private IP addresses and `.local` / `.internal` names are rejected.
- **Microsoft Teams:** in the channel open **... → Workflows** → **Post to a channel when a webhook request is received** → finish the wizard and copy the URL (a host ending in `.logic.azure.com` or `.powerplatform.com`). The old "Office 365 connector" webhooks are retired and not supported.
- **Google Chat:** in the space open **Apps & integrations → Webhooks → Add webhook**, name it and copy the `https://chat.googleapis.com/v1/spaces/...` URL (needs a Google Workspace account that allows webhooks).
- **ntfy (free, no account):** install the ntfy app (or open ntfy.sh), subscribe to a topic with a long random name, and put the same name in `ntfyTopic`. Anyone who knows the topic can read it, so make it unguessable. Own server or a protected topic: set `ntfyServer` (public `https://` address) and `ntfyToken`.
- **Pushover:** copy your user key from pushover.net into `pushoverUserKey`, create an application at pushover.net/apps/build and put its API token in `pushoverAppToken`. Pushover itself is a separate paid app after its trial: check their pricing.
- **Any app (webhook):** paste the catch-hook URL from Zapier, Make, n8n, Pipedream, IFTTT or Home Assistant into `webhookUrl`. It must be a public `https://` address.

#### The recipe: a job alert for the companies you follow, in five steps

1. List the companies in `companies` (ATS board tokens or careers URLs) and add any `keywords`, `locationContains`, `departments` or `remoteOnly` filters.
2. Turn on `onlyNewSinceLastRun`.
3. Add your destination(s) from the table above.
4. Run it once. The first run is the baseline and sends the jobs currently open (up to `maxNotifications`).
5. Create a **Schedule** (daily works for most watches). From then on you only hear about jobs it has not delivered before.

```json
{
  "companies": [
    "airbnb",
    "stripe"
  ],
  "keywords": [
    "engineer"
  ],
  "onlyNewSinceLastRun": true,
  "maxItems": 50,
  "discordWebhookUrl": "https://discord.com/api/webhooks/<id>/<token>",
  "ntfyTopic": "your-long-random-topic-name",
  "maxNotifications": 25
}
```

#### The generic webhook (`webhookUrl`)

Each run sends **one POST per 100 delivered rows** (so usually one) with this body, followed by whatever your tool does with it:

```json
{
  "source": "apify",
  "actor": "greenhouse-job-alerts",
  "runId": "HG7ML7M8z78YcAPEB",
  "count": 2,
  "total": 2,
  "part": 1,
  "parts": 1,
  "items": [
    {
      "...": "the full dataset rows"
    }
  ]
}
```

`count` is the number of rows in this POST, `total` the number delivered in the run, and `part` / `parts` number the POSTs when a run delivers more than 100 rows. `maxNotifications` does not cap the webhook: your tool gets every delivered row. Your endpoint should answer with a 2xx status; redirects are not followed and a failure is reported in the run status, never retried in a loop.

#### What each message contains

Each job is announced as `New job: <title> at <company> — <location>` with the link, the salary when the source publishes one (its own display text, or the structured range with its period), employment type, a `Remote` flag, department, publication (or last update) date, and the ATS and board it came from. The job description is never sent. Anything the source does not publish is left out. Discord gets a card per job, Telegram one line per job, Slack Block Kit sections, Teams an Adaptive Card, Google Chat a card, and ntfy/Pushover a push that opens the job. Link previews are off, and titles are escaped so a title can never inject formatting or mentions.

#### What to expect

- **Only delivered jobs are sent.** A run that finds nothing new sends nothing, so there is no "no new jobs" spam. Rows the run could not deliver (for example because your spending limit was reached) are not sent.
- **Without `onlyNewSinceLastRun`, every delivered row is sent**, so a scheduled plain run would repeat the same jobs: use alert mode for alerts (the message then says "New job"; a plain run says "Job").
- **`maxNotifications` (default 25, max 100)** caps how many jobs go to chat and phone channels per run (the webhook is not capped). The rest are still in the dataset and the status message says so. ntfy and Pushover send at most 10 individual pushes, then one "...and N more" summary.
- **Cost: notifications are free.** You pay only the usual price for delivered jobs, exactly as without alerts. There is no extra charge for any channel.
- **Failures never fail the run.** A deleted webhook or an unreachable service leaves the run successful and the dataset complete, and the status message says what happened, for example `Notified: Discord 12, Slack 12, ntfy 10 (+summary). Teams failed (HTTP 404) - check the webhook URL.` The logs show the channel name and HTTP status only, never a URL or token.
- **Your URLs, tokens and ntfy topic are stored as secret inputs.** Anyone holding a webhook URL can post to that channel, so treat it like a password.
- **It is a monitor that notifies you.** It never applies to jobs, contacts recruiters or logs in to any careers site. The messages go only to the destinations you set up.
- **Nothing changes by default.** With no destination set, a run behaves exactly as before and the dataset rows are identical.

### Input

| Field | Default | What it does |
|---|---:|---|
| `companies` | `["airbnb", "stripe"]` prefill | 1-200 ATS tokens or careers URLs. Unprefixed tokens are Greenhouse. |
| `keywords` | `[]` | Keep titles containing at least one value, case-insensitive. |
| `excludeKeywords` | `[]` | Drop titles containing any value, case-insensitive. |
| `locationContains` | `""` | Keep jobs whose published location contains this text. |
| `departments` | `[]` | Match normalized department, function, team or family labels. |
| `remoteOnly` | `false` | Keep only jobs normalized as remote. |
| `salaryOnly` | `false` | Keep only jobs where the source exposes salary text or structured salary numbers. |
| `postedWithinDays` | `0` | Keep recent jobs using an explicit source timestamp; 0 disables. |
| `onlyNewSinceLastRun` | `false` | Return only unseen jobs after the first successful baseline. |
| `stateStoreName` | `greenhouse-job-alerts-seen-jobs` | Named persistent seen-state store. |
| `discordWebhookUrl` | *(none)* | Discord webhook URL. Must look like `https://discord.com/api/webhooks/<id>/<token>`. Empty means no Discord messages. See the alerts section above. Secret input. |
| `telegramBotToken` | *(none)* | Telegram bot token from @BotFather. Needs `telegramChatId`. Secret input. |
| `telegramChatId` | *(none)* | Telegram chat to post to: a numeric chat id or `@channelusername`. The bot must be added to that chat or channel. Needs `telegramBotToken`. |
| `slackWebhookUrl` | *(none)* | Slack incoming webhook, `https://hooks.slack.com/services/...`. Secret input. |
| `slackCompatibleWebhookUrl` | *(none)* | Mattermost / Rocket.Chat incoming webhook (public `https://` URL; Markdown list, no Block Kit). Secret input. |
| `teamsWebhookUrl` | *(none)* | Microsoft Teams Workflows webhook (host ending `.logic.azure.com` or `.powerplatform.com`). Secret input. |
| `googleChatWebhookUrl` | *(none)* | Google Chat space webhook, `https://chat.googleapis.com/v1/spaces/...`. Secret input. |
| `ntfyTopic` | *(none)* | ntfy topic name; setting it turns ntfy phone pushes on. Pick a long, unguessable name. Secret input. |
| `ntfyServer` | `https://ntfy.sh` | ntfy server. Only change it for your own public `https://` ntfy server. |
| `ntfyToken` | *(none)* | Optional ntfy access token for a self-hosted server or protected topic. Needs `ntfyTopic`. Secret input. |
| `pushoverUserKey` | *(none)* | Pushover user key. Needs `pushoverAppToken`. Secret input. |
| `pushoverAppToken` | *(none)* | Pushover application API token. Needs `pushoverUserKey`. Secret input. |
| `webhookUrl` | *(none)* | Generic JSON webhook (Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant): every delivered row, 100 per POST. Public `https://` only. Secret input. |
| `maxNotifications` | 25 | 1–100. Most jobs sent to chat and phone channels per run (the webhook is not capped). Extra jobs are still in the dataset. Only used when a destination is set. |
| `includeDescription` | `false` | Include `descriptionText`. Workday then performs per-job detail GETs at concurrency <=5. |
| `maxItems` | `50` | Hard delivery cap, 1-5000 jobs across all companies and ATSes. |

### Example output

All leader-parity fields are present and nullable. They stay `null` when the source does not supply them; the Actor does not guess salary, country or employment type.

```json
{
  "jobId": "fc5bbc77-a30c-4e7a-9acc-8a2e748545b4",
  "company": "openai",
  "title": "Data Engineer",
  "url": "https://jobs.ashbyhq.com/openai/fc5bbc77-a30c-4e7a-9acc-8a2e748545b4",
  "location": "San Francisco",
  "departments": ["Applied AI", "Applied AI Engineering"],
  "offices": ["San Francisco", "Mountain View"],
  "updatedAt": null,
  "firstPublished": "2023-09-26T22:34:48.884Z",
  "remote": false,
  "salaryText": "$235K - $385K",
  "salaryMin": 235000,
  "salaryMax": 385000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "employmentType": "FULL_TIME",
  "employmentTypeRaw": "FullTime",
  "country": "US",
  "descriptionText": "ABOUT THE TEAM\nThe Applied team works across research...",
  "atsPlatform": "ashby",
  "sourceBoard": "openai",
  "scrapedAt": "2026-09-28T08:00:00.000Z"
}
```

`descriptionText` is omitted unless `includeDescription=true`. Salary numbers are emitted only from structured source fields; a free-text salary mention is never parsed into `salaryMin` or `salaryMax`.

### Field coverage

Coverage means the platform has a source-native field the parser can use. Individual postings may still return `null`.

| Platform | salaryText | structured salary | employment type | country |
|---|---:|---:|---:|---:|
| Greenhouse | — | ✓ when `pay_input_ranges` is present | — | — |
| Lever | ✓ | ✓ | ✓ | ✓ |
| Workday | ✓/structured only when present in detail shape | ✓ when present | ✓ from detail fields | ✓ when present |
| Ashby | ✓ | ✓ | ✓ | ✓ |
| Workable | ✓/structured when present | ✓ when present | ✓ | ✓ |
| BambooHR | ✓/structured when present | ✓ when present | ✓ | ✓ when present |
| Personio | — | — | ✓ | ✓ only if feed supplies country/countryCode |
| Breezy HR | ✓/structured when present | ✓ when present | ✓ | ✓ when present |
| Teamtailor | — | — | null unless the RSS feed supplies a value | ✓ from the feed's explicit country metadata when present |

### Per-company status and failures

Every requested company gets its own run-status entry, for example `workday:acme.wd5/External: ok 120/120` or `breezy:missing: invalid - unknown company/board (HTTP 404)`. A failed or unsupported company does not stop healthy companies.

HTTP 403, challenge/non-JSON responses and other non-retryable 4xx responses stop that company and are reported as failed/invalid; they are not bypassed. Only transient network/timeout, 429 and selected 5xx responses receive bounded retries.

If every company is invalid, failed or unsupported, an alert run preserves its previous seen-state snapshot.

### Pricing

Pay-per-event: **$0.003 per delivered job**. A job is charged only after it is accepted into the default dataset by the existing shared budget-aware delivery gate. The Actor respects Apify run spending limits and `maxItems`; jobs not delivered are not billed.
Price changes follow Apify's notice rules; the Pricing tab always shows the rate you are charged.

Notifications to Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover and webhooks are free: you pay only for delivered jobs, never for messages sent.

### Limitations

- **BambooHR field mapping is verified against the live response envelope only** (the tenants we could test had no open roles). Any job missing an id, title or link is skipped and never charged, on every platform.

- **Workday posting dates are day-precision**, derived from Workday's own "Posted N Days Ago" label; "30+ Days Ago" is left empty rather than guessed.

- **Public careers sources only.** No login, cookies, proxies, CAPTCHA solving or anti-bot bypasses.

- **Operator verification is required before merge for newly added observed routes.** Handbuilt Workday, BambooHR, Personio and Breezy fixtures model documented/observed shapes; they are intentionally not presented as real captures.

- **Workday pagination is bounded.** Pages are 20 jobs and each company stops at the lower of `maxItems`, the source total/end, or 2,000 fetched jobs. Workday descriptions require separate detail requests and are fetched only when `includeDescription=true`, at no more than five concurrently.

- **Salary fields are conservative.** `salaryText` is copied only from a source salary display field. Numeric salary fields require structured source numbers; no regex guessing from job descriptions.

- **Country is conservative.** It is normalized to ISO-3166 alpha-2 only from an explicit source country/country code; location text alone is not used to guess a country.

- **Employment type keeps provenance.** `employmentTypeRaw` preserves the source value; `employmentType` maps recognized values to `FULL_TIME`, `PART_TIME`, `CONTRACT`, `INTERN`, `TEMPORARY` or `OTHER`.

- **SmartRecruiters and Recruitee are intentionally skipped** for the access reasons in the platform table. Teamtailor is supported through its public careers-site RSS feed rather than its key-protected API.

### Use it from your code, Make, Zapier or n8n

Built for automated pipelines: small runs, stable field names, one row per item, and you pay only for rows actually delivered.

**One API call that runs the Actor and returns the data** (replace `$APIFY_TOKEN` with your token from Apify Console → Settings → Integrations):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/lukehunter~greenhouse-job-alerts/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"companies": ["airbnb", "stripe"], "maxItems": 20}'
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lukehunter~greenhouse-job-alerts').call({
  "companies": [
    "airbnb",
    "stripe"
  ],
  "maxItems": 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`pip install apify-client`):

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lukehunter~greenhouse-job-alerts').call(run_input={"companies": ["airbnb", "stripe"], "maxItems": 20})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**Schedules, webhooks and no-code tools:** save your input as a Task, add a Schedule (e.g. hourly or daily), and attach a webhook or one of the Integrations tab's connectors (Make, Zapier, n8n, Google Sheets, Slack) to push each run's results into your own system.

**Only new items each run:** set `"onlyNewSinceLastRun": true` on a scheduled Task and every run after the first delivers, and charges for, only items it hasn't delivered before for that same input. That makes it a ready-made change feed.

**Reliability:** an automated test runs this Actor's parser against the live site every day, and failures are fixed fast.

**Feedback:** an honest rating on the Store page, good or bad, helps others decide if this Actor fits their needs. Missing a field or found a problem? Open an issue on the Actor page.

### FAQ

**Do old Greenhouse inputs still work?** Yes. Unprefixed tokens still mean Greenhouse, both Greenhouse URL hosts remain supported, and the legacy alert state-store default is unchanged.

**Can I mix ATSes in one watch?** Yes. Up to 200 normalized company inputs can be mixed; companies are processed with bounded concurrency and reported independently. Teamtailor uses the public careers-site RSS feed with bounded offset pagination, not the authenticated API.

**Why does `salaryOnly` sometimes return few jobs?** It is deliberately strict: a job must expose a salary display field or structured salary numbers. The Actor does not mine descriptions for pay-looking text.

**Does changing `includeDescription` reset alert state?** No. It does not change watch identity, and Workday job identity remains based on the listing job ID/external path rather than detail-only fields.

**Does the same job ID on two ATSes collide?** No. Seen identity includes ATS platform, company/source board and job ID.

**Can I get ATS job alerts in Discord, Telegram, Slack or on my phone?** Yes. Set `discordWebhookUrl`, `telegramBotToken` + `telegramChatId`, `slackWebhookUrl`, `teamsWebhookUrl` or `googleChatWebhookUrl`, or use `ntfyTopic` (free, no account) or `pushoverUserKey` + `pushoverAppToken` for phone pushes. Mattermost and Rocket.Chat work through `slackCompatibleWebhookUrl`. With `onlyNewSinceLastRun` on and a schedule, each run sends only the jobs it has not delivered before, across every company and ATS in the watch. Setup steps for each are in the alerts section above. Notifications cost nothing extra.

**Can I get ATS job alerts by email?** Not natively. There are two routes. (1) Set `webhookUrl` to a Zapier, Make or n8n catch hook and add an email or Gmail step: the webhook delivers every row as JSON, so the email can list the jobs. (2) Apify's own run integrations and run notifications can email you when a run finishes, but they only send a link to the run or dataset, not the jobs themselves. For instant alerts without building anything, Telegram, ntfy or Pushover reach your phone directly.

**Can I get ATS job alerts in WhatsApp?** Not natively, and we do not use unofficial WhatsApp APIs, which risk getting your number banned. The official route is the WhatsApp Business Platform (Cloud API) with its own business account, message templates and pricing: point `webhookUrl` at a Zapier, Make or n8n flow that calls it. For free phone alerts use Telegram or ntfy instead.

### Related Actors

Other data tools from the same developer, built to the same standard: official or public sources, hard cost caps, and honest documentation of limits.

- **[Remote Jobs Aggregator](https://apify.com/lukehunter/remote-jobs-aggregator)**: remote job listings from RemoteOK, Himalayas, Jobicy and We Work Remotely in one deduplicated feed.
- **[Wellfound (AngelList) Jobs Scraper](https://apify.com/lukehunter/wellfound-jobs-scraper)**: startup jobs from Wellfound with salary ranges, equity and company stage.
- **[YouTube Channel Scraper](https://apify.com/lukehunter/youtube-stats-tracker)**: new-video alerts and channel monitoring for any list of YouTube channels: subscribers, latest videos and a new-uploads-only mode for scheduled runs.
- **[Google Play App Scraper](https://apify.com/lukehunter/google-play-scraper)**: ratings, installs, developer contact info and pricing for any Google Play app.
- **[Apple App Store Reviews Scraper](https://apify.com/lukehunter/app-store-reviews-scraper)**: Apple App Store reviews for any iOS app, across countries, with rating, version and date.
- **[Spotify Scraper](https://apify.com/lukehunter/spotify-scraper)**: play counts, monthly listeners and playlist track lists for any public Spotify artist, playlist, album or track.
- **[Shopify Product Scraper by URL](https://apify.com/lukehunter/shopify-product-tracker)**: price, compare-at price and stock for specific Shopify product URLs, with a change-only feed.
- **[Walmart Category Scraper](https://apify.com/lukehunter/walmart-category-scraper)**: product names, prices, was-prices and ratings from Walmart category pages.

# Actor input Schema

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

Company board tokens or careers URLs. Unprefixed tokens remain Greenhouse for backwards compatibility. Supported prefixes: greenhouse:, lever:, workday:, ashby:, workable:, bamboohr:, personio:, breezy:, teamtailor:. Supported careers URLs are auto-detected. SmartRecruiters and Recruitee are recognized but reported unsupported. Maximum 200 companies per run.

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

Keep jobs whose normalized title contains at least one keyword, case-insensitive. Leave empty to keep every title across all requested ATS platforms.

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

Drop jobs whose normalized title contains any of these words or phrases, case-insensitive, regardless of which supported ATS supplied the job.

## `locationContains` (type: `string`):

Keep jobs whose normalized published location contains this text, case-insensitive. Example: "London". Leave blank for any location.

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

Keep jobs where at least one normalized department, function, team or family contains one of these values, case-insensitive. Example: "Engineering".

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

Keep only jobs normalized as remote from an ATS remote/workplace field when available, otherwise from conservative published title, location or office text.

## `salaryOnly` (type: `boolean`):

Keep only jobs where the source exposes salary information as its own display text or structured minimum/maximum values. Salary is never guessed from unrelated description text.

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

Keep jobs first published within this many days. When an ATS does not expose an original publication timestamp, its closest explicit update/creation timestamp is used. Set 0 for no age filter.

## `onlyNewSinceLastRun` (type: `boolean`):

When enabled, the first run creates a baseline and later runs deliver and charge only matching job IDs not seen before for this same platform+company/filter watch. Designed for Apify Schedules and webhooks.

## `stateStoreName` (type: `string`):

Named key-value store used only in job-alert mode to persist seen platform+company+job IDs across runs. The legacy default is retained so existing Greenhouse schedules keep their history. Letters, numbers and hyphens only.

## `discordWebhookUrl` (type: `string`):

Post results to a Discord channel. In Discord: Server Settings -> Integrations -> Webhooks -> New Webhook -> choose the channel -> Copy Webhook URL. Looks like https://discord.com/api/webhooks/<id>/<token>. Leave empty to skip Discord.

## `telegramBotToken` (type: `string`):

Post results to Telegram. Create a bot by chatting with @BotFather on Telegram (send /newbot) and paste the token it gives you, e.g. 123456789:AA.... Needs "Telegram chat ID" below. Leave empty to skip Telegram.

## `telegramChatId` (type: `string`):

Where the bot should post: a numeric chat id (e.g. 123456789, or -1001234567890 for a group or channel) or a public @channelusername. The bot must be added to that chat or channel first (as an administrator for a channel), and for a private chat you must press Start on the bot. Needs "Telegram bot token" above.

## `slackWebhookUrl` (type: `string`):

Post results to a Slack channel (Block Kit cards, up to 10 per message). Create an incoming webhook at api.slack.com/apps -> Create New App -> Incoming Webhooks -> Add New Webhook to Workspace. Looks like https://hooks.slack.com/services/T000/B000/XXXX. Leave empty to skip Slack.

## `slackCompatibleWebhookUrl` (type: `string`):

Post results to a Mattermost or Rocket.Chat incoming webhook, which accept Slack-style webhook payloads. Must be a public https:// address (no localhost, private IP or .local/.internal hosts). These apps do not render Slack Block Kit, so they get a plain Markdown list. For real Slack use "Slack webhook URL" above. Leave empty to skip.

## `teamsWebhookUrl` (type: `string`):

Post results to a Teams channel as an Adaptive Card. In Teams: channel -> ... -> Workflows -> "Post to a channel when a webhook request is received" -> copy the URL. The host must end in .logic.azure.com or .powerplatform.com. The retired Office 365 connector webhooks are not supported. Leave empty to skip Teams.

## `googleChatWebhookUrl` (type: `string`):

Post results to a Google Chat space. In the space: Apps & integrations -> Webhooks -> Add webhook -> copy the URL. Looks like https://chat.googleapis.com/v1/spaces/<space>/messages?key=...\&token=.... Leave empty to skip Google Chat.

## `ntfyTopic` (type: `string`):

Get a phone push with no account via ntfy (ntfy.sh). Install the ntfy app, subscribe to a topic name, and enter the same name here. Anyone who knows the topic can read it, so pick a long, unguessable name (letters, numbers, - and \_). At most 10 individual pushes per run, then one "...and N more". Leave empty to skip ntfy.

## `ntfyServer` (type: `string`):

Only used with "ntfy topic". Leave as https://ntfy.sh, or enter the public https:// address of your own ntfy server.

## `ntfyToken` (type: `string`):

Only used with "ntfy topic", for a self-hosted server or a reserved topic that needs a login. An access token from ntfy (starts with tk\_). Leave empty for open topics.

## `pushoverUserKey` (type: `string`):

Get a phone push via Pushover. Your user key is shown on the Pushover dashboard (pushover.net). Needs "Pushover app token" below. At most 10 individual pushes per run, then one "...and N more". Leave empty to skip Pushover.

## `pushoverAppToken` (type: `string`):

The API token of a Pushover application you create at pushover.net/apps/build (name it after this Actor). Needs "Pushover user key" above.

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

POST the delivered rows as JSON to any public https:// URL: {source, actor, runId, count, items}. At most 100 rows per POST; every delivered row is sent regardless of the max-notifications cap. Use it to route results to email, a spreadsheet or any app. Localhost, private IP and .local/.internal addresses are rejected. Leave empty to skip.

## `maxNotifications` (type: `integer`):

Caps how many results are sent to chat and phone channels per run (Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover), 1-100, default 25. Extra results are still in the dataset. The generic webhook is not capped. Only used when a destination above is set.

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

Include normalized descriptionText after stripping upstream HTML and truncating to 3,000 characters. Workday requires per-job detail requests only when this is enabled; those requests are concurrency-bounded to five.

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

Hard cap on delivered jobs across every company and ATS. 1-5000, default 50. Workday also has a 2,000-job per-company fetch cap. At $0.001 per delivered job this caps result-based charges.

## Actor input object example

```json
{
  "companies": [
    "airbnb",
    "stripe"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "locationContains": "",
  "departments": [],
  "remoteOnly": false,
  "salaryOnly": false,
  "postedWithinDays": 0,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "greenhouse-job-alerts-seen-jobs",
  "ntfyServer": "https://ntfy.sh",
  "maxNotifications": 25,
  "includeDescription": false,
  "maxItems": 20
}
```

# Actor output Schema

## `jobs` (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": [
        "airbnb",
        "stripe"
    ],
    "keywords": [],
    "excludeKeywords": [],
    "departments": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/greenhouse-job-alerts").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": [
        "airbnb",
        "stripe",
    ],
    "keywords": [],
    "excludeKeywords": [],
    "departments": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/greenhouse-job-alerts").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": [
    "airbnb",
    "stripe"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "departments": [],
  "maxItems": 20
}' |
apify call lukehunter/greenhouse-job-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukehunter/greenhouse-job-alerts"
        }
    }
}
```

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/kacLHYFHUfbqEDVaA/builds/28GeiKKRTfK3FqmJt/openapi.json