# Buying Signals Monitor — Hiring, Funding, Tech & Exec Triggers (`inovaflow/buying-signals-monitor`) Actor

Every buying signal for your target accounts in one call: hiring intent, tech-stack change, funding, paid-ad activity and executive change — merged into one row per company with a combined 0–100 signal score, a priority, who to sell to and what is new since your last run.

- **URL**: https://apify.com/inovaflow/buying-signals-monitor.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 signal reports

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

## Buying Signals Monitor — Hiring, Funding, Tech & Exec Triggers

**The deal you lose is usually the one you were a month late to.** They raised in March and picked a vendor in
April. The new CRO arrived in May and re-signed everything by July. They ripped out your competitor's tool in
June and nobody told you. None of that is hidden — it is public, scattered across five different places, and
nobody on your team has time to check five places for two hundred accounts every week.

That is what this does. **Give it your target accounts. Get back every buying signal, per company, in one
call** — scored, prioritised, and with the one thing a monitor is actually for: **what changed since last
time**.

***

### The five signals

| Signal | What it answers | Why it is a trigger |
| --- | --- | --- |
| **Hiring** | which roles are open right now | headcount goes up before budget goes out |
| **Tech change** | what they just started — or stopped — using | a tool arriving or leaving is a decision in progress |
| **Funding** | did they just raise, how much, from whom | the single strongest buying window there is |
| **Ads** | are they advertising, ramping, or paused | paid spend tracks growth pressure |
| **Leadership** | who just took a senior seat, and from where | a new leader re-picks their predecessor's stack |

Each one becomes a block on the row: `present`, `value`, `momentum`, `summary` and full `details`. Together
they become **one 0–100 `signalScore`**, a `priority` of hot / warm / watch / cold, a `sellTo` list and a
`whyNow` line you can paste into a sequence.

***

### What a monitor gives you that a scraper does not

Run it once and you get a snapshot. Run it on a schedule and every run also answers **what moved**:

- `newSignalsSinceLastRun` — the signals that started firing since you last looked
- `lostSignalsSinceLastRun` — the ones that stopped
- `signalScoreChange` and `trend` — `heating`, `cooling`, `steady`, `new`
- `isNewCompany`, `runsSeen`, `firstSeen` — how long this account has been on your radar

Turn on **"only what changed since my last run"** and each run hands you a short list of accounts that
actually moved. That list is the product. Wire it to a weekly schedule and stop reading dashboards.

***

### Who it is for

- **Outbound and SDR teams** — a weekly "who got hot" list for the accounts you already care about, with the
  opening line written.
- **AI / GTM agents** — one tool call, a flat dataset, no login and no key. `signalScore`, `priority`,
  `whyNow`, `sellTo`, `newSignalsSinceLastRun` are all on the row.
- **Account managers and CS** — know the day your champion leaves or a competitor's tool appears.
- **Founders and investors** — watch a market, not a spreadsheet.

***

### How to use it

Watch your accounts:

```json
{
  "companies": ["gong.io", "ramp.com", "lemlist.com"],
  "signals": ["hiring", "tech", "funding", "ads", "leadership"],
  "daysBack": 30
}
```

Find the market first, then watch it:

```json
{
  "keywords": ["revenue intelligence software"],
  "locations": ["United States"],
  "companySizes": ["51-200", "201-500"],
  "maxCompanies": 50
}
```

The weekly monitor — only what moved, only what is worth a call:

```json
{
  "companies": ["gong.io", "ramp.com"],
  "onlyChanged": true,
  "minSignalScore": 30
}
```

***

### Scoring, in plain terms

Money in the bank beats a new decision-maker, which beats a stack change, which beats headcount growth, which
beats paid media — so the weights are funding 28, leadership 24, tech 20, hiring 16, ads 12. Each signal is
scored on its own terms first (a $5M round last week outranks a $200M round last quarter), then the total is
**normalised over the signals you enabled**, so a two-signal run still uses the whole 0–100 range and rows
stay comparable inside a run. No model call, no API key, and the same input always gives the same score.

***

### Built to keep running

- **Every signal is independent.** If one source cannot answer, that column is omitted for that company,
  named in `signalsSkipped`, and the rest of the row ships. A run does not fail because one signal did.
- **Quiet accounts still come back** — with `present: false`, which is a different and more useful fact than a
  missing row. They are **never charged for**.
- **Deduplicated by domain**, so the same company on your list twice is fetched once.
- **Bounded spend.** `maxSpendUsd` is a hard ceiling on what the lookups may charge, and the run summary
  reports what each source actually cost.

***

### Notes

- **Dataset-only.** No UI, no dashboard, no login. Four ready-made views: signals, detail, changes, audit.
- **One memory per watch.** The watch ID is derived from what you are watching, so the same list keeps the
  same history automatically — or pin your own to keep it stable while you edit the list.
- **Public data only.** Nothing behind a login is ever touched.

# Actor input Schema

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

One per line: a domain (`gong.io`) or a company name (`Gong`). Also accepted as `domains`, `watchlist` or `accounts`.

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

Used only when the watchlist is empty. What the companies you want to monitor do — `B2B SaaS`, `logistics software`, `dental clinics`.

## `locations` (type: `array`):

Used only with keywords. Cities, countries or regions.

## `companySizes` (type: `array`):

Used only with keywords. Empty = every size.

## `maxCompanies` (type: `integer`):

How many companies this run may watch. Also the ceiling on what it can cost.

## `signals` (type: `array`):

Empty = all five.

## `daysBack` (type: `integer`):

How recent a signal has to be to count. 30 days is the usual outbound window; widen it to catch a round or an executive move that is still worth opening with.

## `hiringRoles` (type: `array`):

Only used when the hiring signal is on. Which open roles mean something to you. Empty = a broad revenue-and-build set.

## `countries` (type: `array`):

Only used when the ads signal is on. Two-letter country codes. Empty = US.

## `onlyWithSignals` (type: `boolean`):

Drop companies where nothing is firing right now.

## `minSignalScore` (type: `integer`):

Keep only companies scoring at least this, out of 100. 30 ≈ warm, 60 ≈ hot.

## `onlyChanged` (type: `boolean`):

The monitor view: report a company only when it is new to the watch, a signal started or stopped, or the score moved. Ignored on the first run of a watch, which is the baseline.

## `watchId` (type: `string`):

Names the memory this watch compares against. Leave empty and one is derived from what you are watching, so the same watchlist keeps the same memory automatically. Set it to keep a stable history while you edit the list.

## `resolveDomains` (type: `boolean`):

Look up the domain for watchlist entries that are only a company name. Needed for the tech-change signal; the other four match on a name as well. Turn it off to save a lookup when every entry is already a domain.

## `maxSpendUsd` (type: `integer`):

A hard ceiling on what the signal lookups may charge your account in this run. Leave empty for no ceiling.

## `nestedTimeoutSecs` (type: `integer`):

How long any one signal may take before the run continues without it. The rows still ship, with that signal listed under signalsSkipped.

## Actor input object example

```json
{
  "companies": [
    "gong.io",
    "Ramp",
    "hubspot.com"
  ],
  "keywords": [
    "revenue intelligence software"
  ],
  "locations": [
    "United States",
    "Berlin"
  ],
  "companySizes": [],
  "maxCompanies": 100,
  "signals": [
    "hiring",
    "tech",
    "funding",
    "ads",
    "leadership"
  ],
  "daysBack": 30,
  "hiringRoles": [
    "Account Executive",
    "RevOps",
    "Data Engineer"
  ],
  "countries": [
    "US",
    "GB"
  ],
  "onlyWithSignals": false,
  "minSignalScore": 0,
  "onlyChanged": false,
  "watchId": "enterprise-accounts",
  "resolveDomains": true,
  "nestedTimeoutSecs": 1200
}
```

# Actor output Schema

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

The call list: company, domain, combined score, priority, which signals are firing, why now and who to sell to.

## `detail` (type: `string`):

Open roles, technologies added and dropped, funding round and size, active ads, the new executive — plus every full signal block.

## `changes` (type: `string`):

The delta since the previous run of this watch: new companies, signals that started or stopped, and which accounts are heating up.

## `audit` (type: `string`):

Which signals could not be answered for which company, and which watchlist entry each row answers.

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

Companies watched and delivered, signal coverage, priority split, what is new since the last run, the per-source report and the cost breakdown.

# 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": [
        "gong.io",
        "ramp.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/buying-signals-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": [
        "gong.io",
        "ramp.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/buying-signals-monitor").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 '{
  "companies": [
    "gong.io",
    "ramp.com"
  ]
}' |
apify call inovaflow/buying-signals-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,inovaflow/buying-signals-monitor"
        }
    }
}
```

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/rpUOuuY5RPs4NpLdj/builds/CCKwyXWeXQqqNRfur/openapi.json