# Hiring Signals to Notion — Hiring Intent Feed API (`nexgendata/hiring-signals-notion`) Actor

Feed it companies, get a hiring-signal scorecard per company — who's hiring, which teams are growing, momentum. Optional ready-to-use Notion database in the same run. Spot expansion and buying intent early for sales & recruiting.

- **URL**: https://apify.com/nexgendata/hiring-signals-notion.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Jobs
- **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 scorecards

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

## Hiring Signals → Notion — Track Who's Hiring & Which Teams Are Growing

**Feed it a list of companies. Get back a hiring-signal scorecard for each — and (optionally) a ready-to-use Notion database, built in the same run.**

Hiring is the most honest signal a company sends. A wave of new engineering reqs means a product push. A sudden run of sales and BD roles means a go-to-market expansion. New offices in a new city means geographic growth. This Actor reads a company's **live, public job board** and turns it into a one-line read on where that company is putting its money — then drops it straight into your Notion workspace if you want it there.

Built for **recruiters, sales/BD teams, competitive-intel analysts, and investors** who want to know who's growing *before* it's obvious.

***

### What you get per company

Each scorecard contains:

| Field | What it tells you |
|---|---|
| `company` / `company_slug` | The company and its resolved Greenhouse board |
| `open_roles_count` | Total live open roles right now |
| `departments` | Every hiring team with an open-role count (ranked) |
| `notable_roles` | A handful of representative open titles |
| `locations` | Where they're hiring, top locations ranked |
| `hiring_velocity_note` | Plain English — e.g. *"expanding eng (28) + sales (11) — 64 open roles total"* |
| `source` | Direct link to the live job board |
| `data_source` | Always the public Greenhouse job-board API |
| `as_of_timestamp` | When the snapshot was taken (UTC) |

### 📊 Sample Output

[![Hiring Signals to Notion sample output — live hiring-signal scorecards for Stripe, Anthropic, Airbnb, Figma, Reddit, GitLab, Asana and Discord showing open-role counts, top hiring department, and a plain-English hiring-velocity note from public Greenhouse job boards](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/hiring-signals-notion-sample)](https://apify.com/nexgendata/hiring-signals-notion?fpr=2ayu9b)

Real scorecards returned by a live run across **8 companies** — every value below comes straight from the public Greenhouse job-board API at run time:

| Company | Open roles | Top hiring department | Hiring-velocity note |
|---|---|---|---|
| Stripe | 506 | 1150 Solutions Architecture (23) | expanding eng (181) + ops (108) + sales (59) — 506 open roles total |
| Anthropic | 378 | Sales (74) | expanding eng (220) + sales (68) + ops (38) — 378 open roles total |
| Airbnb | 222 | Software Engineering (67) | expanding eng (87) + sales (44) + ops (38) — 222 open roles total |
| Figma | 171 | Sales (64) | expanding sales (75) + eng (48) + ops (18) — 171 open roles total |
| Reddit | 146 | Large Customer Sales (26) | expanding eng (82) + sales (36) + product (4) — 146 open roles total |
| GitLab | 138 | EMEA - Commercial (14) | expanding eng (49) + sales (42) + ops (18) — 138 open roles total |
| Asana | 133 | Product Engineering (30) | expanding eng (62) + sales (25) + ops (16) — 133 open roles total |
| Discord | 70 | Core Tech Engineering (14) | expanding eng (41) + ops (10) + product (7) — 70 open roles total |

Each dataset row also carries the full ranked `departments` and `locations` arrays, `notable_roles`, the live `source` link, `data_source`, and `as_of_timestamp` — see the full JSON object under **Example output** below.

***

### Optional: one-run delivery into Notion

Add a **Notion MCP connector** and the Actor builds a fresh Notion database for you in the same run — one row per company, columns for open roles, top departments, notable roles, top locations, hiring-velocity note, source, and snapshot date. The Actor **never sees your Notion credentials**; Apify injects them server-side through the connector. Leave the connector blank and you simply get the dataset.

To use it: authorize a Notion MCP connector in **Apify Console → Settings → API & Integrations**, then pick it in the `notionConnector` field. Optionally pass a `notionParentId` to nest the database under a specific page.

***

### Input

```json
{
  "companies": ["stripe", "airbnb", "anthropic"],
  "notionConnector": null,
  "notionParentId": null
}
```

- **companies** — slugs or company names. Names are normalized to Greenhouse slug candidates automatically (e.g. "Air BnB" → `airbnb`). Verified-working slugs: `stripe`, `airbnb`, `anthropic`, `figma`, `discord`, `gitlab`, `reddit`, `asana`. Companies on a different ATS (Lever, Ashby, Workday) are returned with a clear "not found on Greenhouse" note rather than failing.
- **notionConnector** — optional Notion MCP connector. Blank = dataset-only.
- **notionParentId** — optional Notion page ID to create the database under.

***

### Example output

```json
{
  "company": "stripe",
  "company_slug": "stripe",
  "open_roles_count": 312,
  "departments": [
    { "department": "Engineering", "open_roles": 118 },
    { "department": "Sales", "open_roles": 41 },
    { "department": "Operations", "open_roles": 22 }
  ],
  "notable_roles": ["Staff Software Engineer", "Account Executive, Mid-Market", "Product Manager, Payments"],
  "locations": [
    { "location": "Remote", "open_roles": 96 },
    { "location": "San Francisco", "open_roles": 44 }
  ],
  "hiring_velocity_note": "expanding eng (118) + sales (41) + ops (22) — 312 open roles total",
  "source": "https://boards.greenhouse.io/stripe",
  "data_source": "greenhouse.io (public job-board API)",
  "as_of_timestamp": "2026-06-13T16:40:00+00:00"
}
```

***

### How it works

The Actor queries the **open, unauthenticated Greenhouse public job-board API** (`boards-api.greenhouse.io`) — the same data that renders on `boards.greenhouse.io/<company>`. No logins, no scraping behind walls, **public data only**. It then aggregates departments, locations, and role titles into a single scorecard and phrases a hiring-velocity summary.

***

### Use cases

- **Recruiters** — spot which competitors are mass-hiring for the exact roles you place.
- **Sales / BD** — a company opening 40 sales roles is a company about to buy sales tooling. Time your outreach.
- **Competitive intel** — track a rival's headcount investment by team, week over week.
- **Investors** — hiring velocity is a leading indicator of growth that shows up before revenue does.

***

### 🔗 Related NexGenData actors

- **[Greenhouse Jobs Scraper](https://apify.com/nexgendata/greenhouse-jobs-scraper?fpr=2ayu9b)** — the raw role-level data behind these scorecards: title, location, departments, full description HTML.
- **[LinkedIn Jobs Scraper](https://apify.com/nexgendata/linkedin-jobs-scraper?fpr=2ayu9b)** — hiring data from LinkedIn for companies not on Greenhouse.
- **[Hiring Signal Detector](https://apify.com/nexgendata/hiring-signal-detector?fpr=2ayu9b)** — deeper trend detection across hiring sources.
- **🏢 [About NexGenData](https://apify.com/nexgendata?fpr=2ayu9b)** — our full fleet of business-data and Notion-delivery actors.

***

*Public data only. Use responsibly and follow applicable employment, outreach, and privacy laws.*

# Actor input Schema

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

Companies to score, by Greenhouse slug or company name. Names are normalized to slug candidates automatically. Verified-working: stripe, airbnb, anthropic, figma, discord, gitlab, reddit, asana. Companies on a different ATS (Lever, Ashby, Workday) are returned with a 'not found on Greenhouse' note instead of failing.

## `notionConnector` (type: `string`):

Connect your Notion workspace and this Actor builds your hiring-signals database there in the same run — it never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here. Leave blank to get the dataset only.

## `notionParentId` (type: `string`):

Optional. The Notion page ID to create the hiring-signals database under. If blank, Notion creates it as a private page in your workspace.

## `supabaseConnector` (type: `string`):

Optional. Connect your own Supabase project and the results are also inserted into a table in the same run — the Actor never sees your Supabase credentials. Authorize a write-scoped, project-scoped Supabase MCP connector in Apify Console (Settings -> Integrations), then select it here.

## `supabaseTable` (type: `string`):

Target table in the public schema (created if missing, with id, a jsonb data column, and a scraped\_at timestamp). Default: nexgendata\_leads.

## `supabaseProjectId` (type: `string`):

Your Supabase project reference (e.g. abcdefghijklmnop). Required unless your connector URL is already project-scoped. Find it in your project URL: supabase.com/dashboard/project/THIS\_PART.

## `deliveryDedup` (type: `boolean`):

When on (default), records already delivered in a previous run are not delivered again to the same destination — so scheduled runs only push new items. Turn off to deliver every record on every run.

## Actor input object example

```json
{
  "companies": [
    "figma",
    "discord",
    "gitlab"
  ],
  "supabaseTable": "nexgendata_leads",
  "deliveryDedup": true
}
```

# 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": [
        "stripe",
        "airbnb",
        "anthropic"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/hiring-signals-notion").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": [
        "stripe",
        "airbnb",
        "anthropic",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/hiring-signals-notion").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": [
    "stripe",
    "airbnb",
    "anthropic"
  ]
}' |
apify call nexgendata/hiring-signals-notion --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/hiring-signals-notion",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HOdbBYcjMFo6pqm51/builds/CwVbupm1Abb1tkno1/openapi.json