# Multi-ATS Tech Hiring Signals (`rex-law/tech-hiring-signal-monitor`) Actor

Detect explainable technology hiring-demand changes from public Greenhouse, Lever, and Ashby job boards.

- **URL**: https://apify.com/rex-law/tech-hiring-signal-monitor.md
- **Developed by:** [Rex Law](https://apify.com/rex-law) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 company board successfully checkeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Multi-ATS Tech Hiring Signals

Detect when companies start or stop investing in SRE, DevOps, platform engineering, cloud infrastructure, security, AI infrastructure, data engineering, observability, FinOps, and quantitative engineering.

This Actor reads the public, unauthenticated job-board APIs published by Greenhouse, Lever, and Ashby. It stores a bounded snapshot for each watchlist, compares scheduled runs, and emits explainable company-level changes with direct source links. It does not log in, scrape profiles, collect applicant data, bypass access controls, or invent contact information.

### Why buyers use it

- Cloud, observability, security, and developer-tool vendors can prioritize accounts that are actively building relevant teams.
- Recruiters can monitor target employers without repeatedly downloading the same job list.
- Analysts and AI agents receive compact, evidence-linked signals instead of thousands of raw job rows.
- Scheduled runs emit only material changes after the initial baseline.
- Technology-demand summaries reveal which infrastructure, security, observability, and data tools appear across matching roles.

### Input

Provide up to 25 public ATS boards:

```json
{
  "boards": [
    { "company": "GitLab", "provider": "greenhouse", "token": "gitlab" },
    { "company": "Lever Demo", "provider": "lever", "token": "leverdemo" },
    { "company": "Ashby", "provider": "ashby", "token": "Ashby" }
  ],
  "categories": ["sre", "devops", "platform", "cloud", "security", "ai_infrastructure", "data_engineering", "observability", "finops", "quant"],
  "onlyChanges": true,
  "emitBaseline": true,
  "stateKey": "my-watchlist"
}
````

The token is the final path component of a public board URL:

- `https://boards.greenhouse.io/gitlab` → `gitlab`
- `https://jobs.lever.co/leverdemo` → `leverdemo`
- `https://jobs.ashbyhq.com/Ashby` → `Ashby`

Arbitrary URLs are not accepted. Every upstream request is built from a fixed provider hostname and a validated token.

### Output

Each dataset row is one company signal containing:

- current open and matching role counts;
- added, removed, and materially changed matching roles;
- an explainable 0–100 signal score and trend;
- matched categories, category deltas, technology-demand counts, and newly appearing or disappearing technology requirements;
- workplace type, remote status, employment type, and public compensation text when an ATS provides it;
- direct public source links and timestamps.

The `OUTPUT` record contains run health, source failure counts, budget status, and processing totals.

### Unattended operation

The Actor is designed for scheduled, zero-touch operation:

- three bounded attempts for transient source failures;
- fixed public source hosts and hard response/job caps;
- previous state is preserved when a source fails;
- a fully failed run exits non-zero instead of publishing false removals;
- pay-per-event spending limits stop additional value delivery;
- state namespaces keep independent customer watchlists isolated;
- no API keys or private credentials are required from buyers.

The recommended schedule is once per day using the same `stateKey`. Downstream systems can consume the default dataset through Apify API, webhooks, Make, Zapier, n8n, or MCP.

### Pricing setup

Recommended initial Apify Pay Per Event configuration:

- event name: `company-scan`
- event title: `Company board successfully checked`
- initial price: `$0.05` per successful company check
- platform usage costs: pass through to the buyer
- permissions: limited
- Standby mode: disabled

At an 80% creator share, 5,000 successful company checks produce approximately `$200` before tax when platform usage costs are passed through. Revenue is not guaranteed; usage and customer acquisition must be measured.

### Local development

```bash
npm install
npm test
npm run check
npm run smoke
```

Run locally with an input stored at `storage/key_value_stores/default/INPUT.json`, or deploy with the Apify CLI:

```bash
apify login
apify push
```

Never commit an Apify token. Account ownership, KYC, tax information, payout setup, and acceptance of platform terms must remain with the human account owner.

### Operational kill gate

Do not keep expanding the product without demand. After 30 days in the Store:

- continue if there are at least 3 external paying users or 500 paid company checks;
- otherwise keep the Actor stable, stop feature work, and test a different market hypothesis.

# Actor input Schema

## `boards` (type: `array`):

Public ATS board identifiers. Tokens are the final path segment of a Greenhouse, Lever, or Ashby board URL.

## `categories` (type: `array`):

Only roles matching at least one selected category contribute to signals.

## `onlyChanges` (type: `boolean`):

After the baseline, write a dataset item only when matching roles are added, removed, or materially changed.

## `emitBaseline` (type: `boolean`):

Write one initial company signal before change-only monitoring begins.

## `stateKey` (type: `string`):

Stable namespace for this watchlist. Keep it unchanged across scheduled runs.

## `maxJobsPerBoard` (type: `integer`):

Hard safety cap applied before classification.

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

Timeout for each public ATS request.

## Actor input object example

```json
{
  "boards": [
    {
      "company": "GitLab",
      "provider": "greenhouse",
      "token": "gitlab"
    },
    {
      "company": "Lever Demo",
      "provider": "lever",
      "token": "leverdemo"
    },
    {
      "company": "Ashby",
      "provider": "ashby",
      "token": "Ashby"
    }
  ],
  "categories": [
    "sre",
    "devops",
    "platform",
    "cloud",
    "security",
    "ai_infrastructure",
    "data_engineering",
    "observability",
    "finops",
    "quant"
  ],
  "onlyChanges": true,
  "emitBaseline": true,
  "stateKey": "default",
  "maxJobsPerBoard": 500,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

## `signals` (type: `string`):

Dataset rows emitted for baselines or material hiring changes.

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

Processing counts, source failures, and budget-limit status.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rex-law/tech-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rex-law/tech-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 '{}' |
apify call rex-law/tech-hiring-signal-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Tech Hiring Signals",
        "description": "Detect explainable technology hiring-demand changes from public Greenhouse, Lever, and Ashby job boards.",
        "version": "0.2",
        "x-build-id": "ZB5jj3A1DpQDcFHJu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rex-law~tech-hiring-signal-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rex-law-tech-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/rex-law~tech-hiring-signal-monitor/runs": {
            "post": {
                "operationId": "runs-sync-rex-law-tech-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/rex-law~tech-hiring-signal-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-rex-law-tech-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": [
                    "boards"
                ],
                "properties": {
                    "boards": {
                        "title": "Company job boards",
                        "minItems": 1,
                        "maxItems": 25,
                        "type": "array",
                        "description": "Public ATS board identifiers. Tokens are the final path segment of a Greenhouse, Lever, or Ashby board URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "company",
                                "provider",
                                "token"
                            ],
                            "properties": {
                                "company": {
                                    "title": "Company name",
                                    "description": "Display name used in the output.",
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 120
                                },
                                "provider": {
                                    "title": "ATS provider",
                                    "description": "Public job-board API provider.",
                                    "type": "string",
                                    "enum": [
                                        "greenhouse",
                                        "lever",
                                        "ashby"
                                    ]
                                },
                                "token": {
                                    "title": "Public board token",
                                    "description": "Final path component of the public Greenhouse, Lever, or Ashby board URL.",
                                    "type": "string",
                                    "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$"
                                }
                            }
                        },
                        "default": [
                            {
                                "company": "GitLab",
                                "provider": "greenhouse",
                                "token": "gitlab"
                            },
                            {
                                "company": "Lever Demo",
                                "provider": "lever",
                                "token": "leverdemo"
                            },
                            {
                                "company": "Ashby",
                                "provider": "ashby",
                                "token": "Ashby"
                            }
                        ]
                    },
                    "categories": {
                        "title": "Hiring categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only roles matching at least one selected category contribute to signals.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sre",
                                "devops",
                                "platform",
                                "cloud",
                                "security",
                                "ai_infrastructure",
                                "data_engineering",
                                "observability",
                                "finops",
                                "quant"
                            ],
                            "enumTitles": [
                                "SRE",
                                "DevOps",
                                "Platform Engineering",
                                "Cloud Infrastructure",
                                "Security",
                                "AI Infrastructure / MLOps",
                                "Data Engineering",
                                "Observability",
                                "FinOps",
                                "Quant Engineering"
                            ]
                        },
                        "default": [
                            "sre",
                            "devops",
                            "platform",
                            "cloud",
                            "security",
                            "ai_infrastructure",
                            "data_engineering",
                            "observability",
                            "finops",
                            "quant"
                        ]
                    },
                    "onlyChanges": {
                        "title": "Emit only changes",
                        "type": "boolean",
                        "description": "After the baseline, write a dataset item only when matching roles are added, removed, or materially changed.",
                        "default": true
                    },
                    "emitBaseline": {
                        "title": "Emit first baseline",
                        "type": "boolean",
                        "description": "Write one initial company signal before change-only monitoring begins.",
                        "default": true
                    },
                    "stateKey": {
                        "title": "Monitor state key",
                        "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
                        "type": "string",
                        "description": "Stable namespace for this watchlist. Keep it unchanged across scheduled runs.",
                        "default": "default"
                    },
                    "maxJobsPerBoard": {
                        "title": "Maximum jobs per board",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard safety cap applied before classification.",
                        "default": 500
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 3,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for each public ATS request.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
