# SEC Form D Funding Feed for Startup Funding Rounds (`verrr/sec-form-d-funding-feed`) Actor

New SEC Form D filings as a funding-signal feed. One clean JSON record per filing with issuer, amount raised and sold, first-sale date, industry group, location and revenue range. Operating companies by default, with filters for state, industry and offering size. Company-level data only.

- **URL**: https://apify.com/verrr/sec-form-d-funding-feed.md
- **Developed by:** [VER RR](https://apify.com/verrr) (community)
- **Categories:** Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 form d filings

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

SEC Form D funding feed: the latest startup funding rounds and private offerings from EDGAR as one clean JSON record per filing, with issuer, amount raised and sold, first-sale date, industry group and location.

Companies raising money under Regulation D file a Form D with the SEC. This Actor reads the SEC's own daily index, parses each filing and hands you the company-level facts in one fixed shape. Pooled funds and amendments are left out unless you ask for them, so a plain run shows operating companies with new offerings.

### What data you get

- `accessionNumber`: the SEC's unique filing ID
- `formType`, `isAmendment`, `previousAccessionNumber`: `D` for a new offering, `D/A` for an amendment and the filing it amends
- `filedDate`: the date filed, `YYYY-MM-DD`
- `cik`, `issuerName`, `entityType`, `jurisdictionOfInc`: who is raising
- `yearOfInc`, `companyAge`: the year, given only for companies under five years old, and `withinFiveYears`, `overFiveYears` or `yetToBeFormed`
- `city`, `state`, `stateName`, `zipCode`: where the issuer is based; `state` is the two-character EDGAR state or country code and `stateName` its name
- `industryGroup`, `investmentFundType`: the Form D industry group and, for funds, the fund type
- `revenueRange`, `netAssetValueRange`: the size band the issuer chose to disclose
- `securityTypes`, `otherSecurityDescription`: what is being sold, such as `Equity`, `Debt` or a described SAFE
- `federalExemptions`: the exemptions claimed, such as `06b` for Rule 506(b)
- `dateOfFirstSale`, `firstSaleYetToOccur`: when selling started
- `totalOfferingAmount`, `offeringAmountIndefinite`, `totalAmountSold`, `totalRemaining`: the raise in USD; amounts are null when the issuer filed "Indefinite"
- `minimumInvestment`, `totalInvestors`, `hasNonAccreditedInvestors`: investor facts
- `filingUrl`: the filing on EDGAR

Every record has every key. A value the filing does not give is null.

### Input

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `maxItems` | integer | no | 25 | Stop after this many filings, newest filing day first. Also caps your spend |
| `includeFunds` | boolean | no | false | Also return pooled investment funds. Ignored when you pick industry groups |
| `includeAmendments` | boolean | no | false | Also return D/A amendments, which are often yearly renewals |
| `industryGroups` | array | no | empty | Keep only these Form D industry groups |
| `states` | array | no | empty | Keep only issuers based here, by two-character EDGAR code |
| `minOfferingUsd` | integer | no | 0 | Keep only offerings of at least this amount. Above 0 this drops indefinite amounts |
| `daysBack` | integer | no | 5 | Filing days to scan back when filters are narrow. Weekends and holidays do not count |
| `onlyNew` | boolean | no | false | Return only filings not returned by an earlier run with the same filters |

With no input at all you get 25 new filings from operating companies, starting with the latest filing day. EDGAR's index has no time of day, so these are the first 25 of that day by issuer name, not the 25 most recent by time. To get a whole day, set `maxItems` above its volume: roughly 70 new operating-company filings, or over 300 with funds and amendments.

### Pricing

Pay-Per-Event:

| Event | Price |
|---|---|
| `form-d-filing` | $4.50 per 1,000 filings ($0.0045 each) |
| `apify-actor-start` | $0.00005 per run |

You pay only for filings returned. Filings your filters drop are never charged, and a run stops cleanly at your spending limit.

### Sample output

```json
{
  "accessionNumber": "0002019875-26-000003",
  "formType": "D",
  "isAmendment": false,
  "previousAccessionNumber": null,
  "filedDate": "2026-11-04",
  "cik": "0002019875",
  "issuerName": "AI3 Bio, Inc.",
  "entityType": "Corporation",
  "jurisdictionOfInc": "DELAWARE",
  "yearOfInc": null,
  "companyAge": "overFiveYears",
  "city": "Watertown",
  "state": "MA",
  "stateName": "MASSACHUSETTS",
  "zipCode": "02472",
  "industryGroup": "Biotechnology",
  "investmentFundType": null,
  "revenueRange": "Decline to Disclose",
  "netAssetValueRange": null,
  "securityTypes": ["Equity"],
  "otherSecurityDescription": null,
  "federalExemptions": ["06b"],
  "dateOfFirstSale": "2026-06-09",
  "firstSaleYetToOccur": false,
  "totalOfferingAmount": 48339490,
  "offeringAmountIndefinite": false,
  "totalAmountSold": 48339490,
  "totalRemaining": 0,
  "minimumInvestment": 0,
  "totalInvestors": 8,
  "hasNonAccreditedInvestors": false,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/2019875/000201987526000003/0002019875-26-000003-index.htm"
}
```

### Integrations

Call it from n8n, Make or Zapier, or via the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/VERRR~sec-form-d-funding-feed/runs?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "states": ["<state-code>"], "onlyNew": true }'
```

For a daily feed, turn on `onlyNew`, schedule the run after 10 pm US Eastern, and set `maxItems` above your daily volume. The default of 25 cannot keep up with a full day: each run carries on from where the last one with the same filters stopped, so a low cap falls further behind every day. The run warns in its log and status when that happens.

### Use cases

- Find newly funded companies for sales prospecting, by state, industry or raise size
- Track startup funding rounds and private placements as they are filed
- Feed new Regulation D offerings into a CRM or a deal-flow sheet
- Watch one sector, such as biotechnology, for fresh capital raises
- Monitor new hedge, venture and private equity funds with `includeFunds`

### Limits and FAQ

- **How fresh is it?** It reads EDGAR's daily index, published around 10 pm US Eastern each filing day, so a day's filings appear that night, not during the day.
- **In what order do filings come?** Newest filing day first, and with `onlyNew` oldest new day first. The index has no time of day, so order within a day is by issuer name.
- **Does it include founders or executives?** No. Output is company-level only: related persons, signers, sales recipients, street addresses and phone numbers are left out. For those, open `filingUrl`.
- **What about filings with several issuers?** You get one record for the primary issuer.
- **Is the amount money already raised?** `totalAmountSold` is what the issuer reports as sold so far. `totalOfferingAmount` is the size of the offering.
- **How fast is it?** About 4 filings a second, because it stays well under the SEC's limit of 10 requests a second. A filter is applied after a filing is read, so narrow filters take longer.
- **Do I need a proxy?** No. There is no login or API key either.
- **What if the SEC limits requests?** The run ends cleanly, keeps what it saved and says why in the log. The SEC lifts such a limit after about 10 minutes.
- **What if one filing cannot be read?** It is skipped with a warning and you are not charged. With `onlyNew` it is held and tried again on each run until 5 more filing days are published. If it still cannot be read, it is dropped with an error in the log and the feed never returns it. While one is held, a run that saves nothing ends as failed, even if that filing would not have matched your filters, because it cannot be read to check.
- **What if the format changes?** This Actor is monitored weekly and repaired automatically.

### Legal note

This Actor collects publicly available data only, from the SEC's public EDGAR files, and declares itself to the SEC as an automated tool. You are responsible for using the output in compliance with applicable laws and the target site's terms. This Actor is not affiliated with the SEC.

# Actor input Schema

## `maxItems` (type: `integer`):

Stop after this many filings. Filing days are read newest first, and within a day by issuer name, so a low maximum stops partway through the alphabet: EDGAR's index has no time of day, so this is not the most recent filings by time. A filing day holds roughly 70 new operating-company filings, or over 300 with funds and amendments. Each saved filing is billed once, so this also caps your spend.

## `includeFunds` (type: `boolean`):

Off returns operating companies only. Hedge, private equity and venture funds and their SPVs file most Form Ds, so turn this on only if you want them. Ignored when you pick industry groups.

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

Off returns new offerings only. On also returns D/A filings, which update an existing offering and are often yearly renewals rather than new funding.

## `industryGroups` (type: `array`):

Keep only these Form D industry groups. Leave empty for all.

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

Keep only issuers based in these places, by two-character EDGAR code: the postal code for a US state or Canadian province, the EDGAR country code otherwise. Leave empty for all.

## `minOfferingUsd` (type: `integer`):

Keep only offerings of at least this total amount. Above 0 this also drops offerings filed with an indefinite amount, because they state no number.

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

How many EDGAR filing days to scan back from the latest one before giving up on reaching the maximum. Weekends and holidays do not count. Raise it for narrow filters. Not used with "Only new filings".

## `onlyNew` (type: `boolean`):

Return only filings not returned by an earlier run with the same filters. The first run starts at the latest filing day. Later runs go forward from there, oldest day first, picking up where a run stopped at the maximum or a spending limit. Set the maximum above your daily volume or the feed falls behind; the run warns when it does. A filing EDGAR cannot serve is retried until 5 more filing days are published, then dropped with an error in the log. While one is waiting, a run that saves nothing ends as failed, even if that filing would not have matched your filters. Use it for scheduled runs.

## Actor input object example

```json
{
  "maxItems": 25,
  "includeFunds": false,
  "includeAmendments": false,
  "industryGroups": [],
  "states": [],
  "minOfferingUsd": 0,
  "daysBack": 5,
  "onlyNew": false
}
```

# Actor output Schema

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

All filings returned by the run: issuer, offering amounts, dates, industry group, location and a link to the filing on EDGAR.

# 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("verrr/sec-form-d-funding-feed").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("verrr/sec-form-d-funding-feed").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 verrr/sec-form-d-funding-feed --silent --output-dataset

```

## MCP server setup

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

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/Sapw9obqEKccF0g5w/builds/zItJrmta7goRnVCwu/openapi.json