# Recently Funded Companies — Rounds, Amounts & Investors (`inovaflow/recently-funded-companies`) Actor

Companies that just raised, as a ready-to-use buying signal: round, amount, currency, valuation, investors, announcement date and source — one deduped row per company and round, with who to sell to, the buying window and what is new since your last run. Dataset-only, MCP-ready.

- **URL**: https://apify.com/inovaflow/recently-funded-companies.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 funded companies

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?

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

## Recently Funded Companies — Rounds, Amounts & Investors

**If you sell to startups, a funding announcement is the best two weeks of the year to reach them.** The
money is in the bank, the plan is being written, and nobody has spent it yet. The problem was never finding
out *that* someone raised — it is getting a clean, deduplicated, machine-readable list of *who* raised,
*how much*, *from whom*, and *who inside the company now has budget* — fast enough to act on it.

That is this Actor. Give it a stage, a sector or nothing at all, and it returns **one row per company and
round**: the amount everyone agrees on, the investors, the announcement date, the company's domain, the
roles that just got budget, and how warm the trigger still is. Re-run it and it tells you **only what is
new**.

***

### Who it is for

- **Outbound and SDR teams** — a daily list of accounts that just raised, with the buyer roles to target and
  the announcement to reference in the first line of the email.
- **AI / GTM agents** — one call, a flat dataset, no login and no key. Every row is already a decision:
  `signalScore`, `signalTags`, `sellTo`, `buyingWindow`.
- **VCs and corp dev** — deal flow by stage, sector and geography, with the syndicate on each round.
- **Recruiters** — a Series A or B with `hiring-wave-likely` is a company about to open ten roles.
- **Data teams** — a clean funding feed to join onto your CRM, refreshed on a schedule, deduplicated for you.

***

### What makes it different

| | Typical funding scraper | This Actor |
| --- | --- | --- |
| Row shape | one row per article | **one row per company + round**, merged across every outlet that covered it |
| Amount | whatever the one article said | the figure the reports **agree on** (a bigger number in one headline is usually total capital raised, not this round) |
| Investors | often missing | lead investor + the syndicate, cleaned and deduplicated |
| Domain | rarely | resolved for most companies, so you can enrich straight away |
| Re-runs | the same rows again | **only what is new** since your last run, plus follow-on rounds and revised amounts |
| Output | raw data | raw data **plus the signal**: tags, who to sell to, the buying window, a 0–100 score |

***

### What you get per company

```jsonc
{
  "company": "Lightfield",
  "domain": "lightfield.ai",
  "round": "series-a",
  "amountUsd": 47000000,
  "amountText": "$47 Million",
  "valuationUsd": null,
  "announcedDate": "2026-09-10",
  "daysSinceAnnouncement": 1,
  "leadInvestor": "a16z",
  "investors": ["a16z", "Y Combinator"],
  "industry": "AI",
  "hqLocation": "San Francisco",
  "description": "Lightfield is building a CRM for companies that run on AI agents.",
  "signalScore": 86,
  "signalTags": ["fresh-capital", "just-raised-series-a", "announced-today", "large-round",
                 "hiring-wave-likely", "tier1-lead-investor", "new-since-last-run", "ai"],
  "sellTo": ["CEO", "VP Sales", "Head of Marketing", "Head of People", "Head of Engineering"],
  "buyingWindow": "Reach out now — inside the 14-day window when a just-raised company answers most",
  "isNewSinceLastRun": true,
  "isFollowOnRound": false,
  "previousRounds": [],
  "mentions": 4,
  "sourceUrl": "https://…",
  "sourceUrls": ["https://…", "https://…"]
}
```

Three dataset views are built in: **Recently funded companies** (the signal table), **Outreach** (domain,
who to sell to, buying window, what they do) and **New since last run** (the delta).

***

### Use it in three ways

**1 · Zero-config.** Run it with nothing set: every funding round announced in the last 7 days, worldwide,
sorted by signal strength.

**2 · Your ICP.** Pick the stages you sell into, add a sector word or a country, set a minimum round size:

```json
{ "roundTypes": ["series-a", "series-b"], "keywords": ["fintech"], "locations": ["Germany"],
  "minAmountUsd": 5000000, "daysBack": 14 }
```

**3 · A scheduled feed of what changed.** Set a `watchId`, turn on `onlyNewSinceLastRun`, and schedule it
daily. The first run stores the baseline; every run after it returns only the rounds you have not seen —
which is exactly what an agent should act on.

```json
{ "watchId": "fintech-series-b", "roundTypes": ["series-b"], "onlyNewSinceLastRun": true, "daysBack": 7 }
```

Watching specific accounts instead? Put them in `companies` (names or domains) and you get a row only when
one of them raises.

***

### How the signal is built

- **Merge, then report.** The same raise is announced by five outlets with five different headlines. They
  are merged into one signal — with a `mentions` count, every source URL, and the amount the reports agree
  on. Wide coverage is itself a signal, and it is on the row.
- **Remember, then diff.** Each watch keeps a private memory of every company and round it has already
  reported. That is what powers `isNewSinceLastRun`, `isFollowOnRound`, `previousRounds` and
  `amountChangedFrom` — the delta, not the dump.
- **Score, then sort.** `signalScore` (0–100) combines recency, round size, stage, breadth of coverage and
  investor quality, so the top of the dataset is where to start calling.

***

### Chain it

| Then run | To get |
| --- | --- |
| **Decision-Maker Finder** | the actual people in `sellTo` at each funded company, with work e-mails |
| **Hiring Intent Scraper** | which of them turned the money into open roles — the second wave of the signal |
| **Technology Lookup** | the stack they are buying into |
| **Company Finder** | more companies like the ones that just raised |

***

### Notes

- No login, no cookies, no API key. Everything read is public.
- No other paid Actor is ever started — the run costs what it reads.
- Amounts in other currencies are converted at an indicative rate so filters and sorting work worldwide;
  the amount as reported is kept in `amountText` with its own `currency`.
- Sources are public announcements, so a company that never announced its round will not appear.

### Pricing

Pay per event: you pay per delivered company row. Duplicate reports of the same round, filtered-out rounds
and empty runs are never charged. See `PRICING.md`.

# Actor input Schema

## `roundTypes` (type: `array`):

Only report these stages. Empty = all stages. Seed and Series A mean a founder-led buy; Series B and later mean a department head with a real budget.

## `daysBack` (type: `integer`):

How far back to look. The reply-rate research behind funding triggers says reach out inside two weeks, so 7–14 days is the sweet spot; widen it for a one-off backfill.

## `keywords` (type: `array`):

Words that must appear in the announcement, one per line — `AI`, `fintech`, `cybersecurity`, `climate`. Leave empty for every sector. Several words are combined with OR.

## `locations` (type: `array`):

Narrow to announcements that mention these places, one per line — `Germany`, `United Kingdom`, `New York`, `Southeast Asia`. Leave empty for worldwide coverage.

## `minAmountUsd` (type: `integer`):

Drop rounds smaller than this. Amounts in other currencies are converted at an indicative rate so the filter works worldwide. Rounds with an undisclosed amount are dropped when a minimum is set.

## `maxAmountUsd` (type: `integer`):

Drop rounds bigger than this — useful when mega-rounds are out of your ICP. Rounds with an undisclosed amount are kept.

## `requireAmount` (type: `boolean`):

Skip announcements that never name a figure ("raises Series A funding"). Off by default — an undisclosed round is still a trigger.

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

Report funding only for these companies — names (`Gong`) or domains (`gong.io`), one per line. Leave empty to discover every company that raised in the window.

## `useNewsSearch` (type: `boolean`):

Searches public funding announcements across every outlet, bounded to your date window and narrowed by the stage, sector and country filters. This is the broad source — keep it on.

## `useFundingFeeds` (type: `boolean`):

Adds a set of publications that cover funding continuously. Narrower than the search, but it comes with the article URL and the paragraph that names the investor syndicate.

## `enrichFromArticles` (type: `boolean`):

Opens the best announcement per company to add the investor syndicate, the company's own domain and website, its HQ city, sector and a one-line description. Adds a few seconds and costs nothing extra. Turn off for the fastest possible run.

## `onlyNewSinceLastRun` (type: `boolean`):

Deliver only company+round rows this watch had not reported before. Ideal for a schedule: every run returns just the new raises. The first run of a watch always returns everything as the baseline.

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

Cap on delivered rows (highest signal score first). Also caps what you pay.

## `watchId` (type: `string`):

Optional name for this watch, e.g. `fintech-series-b`. Runs sharing a Watch ID share the memory of what was already reported. Leave empty to derive it from the filters.

## `maxQueries` (type: `integer`):

How many funding-news queries to send. Each returns up to 100 headlines. More queries = wider coverage of small outlets and non-English markets.

## `maxEnrichments` (type: `integer`):

How many of the top companies get their announcement opened for investors, domain and HQ. Set to 0 to skip enrichment entirely.

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

Concurrent requests to news sources and article pages. Lower it if a publisher starts rate-limiting.

## `newsLanguage` (type: `string`):

Language edition of the news search, e.g. `en-US`, `de-DE`, `fr-FR`. Changes which outlets are covered.

## `newsCountry` (type: `string`):

Two-letter country edition of the news search, e.g. `US`, `GB`, `DE`, `IN`. Pair it with the matching language for strong local coverage.

## `proxyConfiguration` (type: `object`):

Optional. Everything here is a public page, so no proxy is needed — the Actor already falls back to Apify Proxy if a publisher rate-limits the run. Set one only if you want every request to go through a specific proxy.

## Actor input object example

```json
{
  "roundTypes": [
    "series-a",
    "series-b"
  ],
  "daysBack": 7,
  "keywords": [
    "AI",
    "fintech"
  ],
  "locations": [
    "Germany",
    "United Kingdom"
  ],
  "minAmountUsd": 5000000,
  "maxAmountUsd": 50000000,
  "requireAmount": false,
  "companies": [
    "gong.io",
    "Ramp"
  ],
  "useNewsSearch": true,
  "useFundingFeeds": true,
  "enrichFromArticles": true,
  "onlyNewSinceLastRun": false,
  "maxCompanies": 200,
  "watchId": "fintech-series-b",
  "maxQueries": 12,
  "maxEnrichments": 60,
  "maxConcurrency": 6,
  "newsLanguage": "de-DE",
  "newsCountry": "DE",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per company and round: amount, stage, investors, announcement date, signal score and tags.

## `outreach` (type: `string`):

Who to sell to, the buying window, the domain, the sector and the source article — the fields an outbound sequence needs.

## `newRounds` (type: `string`):

The delta: rounds this watch had not reported before, follow-on raises and revised amounts.

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

Counts, total capital raised, stage breakdown, signal-tag totals, per-source report and the watch id.

# 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 = {
    "daysBack": 7
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/recently-funded-companies").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 = { "daysBack": 7 }

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/recently-funded-companies").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 '{
  "daysBack": 7
}' |
apify call inovaflow/recently-funded-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,inovaflow/recently-funded-companies"
        }
    }
}
```

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/FypQctANyuUyA75pM/builds/PeRpoGqCWtVcSBwPY/openapi.json