# Company Hiring Monitor (`arched_friend/company-hiring-monitor`) Actor

Track every open role at any company straight from the job board it actually uses: Greenhouse, Lever, Ashby, Workable, SmartRecruiters or Recruitee. Get new postings the day they appear, see which roles were filled, and read hiring as a growth signal.

- **URL**: https://apify.com/arched\_friend/company-hiring-monitor.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 company checkeds

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

## Company Hiring Monitor: Every Open Role, Straight From the Source

Give it a company and get every open role it is advertising — read from the job board the company actually uses, not scraped off a careers page. Run it again and it tells you which roles are new and which quietly disappeared.

Built for sales teams reading hiring as a buying signal, recruiters tracking competitors, and anyone who wants a job alert that is not a week late.

### How it works

```mermaid
flowchart LR
    A["Company name or<br/>board URL"] --> B{"Which platform?"}
    B --> C["Greenhouse"]
    B --> D["Lever"]
    B --> E["Ashby"]
    B --> F["SmartRecruiters"]
    C --> G["One row per role"]
    D --> G
    E --> G
    F --> G
    G --> H{"Compare with<br/>last run"}
    H -->|unseen| I["new"]
    H -->|gone| J["closed"]
```

Each of these platforms publishes its job board as a public JSON endpoint — the same one the company's own careers page calls. That is why this does not break when a company restyles its site, and why it needs no proxy and no browser.

**Paste a board URL and it just works.** Type only a company name and every platform is tried until one answers with real postings.

### Built for

- **Sales and BD teams** — a company hiring 5 support reps is a company with a problem worth selling into
- **Recruiters** — watch competitor headcount and spot teams scaling up
- **Job seekers** — a genuine alert the day a role is posted, not when an aggregator gets round to it
- **Investors and analysts** — hiring velocity as a growth signal

### Input

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "greenhouse:notion",
    "leverdemo"
  ],
  "onlyNew": true,
  "titleContains": ["engineer"],
  "remoteOnly": true
}
```

| Setting | What it does |
| --- | --- |
| `companies` | Board URL, `platform:slug`, or a bare company slug |
| `onlyNew` | Return only roles posted since the last run |
| `reportClosed` | Also return roles that disappeared, usually meaning filled |
| `titleContains` / `titleExcludes` | Narrow to the roles you care about |
| `locationContains` / `departments` | Filter by where and which team |
| `remoteOnly` | Only roles the company itself marks remote |

### Output

```json
{
  "company": "stripe",
  "ats": "greenhouse",
  "atsLabel": "Greenhouse",
  "title": "Abuse Research Engineer",
  "location": "Remote from the US",
  "department": "Security Analytics",
  "isRemote": true,
  "url": "https://stripe.com/jobs/search?gh_jid=8172487",
  "postedAt": "2026-09-12T13:25:25-04:00",
  "changeType": "new",
  "firstSeenAt": "2026-09-17T17:41:02.118Z",
  "checkedAt": "2026-09-17T17:41:02.118Z"
}
```

`changeType` is one of `new`, `open`, `closed` or `first-run`. `firstSeenAt` is when this Actor first saw the role, so you can tell how long a role has been sitting open — which is itself a signal.

### Two things it gets right that matter

**A role is only "closed" for a company you actually checked.** State is kept per company, so running the Actor on one company does not report every other company's roles as filled. Verified: checking one company left another's 25 open roles untouched.

**Remote comes from the company, not from a guess.** Lever, Ashby and SmartRecruiters each state it outright in their API; that flag is used when present, and the location text is only read as a fallback.

### Turn it into a hiring alert

```json
{
  "companies": ["greenhouse:stripe", "greenhouse:notion", "ashby:linear"],
  "onlyNew": true,
  "departments": ["engineering"]
}
```

Schedule it daily. The first run records what is already open; every run after returns only what appeared.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~company-hiring-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["https://boards.greenhouse.io/stripe"],
    "onlyNew": true
  }'
```

### Pricing

You pay $0.01 for each company checked, however many roles it has open. A company with 650 roles costs the same as one with 3.

| Watching 50 companies daily | Monthly cost |
| --- | --- |
| Checking by hand | roughly 25 hours |
| Most hiring-signal tools | $99 to $600 per month |
| This Actor | $15 per month |

### Common questions

**Which platforms are supported?** Greenhouse, Lever, Ashby and SmartRecruiters. Each one was verified against a live public board before shipping. Workable and Recruitee are deliberately not claimed: no public board could be found to confirm their payload shape, and a parser nobody has seen work is a column of nulls waiting to happen.

**What if a company is not on any of them?** You get a `no-board-found` entry in the run summary rather than a silent empty result. Many large enterprises run Workday or Taleo, which do not publish an open endpoint.

**Why did a company return zero roles?** Either they genuinely have none open, or the slug is wrong. Paste the board URL instead of the name to be certain.

**Does it need a proxy?** No. These are public JSON APIs and the Actor defaults to no proxy at all.

### Related products

- **Hiring Signals Tracker** for hiring as a buying signal across a whole market
- **Website Lead Extractor** to pull contacts at the companies that are hiring
- **Tech Stack Checker** to see what those companies are building on
- **Lead Enrichment Pipeline** to turn a list of hiring companies into qualified rows
- **Company Change Monitor** — see Website Change Monitor — to watch their careers page itself

# Actor input Schema

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

One per line. Paste a job board URL such as https://boards.greenhouse.io/stripe, name the platform as greenhouse:stripe, or just type the company slug and every supported platform is tried.

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

Upper limit on how many open roles to return for each company.

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

Return only roles that were not there last time. Turn this on for scheduled monitoring so each run is a short list of what is new.

## `reportClosed` (type: `boolean`):

Include a row for every role that was open last run and is gone now, which usually means it was filled or pulled.

## `titleContains` (type: `array`):

Keep only roles whose title contains one of these words, for example engineer or sales.

## `titleExcludes` (type: `array`):

Drop roles whose title contains one of these words, for example intern or senior.

## `locationContains` (type: `array`):

Keep only roles whose location contains one of these, for example london or united states.

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

Keep only roles in these departments or teams, for example engineering or marketing.

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

Keep only roles the company itself marks as remote, falling back to reading the location when it does not say.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each job board before giving up on it.

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

Optional, and off by default. These are public JSON endpoints that do not need one.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "leverdemo"
  ],
  "maxJobsPerCompany": 1000,
  "onlyNew": false,
  "reportClosed": true,
  "remoteOnly": false,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

One row per role, with the company, platform, title, location, department and whether it is new, still open or newly closed.

## `runSummary` (type: `string`):

Per company counts of open, new and closed roles, which platform each board is on, and any company whose board could not be found.

# 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://boards.greenhouse.io/stripe",
        "leverdemo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/company-hiring-monitor").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://boards.greenhouse.io/stripe",
        "leverdemo",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/company-hiring-monitor").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://boards.greenhouse.io/stripe",
    "leverdemo"
  ]
}' |
apify call arched_friend/company-hiring-monitor --silent --output-dataset

```

## MCP server setup

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

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/hPEaFh5QArTrrr4IU/builds/7gToun7xZVdSTky4I/openapi.json