# Company Funding News Press Signal Scanner Clay Enrichment (`mambalabs/funding-press-signal-scanner`) Actor

Scans Google News and PR wires for funding rounds, exec moves, product launches, and acquisitions at any company. Returns deduplicated, dated events in flat Clay-ready JSON for RevOps and outbound.

- **URL**: https://apify.com/mambalabs/funding-press-signal-scanner.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

## Company Funding News Press Signal Scanner Clay Enrichment

Give it a company domain, get back a clean list of that company's recent business events: funding rounds, executive moves, product launches, acquisitions, partnerships, and IPOs. The actor searches public news and press sources, classifies each story into a typed event, deduplicates the same event reported across multiple outlets, and returns one flat row per company. Built for Clay users, RevOps teams, and outbound agencies who want account signals without paying for a Crunchbase seat.

### Features

- **One domain in, structured events out.** Input `stripe.com`, get funding, exec, launch, M&A, partnership, and IPO events attributed to that company.
- **Six event types, classified for you.** Each event is tagged `funding_round`, `exec_move`, `product_launch`, `acquisition`, `partnership`, `ipo`, with amount, currency, and funding stage pulled out when present.
- **Cross source deduplication.** The same funding round reported by three outlets collapses into one event with a `corroborating_source_count`, so more sources means higher confidence, not more noise.
- **Subject relevance filter.** Events are kept only when the company is the actual subject, not just mentioned. "Stripe raises" stays; "Stripe-backed startup raises" is dropped.
- **Multi source.** Google News RSS is the primary source, with press wire coverage (PR Newswire, Business Wire, GlobeNewswire) and a DuckDuckGo pass layered on top. If a source is unreachable, it is skipped and the run still completes.
- **Clay native output.** Flat JSON, snake_case, one row per company. Read the summary fields for a quick answer or unnest the `events` array for event level workflows.
- **Per company summary.** `has_recent_funding`, `latest_event_date`, `funding_total_estimated`, and `most_recent_headline` give you a usable signal in a single field, no parsing required.
- **No browser, no proxy, no API keys.** Fast HTTP and RSS only.

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `domain` | string | Yes | `stripe.com` | Company domain to scan, without https or www. The main input for single company runs and Clay per row enrichment. |
| `company_name` | string | No | (derived from domain) | Optional search hint. Use it when the domain does not match the brand name, for example domain `deel.com` with name `Deel`. Applied on single company runs. |
| `domains` | array | No | (empty) | Optional list of domains for batch runs. When set and non-empty, it overrides the single `domain` field. |

### Output

One row per company. The flat summary fields:

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `company_domain` | string | The input domain, normalized | `stripe.com` |
| `company_name` | string | Provided hint or derived from the domain | `Stripe` |
| `total_events` | integer | Count of deduped events returned (up to 50) | `41` |
| `latest_event_date` | string | ISO date of the most recent event | `2026-06-18` |
| `has_recent_funding` | boolean | True if a funding event was found in the last 12 months | `true` |
| `funding_total_estimated` | number | Estimated sum of distinct raise amounts found in the last 12 months, in USD | `750000000` |
| `funding_total_currency` | string | Currency of the funding total, normalized to USD | `USD` |
| `most_recent_event_type` | string | Type of the latest event | `product_launch` |
| `most_recent_headline` | string | Headline of the latest event | `Stripe launches Tempo` |
| `events` | array | Array of classified event objects (see below) | `[ {...} ]` |
| `sources_queried` | array | Sources that responded with data this run | `["google_news_rss", "press_wire_rss"]` |
| `run_date` | string | ISO timestamp of the scan | `2026-06-21T12:00:00Z` |

Each object in the `events` array:

| Field | Type | Description |
|-------|------|-------------|
| `event_type` | string | One of `funding_round`, `exec_move`, `product_launch`, `acquisition`, `partnership`, `ipo` |
| `date` | string | ISO date the article was published (a proxy for the event date) |
| `headline` | string | The news headline |
| `source_url` | string | Link to the article |
| `source_name` | string | Publisher name |
| `amount` | number | Raise amount in base currency units, funding events only |
| `currency` | string | Currency of the amount (`USD`, `EUR`, `GBP`) |
| `funding_stage` | string | Normalized stage, for example `seed`, `series_a`, funding events only |
| `names` | array | People named in the story, exec moves only, best effort |
| `description` | string | Short snippet from the article |
| `corroborating_source_count` | integer | How many sources reported this same event |

Sample output (trimmed):

```json
{
  "company_domain": "ramp.com",
  "company_name": "Ramp",
  "total_events": 41,
  "latest_event_date": "2026-06-17",
  "has_recent_funding": true,
  "funding_total_estimated": 750000000,
  "funding_total_currency": "USD",
  "most_recent_event_type": "product_launch",
  "most_recent_headline": "Ramp Launches Applied AI Solutions",
  "events": [
    {
      "event_type": "funding_round",
      "date": "2026-04-15",
      "headline": "Ramp in talks to raise $750M from GIC, Iconiq Capital",
      "source_url": "https://news.google.com/...",
      "source_name": "Fortune",
      "amount": 750000000,
      "currency": "USD",
      "funding_stage": "series_f",
      "names": [],
      "description": "...",
      "corroborating_source_count": 11
    }
  ],
  "sources_queried": ["google_news_rss", "press_wire_rss", "duckduckgo"],
  "run_date": "2026-06-21T12:00:00Z"
}
````

You can download the dataset in JSON, HTML, CSV, or Excel.

### Pricing

This actor uses pay per event. You are charged once per company scanned, no matter how many events come back, so the cost per row is predictable for Clay and batch runs.

| Tier | Discount | Per result | Per 1K results |
|------|----------|-----------|----------------|
| Free (no plan) | 0% | $0.030 | $30.00 |
| Starter (Bronze) | ~5% | $0.0285 | $28.50 |
| Scale (Silver) | ~10% | $0.027 | $27.00 |
| Business (Gold) | ~15% | $0.0255 | $25.50 |

Free tier: 25 results per month included. Upgrade to a paid Apify plan for unlimited runs.

### Usage Examples

#### Apify Console / API

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('funding-press-signal-scanner').call({
  domain: 'stripe.com',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].has_recent_funding, items[0].total_events);
```

#### Clay Integration

1. In your Clay table, add an enrichment and choose **Apify** (or call the actor through the HTTP API action).
2. Map your domain column to the `domain` input.
3. Run the actor. Each row returns one record.
4. Pull the summary fields straight into columns: `has_recent_funding`, `funding_total_estimated`, `most_recent_event_type`, `latest_event_date`.
5. For event level workflows, use Clay's unnest on the `events` array to expand one row per event.

Clay sends inputs as strings; the actor normalizes them, so you can map columns directly.

#### MCP Integration

```bash
npm install -g @mambalabsdev/mcp-funding-press-signal-scanner
```

```json
{
  "mcpServers": {
    "funding-press-signal-scanner": {
      "command": "npx",
      "args": ["-y", "@mambalabsdev/mcp-funding-press-signal-scanner"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then call the `scan_funding_press_signals` tool with a `domain`.

### Error Handling

| Condition | Behavior | Output |
|-----------|----------|--------|
| One source times out, returns a challenge page, or is blocked | The source is skipped, the run continues | That source is absent from `sources_queried` |
| No events found for the company | A valid row is returned | `total_events` is 0, `has_recent_funding` is false |
| No valid domain provided | The run exits without pushing a row | No output, no charge |
| A date cannot be parsed | The event is still returned | `date` is null on that event |

### Limitations

- Events come from news and press, so `date` is the article publish date, a close proxy for the actual event date.
- `funding_total_estimated` is a rough sum of raise amounts detected in the last 12 months, not an all time funding total. News does not always let us separate rounds perfectly, so treat it as a signal, not an audited figure.
- Company matching is keyword based. A company whose name is a common word, or whose name is shared by another firm (for example two different companies both called Ramp), can pick up some off target events.
- Person names in `exec_move` events are best effort and not verified.
- Up to 50 most recent events are returned per company.
- Sources are public and English language, US edition. No login gated sources, no Crunchbase, no PitchBook.
- No proxy is used by default. If blocking becomes a pattern, Google News RSS remains the primary, block resistant source.

### FAQ

**Is this legal?** The actor reads public news and press pages only. It does not access login gated or paywalled sources, and it does not scrape Crunchbase or PitchBook.

**How fresh is the data?** Each scan looks back about 12 months and returns the most recent events first. Repeated scans of the same domain within 24 hours are served from cache.

**Found a bug or want a field added?** Open an issue on the actor's Issues tab.

***

**Part of the [Mamba Labs GTM Intelligence Suite](https://apify.com/mambalabs)**

| Actor | Actor ID |
|-------|----------|
| [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) | D7O1SA2EqwHGsGr1P |
| [GTM Tech Stack Signal Enrichment](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) | qyd7nNyqFPelQViBx |
| [GTM Signals Aggregator](https://apify.com/mambalabs/gtm-signals-aggregator) | xKdRfnfFNkdMpFuNs |
| [Job Board Keyword Signal Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) | 4DvqpvhMR74NLcDDY |
| [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) | 3HtnSaqPHOg1Qg5gx |
| [ICP Fit Scorer](https://apify.com/mambalabs/icp-fit-scorer) | W161DT8W4kW55dMFh |

npm: [@mambalabsdev/ats-scrapers](https://www.npmjs.com/package/@mambalabsdev/ats-scrapers)

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

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

Company domain to scan, without https or www, e.g. stripe.com. This is the main input for single-company runs and for Clay per-row enrichment.

## `company_name` (type: `string`):

Optional search hint. Improves matching when the domain does not match the brand name, e.g. domain deel.com with name Deel. Only applied on single-company runs.

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

Optional list of domains for batch runs. When set and non-empty, this overrides the single domain field. Leave empty for single-company or Clay per-row use.

## Actor input object example

```json
{
  "domain": "stripe.com"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "domain": "stripe.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/funding-press-signal-scanner").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 = { "domain": "stripe.com" }

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/funding-press-signal-scanner").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 '{
  "domain": "stripe.com"
}' |
apify call mambalabs/funding-press-signal-scanner --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Funding News Press Signal Scanner Clay Enrichment",
        "description": "Scans Google News and PR wires for funding rounds, exec moves, product launches, and acquisitions at any company. Returns deduplicated, dated events in flat Clay-ready JSON for RevOps and outbound.",
        "version": "0.0",
        "x-build-id": "r9fmY0YMQ2YEiDq3e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mambalabs~funding-press-signal-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mambalabs-funding-press-signal-scanner",
                "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/mambalabs~funding-press-signal-scanner/runs": {
            "post": {
                "operationId": "runs-sync-mambalabs-funding-press-signal-scanner",
                "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/mambalabs~funding-press-signal-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-mambalabs-funding-press-signal-scanner",
                "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": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Company domain",
                        "type": "string",
                        "description": "Company domain to scan, without https or www, e.g. stripe.com. This is the main input for single-company runs and for Clay per-row enrichment."
                    },
                    "company_name": {
                        "title": "Company name (optional hint)",
                        "type": "string",
                        "description": "Optional search hint. Improves matching when the domain does not match the brand name, e.g. domain deel.com with name Deel. Only applied on single-company runs."
                    },
                    "domains": {
                        "title": "Company domains (batch)",
                        "type": "array",
                        "description": "Optional list of domains for batch runs. When set and non-empty, this overrides the single domain field. Leave empty for single-company or Clay per-row use.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```