# SEC Form D Scraper – New Startup Funding Raises (`cce_partners/sec-form-d-new-raises-feed`) Actor

Daily SEC Form D filings from EDGAR: who just raised, amount offered and sold, industry, state, filing link. Only new filings per saved monitor name. No personal names.

- **URL**: https://apify.com/cce_partners/sec-form-d-new-raises-feed.md
- **Developed by:** [Chris Grant](https://apify.com/cce_partners) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Scraper – New Startup Funding Raises

**SEC Form D scraper** that delivers a daily feed of **new startup and private funding raises** straight from official SEC EDGAR. Form D is filed within 15 days of a Regulation D sale, so it's the earliest public signal that a company or fund just raised money, often before any press release. Each row is one new filing with issuer, CIK, state, industry group, **total offering amount and amount sold**, filing date and a link to sec.gov. Give the run a monitor name and it returns only filings that are new since your last run; without one, it returns the latest filings from the last few days (up to 25 from the last 5 days by default). Runs with filters but no monitor name that still have saved state from an older version keep getting only new filings, with up to 200 filings per run and a 3-day first-run lookback. No personal names are ever output.

### GovCon suite by CCE Partners

- **SEC Form D Scraper – New Startup Funding Raises** (this Actor): newly funded private companies (prospective teaming partners and commercial buyers).
- **[SAM.gov Scraper – New Contract Opportunity Alerts](https://apify.com/cce_partners/samgov-opportunity-radar)**: new and amended SAM.gov opportunities by NAICS, set-aside, agency and state.
- **[Expiring Federal Contracts – Recompete Radar](https://apify.com/cce_partners/govcon-recompete-radar)**: federal contracts ending in 3–18 months (a recompete pipeline from USAspending.gov); only some are matched to an open SAM.gov notice.
- **[Federal Contract Awards – New Winners Feed](https://apify.com/cce_partners/federal-contract-award-winners-feed)**: companies that just won federal contracts (USAspending.gov), with parent company and award amount; pair it with Form D to spot funded companies that also sell to government.

### Why this feed

- **Only new filings.** Set a monitor name (`stateKey`) and the Actor remembers what you've already received. Run it daily for a clean list of who just raised.
- **Amounts already parsed.** Offering amount, amount sold and amount remaining are read from each filing's XML.
- **Filters that matter.** Issuer state, industry group, minimum raise and a CIK watchlist.
- **No personal data.** Executives, promoters and signers are never output, so it's safe for compliance-minded teams.
- **Official SEC sources only.** Requests are polite (5/s, under the SEC's 10/s limit), retry automatically and need no key.

### Use cases

#### 1. B2B sales: newly funded tech companies in CA and NY raising $2M+

```json
{
  "states": ["CA", "NY"],
  "industryGroups": ["Other Technology"],
  "minOfferingAmount": 2000000,
  "stateKey": "sales-tech-ca-ny"
}
```

Schedule it daily and send the results to Google Sheets or HubSpot through Apify integrations.

#### 2. VC deal sourcing: biotech raises, amendments included

```json
{
  "industryGroups": ["Biotechnology", "Pharmaceuticals"],
  "includeAmendments": true,
  "lookbackDays": 7,
  "stateKey": "vc-biotech"
}
```

#### 3. Research backfill: one month of pooled-fund raises

```json
{
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "industryGroups": ["Pooled Investment Fund"],
  "maxFilings": 2000
}
```

Setting a fixed window ignores the monitor name and saves no state, which suits one-off market research.

### Monitor names: get only new results

- **With a monitor name** (input `stateKey`, e.g. `"tech-ca-ny"`): the Actor saves which filings this monitor has returned, in a key-value store in your own Apify account. Each later run with the same name returns only filings it hasn't returned before. The first run looks back `lookbackDays` (default 3). Use one name per filter set; changing the name starts a fresh monitor. Use this for schedules, n8n, Make, Zapier and Sheets.
- **Without a monitor name and without filters** (the default, also when the name is empty): the run is stateless. It doesn't read or save any saved state. Each run returns the latest filings from the last `lookbackDays` days (default 5), newest first, up to 25 (set `maxFilings` to change it). Good for a first look or a one-off check. The run's status message reminds you: "Set a monitor name to get only new results." A monitor name made only of spaces counts as no name: without filters it doesn't read or save state either; with filters it keeps using the state an older version saved for it, if any (see below). Blank entries in `states` and `industryGroups` (e.g. `""`) are ignored, so a list with only blank entries means no filter.
- **With filters but no monitor name:** if an older version saved state for your runs without a monitor name (under the name `default`), these runs keep using the default saved state, as before: they return only new filings and update it, with the same defaults as before (up to 200 filings, 3-day first-run lookback). The run log says so in one line: set monitor name "default" to keep this explicitly. Setting the monitor name to `default` (in the API: `"stateKey": "default"`) uses the same saved state, so nothing is re-sent or re-charged. Without that saved state, these runs return the latest filings and save nothing. If an older version ran with a name made only of spaces, its state is saved under one underscore per space (e.g. `___` for three spaces). Runs with that same spaces-only name and filters keep using it, as before; set `___` as the monitor name to keep it explicitly.
- **Fixed dates** (`dateFrom`/`dateTo`): returns that window; no state is saved, even with a monitor name.
- You're charged per filing returned in every mode. A scheduled run without a monitor name that doesn't use saved state pays again for filings it already returned.
- **Safe to stop or re-run.** A monitor saves the filings it returns as it goes (every 10 filings, before they are charged, and again when a run is aborted or migrated), so an aborted, timed-out or crashed run never makes the next run re-send or re-charge what it already returned. Only one run at a time works on a monitor: a second run started while one is still working on the same monitor name ends right away with "Another run (…) is working on this monitor", returns nothing and is charged only the start. A run frees the monitor when it ends or fails, on a graceful abort (the API abort with `gracefully=true`, or `apify runs abort <runId>` without `--force`; the platform gives a graceful abort about 30 s to finish), on SIGTERM/SIGINT, and shortly before its run timeout: a monitor run stops itself about 15 s before the timeout (status FAILED with an explanation), keeps what it already returned and releases the monitor, because the platform gives a run no time to clean up at the timeout. The default Abort in Console is immediate (forced): like an out-of-memory crash, it kills the run at once, so the run can't release the monitor, which is then blocked for up to 10 minutes; runs started in that window stop without returning or charging filings (the platform still charges their start). Use a graceful abort to release it right away. If a run is hard-killed like that (no time to clean up) between saving a batch and delivering it, up to 10 filings in that batch may be skipped; those filings are never charged. A monitor name with spaces around it (e.g. " tech ") continues from the state saved by older versions for that name.
- **Max items:** if you set the run option "Max items" (maxItems), the run returns at most that many filings, in addition to `maxFilings`.

### Form D filings database: search by state, industry and amount

Filter new Form D filings by issuer state (`states`), Form D industry group (`industryGroups`), minimum offering size (`minOfferingAmount`) or specific companies (`ciks`). For a fixed period, set `dateFrom`/`dateTo` to backfill; leave them empty for a running feed. Pooled investment funds are excluded by default (`excludeFunds`).

### Recently funded companies list (daily)

Schedule a daily run with no dates set and a monitor name (`stateKey`). Each run returns only filings this monitor hasn't delivered yet: issuer name, state, industry, amount offered and sold, date of first sale, and a link to the filing on sec.gov. Send it to Google Sheets, Slack, a CRM or n8n with Apify's integrations.

### Form D vs Crunchbase for funding leads

Form D is the SEC notice an issuer files for an exempt offering, generally within 15 days after the first sale. It is a primary, public source: each row links to the filing itself. It only covers issuers that file a Form D, and it reports offering amounts, not valuations or investor names (this Actor never returns people's names). You can use it on its own or alongside a commercial funding database.

### FAQ

**How fresh is it?** EDGAR's daily index for a day is complete in the evening ET, so a daily morning run picks up the previous day's filings.

**Do I get duplicates?** Never within one run: a filing made by several co-issuers is listed on EDGAR once per co-issuer, but it is returned (and charged) once, with the other issuers in `coIssuers`. Across runs: not with a monitor name. Each `stateKey` remembers which filings it has already delivered. Without a monitor name, every run returns the latest filings in the lookback window, so repeat runs can return the same filings (unless a run with filters keeps using the default saved state from an older version, see Monitor names).

**Does it include executive or investor names?** No, by design. It returns issuer and offering fields only. Open `filingUrl` on sec.gov if you need the full filing.

**Are investment funds included?** Not by default. About 60% of new Form D filings are pooled investment funds (VC, PE, hedge and other funds; 522 of 868 filings over 4 business days in Oct 2026). They are fund vehicles, not company leads, so `excludeFunds` is on by default and excluded filings are not charged. Turn it off, or list "Pooled Investment Fund" in Industry groups, to get them.

**What industry groups can I filter on?** Use Form D's labels (upper/lower case and extra spaces don't matter), e.g. "Other Technology", "Biotechnology", "Pooled Investment Fund", "Commercial", "Residential" or "Other Banking and Financial Services".

**Can I watch specific companies?** Yes. Put their CIKs in `ciks`. If a company you watch is a co-issuer of a filing but not its primary issuer, the row's `cik` and `issuerName` are the primary issuer and your company is listed in `coIssuers`.

**How much does it cost?** $0.01 per run plus $0.005 per filing returned. Use `maxFilings` to cap the cost of each run.

**Does a Form D mean the round closed?** No. Form D is a notice of an exempt offering. "Amount sold" is what the issuer reported when it filed. This isn't investment advice.

**Is it affiliated with the SEC?** No. It's an independent tool that uses official public EDGAR data.

### What you get

| Field | Example |
|---|---|
| issuerName | 222 Show Ltd Liability Co |
| cik | 2157448 |
| formType | D (or D/A if amendments enabled) |
| state / stateDescription | NY / NEW YORK |
| entityType | Limited Liability Company |
| industryGroup | Other Technology, Biotechnology, Pooled Investment Fund… |
| investmentFundType | Venture Capital Fund, Private Equity Fund, Hedge Fund, Other Investment Fund (funds only) |
| totalOfferingAmount / totalOfferingIndefinite | 2400000 / false |
| totalAmountSold / totalRemaining | 622000 / 1778000 |
| dateOfFirstSale, isAmendment | 2026-07-31, false |
| filingDate | 2026-10-09 |
| filingUrl, primaryDocUrl | links to sec.gov |
| coIssuers | the filing's other issuers, e.g. `[{"cik": "2157449", "name": "…"}]`; `[]` when there is one issuer |

One row per filing (accession number). When a filing has several co-issuers, `cik` and `issuerName` are always the filing's primary issuer (also when you found it through a watchlist CIK of another co-issuer) and the others are in `coIssuers`; the filing is returned and charged once, and a monitor never returns it again under another co-issuer.

**No personal data.** Form D lists executives, directors, promoters and signers. This Actor reads only issuer and offering fields through a whitelist; related persons, signature names and sales-compensation recipients are never output.

### Data sources and fair access

Official SEC EDGAR only: the daily form index (`/Archives/edgar/daily-index`), EDGAR full-text search (optional), the submissions API (`data.sec.gov`), and each filing's `primary_doc.xml`. Requests carry a declared User-Agent with a contact email, are throttled to 5/second (SEC limit is 10; a higher or invalid `requestsPerSecond` is treated as 5), and back off and retry on 429/403/5xx. Cost: one request per filing day plus one per filing.

### Limits

- Daily index for today appears in the evening (ET); a filing is picked up on the next run.
- EDGAR full-text search may refuse requests from some cloud IPs; the daily index is the recommended source.
- Data is as filed by issuers; not investment advice.

### Changelog

- **Oct 16, 2026 (0.1.27):** State and industry group filters ignore upper/lower case and extra spaces (`"ca"` = CA, `"other technology"` = "Other Technology"), and blank entries in `industryGroups` are ignored like in `states`. Named monitors whose filters had unusual casing, extra spaces or blank entries may now start receiving filings they used to miss. Saved-state behavior for runs without a monitor name is unchanged. Prices are unchanged.
- **Oct 16, 2026 (0.1.26):** Runs with filters and a monitor name made only of spaces keep using the state an older version saved for that name, as before 0.1.24, so nothing is re-sent or re-charged; without filters such a name still reads and saves nothing. A `states` list of only blank entries (like `[""]`) or with spaces around a code (like `[" CA "]`) no longer filters out every filing. Prices are unchanged.
- **Oct 16, 2026 (0.1.25):** Runs with no monitor name and no filters (an empty input, the Store's example input, an empty name), and names made only of spaces, don't read or save any saved state. Runs with filters but no monitor name keep using the default saved state from older versions, as before; set the monitor name to `default` to keep that explicitly (nothing is re-sent). A graceful abort waits for the filing being delivered for at most about 30 s, the time the platform gives a graceful abort. Fixed-date runs report "Pushed N filings" (not "new"). Prices are unchanged.
- **Oct 16, 2026 (0.1.23):** `cik` is now always the filing's primary issuer; older versions could report a co-issuer's `cik` when a watchlist named that co-issuer. Other issuers are listed in `coIssuers`. A graceful abort now waits for the filing being delivered to finish before it saves and frees the monitor, so a slow delivery is no longer returned again by the next run. Prices are unchanged.
- **Oct 15, 2026 (0.1.22):** A filing listed under several co-issuers is now delivered and charged once (before, it came once per co-issuer). New output field `coIssuers` lists the other issuers. `maxFilings` and "Max items" count filings. Monitors keep their saved state; nothing is re-sent. Prices are unchanged.
- **Oct 15, 2026 (0.1.21):** A monitor run now stops itself about 15 s before its run timeout and releases the monitor, so the next run isn't blocked; it ends FAILED with an explanation and keeps what it already returned. A run that lost its monitor to another run no longer overwrites that run's saved progress. SIGINT is handled like SIGTERM. Prices are unchanged.
- **Oct 15, 2026 (0.1.16):** Monitors now save progress as they go, so stopping or aborting a run never makes the next run re-charge filings already returned; only one run at a time works on a monitor; the "Max items" run option is honored; the request rate never goes above 5/s. Existing users keep their saved state. If you ran the Actor without a monitor name before (so your account already has the old "default" saved state), runs without a monitor name keep returning only new filings, charged only for new ones, and log a one-line notice naming the monitor name (usually `default`) that keeps the same saved state. Everyone else gets stateless runs, as in 0.1.15. Runs with no filters at all are always stateless (the log still names the monitor name that keeps the saved state). Prices are unchanged.
- **Oct 15, 2026:** Runs are **stateless unless you set a monitor name** (`stateKey`). Without one, each run returns the latest filings in the lookback window (up to 25 by default) and saves nothing. With one, you get only new filings, as before. The input no longer defaults `stateKey` to "default", and the old "default" saved state is no longer used: scheduled runs that relied on it should set a monitor name (their first run then looks back `lookbackDays`). `maxFilings` now defaults to 25 without a monitor name and 200 with one, and `lookbackDays` defaults to 5 without a monitor name and 3 with one. Prices are unchanged.
- **Oct 14, 2026:** New `excludeFunds` input, **on by default**. Pooled investment funds (VC, PE, hedge and other funds) are now skipped and not charged. In an Oct 7–13, 2026 sample they were 60% of new Form D filings (522 of 868). To get funds back, set `excludeFunds` to false, or list "Pooled Investment Fund" in Industry groups. New output field `investmentFundType`.

# Changelog

This Actor's version history is a separate document: https://apify.com/cce_partners/sec-form-d-new-raises-feed/changelog.md

# Actor input Schema

## `dateFrom` (type: `string`):

YYYY-MM-DD. Set to fetch a fixed date window (no saved state; monitor name is ignored). Leave empty to use the lookback window.

## `dateTo` (type: `string`):

YYYY-MM-DD, inclusive. Defaults to Date from (one day).

## `lookbackDays` (type: `integer`):

Without a monitor name: every run returns filings from the last N days (default 5). With a monitor name: how far back the first run looks (default 3); later runs continue from where the last one stopped. Runs with filters but no monitor name that keep using saved state from an older version work the same way (default 3).

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

Also return Form D/A amendment filings, not only new Form D notices.

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

Two-letter codes, e.g. CA, NY (upper or lower case). Empty = all. Blank entries are ignored.

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

Form D industry group labels, e.g. 'Other Technology', 'Pooled Investment Fund', 'Biotechnology' (upper/lower case and extra spaces don't matter). Empty = all. Blank entries are ignored.

## `excludeFunds` (type: `boolean`):

Skip pooled investment funds (venture capital, private equity, hedge and other funds), about 60% of new Form D filings in our Oct 2026 sample. They are fund vehicles, not operating-company leads. Ignored if you list 'Pooled Investment Fund' in Industry groups. Excluded filings are not charged.

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

Skip filings whose total offering amount is below this value (USD). 0 = no minimum.

## `ciks` (type: `array`):

Optional. Only check these companies via the data.sec.gov submissions API.

## `source` (type: `string`):

How new filings are discovered. The EDGAR daily index is the most reliable from cloud IPs.

## `query` (type: `string`):

Only for full-text search source.

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

Maximum number of filings to return in one run (charged per filing). Leave empty for the default: 25 without a monitor name, 200 with a monitor name or a fixed date window. Runs with filters but no monitor name that keep using saved state from an older version also default to 200.

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

Set a name (e.g. 'tech-ca-ny') to get only NEW filings: the Actor saves which filings this monitor already returned, and later runs with the same name return only filings it hasn't returned yet. Use one name per filter set. Leave empty to get the latest filings in the lookback window each run (nothing read or saved, up to 25 by default); a name made only of spaces counts as empty (with filters, it keeps using the state an older version saved for it). If you ran this Actor without a name in an older version, runs with filters and no name keep using the default saved state (only new filings); set 'default' here to keep that explicitly (nothing re-sent).

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

Rate limit for SEC requests. SEC fair-access policy allows up to 10/s; this Actor never goes above 5/s (higher or invalid values are treated as 5).

## `userAgent` (type: `string`):

SEC requires a declared User-Agent with contact email. Default is the developer contact.

## Actor input object example

```json
{
  "includeAmendments": false,
  "excludeFunds": true,
  "minOfferingAmount": 0,
  "source": "dailyIndex",
  "requestsPerSecond": 5
}
```

# Actor output Schema

## `filings` (type: `string`):

No description

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cce_partners/sec-form-d-new-raises-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/tIyCut9UDaU8hgkHf/builds/0KE4TKXgs11ZLeaR2/openapi.json