# SEC Form D Funding Feed (private offerings, parsed amounts) (`moment-data/sec-form-d-funding-feed`) Actor

Daily feed of new SEC Form D private-offering filings: issuer, state, industry, offering size, amount raised, investors, Rule 506(b)/(c) exemptions. Filter by industry, state and minimum raise. Official EDGAR data.

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

## Pricing

from $4.00 / 1,000 offering records

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: New Private Offerings with Parsed Amounts

Every startup, fund and private company that raises money under Regulation D must file a **Form D** with the SEC within 15 days of the first sale. This Actor turns those filings into a clean daily feed: **who raised, how much, from how many investors, under which exemption, in which state and industry**, straight from official SEC EDGAR data.

### Who uses it

- **VCs, angels and scouts:** spot new rounds (and new funds) the day they are filed; filter to your sectors, states and check sizes.
- **B2B sales and business development:** a company that just raised $5M is about to hire, buy software, lease space and run launches. Use fresh Form D filings as a buying signal for outbound.
- **Agencies, recruiters, banks, lawyers, accountants:** find newly funded companies in your region before competitors do.
- **Fund-formation and fintech research:** track new VC/PE/hedge fund vehicles, SPV series and 506(c) general-solicitation raises.
- **Journalists and analysts:** monitor private-capital activity by industry and state.

### What you get

- **Parsed, numeric amounts:** total offering amount, amount sold, remaining, % sold, minimum investment, number of investors (and non-accredited count), sales commissions and finder's fees. "Indefinite" amounts are flagged, not mixed into numbers.
- **Issuer profile:** name, CIK, entity type, jurisdiction and year of incorporation (with "within five years" flag), city, state and ZIP of the principal place of business, revenue or NAV range.
- **Offering details:** industry group and fund type, exemptions decoded to plain English (`Rule 506(b)`, `Rule 506(c)`, `Rule 504(b)(1)`, `Section 3(c)(1)`, `Section 3(c)(7)`, ...), security types, date of first sale, new vs amendment (with previous accession number), more-than-one-year flag.
- **Filters applied before you pay:** industry groups, issuer states, minimum offering amount, operating companies only (drop pooled funds/SPVs), exemptions, issuer name, include/exclude amendments.
- **Entity-only:** related-person names, addresses, signatures and phone numbers are dropped. You get company-level data only.
- **New since last run** mode for daily schedules: pay only for filings you have not received before.

### Quick start

1. Run with the defaults (`{}`) to get 30 Form D offerings from the latest EDGAR business day in a few seconds.
2. Narrow it down, for example startups raising $1M+ in tech and biotech:

```json
{
  "industryGroups": ["Technology", "Biotechnology", "Health Care"],
  "excludePooledFunds": true,
  "minOfferingAmount": 1000000,
  "includeAmendments": false,
  "maxItems": 200
}
```

3. **Schedule tip:** create an Apify Schedule that runs every weekday morning (for example 7:00 America/New_York, after EDGAR publishes the previous day's index at about 10 pm ET) with `"mode": "sinceLastRun"`, a unique `"stateKey"` and a higher `maxItems` (a busy day has 200-400 Form D filings). Each run then delivers only filings you have not seen. Connect a webhook, Google Sheets, Slack or Zapier/Make integration to get the leads where you work.

### Input

| Field | Meaning |
|---|---|
| `mode` | `window` (default, stateless) or `sinceLastRun` (**use for schedules**) |
| `daysBack` | Latest EDGAR business days to read, default 2 (weekends/holidays skipped automatically) |
| `includeAmendments` | Include Form D/A amendments, default true |
| `industryGroups` | Words matched against industry group / fund type, e.g. `Biotechnology`, `Other Technology`, `Real Estate`, `Venture Capital Fund` |
| `issuerStates` | Two-letter codes, e.g. `CA`, `NY`, `CO` (non-US issuers use EDGAR country codes) |
| `minOfferingAmount` | Minimum stated total offering (USD); "Indefinite" offerings are excluded when > 0 |
| `excludePooledFunds` | Operating companies only |
| `exemptions` | e.g. `506(b)`, `506(c)`, `504`, `3(c)(7)` |
| `issuerNameContains` | Issuer name words |
| `maxItems` | Cap per run (also caps your spend), default 30 |
| `maxFilingsToCheck` | Safety cap on documents inspected with narrow filters, default 1500 |
| `contactEmail` | Optional; added to the User-Agent sent to the SEC |
| `stateKey` | One key per saved search (sinceLastRun) |

### Output (example, a real record from Oct 30, 2026)

```json
{
  "issuerName": "ACRETRADER 306 LLC",
  "cik": 2157258,
  "formType": "D",
  "filingType": "new",
  "filingDate": "2026-10-30",
  "accessionNumber": "0002157258-26-000001",
  "entityType": "Limited Liability Company",
  "jurisdictionOfIncorporation": "ARKANSAS",
  "yearOfIncorporation": 2026,
  "incorporatedWithinFiveYears": true,
  "issuerCity": "FAYETTEVILLE",
  "issuerState": "AR",
  "industryGroup": "Other Real Estate",
  "isPooledInvestmentFund": false,
  "revenueRange": "No Revenues",
  "exemptionCodes": ["06c"],
  "exemptions": ["Rule 506(c)"],
  "isAmendment": false,
  "dateOfFirstSale": "2026-10-27",
  "securityTypes": ["Equity"],
  "totalOfferingAmount": 1734000,
  "offeringAmountIndefinite": false,
  "totalAmountSold": 1734000,
  "totalRemaining": 0,
  "percentSold": 100,
  "minimumInvestment": 15000,
  "hasNonAccreditedInvestors": false,
  "numberOfInvestors": 27,
  "salesCommissions": 0,
  "findersFees": 0,
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2157258/000215725826000001/0002157258-26-000001-index.htm",
  "primaryDocUrl": "https://www.sec.gov/Archives/edgar/data/2157258/000215725826000001/primary_doc.xml",
  "source": "SEC EDGAR daily form index + Form D primary_doc.xml",
  "firstSeenAt": "2026-10-31T06:55:19.637Z"
}
```

(Some fields shortened; see `sample-output.json` for the full record.) Every run also writes a summary (business days read, filings inspected, filtered, delivered) to the `OUTPUT` record.

### Timing you should know about

- EDGAR publishes the daily form index **nightly** (about 10 pm ET). A run picks up everything filed through the previous business day; weekends and federal holidays have no index and are skipped automatically.
- Form D is due within 15 days of the first sale, so `dateOfFirstSale` is often a few days to two weeks before `filingDate`.

### Data source and fair access

- Sources: the SEC EDGAR daily form index (`sec.gov/Archives/edgar/daily-index`) and each filing's `primary_doc.xml`. The SEC states that EDGAR public filing content is free to access and reuse ([SEC FAQ](https://www.sec.gov/about/webmaster-frequently-asked-questions)).
- The Actor follows the SEC's [fair access rules](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data): a declared User-Agent, about 6 requests per second (limit is 10), and backoff on errors.
- Not affiliated with or endorsed by the SEC. Form D data is self-reported by issuers and provided as filed; it is not investment advice.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `offering-record` | $0.004 | per Form D / D/A offering delivered (filings removed by your filters are free) |

A default test run (30 offerings) costs about $0.125. A filtered lead feed (tech + biotech, >= $1M) yields ~10-20 offerings/day, about $0.05-0.09/day. `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached, so you are never charged for more than you set. No separate platform-usage charges: compute is included in the event prices.

# Actor input Schema

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

window (default): matching Form D filings from the latest N EDGAR business days, no saved state. sinceLastRun: only filings not delivered before for this State key; use this for daily schedules.

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

How many of the latest EDGAR business days to read (weekends and holidays are skipped automatically). Also the first-run window in sinceLastRun mode.

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

Also deliver Form D/A amendments (updated amounts sold, investor counts). Turn off for new offerings only.

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

Keep offerings whose Form D industry group (or fund type) contains any of these words, e.g. Biotechnology, Other Technology, Health Care, Real Estate, Venture Capital Fund, Hedge Fund, Restaurants. Case-insensitive. Empty = all.

## `issuerStates` (type: `array`):

Two-letter state or country codes of the issuer's principal place of business, e.g. CA, NY, CO, TX. Empty = all.

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

Keep only offerings with a stated total offering amount of at least this much. Offerings marked 'Indefinite' are excluded when this is above 0.

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

Drop pooled investment funds (VC, PE, hedge, real-estate funds and SPV series) to keep startups and operating companies only.

## `exemptions` (type: `array`):

Keep offerings claiming any of these exemptions, e.g. 506(b), 506(c), 504, 3(c)(1), 3(c)(7). Empty = all.

## `issuerNameContains` (type: `array`):

Keep filings whose issuer name contains any of these words (case-insensitive).

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

Hard cap on delivered offerings (also caps your spend). Default is small so a first test run is quick and cheap; raise it for production (a typical business day has 200-400 Form D filings).

## `maxFilingsToCheck` (type: `integer`):

Safety cap on how many Form D documents are downloaded per run when narrow filters are used. You are only charged for delivered offerings.

## `contactEmail` (type: `string`):

SEC asks automated clients to declare a contact in the User-Agent. Optional: if set, it is added to the User-Agent sent to sec.gov.

## `stateKey` (type: `string`):

Name of the saved search for sinceLastRun mode. Each key keeps its own history, so use one key per schedule.

## Actor input object example

```json
{
  "mode": "window",
  "daysBack": 2,
  "includeAmendments": true,
  "minOfferingAmount": 0,
  "excludePooledFunds": false,
  "maxItems": 30,
  "maxFilingsToCheck": 1500,
  "stateKey": "default"
}
```

# Actor output Schema

## `offerings` (type: `string`):

One record per Form D or D/A filing.

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

Business days read, counts, filters.

# 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("moment-data/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("moment-data/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 moment-data/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,moment-data/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/wJwwd3GeEqW8DGlGA/builds/YRhKLvMfe7fOp4iqb/openapi.json