# IntentSignal Pro – Tech + Hiring Buying Intent (`enosgb/intent-signal-pro`) Actor

Discover B2B buying intent signals by combining real-time tech stack detection with ATS hiring velocity. Get an intentScore 0-100 per company, ready for Clay, HubSpot, Salesforce, or Zapier.

- **URL**: https://apify.com/enosgb/intent-signal-pro.md
- **Developed by:** [Enos Melo](https://apify.com/enosgb) (community)
- **Categories:** Automation, AI, Jobs
- **Stats:** 9 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 intentsignal - per company analyzeds

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/actors/running/actors-in-store.md#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

## IntentSignal Pro – Tech + Hiring Buying Intent

**IntentSignal Pro** is a B2B sales intelligence tool that discovers **real buying intent signals** for any company by combining two powerful data sources:

1. **Real tech stack** detected directly from the company's website — not self-reported data, but what they actually use in production.
2. **Hiring velocity** extracted from public ATS platforms (Greenhouse, Lever, Ashby, Workday, Rippling) — showing how fast they're growing.

The result is a clear **intentScore from 0 to 100** per company, with a human-readable explanation of why. Ready to pipe directly into **Clay**, **HubSpot**, **Salesforce**, **Zapier**, or any CRM/enrichment pipeline.

Unlike tools that rely on job-posting keywords alone or expensive intent platforms like 6sense, IntentSignal Pro uses **actual infrastructure signals** — the technologies a company has deployed and the speed at which they're hiring. These are the strongest predictors of B2B purchase readiness.

### Why use IntentSignal Pro?

- **More accurate than job-keyword scraping** — Combines real tech stack data with hiring velocity for a true intent signal
- **Cheaper than 6sense or Clay Web Intent** — No subscription needed, pay only per run
- **Auto-detects ATS platforms** — Supports Greenhouse, Lever, Ashby, Workday, and Rippling automatically
- **Tech change detection** — Identifies technologies recently added or removed (e.g., "Added: HubSpot" = likely evaluating marketing tools)
- **Built for SDRs and growth teams** — Output is structured for immediate use in outreach sequences
- **Fast and cost-efficient** — Uses HTTP requests (not browsers), AI only for final scoring
- **Historical tracking** — Remembers previous tech scans to detect changes over time

### How to use IntentSignal Pro

1. Go to the **Input** tab
2. Add your target companies with their name and domain (e.g., `{ "name": "Stripe", "domain": "stripe.com" }`)
3. Optionally set `daysForVelocity` (default: 30 days) and `maxCompanies` (default: 100)
4. Keep `enableWebsiteTechScan` enabled for full intent analysis
5. Click **Start** and download your scored companies

### Input

| Field                   | Required | Description                                       |
| ----------------------- | -------- | ------------------------------------------------- |
| `companies`             | Yes      | Array of `{ name, domain, careersUrl }` objects   |
| `daysForVelocity`       | No       | Days window for hiring velocity (default: 30)     |
| `maxCompanies`          | No       | Max companies per run (default: 100)              |
| `enableWebsiteTechScan` | No       | Enable tech stack detection (default: true)       |
| `useProxy`              | No       | Use Apify Proxy for tech scanning (default: true) |

#### Example Input

```json
{
    "companies": [
        { "name": "Stripe", "domain": "stripe.com" },
        { "name": "Linear", "domain": "linear.app", "careersUrl": "https://jobs.ashbyhq.com/linear" }
    ],
    "daysForVelocity": 30,
    "maxCompanies": 100,
    "enableWebsiteTechScan": true,
    "useProxy": true
}
```

### Data Fields Explained

#### intentScore (0-100)

- **80-100 (High Intent):** Heavy hiring + recent tech additions = actively investing
- **50-79 (Medium Intent):** Moderate hiring or some tech changes = evaluating options
- **20-49 (Low Intent):** Minimal hiring, stable tech = maintain mode
- **0-19 (No Intent):** No hiring signals, no tech changes = unlikely to buy

#### estimatedARRRange

Estimated based on hiring velocity, tech stack sophistication, and ATS platform used:

- `1M-10M` — Early stage, small team
- `10M-50M` — Growth stage, expanding
- `50M-100M` — Scale-up, significant hiring
- `100M+` — Enterprise-level operations

### Pricing / Cost Estimation

#### How much does it cost to run IntentSignal Pro?

**Free Tier:** The first $5/month of platform usage is free on Apify.

**Example costs (with Apify Proxy enabled):**

- **10 companies:** ~$0.05-0.10 per run (fast, ~30 seconds)
- **50 companies:** ~$0.20-0.40 per run (~2 minutes)
- **100 companies:** ~$0.40-0.80 per run (~4 minutes)

**Without proxy:** Costs are ~30-40% lower.

**Groq API:** The AI scoring uses Groq's `llama-3.1-8b-instant` model (~$0.0002 per company). You need your own Groq API key (free tier available at groq.com).

**Compare:** A single 6sense license costs $15,000+/year. IntentSignal Pro gives you comparable intent signals for pennies per company.

### Tips & Advanced Options

- **Provide `careersUrl`** when you know it — skips ATS detection and saves time
- **Disable `enableWebsiteTechScan`** if you only want hiring velocity signals (faster, cheaper)
- **Use `daysForVelocity: 7`** for very recent signals, or `90` for broader trends
- **Run weekly** to track tech changes over time — the Actor remembers previous scans
- **Disable proxy** for companies that don't have anti-bot protection to save costs

### FAQ, Disclaimers & Support

**Q: Is this legal?**
A: IntentSignal Pro only uses publicly available data — public ATS APIs and publicly visible website technologies. It respects robots.txt and terms of service.

**Q: How accurate is the intentScore?**
A: The score combines real data points (actual tech stack + actual job counts) with AI-powered analysis. While no signal is perfect, this approach is significantly more reliable than keyword-based job scraping.

**Q: What technologies can be detected?**
A: 90+ technologies including frameworks (React, Next.js, Vue, Angular), analytics (Google Analytics, Mixpanel, Amplitude), CRMs (HubSpot, Salesforce), hosting (Vercel, AWS, Cloudflare), e-commerce (Shopify), and many more.

**Q: Can I use this with Clay?**
A: Yes! The JSON output is designed for direct integration with Clay, HubSpot, Salesforce, Zapier, Make, and any tool that consumes structured data.

**Q: What if ATS detection fails?**
A: The Actor will still score the company based on tech stack data alone. Hiring velocity will show as "0 jobs detected".

**Q: How does historical tech tracking work?**
A: Each domain's tech stack is saved to Apify Key-Value Store. On subsequent runs, the Actor compares current vs. previous scans to detect additions and removals.

**Known limitations:**

- Some companies block automated tech scanning (proxy helps)
- ATS detection requires the company to use one of the 5 supported platforms
- ARR estimation is heuristic-based, not financial data

**Need help or have feedback?** Use the Issues tab or contact us through Apify Console. Custom enterprise solutions and additional ATS connectors are available on request.

# Actor input Schema

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

List of companies to analyze for buying intent. Each company needs a name and domain. Optionally provide a careers page URL for more accurate ATS detection.

## `daysForVelocity` (type: `integer`):

Number of recent days to analyze for hiring velocity. Jobs posted within this window count toward the velocity score. 0 = all open jobs regardless of date.

## `maxCompanies` (type: `integer`):

Maximum number of companies to process in a single run. Helps control cost and runtime.

## `enableWebsiteTechScan` (type: `boolean`):

Scan each company's website to detect their real tech stack (frameworks, analytics, hosting, etc.). Disable to only use hiring velocity signals.

## `useProxy` (type: `boolean`):

Use Apify Proxy for website tech scanning. Helps avoid anti-bot blocks. Proxy costs apply when enabled.

## Actor input object example

```json
{
  "companies": [
    {
      "name": "Stripe",
      "domain": "stripe.com"
    },
    {
      "name": "Linear",
      "domain": "linear.app"
    }
  ],
  "daysForVelocity": 30,
  "maxCompanies": 100,
  "enableWebsiteTechScan": true,
  "useProxy": true
}
```

# Actor output Schema

## `intentSignals` (type: `string`):

All companies analyzed with intent scores, tech stacks, and hiring velocity

## `summary` (type: `string`):

Execution statistics including companies processed, average intent score, and runtime metadata

## `techHistory` (type: `string`):

Historical tech stack data for tracking changes over time

# 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": "Stripe",
            "domain": "stripe.com"
        },
        {
            "name": "Linear",
            "domain": "linear.app"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("enosgb/intent-signal-pro").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": "Stripe",
            "domain": "stripe.com",
        },
        {
            "name": "Linear",
            "domain": "linear.app",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("enosgb/intent-signal-pro").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": "Stripe",
      "domain": "stripe.com"
    },
    {
      "name": "Linear",
      "domain": "linear.app"
    }
  ]
}' |
apify call enosgb/intent-signal-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enosgb/intent-signal-pro"
        }
    }
}

```

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/O3t97g6C0x1pn1Q5r/builds/yayHbvXa8XlpFWni0/openapi.json