# SEC Form D New Private Raises Feed (`opendatalabs/sec-form-d-feed`) Actor

Parses Form D filings from the SEC's official EDGAR daily index into a structured feed of new private offerings: issuer, state, industry, amount offered and sold, exemption and investor count. Related persons and other individual personal data are excluded by design.

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

## Pricing

from $40.00 / 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 New Private Raises Feed

**Use it to** get a daily list of US companies and funds that just raised private money, straight from SEC Form D filings.

**Cost:** $40 per 1,000 filings delivered. Filings your filters remove are free, and a default run (10 filings) costs at most about $0.40.

**Why this one**

- **The whole form, parsed reliably.** Amounts offered and sold, minimum investment, investor count, exemptions in readable labels, security types, commissions and fees. Amendments, `Indefinite` offerings, weekends and holidays are all handled without failing the run.
- **Official EDGAR data, used politely.** It sends your own contact details as the SEC requires and stays under its rate limit.
- **No personal data.** Executive names and home addresses are never output.

**Sample output** (real run, filings dated Oct 13, 2026):

| issuerName | city, state | industryGroup | totalOfferingAmount | totalAmountSold | investors |
|---|---|---|---|---|---|
| 3LP Hill Valley Madison MM 1 LLC | Milwaukee, WI | Other Real Estate | $11,363,000 | $10,720,000 | 20 |
| A.G.P. Alternative Investment QP Fund LLC - Series 9 | New York, NY | Pooled Investment Fund | $25,000,000 | $11,285,900 | 109 |
| ATJustice, PBC | Pittsburgh, PA | Other | $500,000 | $360,000 | 12 |

A structured daily feed of new private securities offerings, parsed from the SEC's own EDGAR filings.

Every company or fund raising privately in the United States under Regulation D files a **Form D** with the SEC within 15 days of its first sale. This Actor reads EDGAR's official daily index, pulls each Form D, and turns it into a clean row: who is raising, where they are, what industry, how much they are offering, how much they have already sold, the minimum cheque, the exemption claimed, and how many investors are in.

**No personal data.** Form D also lists executives and directors by name and home address. This Actor never outputs any of it. See [What is deliberately excluded](#what-is-deliberately-excluded).

### What it does

- **Official source, no scraping.** Reads `https://www.sec.gov/Archives/edgar/daily-index/…/form.YYYYMMDD.idx` and each filing's `primary_doc.xml`. Public domain government data, no login, no HTML parsing.
- **Respects SEC fair access.** The EDGAR policy requires automated clients to declare themselves with a reachable contact address and caps traffic at 10 requests per second. This Actor sends a `User-Agent` built from **your** contact details, supplied through input, and is rate-limited to 7 requests/second by default with no burst allowance. There is no email address compiled into the Actor.
- **Parses the whole form.** Issuer identity and entity type, industry group, fund type, revenue or NAV band, exemption codes (expanded into readable labels), security types, offering and sold amounts, minimum investment, investor count, commissions and finders' fees.
- **Handles the awkward parts.** Amendments (`D/A`), offerings declared `Indefinite` rather than as a number, first sales that have not happened yet, and weekends and federal holidays where EDGAR publishes no index at all.
- **Filters server-side-ish.** State, industry, entity type, exemption, offering size and amount sold, all applied after parsing, with the run summary recording how many filings each filter removed.

### What is deliberately excluded

Form D's `relatedPersonsList` names executives and directors and frequently includes their **home** addresses. It is public, but it is still personal data about identifiable individuals. This Actor does not emit it, and that is not configurable.

Never output:

- `relatedPersonsList` — related-person names, addresses and relationship notes
- `signatureBlock` — signatory name, name of signer and signature title
- `primaryIssuer.issuerAddress.street1` / `street2` / `zipCode`
- `primaryIssuer.issuerPhoneNumber`
- `salesCompensationList` recipient names, CRD numbers and addresses — only a **count** is published as `salesCompensationRecipientCount`

The issuer's **city and state** *are* published. Those describe the issuing entity, are needed for the state filter, and are the standard geography field for this dataset. The street address is not.

The same exclusion list is written into every run's `RUN_SUMMARY` as `omittedPersonalDataFields`, so it is auditable rather than implicit, and it is asserted by the test suite against both fixtures and live filings.

### Input

Minimum viable input:

```json
{
  "contactEmail": "data-team@your-company.example"
}
```

That returns up to 10 filings (the default `maxFilings`), newest day first, from the last seven days, for at most about $0.40. Raise `maxFilings` to get everything in the window. A daily scheduled feed of venture-scale raises:

```json
{
  "contactEmail": "data-team@your-company.example",
  "organizationName": "Your Company LLC",
  "startDate": "2026-10-18",
  "endDate": "2026-10-19",
  "includeAmendments": false,
  "industryGroups": ["Technology", "Biotechnology", "Health Care"],
  "minAmountSold": 1000000
}
```

California 506(c) offerings over $5M:

```json
{
  "contactEmail": "data-team@your-company.example",
  "startDate": "2026-10-01",
  "endDate": "2026-10-19",
  "states": ["CA"],
  "exemptions": ["06c"],
  "minOfferingAmount": 5000000,
  "includeIndefiniteOfferings": false
}
```

#### Key settings

| Field | Default | Notes |
|---|---|---|
| `contactEmail` | — | **Required to fetch filings.** Sent in the `User-Agent`, as the SEC requires. Use a monitored address. If you leave it empty, the run makes no SEC requests, charges no filings, and returns one row (`errorKind: "missing_contact_email"`) explaining what to add. |
| `organizationName` | — | Also sent in the `User-Agent`, in front of the Actor name. |
| `startDate` / `endDate` | last 7 days | `YYYY-MM-DD`, inclusive. Weekends and holidays are skipped automatically. |
| `includeAmendments` | `true` | `D/A` filings report updated totals for an existing offering. |
| `states` | — | Two-character EDGAR codes (`CA`, `NY`, `X1`). |
| `industryGroups` | — | Case-insensitive substring match (`Technology`, `Pooled Investment Fund`). |
| `exemptions` | — | `06b` = Rule 506(b), `06c` = Rule 506(c), `05` = Rule 504, `3C.x` = fund exclusions. |
| `minOfferingAmount` / `maxOfferingAmount` / `minAmountSold` | — | USD. Indefinite offerings are governed by `includeIndefiniteOfferings`, not by these. |
| `requestsPerSecond` | `7` | The SEC ceiling is 10. The default leaves room for retries. |
| `maxFilings` | `10` | Filings delivered after your filters, newest day first. Keeps a first run at about $0.40 or less. EDGAR sees roughly 100–350 Form D filings on a typical business day, so raise it (e.g. 350) to get a full day. With filters, up to 100 filings are scanned per filing requested (minimum 500); filtered-out filings are free. |

### Output

One row per filing:

```json
{
  "issuerName": "12024 National Blvd Holdings LLC",
  "cik": "0002160256",
  "cikNumber": 2160256,
  "entityType": "Limited Liability Company",
  "jurisdictionOfIncorporation": "DELAWARE",
  "yearOfIncorporation": "2026",
  "incorporatedWithinFiveYears": true,
  "issuerCity": "IRVINE",
  "issuerStateOrCountry": "CA",
  "issuerStateOrCountryDescription": "CALIFORNIA",
  "industryGroup": "Residential",
  "revenueRange": "Decline to Disclose",
  "submissionType": "D",
  "isAmendment": false,
  "dateOfFirstSale": "2026-10-13",
  "offeringDurationOverOneYear": false,
  "securityTypes": ["Equity"],
  "federalExemptions": ["06b"],
  "exemptionLabels": ["Securities Act Rule 506(b)"],
  "minimumInvestmentAccepted": 50000,
  "totalOfferingAmount": 805555,
  "totalAmountSold": 805555,
  "totalRemaining": 0,
  "percentSold": 100,
  "hasNonAccreditedInvestors": false,
  "totalNumberAlreadyInvested": 11,
  "salesCommissionsUsd": 0,
  "findersFeesUsd": 0,
  "salesCompensationRecipientCount": 0,
  "filingDate": "2026-10-16",
  "accessionNumber": "0002160256-26-000003",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2160256/000216025626000003/0002160256-26-000003-index.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/2160256/000216025626000003/primary_doc.xml",
  "scrapedAt": "2026-10-19T01:39:16.402Z"
}
```

A fund with an indefinite offering looks like this instead:

```json
{
  "issuerName": "Harbour Line Capital Fund II LP",
  "entityType": "Limited Partnership",
  "industryGroup": "Pooled Investment Fund",
  "investmentFundType": "Venture Capital Fund",
  "aggregateNetAssetValueRange": "$25,000,000 - $50,000,000",
  "submissionType": "D/A",
  "isAmendment": true,
  "totalOfferingAmountIsIndefinite": true,
  "totalAmountSold": 41250000,
  "totalNumberAlreadyInvested": 63,
  "securityTypes": ["Equity", "Pooled investment fund interests"],
  "exemptionLabels": ["Securities Act Rule 506(b)", "Investment Company Act Section 3(c)", "Section 3(c)(1)"]
}
```

The dataset ships three views: **New raises**, **Deal terms** and **Funds**.

### Use cases

- **VC and PE deal sourcing.** A daily list of companies that just started raising, filtered to your sectors and geography, with the amount and investor count.
- **"They just raised" sales triggers.** Newly funded companies buy software. Filter by state and industry and route straight into your CRM.
- **Fintech and lender lead generation.** Entity type, jurisdiction, offering size and whether non-accredited investors are involved.
- **Fund tracking.** Filter to `Pooled Investment Fund` and watch new vehicles and their NAV bands appear.
- **Market research and journalism.** Aggregate raise counts and amounts by state, industry or exemption over any date range.

### Limits and things to know

- **A contact email is mandatory to fetch filings.** The SEC's fair-access policy requires it, and EDGAR blocks traffic it cannot trace. Placeholder and malformed addresses are rejected by input validation. With no address at all, the run makes no SEC requests, charges no filings, and finishes with one guidance row (`errorKind: "missing_contact_email"`).
- **Form D is self-reported.** Issuers fill it in themselves. Amounts, industry group and investor counts are their claims, not audited figures.
- **A Form D is not always a venture round.** Real-estate syndications, funds and SPVs file Form D too. Use `industryGroups` and `entityTypes` to narrow it.
- **Filings arrive within 15 days of first sale**, so `dateOfFirstSale` can be meaningfully earlier than `filingDate`.
- **Amendments restate the same offering.** With `includeAmendments: true`, one raise can appear several times across dates. Deduplicate on `cik` plus `accessionNumber` prefix, or set `includeAmendments: false`.
- **No index on weekends, federal holidays or future dates.** EDGAR answers those with HTTP 403 rather than 404; the Actor reports them as unavailable days in the run summary, not as errors.
- **Today's index appears after EDGAR's daily dissemination finishes.** An early-morning run can legitimately find nothing for today.
- **Rate limit is a hard ceiling.** Raising `requestsPerSecond` to 10 removes the retry margin under the SEC's published cap.

### Pricing events

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run (per GB of memory). |
| `filing` | **$0.04** ($40 per 1,000) | One Form D filing was written to the dataset. |

Examples: a default run (`maxFilings` 10) costs at most about **$0.40**. A full business day of roughly 100–350 filings, unfiltered, costs about **$4–$14**; filters cut that, because only delivered filings are charged. A run without a contact email returns one guidance row and costs only the start fee.

Filings removed by your state, industry, exemption or offering-size filters were downloaded and parsed, but you did not ask to receive them, so they are not charged. Rows describing a filing that could not be parsed are not charged either.

When the run reaches your maximum total charge it stops cleanly: it writes the filings it could pay for and records the reason in `RUN_SUMMARY` rather than failing. `RUN_SUMMARY.charging` shows the units of work performed next to the units actually billed.

### FAQ

#### Why do I need to enter a contact email?

The SEC's EDGAR fair-access policy requires automated clients to identify themselves. The Actor sends your address in the request header and nothing else. Without it, the run makes no SEC requests, charges nothing for filings and returns one guidance row explaining what to add.

#### How do I get a daily feed of new raises?

Schedule the Actor once a day (Console > Schedules) with your filters, such as states and industry groups. Each run reads the latest EDGAR daily index, and you pay only for the filings that pass your filters.

#### Is every Form D a startup funding round?

No. Real-estate syndications, pooled funds and SPVs file Form D too. Use `industryGroups` and `entityTypes` to keep only the kinds of issuers you care about.

#### Does it include founders' or executives' names?

No. Form D lists related persons by name and often home address. This Actor never outputs them, by design.

#### Can I send new filings to my CRM or Slack?

Yes. Use Apify's integrations (Slack, Google Sheets, Zapier, Make, n8n, webhooks) or the API to forward each scheduled run's dataset.

### Feedback

This Actor is new and actively maintained. If a run fails, a field is missing, or a result looks wrong, please open an issue on the **Issues** tab with the run ID. We read and reply to every issue, and suggestions for new filters or fields are very welcome.

# Actor input Schema

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

The SEC's EDGAR fair-access policy requires automated clients to identify themselves with a reachable contact address, which is sent in the User-Agent header on every request. This Actor has no email compiled into it. Use an address you actually monitor; the SEC blocks traffic that it cannot trace. If you leave this empty, the run makes no SEC requests, charges no filings, and returns one row explaining what to add.

## `organizationName` (type: `string`):

Also sent in the User-Agent, in front of the Actor name, so the SEC can see which company the traffic belongs to.

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

First filing date to include, as YYYY-MM-DD. Defaults to seven days ago. EDGAR publishes an index only on business days; weekends and federal holidays are skipped automatically rather than reported as errors.

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

Last filing date to include, as YYYY-MM-DD, inclusive. Defaults to today. Today's index appears after EDGAR's daily dissemination finishes, so an early-morning run may legitimately find nothing for today.

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

Amendments report updated totals for an offering already filed. Keep them to track how a raise fills up over time; turn them off for a clean feed of first-time filings only.

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

Two-character EDGAR codes for the issuer's own state or country, for example CA, NY, TX or DE. Non-US issuers use codes such as X1. Leave empty for everywhere.

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

Case-insensitive substring match against the Form D industry group, for example Technology, Pooled Investment Fund, Real Estate, Health Care or Biotechnology. Leave empty for every industry.

## `entityTypes` (type: `array`):

Case-insensitive substring match on the issuer's entity type, for example Corporation, Limited Partnership or Limited Liability Company.

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

Form D item codes. 06b is Rule 506(b) (no general solicitation), 06c is Rule 506(c) (general solicitation allowed), 05 is Rule 504, and 3C.x are Investment Company Act section 3(c) exclusions used by funds.

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

Drops filings whose stated total offering is below this. Filings that declare an indefinite offering have no number to compare and are governed by the indefinite-offerings switch instead.

## `maxOfferingAmount` (type: `integer`):

Drops filings whose stated total offering is above this. Useful for screening out large institutional raises when you are looking for early-stage companies. Like the minimum, it is only applied to filings that state a number, so indefinite offerings are governed by the indefinite-offerings switch instead.

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

Useful for filtering out shell filings that have raised nothing yet.

## `includeIndefiniteOfferings` (type: `boolean`):

Pooled investment funds often file an 'Indefinite' total offering amount instead of a number. Keep them in unless you are strictly screening by raise size.

## `maxFilings` (type: `integer`):

Maximum number of Form D filings delivered (after your filters), newest days first. EDGAR sees roughly 100 to 350 Form D filings on a typical business day. With filters, up to 100 filings are scanned per filing requested (at least 500); scanned filings that your filters remove are free. The default of 10 caps a first run at about $0.40 ($0.04 per filing delivered); raise it (for example to 300) for a full business day.

## `requestsPerSecond` (type: `integer`):

Hard rate ceiling, enforced by a token bucket with no burst allowance. The SEC's published limit is 10 per second; the default of 7 leaves room for retries without crossing it. Raising this to 10 removes that margin.

## `concurrency` (type: `integer`):

How many filings are fetched in parallel. The requests-per-second ceiling still applies on top of this.

## `outputFailedFilings` (type: `boolean`):

Emits a row with ok=false, the accession number and the reason, so a gap in the feed is visible rather than silent.

## `maxRetries` (type: `integer`):

Total attempts, including the first. Retries back off exponentially with jitter and honour Retry-After, which matters here because EDGAR throttles clients that exceed its fair-access limits. Only transient failures are retried; a missing filing is not.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single EDGAR request before giving up on that attempt. A daily index listing several thousand filings is the largest download in a typical run.

## Actor input object example

```json
{
  "contactEmail": "data-team@your-company.example",
  "organizationName": "Your Company LLC",
  "includeAmendments": true,
  "states": [
    "CA",
    "NY",
    "MA"
  ],
  "industryGroups": [
    "Technology",
    "Biotechnology"
  ],
  "entityTypes": [
    "Corporation"
  ],
  "exemptions": [
    "06b",
    "06c"
  ],
  "minOfferingAmount": 1000000,
  "includeIndefiniteOfferings": true,
  "maxFilings": 10,
  "requestsPerSecond": 7,
  "concurrency": 5,
  "outputFailedFilings": true,
  "maxRetries": 4,
  "requestTimeoutSecs": 45
}
```

# Actor output Schema

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

One row per parsed SEC Form D filing (issuer, offering size, amount sold, investors, related persons).

## `runSummary` (type: `string`):

Run summary: date range, index entries scanned, filings written/failed/filtered, stop reason and charged events.

# 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("opendatalabs/sec-form-d-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("opendatalabs/sec-form-d-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 opendatalabs/sec-form-d-feed --silent --output-dataset

```

## MCP server setup

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