# Company Signals API - Funding, M\&A, Layoffs, Hiring Data (`nabeelbaghoor/company-signals-funding-layoffs-api`) Actor

Pull company trigger events by date, company, industry, location and deal size: startup funding and venture rounds, mergers, acquisitions and divestments, layoffs and job cuts, business expansion and major hiring, C-suite changes, security breaches and company news. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/company-signals-funding-layoffs-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Business, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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.

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

## Company Signals API - Funding, M\&A, Layoffs, Hiring Data

Pull company trigger events as structured rows: startup funding and venture capital rounds, mergers, acquisitions and divestments, layoffs and job cuts, business expansion and major hiring, C-suite and executive changes, data and security breaches, and curated company news. Seven signal families, one dataset, one set of leading columns.

### What this actor does

- **Collects seven signal families into one table.** Funding, mergers, layoffs, expansion, executive changes, breaches and news each have their own endpoint and their own record shape, and every one of them is flattened here to the same leading columns: signal type, date, company name, company domain, location, amount, currency, people count, headline and source URL.
- **Filters on the server with the provider's own vocabularies.** Industry, company type, funding round, deal status, deal type, layoff type, layoff reason, expansion type, executive title category and incident type are all exact-match lists, and they are offered here exactly as the provider publishes them, so a filter you set actually narrows the query instead of quietly matching nothing.
- **Works around the lack of pagination.** This API has no cursor and no page parameter: one request returns at most the records-per-request limit for the filter it was given. Set a days-per-request window and the actor slices your date range into windows and walks them newest first, which is how a run pulls far more than a single request could.
- **Handles the daily incremental pull properly.** Filter on last modified rather than announced date and each run picks up records that were created or changed since the last one, including late additions to older events.
- **Pins both sides of a deal.** Merger filters can be applied to the acquiring, the acquired or the selling company, and a counterparty name or domain narrows to deals between two specific companies.
- **Carries on when a plan does not cover a signal.** A signal your subscription excludes is skipped with a warning rather than failing the run and losing the signals it does cover.
- **Never charges twice for the same signal.** Overlapping date windows and companies matching more than one filter are de-duplicated before the charge, not after.

### Input

| Field | What it does |
| --- | --- |
| `signalTypes` | Which of the seven signal families to pull. |
| `startDate`, `endDate`, `exactDate` | The date range, or a single date. |
| `dateType` | Filter on the announced date or on the last modified date. |
| `windowDays` | Split the range into windows and make one request per window. |
| `companyName`, `companyDomain`, `companyTicker` | Which company to track. |
| `companyIndustry`, `companyType`, `companyLocation` | Firmographic filters. |
| `mnaCompanyRole` | Apply the company filters to the acquiring, acquired or selling side. |
| `counterpartyCompanyName`, `counterpartyCompanyDomain` | Pin the other side of a deal. |
| `mnaStatus`, `mnaType` | Deal stage and deal structure. |
| `fundingRound`, `investor`, `valuation`, `dealAmount`, `currency` | Funding filters. |
| `layoffType`, `layoffReason` | Layoff filters. |
| `expansionType`, `investment`, `jobs` | Expansion filters. |
| `executiveName`, `executiveTitle`, `executiveTitleCategory`, `executiveChangeReason` | Executive change filters. |
| `incidentType`, `peopleImpacted` | Breach filters. |
| `eventLocation` | Where the event happened, not where the company is based. |
| `newsCompanyDomains`, `newsTriggerCodes` | Which companies and triggers the news signal watches. |
| `recordsPerRequest`, `requestDelayMs` | Request size and pacing. |
| `maxResults` | Hard cap on rows, and therefore on spend and run time. |
| `apiKey` | Your own API key. Stored as a secret. |

### Example output

```json
{
  "signalType": "funding",
  "id": "a1b2c3d4",
  "date": "2026-07-14",
  "companyName": "Example Labs",
  "companyDomain": "examplelabs.com",
  "companyIndustries": ["technology", "bio-technology"],
  "companyLocation": "Boston, Massachusetts, United States",
  "companyType": "Private",
  "companyTicker": null,
  "amount": 42000000,
  "currency": "USD",
  "peopleCount": null,
  "fundingRound": "Series B",
  "investors": "Acme Ventures, Northwind Capital",
  "leadInvestors": "Acme Ventures",
  "valuation": 310000000,
  "title": "Example Labs raises 42 million dollars in Series B",
  "url": "https://example.com/news/example-labs-series-b",
  "lastModified": "2026-07-15",
  "raw": { }
}
```

### Frequently asked questions

#### What data does the Company Signals API return?

Each signal returns the event date, the company with its name, domain, industries, headquarters location, company type, ticker and stock exchange, the event location broken into country, state and city, the headline and the source URL, and the date the record was last modified. On top of that each family carries its own fields: funding adds the round, the investors and lead investors, the deal amount, the valuation and the currency; mergers add the acquiring, acquired and selling companies with the deal type, deal status and deal amount; layoffs add the number and percentage of staff, the layoff type, the reason, the business division and whether the source was a WARN filing or the press; expansion adds the expansion type, the investment and the jobs created; executive changes add the executive name, title, title category, reason and effective date; breaches add the incident type, the people impacted, the notice date and any third party involved; and news adds the publisher, the description, the trigger names and codes, and related coverage.

#### Do I need my own API key?

Yes. This actor does not include data access. You use your own API key from Intellizence, which is the provider whose company signals API this actor calls, requested from them directly. Your own plan, credit balance and terms apply. Paste the key into the `apiKey` field, where it is stored as an Apify secret and sent in a request header rather than a URL parameter, so it never appears in a log line or a redirect.

#### How do I pull more than one request's worth of signals?

Set `windowDays`. The API has no pagination, so one request returns at most `recordsPerRequest` records for the filter it was given, and the documented way to reach more is to narrow the filter. Setting a window of, say, 7 days over a one year range turns that into 53 requests, each covering a week, walked newest first so a run stopped early still has the most recent signals. Without a window the whole range goes out as a single request.

#### How do I run this daily without re-pulling everything?

Set `dateType` to last modified and give a start date of yesterday. The provider then returns records created or changed in that window rather than events announced in it, which is what catches a record added three days late for an event announced last week. Announced date is the right choice for analysis of a fixed historical period; last modified is the right choice for a feed.

#### How do I track acquisitions by a specific company?

Set the company domain and leave `mnaCompanyRole` on acquiring to get the deals that company made. Switch it to acquired to get the deals where it was the target, or to selling for divestments it sold out of. To pin both ends of a deal at once, add `counterpartyCompanyName` or `counterpartyCompanyDomain`.

#### Can I collect several signals in one run?

Yes, and that is the normal way to use this. Select as many families as you want in `signalTypes` and they all land in the same dataset with the same leading columns, so a single table can hold this week's funding rounds, layoffs and executive changes and be sorted by date or filtered by company. A family your plan does not cover is skipped with a warning and the rest still run.

#### Which industries and deal types can I filter on?

The provider publishes exact-match lists and this actor offers them verbatim: 55 industries, 5 company types, 21 funding rounds, 13 deal statuses, 11 deal types, 8 layoff types, 29 layoff reasons, 23 expansion types, 16 executive title categories, 8 change reasons, 8 incident types and 10 currencies. Because they are exact matches, a value outside a list matches nothing rather than matching loosely, which is why they appear as dropdowns rather than free text.

#### How far back does the data go?

The datasets begin at 2020-01-01. How much of that history your own key can reach depends on your subscription, and a request for a range outside it comes back as a subscription error, which this actor reports with that reason rather than as a generic failure.

#### How much does a run cost?

Pricing is pay per result: you are charged for each signal returned to the dataset, and never for duplicates across overlapping date windows. Apify platform usage is included in the per-result price. Your own API provider's credits are separate and billed by them, and the run log reports how many of them a run consumed.

### Keyword map

company signals API, trigger events API, sales trigger data, startup funding API, venture capital deals data, funding rounds dataset, mergers and acquisitions API, M\&A deal data, layoffs API, layoff tracker data, WARN notice data, business expansion signals, hiring signals API, C-suite changes API, executive movement data, leadership change tracking, data breach API, security incident dataset, company news API, buying intent signals, account intelligence, CRM signal enrichment

# Actor input Schema

## `signalTypes` (type: `array`):

Which signal families to pull. Each one is a separate endpoint and a separate request, and all of them land in the same dataset with the same leading columns, so you can pull several at once and sort the lot by date and company. Your plan has to cover each signal you pick; one it does not cover is skipped with a warning rather than failing the run.

## `startDate` (type: `string`):

Earliest date to pull signals from, as YYYY-MM-DD. The datasets begin at 2020-01-01 and how far back your own plan reaches depends on your subscription.

## `endDate` (type: `string`):

Latest date to pull signals up to, as YYYY-MM-DD.

## `exactDate` (type: `string`):

Pull signals for one single date, as YYYY-MM-DD. Use this instead of a range when you are running the actor daily and only want what landed that day. Ignored by the company news signal.

## `dateType` (type: `string`):

Which date the range applies to. Announced filters on when the event was announced, which is what you want for analysis. Last modified filters on when the record was created or changed, which is what you want for a daily incremental pull, because it also catches records added late for an older event.

## `windowDays` (type: `integer`):

Split the date range into windows of this many days and make one request per window. This API has no pagination: a single request returns at most the records-per-request limit for whatever filter it was given, so slicing the range is how you pull more than that. Leave empty to send the whole range as one request.

## `companyName` (type: `string`):

Company name to filter on. Partial matches work. On mergers this is applied to whichever side of the deal the role below selects.

## `companyDomain` (type: `string`):

Company domain to filter on, for example stripe.com. A pasted URL is reduced to the bare hostname before the request. On mergers this is applied to whichever side of the deal the role below selects.

## `companyIndustry` (type: `string`):

Industry to filter on. This is an exact-match list, so a value outside it matches nothing rather than matching loosely.

## `companyLocation` (type: `string`):

Company headquarters location to filter on: a city, a state or a country.

## `companyType` (type: `string`):

Whether the company is publicly listed, private, governmental, not-for-profit or something else.

## `companyTicker` (type: `string`):

Stock ticker symbol to filter on, for public companies.

## `mnaCompanyRole` (type: `string`):

Which side of a deal the company filters above are applied to when the mergers signal is selected. Acquiring finds deals a company made, acquired finds deals it was the target of, and selling finds divestments it sold out of.

## `counterpartyCompanyName` (type: `string`):

Name of the company on the other side of the deal, to pin both ends of a merger at once. Mergers signal only.

## `counterpartyCompanyDomain` (type: `string`):

Domain of the company on the other side of the deal. Mergers signal only.

## `mnaStatus` (type: `string`):

Where the deal has reached: announced, completed, terminated, under regulatory review and so on. Mergers signal only.

## `mnaType` (type: `string`):

The structure of the deal: a total acquisition, an asset sale, a financial stake, a merger, a tender offer and so on. Mergers signal only.

## `fundingRound` (type: `string`):

Which round to filter on, from angel and pre-seed through the lettered series to private equity and debt financing. Funding signal only.

## `investor` (type: `string`):

Investor name to filter on. Funding signal only. Use it to track every deal a given fund took part in.

## `valuation` (type: `integer`):

Company valuation to filter on, in the currency selected below. Funding signal only.

## `dealAmount` (type: `integer`):

Deal or round amount to filter on, in the currency selected below. Applies to the funding and mergers signals.

## `investment` (type: `integer`):

Investment amount announced with an expansion, in the currency selected below. Business expansion signal only.

## `jobs` (type: `integer`):

Number of jobs announced with an expansion. Business expansion signal only.

## `currency` (type: `string`):

Currency the amount filters above are expressed in.

## `layoffType` (type: `string`):

Whether the event was a permanent layoff, a furlough, a hiring freeze, a voluntary programme or a plant closure. Layoffs signal only.

## `layoffReason` (type: `string`):

The reason given for the layoff, from restructuring and cost-cutting through to bankruptcy and automation. Layoffs signal only.

## `expansionType` (type: `string`):

What kind of expansion it was: a new store, factory, data centre, office, country entry, warehouse and so on. Business expansion signal only.

## `eventLocation` (type: `string`):

Where the event itself happened, as opposed to where the company is headquartered. Applies to the layoffs and business expansion signals.

## `executiveName` (type: `string`):

Name of the executive to filter on. C-suite changes signal only.

## `executiveTitle` (type: `string`):

Job title to filter on as free text, for when the category list below is too coarse. C-suite changes signal only.

## `executiveTitleCategory` (type: `string`):

The seniority bucket the role falls into, from chief executive down through the functional chiefs. C-suite changes signal only.

## `executiveChangeReason` (type: `string`):

Why the change happened: a new appointment, a promotion, a retirement, a resignation, a termination and so on. C-suite changes signal only.

## `incidentType` (type: `string`):

What kind of security incident it was: a data breach, ransomware, malware, a denial of service attack and so on. Data breaches signal only.

## `peopleImpacted` (type: `integer`):

Number of people affected by the incident. Data breaches signal only.

## `newsCompanyDomains` (type: `array`):

Company domains to pull news signals for, one per line. The company news signal is domain-driven, so this is how you tell it which companies to watch. The single company domain above is added to this list.

## `newsTriggerCodes` (type: `array`):

Trigger codes to restrict the news signal to, one per line, using the trigger code reference in the API documentation. Leave empty to get every trigger the plan covers.

## `recordsPerRequest` (type: `integer`):

How many records to ask for in one request. The provider defaults to 100. Combined with the days-per-request window above, this is what sets how much a run can pull in total.

## `requestDelayMs` (type: `integer`):

Pause between requests, in milliseconds. Raise it if you are sharing the key with other jobs and want this actor to take a smaller share of the throughput.

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

Stop after this many rows. This is the cap on both spend and run time.

## `apiKey` (type: `string`):

Your own API key for the company signals API, sent in the request header rather than a URL parameter, so it never appears in a log line or a redirect. Required for every request. Stored as a secret.

## Actor input object example

```json
{
  "signalTypes": [
    "funding"
  ],
  "startDate": "2026-07-01",
  "dateType": "ANNOUNCED",
  "mnaCompanyRole": "acquiring",
  "currency": "USD",
  "recordsPerRequest": 100,
  "requestDelayMs": 250,
  "maxResults": 100
}
```

# 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 = {
    "startDate": "2026-07-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/company-signals-funding-layoffs-api").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 = { "startDate": "2026-07-01" }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/company-signals-funding-layoffs-api").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 '{
  "startDate": "2026-07-01"
}' |
apify call nabeelbaghoor/company-signals-funding-layoffs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/company-signals-funding-layoffs-api"
        }
    }
}

```

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/oTg0OVY89cDhBJD5j/builds/quLpmuYLMcBlzO0qf/openapi.json