# Recently Funded Companies: SEC Form D Funding Feed (`steadyline/sec-form-d-funded-companies`) Actor

Daily feed of companies that just raised money, from official SEC Form D filings: amount raised, offering size, first-sale date, industry, city/state, executives and directors, website and filing link. Filter by state, industry and amount; funds excluded by default. By Steadyline Data.

- **URL**: https://apify.com/steadyline/sec-form-d-funded-companies.md
- **Developed by:** [Steadyline Data](https://apify.com/steadyline) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 funded company (form d filing)s

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?

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 API: SEC Form D funding feed (startup funding leads)

**Get a daily list of US companies that just raised money, straight from official SEC Form D filings: amount raised, round size, date of first sale, industry, city and state, executives, directors and promoters, website and a link to the filing.**

Every company that sells securities under Regulation D (most private startup rounds, SAFEs, convertible notes, private-equity and real-estate raises) must file a Form D with the SEC within 15 days of the first sale. This Actor reads those filings from SEC EDGAR's free public endpoints, parses the structured XML, filters them the way you want (state, industry, minimum amount, funds excluded by default) and returns one clean row per filing. No login, no API key, no proxies.

Built and maintained by **Steadyline Data**.

### Use cases

- **Sales prospecting:** companies that just closed a round have budget. Reach them in the first weeks after the raise, when they buy tools and hire.
- **Recruiting and staffing:** freshly funded startups hire next. Get a daily list of new seed and Series A raises in your state or industry.
- **Investor and VC deal flow:** see who raised, how much, from which state and sector, and who sits on the board.
- **Market research:** track funding activity by industry group, state or round size over time.
- **Service providers:** banks, insurers, accountants, lawyers, office and HR vendors targeting newly funded companies.
- **CRM enrichment:** add "raised $X on date Y" to accounts you already track, with the SEC filing as proof.

### Why use it

- **Official source, fresh every day.** Data comes directly from SEC EDGAR (daily Form D index + each filing's `primary_doc.xml`). Every row links to the filing on sec.gov.
- **Operating companies, not funds.** About a third of Form D filings are VC, PE, hedge or real-estate funds. They are excluded by default, so the feed is companies.
- **Filters that save money.** State, industry group or whole sector, minimum amount raised, minimum offering size, first-sale date. Only rows that pass are charged.
- **People as filed.** Executive officers, directors and promoters with their roles, exactly as listed publicly in the filing.
- **Website when it can be found.** From the company's SEC profile, or a conservative name match that is verified on the company's homepage. Left blank rather than guessed.
- **Ready for enrichment.** Feed `websiteDomain` into our contact, domain and tech-stack Actors (recipes below).
- **Polite to the SEC.** Descriptive User-Agent and at most 10 requests per second, as SEC fair-access rules require.

### Input

| Field | What it does | Default |
|---|---|---|
| `lastNDays` | Rolling window of filing dates ending today (US Eastern). Great for daily or weekly schedules. | 7 |
| `startDate` / `endDate` | Exact filing-date range (YYYY-MM-DD). Overrides `lastNDays`. Up to 400 days per run. | – |
| `excludePooledFunds` | Skip filings whose industry group is "Pooled Investment Fund". | `true` |
| `states` | 2-letter state codes or names, e.g. `["CA", "NY", "Texas"]`. | all |
| `industries` | Form D industry groups (e.g. `Biotechnology`, `Other Technology`) or whole sectors (`Technology`, `Health Care`). | all |
| `minAmountSold` | Minimum amount already raised, in USD. | 0 |
| `minOfferingAmount` | Minimum total round size, in USD ("Indefinite" offerings are kept). | 0 |
| `firstSaleOnOrAfter` | Skip older offerings that are only being filed now. | – |
| `includeAmendments` | Also return Form D/A amendments. | `false` |
| `maxResults` | Stop after N rows. 0 = no limit. | 100 |
| `lookupWebsite` / `guessWebsite` | Website from the SEC profile / verified name match. | on |

Example: tech and health-care companies in California or New York that raised $1M+ in the last 14 days:

```json
{
    "lastNDays": 14,
    "states": ["CA", "NY"],
    "industries": ["Technology", "Health Care"],
    "minAmountSold": 1000000,
    "excludePooledFunds": true,
    "maxResults": 200
}
```

### Output

One row per Form D filing, newest filing date first. Main fields:

| Field | Description |
|---|---|
| `companyName`, `cik` | Issuer name and SEC Central Index Key |
| `city`, `state`, `stateName`, `street`, `zipCode`, `phone` | Principal place of business, as filed |
| `industryGroup`, `industrySector` | Form D Item 4 industry group and its sector |
| `totalOfferingAmount`, `totalAmountSold`, `totalRemaining` | Round size and money raised so far (USD; `offeringAmountIndefinite` when no cap) |
| `dateOfFirstSale`, `filingDate` | When the first investor money came in, and when the Form D was filed |
| `relatedPersons`, `relatedPersonsText` | Executive officers, directors and promoters with roles, as listed in the filing |
| `website`, `websiteDomain`, `websiteSource`, `websiteConfidence` | Issuer website if derivable, otherwise blank |
| `filingUrl`, `formUrl`, `xmlUrl` | Links to the filing index, the readable Form D and the raw XML |
| also | `entityType`, `jurisdictionOfInc`, `yearOfInc`, `securitiesOffered` (equity, debt, SAFE…), `federalExemptions` (Rule 506(b), 506(c)…), `numberOfInvestors`, `minimumInvestment`, `revenueRange`, `isAmendment`, `signerName`, `signerTitle` |

A real row from a test run (people list shortened):

```json
{
  "companyName": "General Compute Inc.",
  "cik": "2162999",
  "state": "CA",
  "stateName": "California",
  "city": "San Francisco",
  "industryGroup": "Other Technology",
  "industrySector": "Technology",
  "totalOfferingAmount": 132224819,
  "totalAmountSold": 132224819,
  "dateOfFirstSale": "2026-10-14",
  "filingDate": "2026-10-30",
  "formType": "D",
  "relatedPersonsText": "Finn Puklowski (Executive Officer, Director, Promoter); Jason Goodison (Executive Officer, Director); James Palmer (Director)",
  "website": "https://www.generalcompute.com",
  "websiteDomain": "generalcompute.com",
  "websiteSource": "domain-match",
  "websiteConfidence": "medium",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/2162999/000216299926000001/0002162999-26-000001-index.htm",
  "securitiesOffered": ["Equity"],
  "federalExemptions": ["Rule 506(b)"]
}
```

Dataset views: **Funded companies** (overview), **Leads (with website)** and **All fields**. A `RUN_SUMMARY` record in the run's key-value store shows days scanned, filings listed and parsed, counts filtered by reason, websites found and the number of SEC requests.

#### About the website field

Form D has no website field. The Actor fills it in two ways:

1. **`sec-profile`:** the website on the company's public SEC EDGAR profile, when the company has listed one.
2. **`domain-match`:** if the profile has none, it tries `<name>.com/.io/.ai/.co`. A domain is kept only if the homepage title names the company, the page is not parked or for sale, and either the company's city or state appears on the page (`high`) or the name is distinctive, 10 or more letters (`medium`). Funds and generic SPV or real-estate names are skipped.

Anything that does not verify is left blank. Expect a website on roughly 10–30% of rows, more for venture-backed tech and health-care companies and fewer for real-estate vehicles.

### Pricing: cost per 1,000 funded companies

Pay per event, no subscription:

| Event | Price | Per 1,000 |
|---|---|---|
| Funded company (one Form D row that passed your filters) | $0.002 | **$2.00** |
| Actor start (Apify standard) | $0.00005 per run | – |

Filings that your filters drop, and filings that cannot be read, are never charged. A typical weekday has 150–300 Form D filings, roughly 100–200 after funds are excluded, so a daily all-US feed costs about **$0.20–$0.40 a day**. Set `maxResults` or a maximum cost per run to cap spend; the Actor stops cleanly when the cap is reached.

### Recipes: enrich funded companies with Steadyline Data tools

Run this Actor, collect `websiteDomain` from the rows that have one, and pass the domains to:

- [Website Contact Extractor](https://apify.com/steadyline/website-contact-extractor) for public business emails, phone numbers and social profiles (`startUrls`).
- [Domain Intel](https://apify.com/steadyline/domain-intel) for domain age (RDAP), DNS, SSL, SPF and DMARC (`domains`). A brand-new domain plus a fresh Form D is a strong "new startup" signal.
- [Tech Stack Detector](https://apify.com/steadyline/tech-stack-detector) to see the CMS, analytics, payments and other tools they use (`domains`).

**Python (`pip install apify-client`):**

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("steadyline/sec-form-d-funded-companies").call(run_input={
    "lastNDays": 7, "industries": ["Technology"], "minAmountSold": 500000, "maxResults": 300,
})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
domains = sorted({r["websiteDomain"] for r in rows if r.get("websiteDomain")})

contacts = client.actor("steadyline/website-contact-extractor").call(run_input={"startUrls": [f"https://{d}" for d in domains]})
intel = client.actor("steadyline/domain-intel").call(run_input={"domains": domains})
stack = client.actor("steadyline/tech-stack-detector").call(run_input={"domains": domains})

by_domain = {r["websiteDomain"]: r for r in rows if r.get("websiteDomain")}
for c in client.dataset(contacts["defaultDatasetId"]).iterate_items():
    print(c.get("site"), c.get("emails"), c.get("linkedin"))
```

**JavaScript (`npm i apify-client`):**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('steadyline/sec-form-d-funded-companies').call({ lastNDays: 3, states: ['CA'], maxResults: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const domains = [...new Set(items.map((r) => r.websiteDomain).filter(Boolean))];
const stack = await client.actor('steadyline/tech-stack-detector').call({ domains });
```

**No code:** create a saved Task of this Actor with a daily Schedule, then on the Task's **Integrations** tab add "Run Actor" (Actor-to-Actor integration) for Website Contact Extractor, Domain Intel or Tech Stack Detector, mapping `websiteDomain` from the dataset. Or use Make, Zapier or n8n to run the chain and push results to Google Sheets, HubSpot or Slack.

### Use it from AI agents (MCP), Zapier, Make, n8n or the API

**AI agents (Claude, Cursor, VS Code, ChatGPT and other MCP clients).** Add Apify's hosted MCP server with just this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steadyline/sec-form-d-funded-companies"
    }
  }
}
```

Sign in with Apify (OAuth) on first connect, or add an `Authorization: Bearer <APIFY_TOKEN>` header. Then ask your agent, for example:

> Use steadyline/sec-form-d-funded-companies to list biotech companies in Massachusetts that raised at least $2M in the last 30 days, with their directors and filing links.

**Zapier, Make and n8n.** Use the official Apify app: Zapier "Run Actor" action, Make "Run an Actor" module, or the n8n Apify node. Choose `steadyline/sec-form-d-funded-companies`, paste the input below, then use "Get dataset items" to send results to Google Sheets, Slack, a CRM or a database.

**API (any language).** Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyline~sec-form-d-funded-companies/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"lastNDays": 7, "minAmountSold": 1000000, "maxResults": 50}'
```

### FAQ

**What is a Form D?** A short notice filed with the SEC by companies raising money privately under Regulation D (Rule 504, 506(b) or 506(c)) or Section 4(a)(5). It lists the issuer, its industry, the offering size, the amount sold, the date of first sale and the company's executive officers, directors and promoters.

**How fresh is the data?** SEC publishes each business day's Form D index in the evening (US Eastern), so a daily morning schedule picks up the previous day's filings. Weekends and federal holidays have no filings.

**Why is the amount raised 0?** Some companies file before or right at the first sale, or file for a round that is still open. `totalOfferingAmount` shows the target; `firstSaleYetToOccur` is true when no money has come in yet.

**Is the date of first sale the funding date?** It is the date the first investor money was received in this offering. Filters on `filingDate` (range) and `dateOfFirstSale` (`firstSaleOnOrAfter`) are both available.

**Does it include crowdfunding (Form C) or IPOs?** No. Only Form D (and optionally D/A).

**Can I get older filings?** Yes. Set `startDate`/`endDate` (up to 400 days per run; split longer ranges). EDGAR electronic Form D filings go back to 2009.

**Why do some names look like "XYZ 306 LLC" or "Series 23-1"?** Those are special-purpose vehicles and real-estate syndications that file Form D too. Use `industries`, `minAmountSold` or keep `excludePooledFunds` on to focus on operating companies.

### Legal and data note

This Actor uses only public SEC EDGAR data (the daily form index, Form D XML filings and EDGAR company profiles), accessed under SEC fair-access rules: a descriptive User-Agent with a contact address and at most 10 requests per second. Related-person names and roles are returned exactly as filed publicly with the SEC; their home addresses are not output. The optional website lookup reads only the public homepage of candidate domains. You are responsible for using the data in line with applicable laws (for example anti-spam and data-protection rules such as CAN-SPAM, GDPR and CCPA) when contacting anyone. Steadyline Data is not affiliated with the SEC.

# Actor input Schema

## `lastNDays` (type: `integer`):

Rolling window ending today (US Eastern), counted in calendar days. Ignored when a start date is set. SEC publishes each day's Form D index in the evening, so today's filings appear on the next run.

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

First filing date to include (YYYY-MM-DD). Overrides "last N days". Up to 400 days per run.

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

Last filing date to include (YYYY-MM-DD). Defaults to today. Filings are returned newest first.

## `excludePooledFunds` (type: `boolean`):

Skip Form Ds filed by VC, private equity, hedge and real-estate funds (industry group "Pooled Investment Fund"), so the feed is operating companies. About a third of all Form D filings are funds. Turn off to research fund raises.

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

Keep issuers whose principal place of business is in one of these. Use 2-letter US state codes (CA, NY, TX) or the full name (California). Leave empty for all, including non-US issuers.

## `industries` (type: `array`):

Keep only these Form D industry groups (Item 4). Pick a whole sector (e.g. "Technology" = Computers + Telecommunications + Other Technology) or single groups. Leave empty for all.

## `minAmountSold` (type: `integer`):

Keep filings whose "Total Amount Sold" (money already raised in this offering) is at least this many US dollars. Example: 1000000 for $1M+. 0 = no minimum.

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

Keep filings whose "Total Offering Amount" (the round size the company is targeting) is at least this much. Offerings marked "Indefinite" are kept. 0 = no minimum.

## `firstSaleOnOrAfter` (type: `string`):

Skip older offerings that are only being filed or re-filed now: keep filings whose date of first sale is on or after this date (YYYY-MM-DD).

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

Also return amended filings (Form D/A), which update an earlier offering (e.g. more money sold). Off = only new notices of a raise.

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

Stop after this many filings are written (and charged). Keeps cost predictable. 0 = no limit (a typical weekday has 150 to 300 Form D filings).

## `lookupWebsite` (type: `boolean`):

Form D has no website field. When on, the Actor reads the company's public SEC EDGAR profile and uses the website listed there (websiteSource = "sec-profile"). Most private companies list none. One extra SEC request per kept company; no extra charge.

## `guessWebsite` (type: `boolean`):

If the SEC profile has no website, try <company>.com / .io / .ai / .co and keep a domain only when the homepage title names the company, the page is not parked or for sale, and either the issuer's city/state appears on the page (websiteConfidence = high) or the name is distinctive, 10+ letters (medium). websiteSource = "domain-match". Skipped for funds and generic SPV / real-estate vehicle names. Leaves the field blank when nothing verifies. No extra charge.

## `maxRequestsPerSecond` (type: `integer`):

Rate limit for all requests to sec.gov (shared across the run). SEC fair-access policy allows at most 10 per second; the Actor never exceeds that.

## Actor input object example

```json
{
  "lastNDays": 7,
  "excludePooledFunds": true,
  "minAmountSold": 0,
  "minOfferingAmount": 0,
  "includeAmendments": false,
  "maxResults": 25,
  "lookupWebsite": true,
  "guessWebsite": true,
  "maxRequestsPerSecond": 8
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per Form D filing, newest first.

## `leads` (type: `string`):

Company, people and website, ready to chain into contact / tech-stack enrichment.

## `full` (type: `string`):

Every field parsed from the filing.

# 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 = {
    "lastNDays": 7,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyline/sec-form-d-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 = {
    "lastNDays": 7,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("steadyline/sec-form-d-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 '{
  "lastNDays": 7,
  "maxResults": 25
}' |
apify call steadyline/sec-form-d-funded-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyline/sec-form-d-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/H9JDkrtPkDf42CfnN/builds/vNKtID8LyC0Ojj8Fo/openapi.json