# Career Site Hiring Signal Monitor (`signaltools/career-site-hiring-signal-monitor`) Actor

Monitor public Greenhouse, Lever, and Ashby career boards and emit structured hiring-signal data for sales, recruiting, investor, and market-intelligence workflows.

- **URL**: https://apify.com/signaltools/career-site-hiring-signal-monitor.md
- **Developed by:** [Stephen Coulson](https://apify.com/signaltools) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does Career Site Hiring Signal Monitor do?

**Career Site Hiring Signal Monitor** turns public company job boards into structured hiring-signal data. Give it Greenhouse, Lever, or Ashby board slugs and it returns clean rows showing which companies are hiring for which functions, where, when, and with what signal strength.

Use it for B2B sales, recruiting, market intelligence, portfolio monitoring, and competitor tracking. It runs on Apify, so you can schedule it, call it by API, export results to CSV/Excel/JSON, and connect it to tools like Google Sheets, Zapier, Make, and your CRM.

### Why use Career Site Hiring Signal Monitor?

Hiring is one of the clearest public signals that a company is growing, entering a new market, investing in a function, or feeling operational pressure.

This Actor helps you answer questions like:

- Which target accounts are hiring sales, operations, finance, facilities, or growth roles?
- Which competitors are expanding in a geography?
- Which portfolio companies are increasing or reducing hiring intensity?
- Which job posts suggest budget, new initiatives, or procurement opportunities?

Unlike LinkedIn scraping, this Actor focuses on public career-board JSON endpoints. No cookies, login, or personal enrichment are required.

### How to use Career Site Hiring Signal Monitor

1. Open the Actor on Apify.
2. Add one or more companies in the input field.
3. Choose the provider: `greenhouse`, `lever`, or `ashby`.
4. Add the public board slug, for example `stripe` for Greenhouse.
5. Optionally add keywords such as `sales`, `operations`, `finance`, or `facilities`.
6. Run the Actor.
7. Download the dataset in JSON, CSV, Excel, HTML, or XML, or connect it to an integration.

### Input

Example input:

```json
{
  "companies": [
    { "name": "Stripe", "provider": "greenhouse", "slug": "stripe", "domain": "stripe.com" },
    { "name": "ExampleCo", "provider": "ashby", "slug": "exampleco", "domain": "example.com" }
  ],
  "keywords": ["sales", "operations", "finance", "growth", "facilities"],
  "maxJobsPerCompany": 200,
  "minScore": 0
}
````

#### Input fields

| Field | Description |
|---|---|
| `companies` | List of public career boards to scan. Each item needs `provider` and `slug`. |
| `provider` | Supported values: `greenhouse`, `lever`, `ashby`. |
| `slug` | Public board slug used by the provider. |
| `domain` | Optional company domain for CRM-friendly output. |
| `keywords` | Terms used to tag and score roles. |
| `maxJobsPerCompany` | Safety cap per company board. |
| `minScore` | Emit only roles scoring at least this value. |

### Output

The Actor outputs one row per job.

```json
{
  "company": "Stripe",
  "domain": "stripe.com",
  "provider": "greenhouse",
  "board_slug": "stripe",
  "job_id": "7954688",
  "title": "Account Executive, AI Sales",
  "department": "AI GTM Strategy & Solutions",
  "location": "London",
  "posted_date": "2026-06-26T17:05:44-04:00",
  "seniority": "senior",
  "keywords_matched": ["sales", "growth"],
  "hiring_signal_score": 65,
  "source_url": "https://stripe.com/jobs/search?gh_jid=7954688",
  "detected_at": "2026-07-04T01:18:25Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Meaning |
|---|---|
| `company` | Company name supplied in input. |
| `domain` | Company domain supplied in input. |
| `provider` | Career-board provider. |
| `title` | Job title. |
| `department` | Department/team if available. |
| `location` | Job location if available. |
| `posted_date` | Provider timestamp if available. |
| `seniority` | Simple seniority bucket inferred from title. |
| `keywords_matched` | Input keywords found in the job text. |
| `hiring_signal_score` | 0-100 signal score based on keyword matches, seniority, and data richness. |
| `source_url` | Public job URL. |

### Pricing and cost estimation

This Actor is lightweight. It uses public JSON endpoints and does not launch a browser, use proxies, or perform authenticated scraping.

Typical runs should be inexpensive. Your final Apify cost depends mainly on:

- number of companies scanned;
- number of jobs per company;
- run frequency;
- selected memory and timeout settings.

Start with 10-25 companies, inspect results, then scale.

### Tips and advanced options

- Use `minScore` to filter to stronger buying or expansion signals.
- Use narrow keyword lists for better signal quality, e.g. `facilities`, `property`, `operations` for FM/property suppliers.
- Schedule weekly runs to monitor changes over time.
- Export to CSV for CRM import or connect the dataset through Apify integrations.

### FAQ, disclaimers, and support

**Does this scrape LinkedIn?** No. It intentionally avoids LinkedIn, cookies, and authenticated pages.

**Which providers are supported?** Greenhouse, Lever, and Ashby public job boards.

**Can you add another ATS provider?** Yes. Open an issue with the provider name and example public board URLs.

**Is this legal?** This Actor reads public career-board endpoints. You are responsible for using the data in accordance with applicable laws, website terms, and privacy obligations.

For bugs, feature requests, or custom versions, use the Issues tab on Apify.

# Actor input Schema

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

Public career boards to monitor. Provider must be greenhouse, lever, or ashby. Slug is the public board slug.

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

Keywords used to raise hiring signal scores.

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

Safety cap per board.

## `minScore` (type: `integer`):

Only emit jobs scoring at least this value. Use 0 to emit all jobs.

## `enableDelta` (type: `boolean`):

Compare the current scan with the previous snapshot for the same input and tag rows as new, existing, or removed.

## `emitRemoved` (type: `boolean`):

When delta mode is enabled, emit jobs that existed in the previous snapshot but are no longer present.

## `persistSnapshot` (type: `boolean`):

Save this run as the baseline for future delta detection.

## Actor input object example

```json
{
  "companies": [
    {
      "name": "Stripe",
      "provider": "greenhouse",
      "slug": "stripe",
      "domain": "stripe.com"
    },
    {
      "name": "Netflix",
      "provider": "lever",
      "slug": "netflix",
      "domain": "netflix.com"
    }
  ],
  "keywords": [
    "sales",
    "operations",
    "property",
    "facilities",
    "finance",
    "growth",
    "marketing"
  ],
  "maxJobsPerCompany": 200,
  "minScore": 0,
  "enableDelta": true,
  "emitRemoved": true,
  "persistSnapshot": true
}
```

# Actor output Schema

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

Structured job rows with company, role, location, matched keywords, signal score, and source URL.

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

Aggregate run status, counts, per-company summaries, and top hiring signals.

# 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": [
        {
            "name": "Stripe",
            "provider": "greenhouse",
            "slug": "stripe",
            "domain": "stripe.com"
        },
        {
            "name": "Netflix",
            "provider": "lever",
            "slug": "netflix",
            "domain": "netflix.com"
        }
    ],
    "keywords": [
        "sales",
        "operations",
        "property",
        "facilities",
        "finance",
        "growth",
        "marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signaltools/career-site-hiring-signal-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": [
        {
            "name": "Stripe",
            "provider": "greenhouse",
            "slug": "stripe",
            "domain": "stripe.com",
        },
        {
            "name": "Netflix",
            "provider": "lever",
            "slug": "netflix",
            "domain": "netflix.com",
        },
    ],
    "keywords": [
        "sales",
        "operations",
        "property",
        "facilities",
        "finance",
        "growth",
        "marketing",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("signaltools/career-site-hiring-signal-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    {
      "name": "Stripe",
      "provider": "greenhouse",
      "slug": "stripe",
      "domain": "stripe.com"
    },
    {
      "name": "Netflix",
      "provider": "lever",
      "slug": "netflix",
      "domain": "netflix.com"
    }
  ],
  "keywords": [
    "sales",
    "operations",
    "property",
    "facilities",
    "finance",
    "growth",
    "marketing"
  ]
}' |
apify call signaltools/career-site-hiring-signal-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=signaltools/career-site-hiring-signal-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Career Site Hiring Signal Monitor",
        "description": "Monitor public Greenhouse, Lever, and Ashby career boards and emit structured hiring-signal data for sales, recruiting, investor, and market-intelligence workflows.",
        "version": "0.1",
        "x-build-id": "zaPwCUAltHW93ssuT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/signaltools~career-site-hiring-signal-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-signaltools-career-site-hiring-signal-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/signaltools~career-site-hiring-signal-monitor/runs": {
            "post": {
                "operationId": "runs-sync-signaltools-career-site-hiring-signal-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/signaltools~career-site-hiring-signal-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-signaltools-career-site-hiring-signal-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Public career boards to monitor. Provider must be greenhouse, lever, or ashby. Slug is the public board slug.",
                        "items": {
                            "type": "object",
                            "required": [
                                "provider",
                                "slug"
                            ],
                            "properties": {
                                "name": {
                                    "type": "string",
                                    "title": "Company name",
                                    "description": "Optional human-readable company name."
                                },
                                "provider": {
                                    "type": "string",
                                    "title": "Provider",
                                    "description": "Public career-board provider.",
                                    "enum": [
                                        "greenhouse",
                                        "lever",
                                        "ashby"
                                    ]
                                },
                                "slug": {
                                    "type": "string",
                                    "title": "Board slug",
                                    "description": "Provider-specific public board slug, for example stripe for Greenhouse."
                                },
                                "domain": {
                                    "type": "string",
                                    "title": "Company domain",
                                    "description": "Optional company website domain for CRM-friendly output."
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keywords used to raise hiring signal scores.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap per board.",
                        "default": 200
                    },
                    "minScore": {
                        "title": "Minimum signal score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only emit jobs scoring at least this value. Use 0 to emit all jobs.",
                        "default": 0
                    },
                    "enableDelta": {
                        "title": "Detect changes from previous run",
                        "type": "boolean",
                        "description": "Compare the current scan with the previous snapshot for the same input and tag rows as new, existing, or removed.",
                        "default": true
                    },
                    "emitRemoved": {
                        "title": "Emit removed jobs",
                        "type": "boolean",
                        "description": "When delta mode is enabled, emit jobs that existed in the previous snapshot but are no longer present.",
                        "default": true
                    },
                    "persistSnapshot": {
                        "title": "Persist snapshot for future runs",
                        "type": "boolean",
                        "description": "Save this run as the baseline for future delta detection.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
