# Hiring Signals: New Job Postings by Company (`reaperoak/hiring-signals-new-job-postings-watch`) Actor

Watch companies' Greenhouse, Lever and Ashby careers pages and get only the NEW job postings since your last run, with department, location and pay. Hiring signals for sales, recruiting and market research.

- **URL**: https://apify.com/reaperoak/hiring-signals-new-job-postings-watch.md
- **Developed by:** [Owais Khan](https://apify.com/reaperoak) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Hiring Signals: New Job Postings by Company

Watch companies' **Greenhouse, Lever and Ashby** careers pages and get **only the new job postings** since your last run. Hiring is one of the clearest buying signals there is: a company opening ten sales roles is scaling a sales team; one opening a data-platform lead is about to buy tools. Schedule this Actor and the signals arrive without you checking a single careers page.

### What is Hiring Signals?

It is an Apify Actor that remembers which jobs it has already shown you for each company and reports only the new ones, with department, location, posted date, pay range and apply link. Each run also writes a hiring snapshot: how many jobs each company has open, how that changed, how many closed, and its biggest departments.

### What makes it different?

- **Only new postings.** You pay for new signals, not for the same board every day.
- **Hiring snapshot per company.** Open jobs now, change since last run, jobs closed and top departments, so you can see velocity, not just a list.
- **Filters for your use case.** Watch only sales roles, only engineering, only remote, or only one region.
- **Works across three ATS platforms** with one format.

### What data do you get?

| Field | Example |
|---|---|
| `signal` | `new-posting` |
| `company, ats` | `ramp`, `ashby` |
| `title, department, team` | `Account Executive`, `Sales` |
| `location, remote` | `New York, NY (HQ)`, `true` |
| `publishedAt` | `2026-10-12T14:05:00.000Z` |
| `salaryMin, salaryMax, salaryCurrency` | `143200`, `284000`, `USD` |
| `companyOpenJobs, companyNewThisRun` | `167`, `4` |
| `url, applyUrl, firstSeen` | links, and when it was first reported |

The `SUMMARY` record holds the hiring snapshot per company: open jobs, change since last run, closed jobs, new postings and top departments.

### How to track company hiring signals

1. Add the companies to watch (slugs, `ats:slug` or careers URLs).
2. Optionally restrict by keywords, department, location or remote.
3. Run it once to see the recent past (the first run looks back as many days as you set).
4. Create a **Schedule** (daily or weekly) and send the output to email, Slack, a CRM, Make, n8n or Zapier.

```json
{
    "companies": [
        "ashby:ramp"
    ],
    "lookbackDays": 3650,
    "onlyNew": false,
    "maxNewJobsPerCompany": 5
}
```

- **lookbackDays**: on a company's first run, report jobs published in the last N days.
- **onlyNew**: on by default. Each later run reports only postings not reported before.
- **keywords / departments / locations**: narrow the signal. Changing them starts a fresh memory for that company.

### How much does hiring-signal monitoring cost?

You pay per company checked, plus a small charge per new job reported returned plus a very small start fee. There is no subscription.

| Companies checked | Approximate cost |
|---|---|
| 1 | $0.01 |
| 10 | $0.10 |
| 50 | $0.50 |
| 100 | $1 |

Paid Apify plans get tiered discounts, and you can set a maximum cost per run. You can try it on Apify's free plan without a card.

### Who is it for?

- **Sales and revenue teams** targeting companies that are hiring for a relevant function.
- **Recruiting and staffing agencies** spotting new demand early.
- **Investors and analysts** tracking growth by hiring velocity.
- **Competitive-intelligence teams** watching what rivals build.

### Frequently asked questions

**How is this different from a jobs scraper?** A scraper returns every open job each time. This returns only what is new since last time, plus a snapshot of how hiring is changing.

**Which companies work?** Any company whose careers page runs on Greenhouse, Lever or Ashby.

**Will I get the same job twice?** No. Each company remembers the jobs it has reported, per filter set.

**What does a run cost?** A small charge per company checked plus a small charge per new job reported. A quiet week costs only the company checks.

**What if an ATS changes its API?** The run fails with an explicit error instead of returning empty data, and the Actor is health-checked every night.

### Notes and limits

- Hiring is a signal, not proof of intent. Use it to prioritise outreach, not to assume what a company will buy.
- Reads public job-board endpoints that the platforms provide for this purpose.

# Actor input Schema

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

Company slugs (<code>stripe</code>), prefixed slugs (<code>lever:spotify</code>) or careers URLs on Greenhouse, Lever or Ashby.

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

Only report new jobs whose title contains any of these, for example <code>sales</code> or <code>engineer</code>. Leave empty for every new job.

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

Ignore jobs whose title contains any of these.

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

Only report new jobs in departments or teams containing any of these.

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

Only report new jobs whose location contains any of these.

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

Only report jobs marked remote.

## `lookbackDays` (type: `integer`):

On the first run for a company, report jobs published in the last N days. Later runs report only jobs not reported before.

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

Remembers what each company has already reported. Turn this on when you schedule the Actor. Off by default so a first manual run always shows results.

## `maxNewJobsPerCompany` (type: `integer`):

Safety cap per company per run.

## Actor input object example

```json
{
  "companies": [
    "ashby:ramp"
  ],
  "remoteOnly": false,
  "lookbackDays": 3650,
  "onlyNew": true,
  "maxNewJobsPerCompany": 5
}
```

# Actor output Schema

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

One row per new job posting: company, title, department, location, remote flag, posted date, pay range, and how many jobs the company has open.

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

For each company: open jobs now, change since the last run, jobs closed, new postings reported, and its biggest departments.

# 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": [
        "ashby:ramp"
    ],
    "lookbackDays": 3650,
    "onlyNew": false,
    "maxNewJobsPerCompany": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("reaperoak/hiring-signals-new-job-postings-watch").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": ["ashby:ramp"],
    "lookbackDays": 3650,
    "onlyNew": False,
    "maxNewJobsPerCompany": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("reaperoak/hiring-signals-new-job-postings-watch").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": [
    "ashby:ramp"
  ],
  "lookbackDays": 3650,
  "onlyNew": false,
  "maxNewJobsPerCompany": 5
}' |
apify call reaperoak/hiring-signals-new-job-postings-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reaperoak/hiring-signals-new-job-postings-watch"
        }
    }
}
```

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/t5gx1fCnXo29PwDLW/builds/F3Poc7o4f2DK8TQVW/openapi.json