# Startup Breakout & Growth Radar (`hirepulse/startup-breakout-radar`) Actor

Research up to 50 company domains for startup growth signals: ATS hiring intent, Google Ads Transparency, website technologies and public business contacts. Evidence-backed breakout scores with reasons. Pay only for profiles with at least two data sections.

- **URL**: https://apify.com/hirepulse/startup-breakout-radar.md
- **Developed by:** [HirePulse](https://apify.com/hirepulse) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 qualified company profiles

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

## Startup Breakout & Growth Radar

![Startup Breakout & Growth Radar logo](https://api.apify.com/v2/key-value-stores/oHF7yCUC9wGypbfgV/records/logo.png)

Research startup growth signals across **hiring, Google Ads Transparency, website technologies and public business contacts** in one run. Submit a company domain or up to 50 domains and get structured company profiles with a 0–100 breakout score, plain-language reasons and source statuses.

Built for investor screening, venture scouting, startup research, sales prioritization and company watchlists. No external API key is required. This Actor checks public sources directly and does not call other paid Actors.

### What you get

| Section | Public evidence |
| --- | --- |
| Hiring intent | Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee boards; open roles, recent dated postings, job functions and intent score |
| Google Ads | Up to 40 relevant creatives from Google Ads Transparency, advertiser and creative identifiers, last-shown dates and source links |
| Tech stack | Website signatures for analytics, advertising pixels, CMS, frameworks, payment systems and hosting; MX, SPF and DMARC signals |
| Contacts | Published emails, LinkedIn, X and GitHub profiles, explicit telephone links and page-level source evidence |
| Breakout summary | Signal, score, reasons and the documented gateway v12 method |

### Quick start

1. Click **Try for free**, enter `linear.app` or paste your company domains.
2. Run the Actor. Each company's four sections are scanned in parallel.
3. Open the **Startup growth signals** dataset table or download JSON, CSV or Excel.

```json
{"domains":["linear.app","ramp.com"],"include_jobs":true,"max_jobs_per_company":10,"max_ads_per_company":40,"max_concurrency":3}
```

Use `domain` for a single company when `domains` is omitted. Duplicate domains are removed. Default input is `linear.app`. Submit public company homepages without paths, custom ports or credentials. Maximum 50 domains per run; concurrency 1–5.

### Pricing and fair billing

**$0.03 per qualifying company profile ($30 per 1,000).** Pay per event, with no separate Actor-start fee and no platform-usage surcharge. A profile qualifies only when **at least two of the four sections contain usable data**. Contacts qualify only with a published email or social link, matching gateway v12; MX records and phones alone do not qualify.

Only qualifying profiles enter the charged dataset. Incomplete profiles are available free as `DIAGNOSTIC-<domain>` records in the run's key-value store. `OUTPUT` lists every processed domain, source status and billing eligibility. A source timeout or block is reported as unavailable rather than converted to a zero count. A run with no qualifying profiles can succeed with an empty dataset and no result events.

Use Apify's maximum charge setting to cap each run. The Actor stops scheduling batches after the SDK reports the limit. A batch already in flight may finish scanning; you are charged only within your configured event budget.

### How the score works

The `breakout_summary` is a faithful port of HirePulse gateway **version 12** for `/v1/company-profile`, including thresholds and reason text:

| Component | Formula | Maximum |
| --- | --- | --- |
| Hiring | Round half of the public job-board `intent_score` | 50 |
| Google Ads | 15 + min(15, creatives in sample), when the section is `ok` | 30 |
| Site maturity | min(20, 4 × (pixels + analytics tools) + 8 if at least 10 technologies) | 20 |

**Strong ≥70; moderate ≥45; weak ≥20; none <20.** Fewer than two successful scoring sections (hiring, ads and tech) yields `insufficient_data` with a null score. Contacts contribute to profile completeness and billing, but never add score points. A billable profile can therefore have a null score, for example hiring plus contacts.

Hiring intent uses the same v12 formula: min(50, log2(1 + open roles) × 7) + min(35, dated roles posted in 30 days × 3.5) + min(15, sales/marketing/customer-success roles × 3), rounded and capped at 100. Undated roles are not counted as recently posted. Greenhouse update timestamps and reposted jobs may not represent original opening dates; review individual job evidence.

**The breakout score is an estimate based on public signals and is not investment advice.** It does not establish revenue growth, funding, valuation, financial performance or future returns. Google does not disclose ad spend here. The v12 formula's “Active Google Ads” wording refers to the returned relevance sample; creatives can be historical. Review last-shown dates before concluding a campaign is currently active. A tech signature shows public site maturity, not the completeness of internal infrastructure.

### Output

Each dataset item includes `domain`, `status`, `checked_at`, `sections_status`, `sections_with_data`, `tech_stack`, `hiring_intent`, `google_ads`, `contacts`, `breakout_summary` and flat columns for spreadsheet workflows. JSON retains the detailed nested evidence. The run summary is linked in the Output tab.

### Real output from cloud validation

These are unmodified field excerpts from live Apify runs; omitted evidence remains in the complete JSON dataset. Source availability and scores can change on later runs.

Run [`z9QyzlpHjbjxawx37`](https://console.apify.com/view/runs/z9QyzlpHjbjxawx37):

```json
{
  "domain": "linear.app",
  "checked_at": "2026-10-25T21:19:16.726466+00:00",
  "status": "ok",
  "sections_with_data": [
    "tech_stack",
    "hiring_intent",
    "google_ads",
    "contacts"
  ],
  "breakout_summary": {
    "signal": "strong",
    "score": 73,
    "reasons": [
      "Hiring: active_hiring, 10 roles posted in the last 30 days (+43).",
      "Active Google Ads: 26 ads in the sample (+30).",
      "Site maturity: 0 ad/analytics tools, 3 technologies (+0)."
    ],
    "method": "score = half of the hiring intent_score (max 50) + Google Ads activity (max 30) + site ad/analytics maturity (max 20). strong >= 70, moderate >= 45, weak >= 20. Estimate from public signals only; not investment advice."
  },
  "open_roles": 34,
  "ads_count": 26
}
```

Run [`Kvb1bZTfQCW0un7CB`](https://console.apify.com/view/runs/Kvb1bZTfQCW0un7CB):

```json
{
  "domain": "ramp.com",
  "checked_at": "2026-10-25T21:21:35.331023+00:00",
  "status": "ok",
  "sections_with_data": [
    "tech_stack",
    "hiring_intent",
    "contacts"
  ],
  "breakout_summary": {
    "signal": "moderate",
    "score": 50,
    "reasons": [
      "Hiring: hypergrowth, 40 roles posted in the last 30 days (+50).",
      "Site maturity: 0 ad/analytics tools, 4 technologies (+0)."
    ],
    "method": "score = half of the hiring intent_score (max 50) + Google Ads activity (max 30) + site ad/analytics maturity (max 20). strong >= 70, moderate >= 45, weak >= 20. Estimate from public signals only; not investment advice."
  },
  "open_roles": 167,
  "ads_count": null
}
```

### Integrations

#### Apify MCP

Connect your MCP client to `https://mcp.apify.com` and authorize your Apify account. Ask: “Run hirepulse/startup-breakout-radar for linear.app and ramp.com, then return domain, breakout_summary, hiring and contact evidence.” Discover the Actor input schema first, call the Actor using the MCP server's Actor execution tool, then retrieve its dataset. Tool names vary with your MCP client/server tool selection. The same input JSON above works through MCP.

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("hirepulse/startup-breakout-radar").call(
    run_input={"domains": ["linear.app", "ramp.com"]},
    max_total_charge_usd=0.10,
)
for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["domain"], company["breakout_summary"])
```

#### cURL

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/hirepulse~startup-breakout-radar/run-sync-get-dataset-items?maxTotalChargeUsd=0.10' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"domains":["linear.app"]}'
```

For larger lists, start an asynchronous run with `/runs`, poll its status, and fetch `/v2/datasets/{defaultDatasetId}/items`; synchronous endpoints have a time limit.

#### n8n

Use an **Apify → Run Actor** node with `hirepulse/startup-breakout-radar` and `{"domains":["{{$json.domain}}"]}`. Wait for completion, use **Get Dataset Items**, then filter `breakout_summary.signal` for `strong` or `moderate`. Map the score, reasons, open roles and public email fields into your research sheet or CRM. Use the OUTPUT summary to handle nonqualifying companies. Set an Apify maximum-charge budget.

#### Clay

In Clay's Apify integration, choose a saved task for this Actor or use an HTTP API enrichment. Map your company-domain column into `domain`, wait for the asynchronous run, and retrieve the dataset. Map `breakout_score`, `breakout_reasons`, `open_roles`, `ads_count` and `contact_emails` into columns. Avoid sending 50 domains through a short synchronous HTTP enrichment; use an asynchronous workflow for batches.

### Coverage and limitations

- This Actor researches a supplied company list. It does not discover every startup, investors, funding rounds or cap tables from the open web.
- A one-time scan measures current public observations, not a longitudinal growth rate. Schedule repeated runs and compare results to build a history.
- Six supported ATS families do not cover every hiring site. Missing or inaccessible boards produce an explicit status. A board matched only by name is marked `unverified` and can belong to a different company; review it before using the signal. At most 300 jobs are returned for scoring, with truncation flagged.
- Google can rate-limit, block or change its public response format. That section may be unavailable while other sections still return evidence. Up to 40 relevance-ranked creatives are a sample, not an exhaustive campaign inventory or proof of current spend.
- Only public homepage and common contact/about/team/careers pages are checked for contacts. No private records, inferred email addresses, authentication or individual mailbox tests are used.
- DNS and technology signatures can be stale, incomplete or hidden behind consent controls. Absence of a signature is not proof that a technology is unused.
- Input URLs and redirects to private/reserved addresses are rejected. No customer-provided target is used as a paid upstream service.

### FAQ

**Why is my company missing from the dataset?** It did not have two usable sections. Read the OUTPUT summary and its free DIAGNOSTIC record.

**Why is a profile charged with no breakout score?** Two sections can qualify for billing while fewer than two of hiring, Google Ads and tech are available. Contacts improve research coverage without adding score points.

**Can I monitor companies?** Save a task, schedule it in Apify, and compare datasets across runs. This Actor does not automatically retain previous job or revenue history.

**Can I export or integrate the results?** Yes: JSON, CSV, Excel, API, MCP, n8n and Clay.

For support, use the Actor's **Issues** tab and include your run ID and affected domain, without posting credentials.

# Actor input Schema

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

One to fifty public company domains or homepage URLs. Examples: ramp.com, linear.app. Duplicates are removed. Use either domains or domain; domains takes precedence.

## `domain` (type: `string`):

Optional single-domain alternative when domains is omitted. Working examples: ramp.com or linear.app.

## `include_jobs` (type: `boolean`):

Include the sampled jobs as well as hiring summaries. Public job descriptions are not stored.

## `max_jobs_per_company` (type: `integer`):

Maximum jobs included when include_jobs is true. The hiring score uses all returned jobs, up to the source safety limit.

## `max_ads_per_company` (type: `integer`):

Sample up to 40 creatives from Google Ads Transparency. Last-shown dates distinguish recent from historical ads; no ad-spend estimate.

## `max_concurrency` (type: `integer`):

Scan this many companies at once. All four sections run in parallel per company. Lower this for small resource budgets.

## Actor input object example

```json
{
  "domains": [
    "linear.app"
  ],
  "include_jobs": false,
  "max_jobs_per_company": 50,
  "max_ads_per_company": 40,
  "max_concurrency": 3
}
```

# Actor output Schema

## `profiles` (type: `string`):

Qualifying company profiles with four source sections, breakout score and reasons. Download as JSON, CSV or Excel from the dataset.

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

All company statuses, billing eligibility and breakout summaries. Nonqualifying full reports are DIAGNOSTIC-<domain> records in the same key-value store.

# 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": [
        "linear.app"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hirepulse/startup-breakout-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": ["linear.app"] }

# Run the Actor and wait for it to finish
run = client.actor("hirepulse/startup-breakout-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": [
    "linear.app"
  ]
}' |
apify call hirepulse/startup-breakout-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hirepulse/startup-breakout-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/euUP0JdP0XPgDi8ox/builds/QOM2Ay57GuYI6Tnch/openapi.json