# B2B Company Buying Signals — Hiring & Tech Radar (`nexascout/b2b-company-buying-signal-radar`) Actor

Find B2B buying signals from company hiring activity. Track Greenhouse, Lever, Workday and career pages for growth, leadership hires, tech-stack changes and account-level sales intelligence.

- **URL**: https://apify.com/nexascout/b2b-company-buying-signal-radar.md
- **Developed by:** [NexaScout](https://apify.com/nexascout) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 company buying intelligences

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/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

## B2B Company Buying Signals — Hiring & Tech Radar

Turn public hiring activity into **company-level B2B buying-signal intelligence**.

Monitor Greenhouse, Lever, Workday, and public company career pages to identify companies that are expanding teams, hiring leadership, changing technology stacks, entering new locations, or showing other signals relevant to sales and account prioritization.

Instead of returning hundreds of raw job postings, this Actor produces **one structured intelligence record per company**.

It helps answer:

> **Which companies are changing right now, what changed, and why could that matter to a seller?**

***

### What you get

For each successfully resolved company, the Actor can return:

- `buyingSignalScore` — explainable 0–100 prioritization score
- `buyingSignalTier` — `HOT`, `WARM`, `WATCH`, or `LOW`
- `buyingSignalState` — `NEW`, `RISING`, `PERSISTENT`, `STABLE`, `FADING`, or `RESURFACED`
- current open-role count
- hiring deltas across recurring runs
- newly posted jobs
- removed jobs
- department expansion
- geographic expansion
- leadership-level hiring
- technology mentions found in current job descriptions
- newly observed technologies
- structured `intentSignals`
- `whyNow[]` evidence
- likely `targetBuyerRoles[]`
- relevant `solutionCategories[]`
- source status and data-quality indicators
- evidence jobs with public source URLs

***

### Not just another jobs scraper

Traditional job scrapers return job postings.

This Actor adds a transformation layer:

**public hiring data → company changes → buying signals → account intelligence**

Instead of asking:

> What jobs does this company have open?

you can ask:

> What is changing inside this company, how strong is the signal, and which buyer or solution category could be relevant?

That makes the output useful for:

- Sales teams
- RevOps
- Account-based prospecting
- Lead-generation agencies
- Recruiting agencies
- Technology vendors
- Investors and researchers
- AI agents
- Automated enrichment and routing workflows

***

### Example

A company with expanding engineering, AI, security, or GTM hiring could produce an intelligence record like:

```json
{
  "companyName": "Example Company",
  "companyDomain": "example.com",
  "buyingSignalScore": 59,
  "buyingSignalTier": "WARM",
  "buyingSignalState": "RISING",
  "openRoles": 100,
  "openRoleDelta": 18,
  "leadershipOpenings": 5,
  "buyingSignals": [
    "Hiring acceleration",
    "Leadership hiring",
    "Technology-stack expansion"
  ],
  "whyNow": [
    "Open roles increased since the previous observation",
    "Leadership-level positions are currently open",
    "Cloud and data technologies appear in current job descriptions"
  ],
  "targetBuyerRoles": [
    "CTO",
    "VP Engineering",
    "VP Data"
  ],
  "solutionCategories": [
    "Cloud infrastructure",
    "Data infrastructure",
    "Developer tools"
  ],
  "techSignals": [
    {
      "technology": "AWS",
      "category": "CLOUD",
      "mentions": 4
    },
    {
      "technology": "Snowflake",
      "category": "DATA",
      "mentions": 2
    }
  ]
}
```

The exact values depend on the company's current public hiring data and previous observations.

***

### Use cases

#### Sales prospecting and account prioritization

Find companies showing:

- hiring acceleration
- leadership changes
- department expansion
- new locations
- technology-stack signals
- security, cloud, AI, data, or GTM expansion

Use the structured score and evidence to decide which accounts deserve attention first.

***

#### RevOps and CRM enrichment

Add structured company-change intelligence to CRM or enrichment workflows:

- buying-signal score
- signal tier
- signal state
- hiring changes
- buyer-role hints
- solution categories
- technology signals
- evidence URLs

***

#### Technology-vendor prospecting

Identify organizations hiring around technologies and categories such as:

- AWS
- Azure
- GCP
- Kubernetes
- Terraform
- Snowflake
- BigQuery
- Kafka
- dbt
- Salesforce
- Workday
- Okta
- GitHub
- GitLab
- observability tools
- security tools
- AI / ML technologies

You can also supply a custom `technologyWatchlist`.

***

#### Market and competitor intelligence

Track peer companies for:

- hiring expansion
- hiring contraction
- new departments
- new locations
- leadership hiring
- newly observed technologies
- persistent or fading signals

***

#### Recruiting and agency lead generation

Find organizations expanding:

- Engineering
- Data & AI
- Sales & GTM
- Security & Compliance
- Operations
- Customer Success
- People & Talent
- Finance & Procurement
- Product & Design

***

#### AI agents and automated workflows

The Actor produces structured company-level intelligence suitable for:

- AI sales agents
- research agents
- account scoring
- lead routing
- enrichment pipelines
- MCP workflows
- CRM automations
- alerting systems
- recurring account monitoring

***

### Supported sources

The Actor is HTTP-first and supports public hiring data from:

- Greenhouse
- Lever
- Workday
- selected public company career pages

You can provide either:

1. company domains and let the Actor discover supported career sources, or
2. direct career / ATS URLs when you already know the source.

No LinkedIn login, browser account, cookies, or LinkedIn credentials are required.

***

### Quick start

#### Option 1 — Company domains

```json
{
  "companyDomains": [
    "stripe.com",
    "cloudflare.com"
  ],
  "trackerName": "my-b2b-buying-signals",
  "trackingEnabled": true,
  "includeStable": false,
  "signalScoreThreshold": 35
}
```

The Actor will try to discover supported public career or ATS sources automatically.

***

#### Option 2 — Direct career / ATS URLs

If you already know the source:

```json
{
  "careerUrls": [
    "https://job-boards.greenhouse.io/example"
  ],
  "trackerName": "direct-ats-monitor",
  "trackingEnabled": true
}
```

Direct URLs are useful when:

- you already know the company's ATS
- automatic discovery is unnecessary
- you want to monitor a specific public hiring source

***

### Recurring monitoring

The Actor becomes more useful when the same companies are monitored repeatedly.

Enable:

```json
{
  "trackingEnabled": true,
  "trackerName": "my-account-list"
}
```

Then reuse the same `trackerName` in future runs.

The Actor can compare current data with previous observations and detect:

- hiring acceleration
- hiring contraction
- newly added jobs
- removed jobs
- new locations
- newly observed technologies
- persistent signals
- fading signals
- resurfacing activity

This enables signal states such as:

```text
NEW
RISING
PERSISTENT
STABLE
FADING
RESURFACED
```

***

### Buying-signal score

Each company can receive an explainable score from:

```text
0–100
```

The score is converted into a categorical tier:

```text
HOT
WARM
WATCH
LOW
```

The score is based on observable public signals such as:

- hiring activity
- changes across runs
- leadership hiring
- department expansion
- location expansion
- technology-stack signals
- strategic hiring patterns

The score is intended for prioritization.

It is not proof that a company intends to purchase a specific product.

***

### Signal state

The Actor also tracks how a signal behaves over time.

Possible states include:

#### `NEW`

A company or signal appears for the first time.

#### `RISING`

Activity is increasing compared with previous observations.

#### `PERSISTENT`

A meaningful signal continues across multiple observations.

#### `STABLE`

Activity remains relatively unchanged.

#### `FADING`

Previously observed activity is weakening.

#### `RESURFACED`

A previously weaker or absent signal becomes active again.

***

### Technology signals

The Actor scans bounded sets of current job descriptions for technology mentions.

The built-in technology dictionary covers categories such as:

- Cloud & infrastructure
- Data platforms
- AI & machine learning
- Security
- CRM & GTM
- Observability
- Engineering tooling
- ITSM
- HRIS
- ERP

Technology output can include:

```json
{
  "technology": "Kubernetes",
  "category": "CLOUD",
  "mentions": 3,
  "sampleRoles": [
    "Platform Engineer",
    "Site Reliability Engineer"
  ]
}
```

***

### Custom technology watchlist

You can monitor additional technologies or vendors:

```json
{
  "technologyWatchlist": [
    "Wiz",
    "CrowdStrike",
    "Datadog",
    "Outreach"
  ]
}
```

The custom watchlist is evaluated together with the built-in technology dictionary.

***

### Intent signals

The Actor converts raw hiring evidence into structured strategic signals.

Examples can include:

```text
LEADERSHIP_HIRING
ENGINEERING_EXPANSION
DATA_AI_EXPANSION
SALES_GTM_EXPANSION
SECURITY_COMPLIANCE_EXPANSION
AI_STACK_SIGNAL
GTM_STACK_SIGNAL
SECURITY_STACK_SIGNAL
```

Each intent signal can include:

- type
- strength
- supporting evidence

Example:

```json
{
  "type": "DATA_AI_EXPANSION",
  "strength": 2,
  "evidence": "16 current data/AI roles"
}
```

***

### Buyer-role mapping

The Actor can map observed signals to likely relevant buyer roles.

Examples:

```text
CTO
VP Engineering
VP Data
Head of AI
CISO
VP Security
RevOps
VP Sales
CRO
GRC
Executive team
```

These are relevance indicators based on observed company activity.

They are not claims that a specific person is actively purchasing.

***

### Solution-category mapping

Observed signals can also be mapped to relevant solution categories.

Examples include:

- Cloud infrastructure
- Cloud compute
- Data infrastructure
- AI tooling
- Developer tools
- Security
- Compliance
- CRM
- GTM tooling
- Sales tech
- Lead generation
- Observability
- Strategic services

This makes the output easier to route into downstream sales and enrichment workflows.

***

### Evidence-first output

Buying signals include supporting public evidence wherever available.

Evidence jobs can contain:

```json
{
  "id": "job-id",
  "title": "Senior Platform Engineer",
  "department": "ENGINEERING",
  "location": "New York, NY",
  "postedAt": "2026-09-24T00:00:00.000Z",
  "url": "https://example.com/jobs/123",
  "isNew": true
}
```

This allows users and downstream systems to inspect the evidence behind a signal.

***

### Main input fields

#### `companyDomains`

Company domains to monitor.

Example:

```json
[
  "stripe.com",
  "cloudflare.com"
]
```

***

#### `careerUrls`

Optional direct Greenhouse, Lever, Workday, or public career URLs.

***

#### `trackerName`

Stable history namespace.

Reuse the same value across recurring runs to unlock historical comparison.

***

#### `trackingEnabled`

Persist private history and compare the current observation with previous runs.

Default:

```text
true
```

***

#### `resetHistory`

Treat the current run as a fresh baseline.

***

#### `includeStable`

When disabled, recurring runs can focus on changed or sufficiently strong company signals rather than returning every unchanged company.

***

#### `signalScoreThreshold`

Minimum buying-signal score for stable companies when `includeStable` is disabled.

Default:

```text
35
```

***

#### `maxJobsPerCompany`

Maximum number of public jobs processed per company.

Default:

```text
100
```

***

#### `maxOutputRows`

Maximum number of company intelligence rows written to the dataset.

***

#### `descriptionScanLimit`

Maximum number of recent job descriptions used per company for technology-signal analysis.

Default:

```text
15
```

***

#### `technologyWatchlist`

Optional custom technologies or vendors to monitor.

***

### Output philosophy

The Actor intentionally produces **company intelligence**, not a raw job dump.

A single company-level row can consolidate evidence from many individual public job postings.

This makes the output easier to use for:

- prospecting
- ranking
- CRM enrichment
- account research
- automation
- AI-agent workflows

***

### Data quality

Each company result can include source and quality information such as:

- `sourceStatus`
- `dataQuality`
- `careerUrl`
- `careerUrls`
- `atsProvider`
- `discoveryMethods`

This helps downstream systems distinguish successfully resolved companies from incomplete or lower-confidence observations.

***

### Recommended recurring workflow

A typical workflow looks like:

```text
Target account list
        ↓
B2B Company Buying Signals Actor
        ↓
Hiring + leadership + department + technology analysis
        ↓
Buying Signal Score
        ↓
Why Now evidence
        ↓
Buyer roles + solution categories
        ↓
CRM / AI agent / outbound workflow
```

Run the same tracker repeatedly to move from a static company snapshot to ongoing change detection.

***

### Good fit for

This Actor is designed for users who need:

- company buying signals
- B2B sales intelligence
- account intelligence
- hiring signals
- company growth signals
- technology-stack signals
- account prioritization
- lead generation
- sales prospecting
- RevOps enrichment
- competitor monitoring
- Greenhouse monitoring
- Lever monitoring
- Workday monitoring
- career-page monitoring
- AI-agent-ready company intelligence

***

### Important caveat

A buying signal is a **sales-intelligence indicator**, not proof that a company intends to purchase a specific product.

The Actor analyzes observable public hiring activity and converts it into structured prioritization signals.

Users should combine these signals with their own qualification criteria, account data, and sales process.

# Changelog

This Actor's version history is a separate document: https://apify.com/nexascout/b2b-company-buying-signal-radar/changelog.md

# Actor input Schema

## `companyDomains` (type: `array`):

Company domains to monitor. The Actor tries to discover public careers/ATS links automatically.

## `careerUrls` (type: `array`):

Optional direct Greenhouse, Lever, Workday, or public careers URLs. Use these when you already know the company's career board.

## `trackerName` (type: `string`):

Stable history namespace. Reuse the same tracker name across recurring runs to unlock deltas, RISING/PERSISTENT/FADING states and new-tech detection.

## `trackingEnabled` (type: `boolean`):

Persist private company history and compare current hiring signals with prior runs.

## `resetHistory` (type: `boolean`):

Treat this run as a fresh baseline for the tracker.

## `includeStable` (type: `boolean`):

When disabled, recurring runs focus on changed or sufficiently strong buying-signal rows instead of returning every unchanged company.

## `signalScoreThreshold` (type: `integer`):

Stable companies below this score are suppressed when includeStable is off.

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

Safety cap for public job postings processed per company.

## `maxOutputRows` (type: `integer`):

Maximum company-level rows written to the dataset.

## `descriptionScanLimit` (type: `integer`):

Maximum recent job descriptions fetched/used per company for technology-signal analysis. Greenhouse uses lightweight list retrieval plus bounded job-detail enrichment; Workday uses the same limit. Keep modest for broad scans.

## `workdayDetailLimit` (type: `integer`):

Backward-compatibility field. descriptionScanLimit takes precedence when provided.

## `technologyWatchlist` (type: `array`):

Optional custom technologies or tools to detect in job descriptions in addition to the built-in cloud, data, AI, security, GTM and enterprise-software dictionary.

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

Maximum seconds for an individual public HTTP request.

## `proxyConfiguration` (type: `object`):

Optional. V0.1.0 is HTTP-first and defaults to direct requests; enable Apify Proxy only when a target source needs it.

## Actor input object example

```json
{
  "companyDomains": [
    "stripe.com",
    "cloudflare.com"
  ],
  "careerUrls": [],
  "trackerName": "my-b2b-buying-signals",
  "trackingEnabled": true,
  "resetHistory": false,
  "includeStable": false,
  "signalScoreThreshold": 35,
  "maxJobsPerCompany": 100,
  "maxOutputRows": 100,
  "descriptionScanLimit": 15,
  "workdayDetailLimit": 15,
  "technologyWatchlist": [],
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `overview` (type: `string`):

No description

## `triggers` (type: `string`):

No description

## `tech` (type: `string`):

No description

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

No description

# 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 = {
    "companyDomains": [
        "stripe.com",
        "cloudflare.com"
    ],
    "trackerName": "my-b2b-buying-signals"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/b2b-company-buying-signal-radar").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 = {
    "companyDomains": [
        "stripe.com",
        "cloudflare.com",
    ],
    "trackerName": "my-b2b-buying-signals",
}

# Run the Actor and wait for it to finish
run = client.actor("nexascout/b2b-company-buying-signal-radar").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 '{
  "companyDomains": [
    "stripe.com",
    "cloudflare.com"
  ],
  "trackerName": "my-b2b-buying-signals"
}' |
apify call nexascout/b2b-company-buying-signal-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/b2b-company-buying-signal-radar"
        }
    }
}
```

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/D5Nq52v1UzYqZKtd9/builds/BhVC1jeivpHkVGgDj/openapi.json