# Intent Signal Aggregator (`zinin/intent-signal-aggregator`) Actor

Is this company in-market right now? Combines public hiring activity (Greenhouse, Lever, Ashby) and recent news (funding, launches, partnerships) into one intent score per company. No login, no API keys, no proxies.

- **URL**: https://apify.com/zinin/intent-signal-aggregator.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 signal founds

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Intent Signal Aggregator — Hiring + News Buying Signals

**Is this company in-market right now?** This Actor pulls two public, keyless buying-intent signals into one row per company — hiring activity and recent press coverage — and combines them into a single intent score. No login, no API keys, no proxies.

### The problem

Sales and marketing teams pay $15,000+/year for intent-data platforms (Bombora, ZoomInfo Signals) to answer one question: is this account showing signs of budget movement? Most of that signal is sitting in public data — a company's own job board and its recent press coverage — you just have to pull and score it yourself.

### What you get

- 💼 **Hiring signal** (reused from company-hiring-radar) — open roles on Greenhouse/Lever/Ashby, broken down by sales/marketing/engineering headcount.
- 📰 **News signal** — recent headlines (last 30 days) from Google News RSS, flagged for intent keywords (funding, launch, expansion, partnership, acquisition, new exec hires…).
- 🎯 **Combined intent score (0–100)** and a plain-English list of the signals that drove it.
- **Honest source coverage.** Every row says which of the two signals it actually managed to check — a source that timed out is never silently folded into the score as if it came back empty (see below).
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON, CSV or Excel, or push results straight into your own pipeline.

### Source coverage — partial data is never passed off as complete

Earlier runs scored whatever came back and stayed silent about the rest: if the news feed timed out, a company with genuine news momentum could score as "quiet" with no way to tell the difference from an actual zero-signal company. Every row now carries `sourceCoverage` and `sourceErrors` alongside the score:

- `sourceCoverage.hiring` / `sourceCoverage.news` — one of `ok` (checked successfully), `error` (that source failed this run — timeout, rate limit, bad response) or `not_requested` (you didn't give a hiring token for this company).
- `sourceErrors.hiring` / `sourceErrors.news` — the reason, when a source is `error`; `null` otherwise.

If **every** signal you asked for errors out, the row comes back `found: false` with `intentScore: null` and is **not charged**. If at least one signal came through, you get a real score and a real charge — but the row also tells you which half (if any) is missing, so a partial result never quietly reads as a complete one.

### How to run it

1. Click **Try for free** — no card needed on the free plan.
2. Paste companies into **Companies**, one per line — an ATS token for hiring, a plain name for news, or `Name|token` for both.
3. Press **Start**. Results appear in the dataset — read them in the UI, pull them from the API, or have a webhook push them onward.

### Pricing

Pay-per-event: **$0.005 per run start + $0.004 per result**. No monthly seat, no minimum. 100 companies checked cost about **$0.41**; 1,000 about **$4.01**.

A company where every requested signal errored out is `found: false` and not billed. A genuine zero-signal company (both sources checked successfully, nothing found) is also `found: false` and free. You only pay when at least one signal actually came back — and even then, the row's `sourceCoverage` tells you if the other half is missing.

### Input

| Field | Required | What it does |
|---|---|---|
| `companies` | yes | One entry per company. `greenhouse:stripe` / `lever:x` / `ashby:y` → hiring signal only. A plain name like `Microsoft` → news signal only. `Name\|greenhouse:token` → both signals for the same company. |
| `maxConcurrency` | no | How many companies to check in parallel, 1–10 (default 4). |

```json
{
  "companies": ["greenhouse:stripe", "Microsoft", "Ramp|ashby:ramp"],
  "maxConcurrency": 4
}
````

### Output

One dataset row per company. This is a real row from a real run (trimmed to the first few headlines):

```json
{
  "input": "Microsoft",
  "companyName": "Microsoft",
  "found": true,
  "hiring": null,
  "recentNews": [
    {
      "title": "Microsoft and Mistral expand strategic partnership to give enterprises and regulated industries frontier AI they can control - Microsoft Source",
      "link": "https://news.google.com/rss/articles/CBMi_wFBVV95cUxOYXY2QVMzcXpqZGY5T3NmRl9BX3FQdWkybktodjNVQWxxTTFFSjhfcHFWdUVNRVlRUkNlWFNFT1hUa2pIQks0ek9DNGp5WFJ3VXROeVZDS1BMU3JGd0JNc3U3LTBJcUNIRHBELUM1UFBGcHdRWGNxdkJJbnU2bk5ZUFlLODFaY2xNaDhrMDFxUy02S3dCWFhtb2VxazZVdERlN3lDX1l6ZjdfVkwtUXM2N0JaaWQ4cGRtbkNWRXVqUEJEdS1WbVRBalZVeWZLLUVMZms2am5mdDBDYnJoNThMUTZwbWUyUUdMRUhMM0tPNUIzN3pXc2s2eTNZWWtjeDA?oc=5",
      "pubDate": "2026-07-21T12:38:22.000Z"
    },
    {
      "title": "Improving Windows Search Box, with less clutter and more control - Windows Blog",
      "link": "https://news.google.com/rss/articles/CBMiuAFBVV95cUxQZm9YZTFTVkQ1SlZTelNUc1doVzdESkE0WFQ1Z2lDVnJrTzYtTEdBZlNhYkR4SzNtaXhfTmR1X19VaDFzV3Z4UVRCN05ITTJIUGFBUzZqQnRyNi00MWJtTGFic0Z6clpJQUFPT21yX3FOb2ktRGZGVmpLbGZMX3FENm8yOWtFVVllVGktUXc4RjJONFV3azBXeTZVWTJnUlNzLUpHSU53WUM2ZjZDMVdTWWVoSERGUHBV?oc=5",
      "pubDate": "2026-07-13T07:00:00.000Z"
    },
    "… 13 more headlines, same shape"
  ],
  "intentSignals": [
    "news: \"Microsoft and Mistral expand strategic partnership to give enterprises and regulated industries frontier AI they can control - Microsoft Source\" (partnership)",
    "news: \"Microsoft expands Azure AI and HPC infrastructure with AMD - The Official Microsoft Blog\" (expands)",
    "news: \"Databricks and Microsoft expand partnership to help enterprises bring business context to enterprise AI - Microsoft Source\" (partnership)"
  ],
  "intentScore": 30,
  "sourceCoverage": {
    "hiring": "not_requested",
    "news": "ok"
  },
  "sourceErrors": {
    "hiring": null,
    "news": null
  },
  "summary": "Microsoft — 15 recent headline(s), intent score 30/100.",
  "checkedAt": "2026-07-26T13:19:32.328Z"
}
```

| Field | What it means |
|---|---|
| `found` | Whether any signal was found — `false` means not billed |
| `hiring` | `{provider, openRoles, salesHiring, marketingHiring, engineeringHiring}` or `null` if no ATS token was given, or none was found |
| `recentNews` | Up to 15 headlines from the last 30 days, each `{title, link, pubDate}` |
| `intentSignals` | Human-readable list of what drove the score |
| `intentScore` | 0–100, combining hiring volume/function mix and intent-keyword news hits; `null` when no signal could be verified at all |
| `sourceCoverage` | `{hiring, news}`, each `ok` / `error` / `not_requested` — for this "Microsoft" row (no ATS token given, news fetched cleanly) that reads `{"hiring": "not_requested", "news": "ok"}` |
| `sourceErrors` | `{hiring, news}` — the failure reason when `sourceCoverage` says `error`, `null` otherwise |
| `summary` | One-liner |

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |
| [Company Hiring Radar](https://apify.com/zinin/company-hiring-radar) | Pull every open role a company is hiring for from its public job board (Greenhouse, Lever, Ashby) and turn… |
| [Company Profile Lookup](https://apify.com/zinin/company-lookup) | Turn a domain or company name into one unified company card: website tech stack (CMS, ecommerce, key tech)… |
| [Company Registry Enricher](https://apify.com/zinin/company-registry-enricher) | Turn a company name, LEI or UK company number into an official registry card: legal name, status,… |
| [Website Tech Stack Detector](https://apify.com/zinin/tech-stack-detector) | Detect the technologies a website runs — CMS, ecommerce platform, analytics, marketing/CRM, JS framework,… |

### FAQ

**Does it need an API key / login?** No. Greenhouse, Lever and Ashby expose public unauthenticated job-board APIs; Google News RSS is a public feed. No credentials anywhere.

**How fresh is the data?** Hiring is live at request time. News covers the last 30 days from Google News' index.

**What if a company has no ATS board and no recent news?** You get `found: false` and `intentScore: 0` with `sourceCoverage` showing both sources as `ok` — genuinely nothing to build a signal from, not a source failure.

**What if my hiring or news source times out?** The row still returns whatever the other source found (and is billed for it), but `sourceCoverage` marks the failed side `error` with a reason in `sourceErrors` — the score never pretends to be based on both signals when it isn't.

**Can I call it from an AI agent?** Yes — it's a standard Apify Actor, callable via the Apify API or the Apify MCP server.

**What this is NOT.** It is not a paid intent-data feed with proprietary co-op data (Bombora-style) — both signals here are public and keyless, which is also why they're cheap. It does not infer intent from anything private.

Found a wrong result, or need a signal we don't track? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

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

One entry per company. Forms: `greenhouse:stripe` / `lever:x` / `ashby:y` (hiring signal from an ATS token), a plain company name like `Microsoft` (news signal only), or `Name|greenhouse:token` to get both hiring and news for the same company.

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

How many companies to check in parallel.

## Actor input object example

```json
{
  "companies": [
    "greenhouse:stripe",
    "Microsoft",
    "Ramp|ashby:ramp"
  ],
  "maxConcurrency": 4
}
```

# 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": [
        "greenhouse:stripe",
        "Microsoft",
        "Ramp|ashby:ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/intent-signal-aggregator").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": [
        "greenhouse:stripe",
        "Microsoft",
        "Ramp|ashby:ramp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/intent-signal-aggregator").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 '{
  "companies": [
    "greenhouse:stripe",
    "Microsoft",
    "Ramp|ashby:ramp"
  ]
}' |
apify call zinin/intent-signal-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/intent-signal-aggregator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Intent Signal Aggregator",
        "description": "Is this company in-market right now? Combines public hiring activity (Greenhouse, Lever, Ashby) and recent news (funding, launches, partnerships) into one intent score per company. No login, no API keys, no proxies.",
        "version": "0.1",
        "x-build-id": "At9lxlVgjM9gPcooO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zinin~intent-signal-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zinin-intent-signal-aggregator",
                "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/zinin~intent-signal-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-zinin-intent-signal-aggregator",
                "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/zinin~intent-signal-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-zinin-intent-signal-aggregator",
                "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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "maxItems": 100,
                        "type": "array",
                        "description": "One entry per company. Forms: `greenhouse:stripe` / `lever:x` / `ashby:y` (hiring signal from an ATS token), a plain company name like `Microsoft` (news signal only), or `Name|greenhouse:token` to get both hiring and news for the same company.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many companies to check in parallel.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
