# B2B Intent Radar — AI Buying-Signal & Intent Scoring (`fuze/b2b-intent-radar`) Actor

Give target company domains and what you sell; the radar orchestrates firmographic, technographic and news organs, then AI synthesizes a buying-intent score (0-100), concrete signals, the best outreach angle and a paste-ready cold-email hook per company.

- **URL**: https://apify.com/fuze/b2b-intent-radar.md
- **Developed by:** [Fredrik Hansson](https://apify.com/fuze) (community)
- **Categories:** Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $110.00 / 1,000 company analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Intent Radar — AI Buying-Signal & Intent Scoring

**Stop guessing which accounts to call first.** Hand this Actor a list of target company domains and one line about what you sell. It quietly runs three research "organs" against every company — firmographics, technology stack and recent news — then an AI reads all of it together and returns a **buying-intent score (0–100)**, the **concrete signals** behind that score, the **single best outreach angle**, and a **paste-ready cold-email hook**. You get a prioritised account list instead of a flat spreadsheet.

You bring the domains and your pitch. It hands back a ranked call sheet with the opener already written.

![B2B Intent Radar — AI Buying-Signal & Intent Scoring — input and sample output](https://datatools-hub.vercel.app/actor-shots/b2b-intent-radar.png)

### 🔗 Chain it after your scraper

Already building target lists with **[Google Maps Scraper (`compass/crawler-google-places`)](https://apify.com/compass/crawler-google-places)**, **[LinkedIn Jobs Scraper (`curious_coder/linkedin-jobs-scraper`)](https://apify.com/curious_coder/linkedin-jobs-scraper)** or **[LinkedIn Company Details Scraper (`harvestapi/linkedin-company`)](https://apify.com/harvestapi/linkedin-company)**? Pipe the dataset straight in — paste its dataset ID (via the Integrations tab) and get every account scored 0–100 with the signals, best angle and a ready cold-email hook. Works with any Maps, LinkedIn or company scraper's output.

### Quick start

1. **Fill in the input** — set the fields in the input tab (prefilled with a working example).
2. **Click Start** — the Actor runs and writes one record per item to the dataset.
3. **Get your data** — export to **JSON, CSV or Excel**, or pull it via the API.

***

### The flow

```
                       ┌─ firmographics (ai-company-enrichment) ─┐
  domains + offering → ├─ technographics (b2b-tech-stack-detector)├─→  AI synthesis  →  scored
                       └─ news (google-news-scraper) ────────────┘   (grounded only)    accounts
                                                                                        intent · signals
                                                                                        angle · hook
```

1. **Paste your target domains** and describe your `offering` (what you sell). That one line drives the ICP fit, the scoring and the angle.
2. **The radar gathers signals** by calling other fuze Actors as organs — once per organ, batched across the whole list. Each organ is optional and degrades gracefully: if one returns nothing, the run continues on whatever signals remain.
3. **An AI synthesizes each company** into an intent score, the signals it found, a recommended angle and a ready-to-send hook — grounded **only** in the gathered data, never invented.

***

### What you get per company

For every target company, the Actor returns:

1. **`intentScore`** (0–100) — how likely this company is in-market, and how good a time it is to reach out, for *your* specific offering.
2. **`stage`** — where they sit in the buying journey: `cold` · `aware` · `warming` · `in-market`.
3. **`recommendation`** — a blunt verdict for your pipeline: `prioritize` · `nurture` · `skip`.
4. **`signals`** — the concrete evidence behind the score, each with a `type`, a `detail` and a `weight` (`low` / `medium` / `high`). Examples: a hiring push, fresh funding, a technology they just adopted, an expansion announcement, or a clean ICP match. Every signal is drawn from real gathered data.
5. **`outreachAngle`** — one sentence: the single best angle to open with.
6. **`personalizedHook`** — one or two sentences you can paste straight into a cold-email opener, anchored to a real signal about *that* company.
7. **`bestTiming`** — a short read on when to reach out (e.g. `now`, `next quarter`).
8. **Supporting context** — `icpFitScore`, `topTechnologies`, `recentNews` (headlines), `companyName`, and `sourcesUsed` so you can see exactly which organs fired for each company.

***

### Three ways people use it

- **SDR / outbound teams** — turn a raw list of target accounts into **buying intent data** with the opener pre-written. Work `prioritize` accounts first, drop `skip` accounts, and never open a cold email with "I hope this finds you well" again.
- **Account-based marketing (ABM)** — score and tier your named-account list by real **sales intent signals** before spending ad or BDR budget. A lightweight, pay-as-you-go take on what **Bombora / 6sense**-style intent platforms do, with no annual contract.
- **Founders & solo sellers** — point it at 25–50 dream customers, get an instant **account prioritization** pass that tells you who's **warming**, what the hook is, and the right **cold outreach timing** — in minutes, for a few dollars.

***

### How the orchestration works

Intent Radar is a thin orchestrator: the intelligence lives in other fuze Actors that it calls via the Apify API (`Actor.call`) and then reads back from their datasets. Each organ is independently toggle-able and fails soft (returns nothing rather than breaking the run):

| Organ | Actor called | Signal it adds |
|---|---|---|
| Firmographics | [`fuze/ai-company-enrichment`](https://apify.com/fuze/ai-company-enrichment) | What they do, size, industry, target customers, ICP fit |
| Technographics | [`fuze/b2b-tech-stack-detector`](https://apify.com/fuze/b2b-tech-stack-detector) | Technology stack, maturity, inferred team signals |
| News | [`fuze/google-news-scraper`](https://apify.com/fuze/google-news-scraper) | Funding, expansion, launches, leadership changes |

Organs are called **once per run** (batched across all domains), so costs and runtime stay flat as your list grows.

***

### Input

| Field | Type | Notes |
|---|---|---|
| `domains` | array | Target company domains, website URLs or emails (the domain is extracted). One per line. |
| `offering` | string | **Required.** What you sell — drives ICP fit, the intent score and the outreach angle. |
| `maxResults` | integer | Max companies to analyze. Default `25`. One pay-per-event charge per company. |
| `maxConcurrency` | integer | Companies synthesized in parallel. Orchestration is heavy — keep it low. Default `3`. |
| `model` | string | Override the OpenAI model. Default `gpt-4o-mini`. |
| `useEnrichment` | boolean | Call the firmographic organ. Default `true`. |
| `useTechStack` | boolean | Call the technographic organ. Default `true`. |
| `useNews` | boolean | Call the news organ for recent buying signals. Default `true`. |

#### Minimal input example

```json
{
  "domains": ["stripe.com", "notion.so"],
  "offering": "We sell a SOC2 compliance automation platform for SaaS companies."
}
```

***

### Output example

```json
{
  "domain": "notion.so",
  "companyName": "Notion Labs",
  "intentScore": 85,
  "stage": "in-market",
  "recommendation": "prioritize",
  "signals": [
    { "type": "icp-match", "detail": "Sells software to other SaaS companies — a textbook fit for a SOC2 automation platform.", "weight": "high" },
    { "type": "tech-adoption", "detail": "Runs a modern Next.js stack, signalling an engineering-led team that buys developer tooling.", "weight": "medium" }
  ],
  "outreachAngle": "Leverage Notion's SaaS footprint to position SOC2 automation as the fast path to enterprise deals.",
  "personalizedHook": "As Notion keeps moving upmarket into enterprise, SOC2 evidence collection quietly becomes a sales blocker — we make it a one-click report instead of a quarter-long project.",
  "bestTiming": "now",
  "icpFitScore": 85,
  "topTechnologies": ["Next.js", "Cloudflare", "Vercel"],
  "recentNews": ["Notion launches new enterprise features"],
  "sourcesUsed": ["enrichment", "techstack", "news"]
}
```

A company for which only some organs return data still comes back scored — `sourcesUsed` tells you exactly what the score was built on, and thin data yields an honestly low score.

***

### Pay-per-event pricing

This Actor uses **pay-per-event** billing with a single event:

| Event | Charged when |
|---|---|
| `company-analyzed` | Once per company successfully synthesized into an intent score + recommendation. |

One `company-analyzed` charge bundles **all three orchestrated sub-actor runs** (enrichment + tech stack + news) **plus** the AI synthesis for that company — so it comes in far cheaper than buying each signal from a separate tool. The Actor logs its OpenAI token usage and estimated AI cost at the end of every run; the AI cost is a tiny fraction of the event price, the rest covers the organ compute.

***

### Setup

The synthesis step calls the OpenAI API, so set the environment variable / secret **`OPENAI_API_KEY`** on the Actor. The orchestrated organs run on your Apify account automatically — no extra wiring needed.

***

### Use it from an AI agent (Apify MCP server)

This Actor is available through the [Apify MCP server](https://mcp.apify.com), so AI agents (Claude, ChatGPT, or anything that speaks MCP) can call it as a tool — hand it `domains` and an `offering`, and read back scored, ranked accounts with ready-to-send hooks — with no custom integration code.

***

### Run it locally

```bash
npm install
## put your input in storage/key_value_stores/default/INPUT.json
export OPENAI_API_KEY=sk-...   # required for the synthesis
apify run -p
```

***

### Related actors

- [Company Enrichment (AI)](https://apify.com/fuze/ai-company-enrichment) — Turn a list of domains into structured company profiles: firmographics, contacts, socials and ICP fit.
- [B2B Tech Stack Detector (AI)](https://apify.com/fuze/b2b-tech-stack-detector) — Detect the technology stack behind any domain — CMS, ecommerce, analytics, CRM, pixels, framework, email provider — with AI buying-signals.
- [AI Prospecting Pipeline](https://apify.com/fuze/ai-prospecting-pipeline) — End-to-end cold-outreach pipeline: domains or Maps search → ICP leads → verified emails → personalized drafts.
- [Google News Scraper](https://apify.com/fuze/google-news-scraper) — Fetch recent news articles for any set of queries — the news organ behind this radar.

# Actor input Schema

## `domains` (type: `array`):

Target company domains, website URLs or emails (the domain is extracted). One per line.

## `offering` (type: `string`):

Describe what your company sells. Drives the ICP fit, intent scoring and the recommended outreach angle. Required.

## `datasetId` (type: `string`):

Optional. Read the domains from a previous Actor run's dataset — for no-code chaining via the Integrations tab.

## `datasetField` (type: `string`):

Which dataset field holds the domain/URL. Leave blank to auto-detect (domain, website, companyDomain, url, companyUrl).

## `maxResults` (type: `integer`):

Max companies to analyze. One pay-per-event charge per company analyzed.

## `maxConcurrency` (type: `integer`):

How many companies to synthesize in parallel. Orchestration is heavy — keep this low.

## `model` (type: `string`):

Override the model (default gpt-4o-mini).

## `useEnrichment` (type: `boolean`):

Call fuze/ai-company-enrichment for firmographics, size and ICP fit.

## `useTechStack` (type: `boolean`):

Call fuze/b2b-tech-stack-detector for the technology stack and team signals.

## `useNews` (type: `boolean`):

Call fuze/google-news-scraper for recent buying signals (funding, expansion, launches, leadership changes).

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so"
  ],
  "offering": "We sell a SOC2 compliance automation platform for SaaS companies.",
  "maxResults": 25,
  "maxConcurrency": 3,
  "useEnrichment": true,
  "useTechStack": true,
  "useNews": true
}
```

# Actor output Schema

## `companies` (type: `string`):

All scored companies in the default dataset.

# 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 = {
    "domains": [
        "stripe.com",
        "notion.so"
    ],
    "offering": "We sell a SOC2 compliance automation platform for SaaS companies."
};

// Run the Actor and wait for it to finish
const run = await client.actor("fuze/b2b-intent-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 = {
    "domains": [
        "stripe.com",
        "notion.so",
    ],
    "offering": "We sell a SOC2 compliance automation platform for SaaS companies.",
}

# Run the Actor and wait for it to finish
run = client.actor("fuze/b2b-intent-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 '{
  "domains": [
    "stripe.com",
    "notion.so"
  ],
  "offering": "We sell a SOC2 compliance automation platform for SaaS companies."
}' |
apify call fuze/b2b-intent-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fuze/b2b-intent-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/ComeoRbRtIOPU4iwA/builds/Q37m21x6nVtHIcy7d/openapi.json