# Greenhouse, Lever & Ashby Jobs Scraper — Hiring Velocity Signal (`borisinc/greenhouse-lever-ashby-hiring-signal`) Actor

Scrape Greenhouse, Lever and Ashby job boards into a hiring-intent signal: roles opened vs closed, net hiring velocity, a 30-day trend, and every new role tagged by seniority and function. Public data, no PII.

- **URL**: https://apify.com/borisinc/greenhouse-lever-ashby-hiring-signal.md
- **Developed by:** [Donk](https://apify.com/borisinc) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## ATS Hiring Velocity & Signal Feed

**Turn public job boards into a hiring-intent signal — not another raw job scraper.**

This Actor tracks companies' **Greenhouse, Lever, and Ashby** job boards and tells you what actually matters: what roles **opened**, what **closed**, the net hiring direction, a rolling **30-day velocity trend**, and every new role tagged by **seniority** and **function**.

Companies expanding a team are actively buying tools, services, and headcount — and job postings are the most honest growth signal a company emits. Catch them first.

> A company that raises its open postings 30%+ in a quarter is ~2.4x likelier to buy new software the next quarter (LinkedIn Economic Graph). This Actor surfaces exactly that signal — the delta, not a raw dump.

### What you get

For every company, every run:

- `open_count`, `opened`, `closed`, `net_change`, `velocity_pct`
- a rolling `hiring_signal` label: **strong\_expansion → expanding → steady → cooling → contracting**
- 30-day trend: `opened_30d`, `closed_30d`, `net_change_30d`, `velocity_pct_30d`
- `new_by_function` and `new_by_seniority` breakdowns
- (optional) one row per **new** role, tagged with **seniority** and **function**

### Who it's for

- **B2B sales / RevOps** — spot accounts scaling a team (Engineering, Sales, Data…) and reach out before your competitors do
- **Recruiters & staffing** — companies opening lots of roles in your niche are warm leads
- **Investors / market intel** — track portfolio and competitor hiring velocity over time

### Sources

Public JSON board feeds — **Greenhouse, Lever, Ashby** (Workable best-effort). No login, no CAPTCHAs, no personal data.

### Input

Provide companies as `<ats>:<token>`, where the token is the board slug in the company's careers URL (`boards.greenhouse.io/gitlab` → `greenhouse:gitlab`):

```json
{
  "companies": ["greenhouse:stripe", "ashby:openai", "lever:spotify"],
  "emitJobRecords": true,
  "classifier": "heuristic"
}
```

Comes **pre-filled with a dozen high-growth tech companies** so you can run it immediately. Optional `classifier: "llm"` uses any OpenAI-compatible endpoint for messy titles.

### Output example

```json
{
  "company": "stripe",
  "ats": "greenhouse",
  "open_count": 497,
  "opened": 12, "closed": 4, "net_change": 8, "velocity_pct": 1.6,
  "velocity_pct_30d": 21.4, "hiring_signal": "expanding",
  "new_by_function": { "Engineering": 6, "Sales": 3, "Product": 2 },
  "new_by_seniority": { "senior": 5, "mid": 4, "staff": 2 }
}
```

Velocity accumulates across scheduled runs: the first run sets a baseline (no false spike), and every run after tracks what changed. **Schedule it daily or weekly** to build a live hiring-intent feed.

### Why this, not a raw job scraper

Everyone ships the current job list. This ships the **change** — opened/closed deltas, a velocity trend, and seniority/function tags — which is the layer intent-data vendors charge $15–50k/yr for. It's also low-maintenance by design: stable public JSON APIs, no headless browser, no anti-bot arms race.

### Notes

- **Public data only, no PII** — reads public job-board listings, never personal information.
- **Near-zero maintenance** — stable JSON board APIs.
- Point it at any companies you care about, or run the built-in high-growth seed as-is.

# Actor input Schema

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

One entry per company as '<ats>:<token>'. Supported ats: greenhouse, lever, ashby, workable. The token is the board slug in the company's careers URL (boards.greenhouse.io/gitlab -> 'greenhouse:gitlab').

## `emitJobRecords` (type: `boolean`):

Also output one row per NEW requisition (with seniority + function tags), not just the per-company summary.

## `classifier` (type: `string`):

heuristic = zero-cost regex (default). llm = OpenAI-compatible endpoint for messy titles (works with a local vLLM server).

## `velocityWindowDays` (type: `integer`):

Window for the rolling opened/closed/net trend across scheduled runs.

## `llmBaseUrl` (type: `string`):

OpenAI-compatible base, e.g. https://api.openai.com/v1 . Only used when Tagging mode = llm.

## `llmModel` (type: `string`):

e.g. gpt-4o-mini or a local model name. Only used when Tagging mode = llm.

## `llmApiKey` (type: `string`):

Bearer token for the LLM endpoint (blank for a keyless local server).

## Actor input object example

```json
{
  "companies": [
    "greenhouse:stripe",
    "ashby:openai"
  ],
  "emitJobRecords": true,
  "classifier": "heuristic",
  "velocityWindowDays": 30
}
```

# 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": [
        "greenhouse:stripe",
        "greenhouse:anthropic",
        "ashby:openai",
        "greenhouse:databricks",
        "ashby:ramp",
        "greenhouse:figma",
        "ashby:notion",
        "lever:spotify",
        "greenhouse:reddit",
        "greenhouse:coinbase",
        "ashby:snowflake",
        "greenhouse:gitlab"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("borisinc/greenhouse-lever-ashby-hiring-signal").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": [
        "greenhouse:stripe",
        "greenhouse:anthropic",
        "ashby:openai",
        "greenhouse:databricks",
        "ashby:ramp",
        "greenhouse:figma",
        "ashby:notion",
        "lever:spotify",
        "greenhouse:reddit",
        "greenhouse:coinbase",
        "ashby:snowflake",
        "greenhouse:gitlab",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("borisinc/greenhouse-lever-ashby-hiring-signal").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": [
    "greenhouse:stripe",
    "greenhouse:anthropic",
    "ashby:openai",
    "greenhouse:databricks",
    "ashby:ramp",
    "greenhouse:figma",
    "ashby:notion",
    "lever:spotify",
    "greenhouse:reddit",
    "greenhouse:coinbase",
    "ashby:snowflake",
    "greenhouse:gitlab"
  ]
}' |
apify call borisinc/greenhouse-lever-ashby-hiring-signal --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JBLfMWUoxjL9cY2zx/builds/5raQ3q6dm5IRHLEHR/openapi.json