# Recently Funded Companies — SEC Form D Startup Funding Tracker (`viridian_layout_ea2/sec-form-d-funding-tracker`) Actor

Every US company that just raised money, from SEC Form D filings: ~290 new raises a week. Amount raised, industry, address, phone and the executives' names and titles. Filter by sector, state and amount; funds left out by default. Official SEC data, no login or proxies.

- **URL**: https://apify.com/viridian_layout_ea2/sec-form-d-funding-tracker.md
- **Developed by:** [CMM Research](https://apify.com/viridian_layout_ea2) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 filings

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?

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

## Recently Funded Companies — SEC Form D Startup Funding Tracker

See **every US company that just raised money**, usually within days of the raise. When a
company sells shares, SAFEs or notes in a private round, it must file a **Form D** with the
SEC within 15 days. This Actor reads those filings straight from the SEC and turns each one
into a clean lead record: the company, what it does, where it is, its phone number, how much
it raised, and the **names and titles of its executives**. About **290 operating companies
file each week**.

You don't need any coding, logins or proxies. Export to JSON, CSV or Excel, or schedule it to
get each week's new raises.

*Built and maintained by CMM Research.* Need a custom feed or a field we don't have?
Email us at <chazmichael_michaels@icloud.com>.

**Who uses it**

- **Sales teams.** A company that just raised has a new budget. Reach the CEO in the week
  the money lands, not months later when it shows up in a paid database.
- **Agencies, recruiters and service firms.** Freshly funded startups hire, build and buy
  software. Filter to Technology or Health Care in your state.
- **Investors and analysts.** Track who is raising, how much and on what terms (equity,
  debt or SAFEs), by sector and region.
- **Fund watchers.** Switch to *Investment funds only* to see new VC, private-equity and hedge
  funds being raised.

**A real result** (filed 13 Oct 2026):

```json
{
  "companyName": "ExBrain, Inc.",
  "filingType": "New",
  "filedAt": "2026-10-13",
  "firstSaleDate": "2025-11-24",
  "sector": "Technology",
  "industry": "Other Technology",
  "yearOfIncorporation": 2025,
  "city": "Austin",
  "state": "TX",
  "phone": "+1 415-813-0515",
  "totalOfferingAmount": 1000000,
  "totalAmountSold": 425000,
  "investorCount": 6,
  "securitiesOffered": ["Other: Simple Agreements for Future Equity (SAFEs)"],
  "exemptions": ["Rule 504(b)(1)"],
  "executives": [
    { "name": "Dena Neek", "roles": ["Executive Officer", "Director"], "title": "President and Chief Executive Officer", "city": "Austin", "state": "TX" },
    { "name": "Cyrus Neek", "roles": ["Executive Officer", "Director"], "title": "Secretary", "city": "Austin", "state": "TX" },
    { "name": "Afshin Sepehri", "roles": ["Executive Officer"], "title": "Chief Technology Officer", "city": "Austin", "state": "TX" }
  ],
  "executivesText": "Dena Neek (President and Chief Executive Officer); Cyrus Neek (Secretary); Afshin Sepehri (Chief Technology Officer)",
  "formUrl": "https://www.sec.gov/Archives/edgar/data/2160087/000216008726000001/xslFormDX01/primary_doc.xml"
}
```

Each record also has the street address and ZIP, the round's remaining amount, minimum
investment, brokers paid, and links to the filing. See **Output** below.

### Why this one

- **Operating companies only, by default.** About 6 in 10 Form D filings are investment
  funds, not businesses. They're left out unless you ask for them, so you don't pay for
  rows you'll delete.
- **New raises, not paperwork.** Yearly renewals and corrections (Form D/A) are left out by
  default, and a company that filed twice shows up once.
- **Executives with titles.** Every officer and director named on the form, with their
  title when the company gave one ("Chief Technology Officer"), plus a one-line
  `executivesText` that pastes straight into a CRM.
- **Fresh.** Filings appear here the same day the SEC receives them, small rounds included.
- **Official, public data.** It comes from the SEC's own EDGAR system, with a link to the
  original filing on every record.
- **Only what's new, on a schedule.** Turn on `onlyNewSinceLastRun` and schedule a weekly
  run: each run returns only the companies that search hasn't delivered before.
- **Pay only for what you get.** Filters run before charging, so filtered-out filings are
  never billed.

### Pricing

**$20 per 1,000 filings** ($0.02 per company), plus Apify's standard $0.00005 run-start fee.
On Apify's paid plans it's cheaper: $18 (Starter), $16 (Scale) or $14 (Business) per 1,000.
Platform usage is included, so you are not billed for compute separately. A full week of
new operating companies (about 290) costs about $5.80.

- **`maxResults`** is a hard cap per run (default 200).
- **Apify's maximum cost per run** also works: if the limit is reached mid-run, the Actor
  stops cleanly and keeps everything delivered so far.
- A whole week of new operating companies is about 290 records.

### Input

| Field | What it does |
|---|---|
| `daysBack` | How far back to look (default 7 days). |
| `filedFrom` / `filedTo` | An exact date range instead, YYYY-MM-DD. |
| `companyType` | Operating companies (default), investment funds only, or both. |
| `sectors` | Technology, Health Care, Real Estate, Financial Services, Energy, Business Services, Manufacturing, Retail, Restaurants, Travel, Agriculture, Other. |
| `states` | Business address in these US states, e.g. `["CA", "NY"]`. |
| `minAmountRaised` | Only filings reporting at least this much already raised (USD). |
| `minOfferingAmount` | Only rounds with at least this target size (USD). |
| `incorporatedWithinYears` | Only companies founded in the last N years. |
| `companyKeywords` | Company name contains, e.g. `["AI", "Therapeutics"]`. |
| `includeAmendments` | Also return Form D/A renewals and corrections. |
| `latestPerCompany` | One row per company (on by default). |
| `onlyNewSinceLastRun` / `monitorName` | Only filings this same search hasn't delivered before. |
| `maxResults` | Cap on results, and your main cost control. |

### Output

| Field | Description |
|---|---|
| `companyName` | Exactly as filed with the SEC |
| `cik` | The SEC's permanent company id |
| `filingType` | "New" or "Amendment" |
| `filedAt` | Date the SEC received the filing |
| `firstSaleDate` | Date of the round's first sale (`firstSaleYetToOccur` when it hasn't happened yet) |
| `sector` / `industry` | e.g. "Technology" / "Other Technology", as chosen by the company |
| `isFund` / `fundType` | Investment funds, and their type: Venture Capital, Private Equity, Hedge or Other |
| `entityType` / `jurisdiction` | e.g. "Corporation" / "DELAWARE" |
| `yearOfIncorporation` / `incorporatedWithin` | Year founded, or "Within five years" / "Over five years" when no year is given |
| `street` / `city` / `state` / `zipCode` / `stateOrCountryName` | Business address |
| `phone` | Company phone number |
| `totalOfferingAmount` / `offeringAmountIndefinite` | Round target in USD (null when "indefinite") |
| `totalAmountSold` / `totalRemaining` | Raised so far, and still to raise, in USD |
| `minimumInvestment` / `investorCount` / `nonAccreditedInvestorCount` | Round terms and investors so far |
| `securitiesOffered` | Equity, Debt, Options, SAFEs (as described), fund interests… |
| `exemptions` | e.g. "Rule 506(b)", "Rule 506(c)" (506(c) rounds may be publicly advertised) |
| `revenueRange` | When disclosed (most companies decline) |
| `executives` | Name, roles, title, city and state of each officer, director and promoter |
| `executivesText` | The same as one readable line |
| `salesBrokers` / `salesCommissions` / `findersFees` | Brokers paid on the raise, and what they were paid |
| `proceedsToExecutives` | Amount of the raise paid to executives, directors or promoters |
| `notes` | The company's own footnotes on amounts and investors |
| `filingUrl` / `formUrl` / `companyFilingsUrl` | The filing on EDGAR, the readable form, and all of the company's Form D filings |

### Examples

**Tech startups in California that raised $1M+ this month**

```json
{ "daysBack": 30, "sectors": ["Technology"], "states": ["CA"], "minAmountRaised": 1000000, "maxResults": 500 }
```

**Weekly lead list: health-care companies founded in the last 3 years (schedule weekly)**

```json
{ "daysBack": 7, "sectors": ["Health Care"], "incorporatedWithinYears": 3, "onlyNewSinceLastRun": true, "maxResults": 1000 }
```

**New venture capital funds being raised**

```json
{ "daysBack": 30, "companyType": "funds", "companyKeywords": ["venture", "ventures"] }
```

**Everything filed on one day, companies and funds, renewals included**

```json
{ "filedFrom": "2026-10-13", "filedTo": "2026-10-13", "companyType": "all", "includeAmendments": true, "latestPerCompany": false, "maxResults": 2000 }
```

### Use it from Claude, Cursor or any AI agent (MCP)

Apify's hosted MCP server lets an AI assistant run this Actor as a tool. It writes the
input from a plain-English request and reads back the results. Add this to your client's
MCP settings (Claude Desktop, Cursor, VS Code, Windsurf and others):

```json
{
  "mcpServers": {
    "form-d-funding": {
      "url": "https://mcp.apify.com?tools=viridian_layout_ea2/sec-form-d-funding-tracker"
    }
  }
}
```

The first time it connects, a browser window opens so you can sign in to Apify. If your
client can't do that, add `"headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }`.
You'll find your token under **Settings → API & Integrations** in Apify Console.

In Claude Code, run this once:

```bash
claude mcp add --transport http form-d-funding "https://mcp.apify.com?tools=viridian_layout_ea2/sec-form-d-funding-tracker"
```

Then ask in plain English, for example:

- *"Which tech startups in California raised $1M or more in the last 30 days? Sort by amount raised."*
- *"List health-care companies founded in the last 3 years that filed a Form D this week, with their executives."*
- *"Show me new venture capital funds that started raising this month."*

Runs started by an agent are billed exactly like any other run, at $20 per 1,000 filings
($14–$18 on paid Apify plans). Ask it to set `maxResults` if you want a hard cap.

### Notes

- **What Form D covers.** Private raises under Regulation D, the exemption most startups,
  real-estate deals and funds use. It doesn't include public offerings, Reg CF crowdfunding
  or every company that raises (some rely on other exemptions). Some companies file after
  their deadline, so a raise can appear weeks after its first sale.
- **Investors aren't named.** Form D lists the company's own executives and any paid
  brokers, not who invested.
- **Websites and emails aren't on the form.** The phone number and address are. Pair the
  output with an email-finder Actor if you need emails.
- The Actor follows the SEC's fair-access rules: it identifies itself and stays under 10
  requests per second. A week of filings takes about 2 minutes.
- `onlyNewSinceLastRun` remembers each search's delivered filings for 400 days in a
  key-value store named `form-d-funding-monitor` in your own Apify account. Filings cut off
  by `maxResults` or your spending limit are still delivered on the next run.
- The data is public: it is published by the US Securities and Exchange Commission. CMM
  Research isn't affiliated with the SEC.

# Actor input Schema

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

How far back to look. Companies must file Form D within 15 days of their first sale, so the last 7 days is the freshest view of who just raised.

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

About 6 in 10 Form D filings are investment funds (VC, private equity, hedge and real-estate funds). They are left out by default so you get operating companies.

## `sectors` (type: `array`):

Only companies in these sectors, as the company chose on the form. Leave empty for all.

## `states` (type: `array`):

Only companies whose business address is in these US states (two-letter codes). Leave empty for everywhere, including companies abroad.

## `minAmountRaised` (type: `integer`):

Only filings reporting at least this much already sold in the round, e.g. 1000000.

## `minOfferingAmount` (type: `integer`):

Only rounds whose stated target is at least this much. Rounds with no fixed size ("indefinite") are kept.

## `incorporatedWithinYears` (type: `integer`):

Only young companies: incorporated in the last N years. Good for finding startups.

## `companyKeywords` (type: `array`):

Only companies whose name contains one of these, e.g. "AI", "Therapeutics", "Labs".

## `includeAmendments` (type: `boolean`):

Also return Form D/A filings: yearly renewals and corrections of an earlier notice. Off by default, so you see new raises.

## `latestPerCompany` (type: `boolean`):

When a company filed more than once in the period, return only its newest filing.

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

For scheduled runs: skip every filing this same search has already delivered, so you never pay twice for the same company. The Actor remembers each search in a key-value store named <code>form-d-funding-monitor</code> in your account; changing any filter (other than the date range) starts a new history.

## `monitorName` (type: `string`):

Only needed to keep two searches with identical filters separate, e.g. one per client.

## `filedFrom` (type: `string`):

An exact start date, YYYY-MM-DD, instead of 'Filed in the last (days)'. SEC search covers filings from 2001 onwards.

## `filedTo` (type: `string`):

An exact end date, YYYY-MM-DD. Defaults to today.

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

Hard cap on results for the whole run, and your main cost control: you are charged per filing returned. Newest filings come first.

## Actor input object example

```json
{
  "daysBack": 7,
  "companyType": "companies",
  "sectors": [],
  "states": [],
  "companyKeywords": [],
  "includeAmendments": false,
  "latestPerCompany": true,
  "onlyNewSinceLastRun": false,
  "maxResults": 200
}
```

# Actor output Schema

## `filings` (type: `string`):

Every filing delivered, one record each: company, address, phone, amount raised, round details and executives.

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

Filings returned and scanned, the date range, and why the run stopped.

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

// Run the Actor and wait for it to finish
const run = await client.actor("viridian_layout_ea2/sec-form-d-funding-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("viridian_layout_ea2/sec-form-d-funding-tracker").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 '{}' |
apify call viridian_layout_ea2/sec-form-d-funding-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,viridian_layout_ea2/sec-form-d-funding-tracker"
        }
    }
}
```

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/jCLHVtAcrQRjONvIX/builds/8zKuRmfgGQKx7F76m/openapi.json