# Funding Round Intelligence API — SEC Form D, TechCrunch & YC (`nexgensignal/funding-round-intelligence-api`) Actor

Track startup funding rounds from SEC Form D filings (with amounts) and TechCrunch coverage, unified. Watch/delta mode bills only new rounds since last run. Keyless, pay per round. Not investment advice.

- **URL**: https://apify.com/nexgensignal/funding-round-intelligence-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $53.60 / 1,000 funding rounds

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

## Funding Round Intelligence API — SEC Form D, TechCrunch & YC

**Pay per round. Track new startup funding as it's filed and reported — from SEC Form D exempt-offering filings and TechCrunch funding coverage — with a first-class watch/delta mode that bills only new rounds since your last run.**

Point this actor at a keyword, a sector, or the whole market and get back a clean, unified record for each funding round: the company, the amount raised, the stage, the date, the industry, and a link back to the source filing or article. Run it once for a snapshot, or turn on **watch mode** and run it on a schedule to receive only the rounds that are new since last time — so a recurring workflow bills recurring value instead of re-paying for rounds you've already seen.

### What this is, in one paragraph

Startup funding surfaces in two very different public places: the **SEC's EDGAR system**, where US companies file a **Form D** whenever they raise capital under a Regulation D exemption (a structured filing that carries the issuer, the total offering amount, and the industry), and the **tech press**, where rounds are announced as news. This actor reads both — the SEC EDGAR full-text search plus each matching Form D's own XML for the offering amount, and TechCrunch's public funding coverage for the headline, amount, date, and link — and unifies them into one funding-round feed. The upgrade over a plain tracker is a proper **watch/delta layer**: give a run a `watchLabel`, turn on `newSinceLastRun`, and the actor remembers what it has already delivered and hands you only the new rounds on each subsequent run.

### Who buys this and for what job

- **Venture and PE sourcing teams** watching a sector for fresh raises the moment a Form D hits or a round is announced.
- **Sales teams** targeting newly funded companies — a fresh raise is a buying signal.
- **Market and competitive analysts** tracking funding velocity in a space over time.
- **Builders and agents** who need a keyless, unified funding feed they can poll on a schedule.

### The upgrade: watch / delta mode

A tracker you run every morning is only useful if it tells you what changed. Turn on **`newSinceLastRun`** (watch mode) and give the run a **`watchLabel`** — say, `ai-seed` — and the actor keeps a memory of every round it has already delivered under that label. On the next run it fetches the sources fresh, compares against that memory, and delivers **only the new rounds**, marking each `is_new`. A `watch-check` event is billed once per watch run for the comparison, and each new round is billed as it's delivered — so the cost of a daily watch tracks the actual new-deal flow, not the size of the back catalogue.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `apify-actor-start` | $0.01 | $0.01 | $0.01 | $0.01 |
| `apify-default-dataset-item` | $0.08 | $0.072 | $0.064 | $0.0536 |
| `watch-check` | $0.05 | $0.05 | $0.05 | $0.05 |

A small start fee, one item charge per funding round delivered, and a single `watch-check` per watch/delta run. Delivered before charged.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `all_sources` | `all_sources` (SEC + TechCrunch + YC best-effort), `sec_edgar`, `techcrunch`, or `yc_startups`. |
| `searchQuery` | string | — | Keyword or company to search across sources. |
| `minAmount` | integer | 0 | Keep only rounds at or above this USD amount (where an amount is known). |
| `daysBack` | integer | 30 | SEC filing-date window (1–365). |
| `maxResults` | integer | 25 | Maximum rounds delivered (1–500). |
| `newSinceLastRun` | boolean | false | **Watch/delta:** deliver only rounds new since the last run for this label. |
| `watchLabel` | string | mode | Namespace for the watch memory. |

### Output

One JSON object per funding round. Real example (SEC Form D):

```json
{
  "record_id": "sec:0001798621-26-000003",
  "source": "sec_edgar",
  "company_name": "Flo Artificial Intelligence, Inc.",
  "amount_usd": 13992757.0,
  "amount_display": "$13,992,757",
  "round_stage": "Reg D exempt offering (Form D)",
  "date": "2026-07-06",
  "industry": "Other Technology",
  "location": "Menlo Park, CA",
  "url": "https://www.sec.gov/Archives/edgar/data/1798621/000179862126000003/primary_doc.xml",
  "cik": "0001798621",
  "is_new": true,
  "observed_at": "2026-08-25T00:00:00Z"
}
```

A TechCrunch record carries the `title`, `date`, `amount_usd` (parsed from the headline), and `url` back to the article. An unbilled `RUN_RECEIPT` records the mode, watch settings, and how many rounds were found and delivered.

### Field reference

Each record carries `record_id` (source-prefixed), `source` (`sec_edgar` / `techcrunch` / `yc_startups`), `company_name`, `amount_usd` and `amount_display`, `round_stage`, `date`, `industry`, `location`, `title` (news items), `url` and `source_url`, `cik` (SEC), `batch` (YC), and `is_new` (set on watch runs). Provenance travels on every record: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

For the SEC source, the actor runs the EDGAR full-text search for Form D filings in your date window (optionally narrowed by `searchQuery`), then fetches each matching filing's own Form D XML to read the total offering amount and industry — so the amount is the issuer's own reported figure, not a guess. For TechCrunch, it queries the public posts API for funding coverage and keeps only funding-relevant headlines, parsing the amount from the headline where present. Results are de-duplicated by a stable per-source id. On a watch run, the actor loads the memory for your `watchLabel`, drops anything already delivered, emits the rest marked `is_new`, and saves the updated memory. Each delivered round is charged; a watch run also bills one `watch-check`.

### Working with the data

Because SEC amounts come from the filing's own XML, `amount_usd` on a `sec_edgar` record is authoritative and directly filterable — `minAmount` lets you keep only rounds above a threshold. The `cik` is the SEC's permanent company identifier, a clean join key into any EDGAR-based dataset. Run `sec_edgar` mode for structured, amount-bearing rounds; run `techcrunch` for the narrative coverage; run `all_sources` for both. Schedule a watch run each morning and pipe the new rounds straight into a CRM or a Slack alert.

### Honest limitations

- **Public data, as filed and reported.** SEC amounts are the reported Form D total offering amount; news items carry the headline, date, and link, not the article text. Point-in-time public data, **not investment advice**.
- **YC is best-effort.** The YC company source depends on a public search key that is not always exposed keylessly; when it isn't, `yc_startups` degrades gracefully and the SEC and TechCrunch sources carry the run.
- **No person data.** Only company- and round-level facts are collected; no investor, signatory, or individual data is selected or emitted, even though Form D filings contain related-person sections.

### Use with AI agents and schedules

The output is flat JSON keyed by a stable `record_id`, so an agent can call this actor as a tool and reason over the rounds directly — "any new AI seed rounds over five million filed this week?" is answerable by running `sec_edgar` with a `minAmount` and a `daysBack`, then reading the results. Paired with a scheduler, the watch/delta mode turns the actor into a standing monitor: a daily run with `newSinceLastRun` on delivers only the fresh rounds, which pipe cleanly into a CRM, a Slack alert, or an agent's morning briefing. Because each run is bounded by `maxResults` and priced per delivered round, the cost of a standing funding watch is small and predictable.

### Differentiation

A **funding-round intelligence API** unifying SEC Form D exempt-offering filings (with real amounts) and TechCrunch funding coverage, upgraded with a first-class watch/delta mode that bills only new rounds since the last run. Keyless, pay-per-round, callable from code or an AI agent.

***

*Sources: US SEC EDGAR (Form D, public-domain US Government data) and TechCrunch (headlines/links). Reformatted to per-round records; values unmodified. Not investment advice. No natural-person data of any kind.*

# Actor input Schema

## `mode` (type: `string`):

Which sources to pull. all\_sources = SEC Form D + TechCrunch (+ YC best-effort).

## `searchQuery` (type: `string`):

Keyword or company to search across sources (optional).

## `minAmount` (type: `integer`):

Only keep rounds at or above this USD amount (applies where an amount is known).

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

How many days back to search (SEC filing date window).

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

Maximum funding rounds delivered.

## `newSinceLastRun` (type: `boolean`):

Watch/delta mode: deliver ONLY rounds not seen on a previous run for this watch label. Recurring runs bill recurring value.

## `watchMode` (type: `boolean`):

Alias for 'New rounds since last run'.

## `watchLabel` (type: `string`):

Namespace for the watch/delta memory (e.g. 'ai-seed'). Defaults to the mode.

## Actor input object example

```json
{
  "mode": "all_sources",
  "minAmount": 0,
  "daysBack": 30,
  "maxResults": 25,
  "newSinceLastRun": false,
  "watchMode": false
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "mode": "all_sources",
    "daysBack": 30,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/funding-round-intelligence-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 = {
    "mode": "all_sources",
    "daysBack": 30,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/funding-round-intelligence-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 '{
  "mode": "all_sources",
  "daysBack": 30,
  "maxResults": 25
}' |
apify call nexgensignal/funding-round-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/funding-round-intelligence-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/IPieP8aeWwHJ7Kgsk/builds/KDZcCNfDLNhhxg4sE/openapi.json