# Greenhouse Job Feed Watch (`ventilated_xanthophyta/my-actor`) Actor

Monitor a Greenhouse job board across runs. Detect new postings, title and location changes, and confirmed removals. Export structured results for recruitment and job-data workflows.

- **URL**: https://apify.com/ventilated_xanthophyta/my-actor.md
- **Developed by:** [Talha](https://apify.com/ventilated_xanthophyta) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 completed board checks

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 Job Feed Watch

Track changes to one Greenhouse job board across runs. Get structured observations for job-data pipelines, recruitment research, and job-board maintenance.

### What it does

- Creates a baseline on the first run.
- Detects newly observed postings.
- Detects changes to titles, locations, and posting URLs.
- Tracks missing postings before marking them removed.
- Identifies postings that reappear.
- Preserves tracking history between runs.

This Actor monitors posting metadata. It does not track full job descriptions or send notifications.

### Quick start

Use this input:

{
"board": "webflow",
"watchName": "pilot"
}

`board`: The Greenhouse board token, such as `webflow` from
https://job-boards.greenhouse.io/webflow

`watchName`: A name for this tracking history. Keep the same board and watch name on subsequent runs. A different watch name starts a separate history.

Recommended run settings:

- Memory: 256 MB
- Timeout: 60 seconds
- Maximum cost per run: $0.03 or more
- Restart on error: Off

The Actor requires a bounded cloud-run timeout and rejects unlimited or long runs.

### Example: keep a niche job board up to date

Suppose you track one company's Greenhouse board.

1. Run with a board token and a watch name. The first check saves a baseline.
2. Run again later using exactly the same input.
3. Use the status field to decide what your downstream workflow should update.

Illustrative example — these are fictional postings, not live results:

| Posting | First check | Later check |
| --- | --- | --- |
| Backend Engineer | baseline | unchanged |
| Product Designer | baseline | changed — location updated |
| Data Analyst | Not present | added |
| Sales Manager | baseline | missing_pending |

A missing posting becomes `removed` only if it is still absent in a later complete check at least one hour after it was first missing.

For a job-board workflow:

- `added`: create a listing.
- `changed`: update its tracked metadata.
- `removed`: flag it for removal or review.
- `reappeared`: restore or review the listing.
- `unchanged`: no metadata update needed.

The Actor supplies these observations. Updating your website or sending an alert requires your own integration.

The first run establishes a baseline; it does not provide historical changes from before you started tracking.

### Output statuses

| Status | Meaning |
| --- | --- |
| baseline | Posting recorded on the first check. |
| added | Posting first observed after the baseline. |
| unchanged | Tracked metadata has not changed. |
| changed | Title, location, or posting URL changed. |
| missing_pending | Previously observed posting is absent from a complete source response. |
| removed | Posting remains absent in a later complete check, at least one hour after it was first missing. |
| reappeared | A previously missing posting is present again. |

“Added” means newly observed by this watch, not necessarily newly published.

“Removed” means absent from the monitored feed under the rule above. It does not prove the role was filled.

### Output fields

Each observation includes:

- status
- jobId
- title
- location
- url
- board
- observedAt
- eventId
- previous: earlier metadata for a changed posting

The default dataset contains observations. The default key-value store's OUTPUT record contains the run summary.

Checks include unchanged postings. Download dataset results using Apify's export options.

### Pricing

- Completed board check: $0.02
- Actor start: $0.00005 per start at up to 1 GB memory
- No per-posting fee
- Standard-run platform usage is included

At the recommended memory setting, one completed check costs $0.02005.

A completed check includes the initial baseline, checks with no changes, and valid checks returning zero current postings.

The board-check event is requested only after results and tracking state are saved. The separate Actor-start fee can apply even if the check fails.

### Repeat checks and integrations

Run again with the same board and watch name to compare against the saved history.

You can configure an Apify schedule or call the Actor through the API. Scheduling and external notifications are not configured automatically.

Avoid overlapping runs for the same watch. The Actor uses a shared lock to reject concurrent processing.

### Limits and recovery

- One board per run.
- Up to 1,000 current postings.
- Up to 5,000 retained history entries.
- Removed-posting records are retained for approximately 30 days, with cleanup on later runs.
- Full job descriptions and changes between checks are not captured.
- Incomplete or invalid source responses stop processing.
- An interrupted run can leave the watch locked for up to 10 minutes.
- Do not resurrect runs. Start a new run instead.
- If billing is reported as uncertain, inspect that run's charge records before taking further action.

A failed run may contain partial output. Use successful runs for downstream processing. Delivery is not guaranteed to be exactly once.

Deleting the named tracking storage resets the watch history. Do not modify its state or lock queue manually.

### Pilot status and support

This is an early release. Source availability and behavior can change.

Report issues through the Actor's Issues tab. Include the run ID, board token, and error message. Never include API tokens, identity documents, or other secrets.

This Actor is independently developed and is not affiliated with Greenhouse. Use source data only where you have the right to do so.

# Actor input Schema

## `board` (type: `string`):

Enter the board token only, for example webflow from job-boards.greenhouse.io/webflow. Do not paste a full URL. Use a source you are entitled to process. Maximum 1,000 current jobs per board.

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

Keep the same name and board to continue the same history. A different name starts a separate baseline. Use letters, digits, hyphens or underscores.

## Actor input object example

```json
{
  "board": "webflow",
  "watchName": "pilot"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "board": "webflow",
    "watchName": "pilot"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ventilated_xanthophyta/my-actor").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 = {
    "board": "webflow",
    "watchName": "pilot",
}

# Run the Actor and wait for it to finish
run = client.actor("ventilated_xanthophyta/my-actor").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 '{
  "board": "webflow",
  "watchName": "pilot"
}' |
apify call ventilated_xanthophyta/my-actor --silent --output-dataset

```

## MCP server setup

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

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/T9y2DaIcbAh2Tj29Y/builds/6OJIb8eGhsi4N5nTI/openapi.json