# Business Buying Signal Detector (`moving_beacon-owner1/business-buying-signal-detector`) Actor

Detect actionable business signals from public data, including recent news, website changes, technology updates, and hiring activity. Each signal includes verifiable evidence, a source URL, importance, and confidence—so you can identify potential opportunities based on real, observable events.

- **URL**: https://apify.com/moving\_beacon-owner1/business-buying-signal-detector.md
- **Developed by:** [Jamshaid Arif](https://apify.com/moving_beacon-owner1) (community)
- **Categories:** Lead generation, News, Jobs
- **Stats:** 130 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

from $10.00 / 1,000 results

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

## Business Buying Signal Detector

Detect **publicly observable business-activity signals** ("buying signals") for a list of companies. The Actor reports only concrete, checkable facts — recent news, changes to a company's public website, and optional public hiring activity — and it **never infers private intentions**. Every signal ships with the evidence behind it, an importance level and a confidence score, so your outreach can cite a real, verifiable event.

### What does this Actor do?

For each company it can produce these signal types:

1. **News events** (`news`) — recent public articles mentioning the company (Google News RSS). Headlines containing strong indicators (funding, acquisition, expansion, hiring, new contract, etc.) are flagged as higher importance.
2. **Website changes** (`website_changes`) — a change to the company's public homepage vs. the previous run: page title or heading structure. Detected via a lightweight fingerprint stored in the Apify key-value store.
3. **Technology changes** (`tech_changes`) — a change in the technologies detected on the homepage (analytics, CMS, e-commerce, etc.).
4. **New jobs** (`new_jobs`) — *best-effort*: when the company website is a public Greenhouse or Lever job board, the count of open public roles is reported. Skipped otherwise.

### Why use it?

- Sales and partnerships teams get a **feed of timing signals** — the moment a target is in the news, refreshes its site, or ramps hiring — instead of scraping each source manually.
- Every signal is a **public, observable fact** with a source URL, so it is safe to act on and easy to verify.

### How to use it

1. Provide **companies** (objects `{name, website}` or plain strings), or **startUrls**.
2. Pick the **signalTypes** to detect (default: all).
3. Optionally add **newsKeywords** to bias/highlight news matches.
4. Run the Actor. For website/technology change detection, run it on a **schedule** — the first run records a baseline, later runs report what changed.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `companies` | array | Companies to scan — objects `{name, website}` or strings (name, domain, or URL). |
| `startUrls` | array | Company website URLs, as an alternative to `companies`. |
| `signalTypes` | array | `new_jobs`, `website_changes`, `news`, `tech_changes` (default: all). |
| `newsKeywords` | array | Optional keywords to bias and highlight news matches. |
| `proxyConfiguration` | object | Proxy settings for news and website requests. |

Provide at least one of `companies` or `startUrls`.

#### Input example

```json
{
  "companies": [
    { "name": "Acme Corp", "website": "https://acme.com" },
    "example.com"
  ],
  "signalTypes": ["news", "website_changes"],
  "newsKeywords": ["funding", "expansion"]
}
```

### Output

One record per detected signal:

| Field | Description |
| --- | --- |
| `company` | The company the signal is about. |
| `signalType` | `news_event`, `website_change`, or `hiring_activity`. |
| `evidence` | The observable fact (headline, the field that changed, role count). |
| `sourceUrl` | Link to the public source. |
| `timestamp` | When the event was published / observed. |
| `importance` | `low`, `medium`, or `high`. |
| `confidence` | 0–1 confidence in the signal. |
| `source` | News source (for news events). |

#### Output example

```json
{
  "company": "Acme Corp",
  "signalType": "news_event",
  "evidence": "Acme Corp raises $50M in Series B funding",
  "sourceUrl": "https://news.google.com/articles/...",
  "timestamp": "Mon, 10 Aug 2026 12:00:00 GMT",
  "importance": "high",
  "confidence": 0.75,
  "source": "TechCrunch"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Change detection & snapshots

Website and technology change detection compares each run against a **snapshot stored in the Apify key-value store** (via the shared `ChangeMonitor`). The first run for a website records the baseline and emits no change signals; subsequent runs emit a `website_change` signal for each field (title, heading structure, technologies) that differs. Schedule the Actor to turn this into a running change feed.

### What it does NOT do

- It does **not** infer intentions, budgets, or private plans — only observable public facts.
- It does **not** access private, authenticated, or personal data.

# Actor input Schema

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

Companies to scan. Each item can be an object like {"name": "Acme", "website": "https://acme.com"} or a plain string (a company name, or a domain/URL).

## `startUrls` (type: `array`):

Company website URLs to scan, as an alternative to the companies list.

## `signalTypes` (type: `array`):

Which observable signals to detect.

## `newsKeywords` (type: `array`):

Optional keywords to bias and highlight news matches (e.g. 'funding', 'expansion', 'hiring').

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

Proxy settings used for news and website requests.

## `cookies` (type: `string`):

Optional Cookie header string replayed on every request.

## Actor input object example

```json
{
  "companies": [
    {
      "name": "Acme Corp",
      "website": "https://acme.com"
    }
  ],
  "signalTypes": [
    "new_jobs",
    "website_changes",
    "news",
    "tech_changes"
  ],
  "proxyConfiguration": {
    "useApifyProxy": 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": [
        {
            "name": "Acme Corp",
            "website": "https://acme.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("moving_beacon-owner1/business-buying-signal-detector").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": [{
            "name": "Acme Corp",
            "website": "https://acme.com",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("moving_beacon-owner1/business-buying-signal-detector").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": [
    {
      "name": "Acme Corp",
      "website": "https://acme.com"
    }
  ]
}' |
apify call moving_beacon-owner1/business-buying-signal-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moving_beacon-owner1/business-buying-signal-detector"
        }
    }
}

```

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/Os2rx0oxjNr3fVfcw/builds/iRegeZDlsC5irOA6b/openapi.json