# B2B Sales Trigger Intelligence (`crawlerbros/b2b-sales-triggers`) Actor

Detect high-intent B2B sales triggers hiring surges, funding rounds, executive changes, and news momentum from a list of company names. Produces a graded (A/B/C/D) priority list with rationale and source signals.

- **URL**: https://apify.com/crawlerbros/b2b-sales-triggers.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, News, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## B2B Sales Trigger Intelligence

Identify which accounts in your pipeline are showing **real buying signals right now** — without spending hours digging through LinkedIn, Crunchbase, and news feeds by hand.

Paste a list of companies. Get back a **graded priority list** (A / B / C / D) with a one-line rationale, a composite 0–100 score, and the strongest signal detected across hiring, funding, and news.

### Why use this actor

Sales teams waste a huge amount of time researching accounts. Most of the intent signals that matter are public:

- A company just raised a Series B? They are hiring, buying tools, and have budget.
- A company opened 30 new engineering roles this quarter? They are scaling, and scaling teams need vendors.
- A company is dominating headlines with a new product launch? Reach out while momentum is high.

This actor automates the "is this account worth a touch right now?" question for every company on your list.

### What you get

For each company, the output includes:

- **Grade** (A / B / C / D) — an at-a-glance priority flag
- **Composite score** (0–100) combining hiring, funding, and news signals
- **Priority flag** — true for A-graded companies or those funded in the last 180 days
- **Top signal** — the single strongest trigger, in plain English
- **Rationale** — why this company got its grade
- **Per-source breakdown** (in Full mode) — job posting counts, funding rounds, news volume and sentiment

### Input

| Field | Description |
|---|---|
| **Companies (one per line)** | Paste company names into a textarea, one per row |
| **Companies (advanced)** | Optional: structured array with `companyName` + `domain`. Overrides the text list |
| **Output format** | `compact` for a scannable priority list; `full` for per-source details |
| **Max concurrency** | How many companies to process in parallel (1–10) |
| **Include raw signals** | Adds top headlines and sample job titles to the output |
| **Proxy** | Residential proxy recommended (Google News RSS is always direct) |

### Output fields (compact mode)

- `companyName` — company as provided
- `domain` — inferred primary domain
- `grade` — A / B / C / D
- `score` — 0–100 composite
- `priorityFlag` — boolean
- `topSignal` — strongest buying signal
- `rationale` — short explanation
- `runTimestamp` — ISO 8601

Full mode adds: `scoreBreakdown`, `hiringSignal`, `fundingSignal`, `newsSignal`.

### Dataset views

- **Overview** — the priority list (one row per company, grade + top signal)
- **Hiring Signals** — focus on LinkedIn hiring activity
- **Funding Signals** — focus on Crunchbase funding rounds
- **News Signals** — focus on Google News volume and sentiment

### FAQ

**How do you decide the grade?**
The score is a weighted sum of three pillars: hiring (up to 40 points), funding (up to 40 points), and news momentum (up to 20 points). A ≥ 70, B = 45–69, C = 20–44, D < 20.

**What counts as a hiring signal?**
Active LinkedIn job postings, the mix of roles (eng/sales/exec), and the rate of new posts in the last 30 days.

**What if a company has a private or locked-down Crunchbase page?**
That pillar is skipped silently and the grade is computed from the remaining pillars. We never fabricate data.

**How is news sentiment measured?**
A fast keyword classifier tags each headline as positive / neutral / negative. Companies with positive coverage momentum score higher.

**Do you need cookies or logins?**
No. All three sources are scraped from publicly accessible endpoints.

**How fresh are the signals?**
Every run fetches live data. Nothing is cached server-side.

**What if a company name is ambiguous (e.g., "Apple")?**
Provide the domain in the advanced input to disambiguate. Otherwise the actor uses the best web match it finds.

**Can I feed this into my CRM?**
Yes — the compact output is designed to map directly onto CRM fields. Pipe the dataset URL into Zapier / Make / your warehouse.

**Will all three sources always return data?**
No. If all three sources fail for a company, that company is emitted as a `company_error` row with the specific failures so you can retry or investigate.

# Actor input Schema

## `companiesText` (type: `string`):

Paste a list of company names, one per line. These are the accounts we will score for sales-ready signals.
## `companies` (type: `array`):

Advanced input. Each item is an object with companyName (required) and domain (optional). If provided, this overrides the text list.
## `outputFormat` (type: `string`):

compact = one row per company with grade + top signal. full = adds score breakdown and per-source details.
## `maxConcurrency` (type: `integer`):

How many companies to process in parallel. Lower values are more reliable on rate-limited endpoints.
## `includeRawSignals` (type: `boolean`):

If enabled, adds the top news headlines and a sample of job titles to the output for auditing.
## `cacheTtlHours` (type: `integer`):

Reuse cached source data within this window. Higher = cheaper but less fresh. 0 disables cache.
## `proxy` (type: `object`):

Residential proxy recommended for LinkedIn and Crunchbase. Google News RSS is always fetched without proxy.

## Actor input object example

```json
{
  "companiesText": "Notion Labs\nLinear\nFigma",
  "outputFormat": "compact",
  "maxConcurrency": 3,
  "includeRawSignals": false,
  "cacheTtlHours": 24,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# 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 = {
    "companiesText": `Notion Labs
Linear
Figma`,
    "outputFormat": "compact",
    "maxConcurrency": 3,
    "includeRawSignals": false,
    "cacheTtlHours": 24,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/b2b-sales-triggers").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 = {
    "companiesText": """Notion Labs
Linear
Figma""",
    "outputFormat": "compact",
    "maxConcurrency": 3,
    "includeRawSignals": False,
    "cacheTtlHours": 24,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/b2b-sales-triggers").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 '{
  "companiesText": "Notion Labs\\nLinear\\nFigma",
  "outputFormat": "compact",
  "maxConcurrency": 3,
  "includeRawSignals": false,
  "cacheTtlHours": 24,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/b2b-sales-triggers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/b2b-sales-triggers",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Sales Trigger Intelligence",
        "description": "Detect high-intent B2B sales triggers hiring surges, funding rounds, executive changes, and news momentum from a list of company names. Produces a graded (A/B/C/D) priority list with rationale and source signals.",
        "version": "1.0",
        "x-build-id": "uncU2CJDZNnzOW7gp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~b2b-sales-triggers/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-b2b-sales-triggers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~b2b-sales-triggers/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-b2b-sales-triggers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~b2b-sales-triggers/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-b2b-sales-triggers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companiesText": {
                        "title": "Companies (one per line)",
                        "type": "string",
                        "description": "Paste a list of company names, one per line. These are the accounts we will score for sales-ready signals."
                    },
                    "companies": {
                        "title": "Companies (advanced: name + optional domain)",
                        "type": "array",
                        "description": "Advanced input. Each item is an object with companyName (required) and domain (optional). If provided, this overrides the text list.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "companyName": {
                                    "type": "string",
                                    "title": "Company Name",
                                    "description": "The company's legal or brand name."
                                },
                                "domain": {
                                    "type": "string",
                                    "title": "Domain (optional)",
                                    "description": "Optional root domain (e.g., notion.so). Skips domain inference when provided."
                                }
                            },
                            "required": [
                                "companyName"
                            ]
                        }
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "compact",
                            "full"
                        ],
                        "type": "string",
                        "description": "compact = one row per company with grade + top signal. full = adds score breakdown and per-source details.",
                        "default": "compact"
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many companies to process in parallel. Lower values are more reliable on rate-limited endpoints.",
                        "default": 3
                    },
                    "includeRawSignals": {
                        "title": "Include Raw Signals",
                        "type": "boolean",
                        "description": "If enabled, adds the top news headlines and a sample of job titles to the output for auditing.",
                        "default": false
                    },
                    "cacheTtlHours": {
                        "title": "Cache TTL (hours)",
                        "minimum": 0,
                        "maximum": 168,
                        "type": "integer",
                        "description": "Reuse cached source data within this window. Higher = cheaper but less fresh. 0 disables cache.",
                        "default": 24
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy recommended for LinkedIn and Crunchbase. Google News RSS is always fetched without proxy."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
