# Signal Radar — AI Account Intelligence & ICP Scoring (`fuze/signal-radar`) Actor

Turn company domains into ICP-scored, signal-tagged account intelligence from public sources only — hiring, tech-stack, funding and news signals. Schedule it to monitor what changed. Actively maintained. · More no-code data tools → datatools-hub.vercel.app

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

## Pricing

from $52.80 / 1,000 company enricheds

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

## Signal Radar — AI Account Intelligence & ICP Scoring

Turn a list of company domains into **ICP-scored, signal-tagged account intelligence** — built entirely on public, legal, company-level sources. It's the AI judgment layer that raw scrapers don't give you: feed it domains plus a plain-English description of your ideal customer, and it returns a fit score, the reasons behind it, and the concrete buying signals worth acting on.

This is the **"signal → enrich → score"** loop (think Clay) as a self-serve Apify actor.

![Signal Radar — AI Account Intelligence & ICP Scoring — input and sample output](https://datatools-hub.vercel.app/actor-shots/signal-radar.png)

### 🔗 Chain it after your scraper

Already pulling company lists with **[Google Maps Scraper (`compass/crawler-google-places`)](https://apify.com/compass/crawler-google-places)**, **[Google Maps Email Extractor (`lukaskrivka/google-maps-with-contact-details`)](https://apify.com/lukaskrivka/google-maps-with-contact-details)** or **[LinkedIn Jobs Scraper (`curious_coder/linkedin-jobs-scraper`)](https://apify.com/curious_coder/linkedin-jobs-scraper)**? Pipe those companies straight in — paste the domains (or the websites column from that run) and get each account ICP-scored and signal-tagged. Works with the output of any Maps, LinkedIn or company-list scraper.

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

### What it does

For every company domain it gathers **public, logged-out signals**:

- **Firmographics** — name, industry, description, location, size — from the homepage and about page
- **Hiring signals** — open roles from the company's public job board (Greenhouse, Lever, Ashby)
- **Tech stack** — detected from the homepage (commerce, analytics, CRM, payments, frameworks…)
- **Recent news** — headlines via Google News

Then OpenAI fuses everything into:

- A **0–100 ICP-fit score** with an `icpTier` (strong / medium / weak / none) and written reasoning
- A suggested **outreach angle**
- The qualified **buying signals** it can justify from the evidence
- An optional **role-based contact email** (`sales@`, `info@` — never personal data)

#### Recurring monitoring

Pass a previous run's dataset as `baselineDatasetId` and Signal Radar reports **what changed** — hiring surges, newly adopted tools, fresh news — turning it into a scheduled account monitor. Signals change constantly and B2B data decays ~25%/year, so there's always a reason to re-run.

### Legally clean by design

Only logged-out, public, company-level sources (registries, public ATS job boards, RSS, homepages). **No LinkedIn personal profiles, no logins, role-based inboxes only** — GDPR-minimized.

### Input

| Field | Type | Description |
|---|---|---|
| `domains` | array | Company domains/URLs/emails (domain is extracted). Required. |
| `icpDescription` | string | Your ideal customer, in plain English. The AI scores fit against this. |
| `monitorSignals` | array | Which signal types to keep (empty = all). |
| `baselineDatasetId` | string | A previous run's dataset ID → report changes since then. |
| `findRoleEmail` | boolean | Surface a role-based inbox (default false). |
| `maxConcurrency` | integer | Companies analyzed in parallel (default 5). |

```json
{
  "domains": ["stripe.com", "linear.app", "notion.so"],
  "icpDescription": "Mid-market B2B SaaS (50-500 employees) in fintech or devtools, actively hiring engineers, on a modern cloud stack.",
  "findRoleEmail": true
}
```

### Output

One record per company:

```json
{
  "domain": "linear.app",
  "name": "Linear",
  "industry": "B2B SaaS",
  "icpFitScore": 85,
  "icpTier": "strong",
  "icpReasoning": "Cloud-based product-development tool aligned with devtools ICP…",
  "outreachAngle": "Reference their push into AI-assisted development…",
  "hiring": { "ats": "ashby", "openRoles": 30, "sampleTitles": ["Senior Fullstack Engineer", "…"] },
  "techStack": ["Next.js", "Zendesk"],
  "signals": [{ "type": "hiring", "detail": "Hiring 30 roles incl. multiple engineering…", "strength": "high" }],
  "roleEmail": "hello@linear.app",
  "citations": ["https://linear.app", "ashby:job-board", "…"]
}
```

### Pricing (pay-per-event)

| Event | When | Price |
|---|---|---|
| `company-enriched` | per company (public-signal gather) | $0.15 |
| `ai-icp-scored` | per company (AI fusion + score) | $0.30 |
| `signal-detected` | per qualified buying signal | $0.20 |

### Who it's for

Sales teams, RevOps, agencies and GTM engineers running signal-based outbound. Signal-based outreach converts several times better than static lists.

### Notes

- Requires an OpenAI API key (set as the `OPENAI_API_KEY` environment variable).
- Schedule it against your watchlist (weekly/monthly) with a `baselineDatasetId` to catch changes automatically.

### Related actors

- [Competitor Pulse — AI Competitor Intelligence Monitor](https://apify.com/fuze/competitor-pulse) — Watch competitors holistically — pricing, website, hiring, tech, news and
- [Argus — Autonomous Intelligence Agent](https://apify.com/fuze/argus) — Describe a mission in plain English; Argus plans what to watch, gathers from public
- [AI Company Enrichment](https://apify.com/fuze/ai-company-enrichment) — Turn a list of domains into structured company profiles — firmographics, contacts

# Actor input Schema

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

The companies to analyze — one per line. Accepts domains, full URLs or email addresses (the domain is extracted). This is your ICP watchlist, a CRM export, or the output of any Maps/scraper actor.

## `icpDescription` (type: `string`):

Describe your ideal customer in plain English — industry, size, what they do, buying triggers. The AI scores each company's fit against THIS. Example: 'Mid-market B2B SaaS companies (50-500 employees) in fintech or devtools that are actively hiring engineers and use a modern cloud stack.'

## `monitorSignals` (type: `array`):

Which buying signals to keep (leave empty for all). On scheduled re-runs these are compared to the baseline to surface what changed.

## `baselineDatasetId` (type: `string`):

Optional. The dataset ID of a PREVIOUS run of this actor. When set, results report what CHANGED since then (hiring surges, new tools, fresh news) — turning this into a recurring account monitor. Leave empty for a first/one-off run.

## `findRoleEmail` (type: `boolean`):

If on, surface a published role-based inbox (sales@, info@…) or propose one when the domain accepts mail. Role inboxes only — never personal data, to stay GDPR-clean.

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

Cap on how many domains to process this run.

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

How many companies to analyze in parallel.

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

OpenAI model for the scoring/fusion step. gpt-4o-mini is the cost-effective default.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so",
    "linear.app"
  ],
  "monitorSignals": [],
  "findRoleEmail": false,
  "maxResults": 1000,
  "maxConcurrency": 5,
  "model": "gpt-4o-mini"
}
```

# Actor output Schema

## `accounts` (type: `string`):

All account-intelligence records 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",
        "linear.app"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fuze/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 = { "domains": [
        "stripe.com",
        "notion.so",
        "linear.app",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fuze/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 '{
  "domains": [
    "stripe.com",
    "notion.so",
    "linear.app"
  ]
}' |
apify call fuze/signal-radar --silent --output-dataset

```

## MCP server setup

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