# SEC Form D Filings Feed: New US Private Offerings (`cpt_engineering/form-d-private-offerings-feed`) Actor

Daily SEC Form D filings feed (private placements and startup funding under Reg D) from the official EDGAR index: issuer, state, industry, offering size, amount sold, investors, 506(b)/506(c) exemptions, placement agents and filing link. No personal names.

- **URL**: https://apify.com/cpt_engineering/form-d-private-offerings-feed.md
- **Developed by:** [Christopher Tolentino](https://apify.com/cpt_engineering) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.
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

## SEC Form D Filings Feed: New US Private Offerings

Get a **daily or weekly list of new Form D filings** (SEC private placements and startup funding rounds): the notices US companies and funds file with the SEC when they raise money privately under Regulation D (Rule 506(b), 506(c), 504) or Section 4(a)(5). Each filing comes back as **one clean record** with issuer, state, industry, offering size, amount sold, investor count, exemptions, date of first sale and a link to the filing. The data comes from the official SEC EDGAR daily index and each filing's structured Form D XML, so there is no web scraping.

**Last verified:** 2026-10-16 (daily automated self-test against live SEC EDGAR data).

**Who it's for**

- **Investors, lenders and service providers** looking for companies that just raised or are raising private capital.
- **Law, accounting and fund-administration firms, placement agents and B2B vendors** that follow new raises every week (a Form D is a sign a company has fresh capital to spend).
- **Market and fundraising research**: private-raise activity by state, industry, size, fund type or exemption.
- **Data pipelines and AI agents** that need Form D data in a fixed schema (JSON, CSV, Excel).

**What it does well**

- **Official source only**: EDGAR daily form index plus each filing's `primary_doc.xml`, read at a polite 5 requests per second (the SEC's fair-access limit is 10).
- **Filters that matter**: issuer state, industry sector or group, minimum offering size, minimum amount already sold, exemption (Rule 506(b), 506(c), 504), fund type (venture capital, private equity, hedge), young issuers only (formed within 5 years), issuer name keywords, new filings or amendments, and an option to drop investment funds and keep operating companies.
- **Placement agents**: the broker-dealer firms paid to sell the offering, as firm names only.
- **Scheduled feeds**: turn on *Only new since last run* and each run returns only filings it hasn't given you before.
- **Entity-level data only**: no names of executives, directors, promoters, signers or brokers (see *Data and privacy*).

**Why choose this Actor**
| | |
|---|---|
| Reliability | 20 of 20 runs succeeded since launch (Oct 16, 2026); reads EDGAR at 5 requests/second, under the SEC fair-access limit; throttling and server errors are retried with exponential backoff (up to 6 attempts) |
| Source | SEC EDGAR daily index + each filing's structured Form D XML (official, no scraping) |
| Repeat use | *Only new since last run* for daily or weekly schedules; new filings or amendments |
| Filters | Issuer state, industry, minimum offering size, minimum amount sold, exemption (506(b), 506(c), 504), fund type, young issuers, name keywords, operating companies only |
| Fields | Issuer, CIK, state, industry, offering size, amount sold, investors, exemptions, first-sale date, placement-agent firms, filing link |
| Compliance | Entity-level data only: no executive, director, promoter or signer names |
| Price | $5.00 per 1,000 filings, no start fee; filings that don't match your filters are free |

### Quick start

**New Form D filings from the last 7 days (default input):**

```json
{ "lastNDays": 7, "filingType": "new", "maxResults": 100 }
```

**Operating companies raising $1M+ in California and Texas, tech and health care:**

```json
{
  "lastNDays": 7,
  "states": ["CA", "TX"],
  "industrySectors": ["Technology", "Health Care"],
  "excludePooledFunds": true,
  "minOfferingAmountUsd": 1000000,
  "maxResults": 500
}
```

**Startup funding feed (operating companies formed in the last 5 years that already sold $250k+):**

```json
{ "lastNDays": 7, "excludePooledFunds": true, "onlyYoungIssuers": true, "minAmountSoldUsd": 250000, "maxResults": 200 }
```

**New venture capital funds being raised:**

```json
{ "lastNDays": 14, "investmentFundTypes": ["Venture Capital Fund"], "maxResults": 200 }
```

**Rule 506(c) offerings (issuers allowed to advertise to accredited investors):**

```json
{ "lastNDays": 7, "exemptions": ["506c"], "maxResults": 200 }
```

**Weekly feed:** save the input as a task with *Only new since last run* on, add a schedule (for example Mondays 9:00 ET), and export to CSV or Google Sheets, or connect a webhook (`ACTOR.RUN.SUCCEEDED`) to your CRM, Zapier, Make or n8n. Latest results by API: `https://api.apify.com/v2/actor-tasks/<TASK_ID>/runs/last/dataset/items?format=csv&status=SUCCEEDED`.

**Backfill:** set *Filed on or after* and *Filed on or before*, for example `2026-09-01` to `2026-09-30`.

### What you get

| Field | Description |
|---|---|
| `issuer_name`, `cik` | Primary issuer and its SEC Central Index Key |
| `accession_number`, `form_type`, `is_amendment`, `previous_accession_number` | Filing identity; `D` = new notice, `D/A` = amendment |
| `filing_date` | Date the SEC received the filing |
| `issuer_city`, `issuer_state`, `issuer_state_or_country`, `issuer_state_or_country_name`, `issuer_zip` | Principal place of business as filed |
| `issuer_street` | Only when *Include issuer street address* is on (default off) |
| `jurisdiction_of_incorporation`, `entity_type`, `year_of_incorporation`, `incorporation_age` | Year is given on the form only for issuers formed within the last five years |
| `industry_group`, `industry_sector`, `investment_fund_type` | Form D Item 4 (for example Biotechnology, Other Technology, Pooled Investment Fund: Venture Capital Fund) |
| `revenue_range`, `aggregate_net_asset_value_range` | Issuer size as filed (most issuers choose "Decline to Disclose") |
| `federal_exemptions`, `federal_exemption_codes` | For example `Rule 506(b)`, `Rule 506(c)`, `Investment Company Act Section 3(c)(1)` |
| `date_of_first_sale`, `first_sale_yet_to_occur`, `offering_more_than_one_year` | Timing |
| `securities_offered`, `securities_other_description` | Equity, Debt, Pooled investment fund interests, Other (for example SAFE) |
| `minimum_investment_usd` | Minimum investment accepted from outside investors |
| `total_offering_amount_usd`, `total_amount_sold_usd`, `total_remaining_usd` | `null` with the matching `*_indefinite` flag set to `true` when the issuer reports "Indefinite" |
| `percent_sold` | Amount sold as a % of the offering amount |
| `has_non_accredited_investors`, `number_non_accredited_investors`, `total_number_already_invested` | Investors |
| `sales_commissions_usd`, `finders_fees_usd`, `gross_proceeds_to_related_persons_usd` | Fees and use of proceeds as filed |
| `placement_agent_firms` | Broker-dealer firms paid sales compensation (firm names only, never individual representatives) |
| `sales_compensation_recipients_count`, `related_persons_count` | Counts only, no names of people |
| `co_issuers` | Other issuers on the same filing (CIK and name) |
| `filing_url`, `form_xml_url`, `retrieved_at` | Links to the filing on EDGAR, and provenance |

The run also saves `RUN_SUMMARY` with the window, the newest SEC daily index it read, how many filings were listed, scanned and returned, and any errors.

#### Example record

```json
{
  "issuer_name": "ADA Payments Technologies, Inc.",
  "cik": "2157886",
  "accession_number": "0002157886-26-000001",
  "form_type": "D",
  "is_amendment": false,
  "filing_date": "2026-10-15",
  "issuer_city": "MANHATTAN BEACH",
  "issuer_state": "CA",
  "issuer_zip": "90266",
  "jurisdiction_of_incorporation": "DELAWARE",
  "entity_type": "Corporation",
  "year_of_incorporation": 2025,
  "industry_group": "Other Technology",
  "industry_sector": "Technology",
  "federal_exemptions": ["Rule 506(b)"],
  "date_of_first_sale": "2026-08-11",
  "securities_offered": ["Other"],
  "securities_other_description": "Simple Agreement for Future Equity (SAFE)",
  "minimum_investment_usd": 25000,
  "total_offering_amount_usd": 500000,
  "total_amount_sold_usd": 35000,
  "total_remaining_usd": 465000,
  "total_number_already_invested": 1,
  "related_persons_count": 1,
  "filing_url": "https://www.sec.gov/Archives/edgar/data/2157886/000215788626000001/0002157886-26-000001-index.htm"
}
```

### Coverage and freshness

- **All Form D and D/A filings** on EDGAR, about 250-400 per business day, from any state or country. More than half are investment funds (hedge, private equity, venture and other funds). Use *Exclude investment funds* to keep operating companies only.
- **Freshness:** the SEC posts each day's index in the evening, usually around 10 PM US Eastern. A filing made today is normally available from tomorrow morning. Weekends and federal holidays have no index.
- **Speed:** filters on state, industry and amount are applied after each form is read, at about 5 forms per second. A whole week of filings (about 1,200-1,800) takes about 4-6 minutes to scan, and runs stop as soon as *Max results* is reached.
- A Form D is a **notice**, not proof that money was raised. The amounts are as reported by the issuer, often while the offering is still open. Amendments (D/A) update the amount sold.

### Pricing

Pay per result: **$0.005 per filing** ($5.00 per 1,000) saved to the dataset. No start fee. Filings that are scanned but don't match your filters are free, and empty runs cost nothing. Apify Store discount tiers pay less per filing:

| Apify Store discount tier | Per 1,000 filings |
|---|---|
| No discount (Free / Starter) | $5.00 |
| Bronze | $4.65 |
| Silver | $4.35 |
| Gold and above | $4.00 |

| Filings | Price (no discount) |
|---|---|
| 100 | $0.50 |
| 1,000 | $5.00 |
| 10,000 | $50.00 |

Set *Max results* to cap what a run can cost.

### Data and privacy

Form D lists **related persons** (executive officers, directors and promoters) with names and addresses, and the people who sign the form and receive sales commissions. This Actor **never returns them**:

- **Not returned:** related-person names, addresses and relationships; signer names and titles; sales-compensation recipient names, CRD numbers and addresses; the issuer's phone number. Only counts (`related_persons_count`, `sales_compensation_recipients_count`) are kept, plus the names of broker-dealer **firms** in `placement_agent_firms` (a recipient's own name is used only when it is itself a firm).
- **Issuer street address is off by default.** You get city, state or country, and ZIP. Turn on *Include issuer street address* to also get the street as filed (some small issuers list a home address).
- Issuer names are the legal names of companies and funds. Some contain a person's name.

You are responsible for using the data lawfully, including anti-spam, telemarketing and privacy laws that apply to any outreach you do.

### FAQ

**What is a Form D?** A short notice that companies and funds file with the SEC within 15 days of the first sale in a private offering that relies on Regulation D (for example Rule 506(b) or 506(c)). It shows who is raising, how much, from how many investors and under which exemption.

**How do I get only startups, not investment funds?** Turn on *Exclude investment funds* and *Only young issuers*. Add *Minimum amount already sold* to skip offerings that have not raised anything yet.

**How do I track new funds (VC, private equity, hedge)?** Set *Investment fund types*, for example `["Venture Capital Fund"]`.

**Does it include the founders' or executives' names?** No. People listed on the form are never returned, only counts.

**How fresh is it?** Next-day. The SEC posts each day's index in the evening, and filings are available from the next morning.

**Can AI agents use it?** Yes. It works through the Apify MCP server and the Apify API, every input field is described for automated use, and you pay only per returned filing. Example: `POST https://api.apify.com/v2/acts/cpt_engineering~form-d-private-offerings-feed/run-sync-get-dataset-items` with the JSON input as the body.

### Fair access to SEC EDGAR

The Actor identifies itself to the SEC in its User-Agent and stays at about 5 requests per second, below the SEC's limit of 10. If you run large or frequent pulls, add your own email in *Your contact email for SEC*, which the SEC asks automated tools to provide. It is sent only to sec.gov and is not stored in the output. If the SEC throttles a request, the Actor waits and retries.

### Related Actors

- [US Company Lookup & KYB Verification](https://apify.com/cpt_engineering/us-company-lookup-kyb): verify that issuers or other companies are registered in CO, CT, NY, OR, PA or TX (status, formation date, registry ID).
- [US New Business Registrations](https://apify.com/cpt_engineering/us-business-registrations-open-data): newly formed LLCs and corporations from six states' official open data.

### Support

Open an issue on this Actor or email **cpt-datatools@mail.grokbot.com**. We reply to issues and support emails within 1 business day.

### Changelog

- **Oct 16, 2026 (night):** daily automated self-test with source schema-change detection; *Last verified* line; support response promise.
- **Oct 16, 2026 (evening):** price set to $5.00 per 1,000 filings (tiers $4.65 / $4.35 / $4.00).
- **Oct 16, 2026:** launched: daily EDGAR index + Form D XML, filters, *Only new since last run*.

### Limitations

- Next-day data. Today's filings are not available until the SEC posts the daily index.
- Data is as filed, with no enrichment (no websites, emails or phone numbers).
- Not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission. EDGAR is a registered trademark of the SEC, and the name is used here only to describe the data source.

# Actor input Schema

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

Window size in calendar days counted back from today, by SEC filing date, e.g. 7 = this week, 1 = since yesterday. Ignored when 'Filed on or after' is set. Filings appear after the SEC posts its daily index, usually the evening of the filing day (US Eastern), so today's filings are normally available from the next morning.

## `sinceDate` (type: `string`):

Optional exact start date (SEC filing date), e.g. 2026-09-01. Overrides 'Filed in the last N days'.

## `untilDate` (type: `string`):

Optional end date for backfills, e.g. 2026-09-30. Empty = today.

## `filingType` (type: `string`):

new: first notices of an offering (form type D). amendments: updates to an earlier notice (D/A), often with a new amount sold. all: both; use the is_amendment field to tell them apart.

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

Optional. Two-letter codes of the issuer's principal place of business, as reported on the form, e.g. \['CA','NY','TX']. Empty = all states and countries.

## `industrySectors` (type: `array`):

Optional. Broad Form D industry sectors, e.g. Technology or Health Care. A filing passes if it matches any selected sector or any selected industry group. Empty = all.

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

Optional. Exact Form D industry groups (Item 4 of the form), e.g. Biotechnology, Other Technology, Pooled Investment Fund. Empty = all.

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

true: drop filings whose industry group is Pooled Investment Fund (hedge, private equity, venture and other funds), which are often over half of all Form D filings. Use it to keep only operating companies. Ignored when 'Investment fund types' is set.

## `onlyYoungIssuers` (type: `boolean`):

true: keep only issuers formed within the last five years or not yet formed, as reported on the form (Item 2). Combine with 'Exclude investment funds' for a startup funding feed.

## `investmentFundTypes` (type: `array`):

Optional. Keep only pooled investment funds of these types, e.g. \['Venture Capital Fund'] for new venture funds being raised. Operating companies have no fund type and are dropped when this is set. Empty = no fund-type filter.

## `minOfferingAmountUsd` (type: `integer`):

Optional. Only filings whose total offering amount is at least this, e.g. 1000000 for $1M+. Filings that report the amount as 'Indefinite' are excluded when this is above 0. 0 = no minimum.

## `minAmountSoldUsd` (type: `integer`):

Optional. Only filings reporting at least this much already sold, e.g. 500000 for issuers that have raised $500k+. 0 = no minimum.

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

Optional. Keep filings that claim any of these exemptions. 506b = Rule 506(b) (no general solicitation), 506c = Rule 506(c) (may advertise; accredited investors only), 506 = Rule 506 (older filings), 504 = Rule 504, 4a5 = Securities Act Section 4(a)(5), 3c = Investment Company Act Section 3(c) (funds). Empty = all.

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

Optional. Case-insensitive words or phrases matched against the issuer and co-issuer names, e.g. \['therapeutics', 'ai']. Several = OR. Empty = all.

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

Maximum filings returned (and charged) per run, newest filing date first. Default 100 (= $0.50 at the no-discount price); raise it for full weekly lists.

## `maxFormsScanned` (type: `integer`):

Safety cap on how many Form D documents one run reads from the SEC (about 5 per second). Filters on state, industry and amount are applied after reading each form, so narrow filters over long windows scan many forms per result. About 1,200-1,800 Form D and D/A filings are made per week. 10,000 takes roughly 35 minutes. You are only charged for filings returned, not scanned.

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

true: remember which filings this Actor already returned to you for the same filters (in a named key-value store on your account) and skip them. Best for scheduled daily or weekly runs. false: always return the full window.

## `includeStreetAddress` (type: `boolean`):

false (default): issuer city, state/country and ZIP only. true: also the street lines of the issuer's principal place of business as filed. Small issuers sometimes list a home address, so leave it off unless you need it.

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

Optional. The SEC asks automated tools to identify themselves. Without this, requests identify as this Actor and its Apify page. Add your own email if you run large or frequent pulls; it is sent only to sec.gov in the User-Agent header and is not stored in the output.

## Actor input object example

```json
{
  "lastNDays": 7,
  "filingType": "new",
  "states": [],
  "industrySectors": [],
  "industryGroups": [],
  "excludePooledFunds": false,
  "onlyYoungIssuers": false,
  "investmentFundTypes": [],
  "minOfferingAmountUsd": 0,
  "minAmountSoldUsd": 0,
  "exemptions": [],
  "issuerNameContains": [],
  "maxResults": 100,
  "maxFormsScanned": 10000,
  "onlyNewSinceLastRun": false,
  "includeStreetAddress": false
}
```

# Actor output Schema

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

Dataset items: one Form D filing per item (issuer, CIK, state, industry, amounts, exemptions, dates, filing URL).

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

JSON record RUN_SUMMARY: window, newest SEC daily index read, filings listed/scanned/returned, errors, HTTP requests and duration.

# 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": 100
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cpt_engineering/form-d-private-offerings-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/bjxeEhYGqtmZ9GFcq/builds/OJVirYFXuqrZnQ0oZ/openapi.json