# SEC Form D Filings Monitor — New Funded Companies & Funds (`magnova/sec-form-d-monitor`) Actor

New SEC Form D filings as clean records — issuer name, city/state, industry group, fund type, exemptions (506b/506c/504), total offering amount, amount sold, first-sale date, investor count. Official SEC EDGAR data, no API key, no login. $0.01 per filing record, no start fee, empty runs free.

- **URL**: https://apify.com/magnova/sec-form-d-monitor.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Business, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 form d filing records

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 Monitor — New Funded Companies & Funds

Every company or fund that raises private money in the United States under Regulation D must tell the SEC by filing a Form D — usually within days of the first sale. This Actor turns those filings into a clean, scheduled feed: give it a date window (or just "the last 2 days") and it returns each new filing as one structured record with the issuer name, city and state, industry group, fund type, exemptions claimed, total offering amount, amount already sold, date of first sale, and investor count.

A Form D is the earliest public signal that a company has fresh capital. Startups file them right after a priced round or a SAFE converts, funds file them as they raise, and real-estate and energy sponsors file them for each new offering. If you sell to companies that just raised, invest alongside them, recruit for them, or compete with them, this is the feed you want running every morning — not a search you remember to do once a month.

### What you get

Each run writes three kinds of rows to the dataset:

- **filing** rows — one per Form D filing, with the fields listed in the output table below. These are the only rows you pay for.
- **error** rows — one per filing that could not be fetched or parsed, with the accession number and the reason. Never charged.
- One **summary** row at the end of every run: the window covered, how many candidates EDGAR reported, how many were delivered, skipped as duplicates, skipped by your filters, or failed. Never charged.

### Use with AI agents / MCP

The input is deliberately minimal so an agent can call this Actor zero-shot: only `lastNDays` is required, and it comes prefilled. A minimal call looks like this:

```json
{
  "lastNDays": 2,
  "maxResults": 200
}
```

A filtered call — newly funded operating companies in New York that already sold at least $1M:

```json
{
  "lastNDays": 7,
  "industryGroups": ["Other Technology", "Biotechnology"],
  "states": ["NY"],
  "minAmountSold": 1000000,
  "maxResults": 100
}
```

Sample output (one filing row, abridged):

```json
{
  "recordType": "filing",
  "accessionNumber": "0001231919-26-001500",
  "issuerName": "IRIS AI Technologies, Inc.",
  "entityType": "Corporation",
  "issuerCity": "New York",
  "issuerState": "NY",
  "industryGroup": "Other Technology",
  "totalOfferingAmount": 4999999,
  "totalAmountSold": 4996012,
  "dateOfFirstSale": "2025-12-22",
  "rule506b": true,
  "investorCount": 10,
  "primaryDocUrl": "https://www.sec.gov/Archives/edgar/data/2056666/000123191926001500/primary_doc.xml"
}
```

### Input

| Field | Description |
|---|---|
| Last N days (required, prefilled 7) | Look back N days from today. Roughly 85 Form D filings arrive per business day (none on weekends), so the 7-day prefill always spans business days and always returns data. |
| Filed after / Filed before | Optional explicit window (YYYY-MM-DD). Overrides Last N days. |
| Industry groups | Filter on the Form D industry group, using EDGAR's exact values, e.g. `Pooled Investment Fund`, `Other Technology`, `Biotechnology`, `Other Real Estate`. |
| Issuer states | Two-character codes of the issuer's principal place of business, e.g. `["NY", "DE"]`. |
| Exemptions | Filter to filings claiming Rule `506b`, `506c`, or `504`. |
| Minimum amount sold | Only filings that have already sold at least this much (USD). Best single filter for "actually raised" vs "intends to raise". |
| Max results | Cap on filing records delivered (and charged). |
| Only new filings | Monitor mode: skip filings delivered by earlier runs. Requires the state store below. |
| Seen-filings state store | A key-value store you own where the Actor remembers delivered accession numbers (read/write). If it is missing or fails, the run simply continues without dedupe — it never crashes. |

### Output

| Field | Meaning |
|---|---|
| `accessionNumber`, `cik` | The filing's unique SEC identifiers — use the accession number to dedupe in your own systems. |
| `issuerName`, `entityType` | The company or fund that raised, and its legal form. |
| `issuerCity`, `issuerState` | Principal place of business (street address is deliberately not collected). |
| `industryGroup`, `fundType` | Form D industry group; for funds, the fund type (Venture Capital, Hedge Fund, Private Equity, Other). |
| `totalOfferingAmount`, `totalAmountSold`, `totalRemaining` | The raise, in USD. `amountsIndefinite` flags filings that state "Indefinite" (open-ended funds). |
| `dateOfFirstSale`, `firstSaleYetToOccur` | When money first changed hands — or that none has yet. |
| `rule506b`, `rule506c`, `rule504`, `exemptions` | Normalized exemption flags plus the raw SEC codes from the filing. |
| `isAmendment`, `previousAccessionNumber` | Whether this filing updates an earlier one, and which. |
| `investorCount`, `hasNonAccreditedInvestors`, `minimumInvestment` | Offering texture: how many are in, and the ticket size. |
| `primaryDocUrl` | Link to the official filing document on sec.gov. |

### Use cases

- **B2B sales to newly funded companies.** A startup that just sold $2M of securities has budget and urgency. A daily run filtered by `minAmountSold` and industry gives your SDRs a fresh, legal, self-updating lead list — the same job people pay funding databases $49–99/mo for, at per-record prices.
- **VC and angel deal flow.** Watch `Pooled Investment Fund` filings and new operating-company raises in your sectors and states; amendments tell you when a round keeps growing.
- **Recruiters and staffing firms.** Newly raised companies hire. A weekly feed by state and industry is a hiring-signal list days ahead of job boards.
- **Competitor and market watch.** Monitor raises in your category — who raised, how much, under which exemption (506(c) filers can advertise their raise; 506(b) filers cannot).
- **Service providers.** Accountants, law firms, registered agents and fund administrators all sell to exactly the entities in this feed, at exactly this moment.

### How it works

1. Discovery queries the EDGAR full-text backend for Form D filings in your window, newest day first, at a polite ~5 requests/second — well inside the SEC's fair-access limit.
2. Each filing's official `primary_doc.xml` is fetched from the SEC Archives and parsed field by field. A filing that fails becomes an error row; the run continues.
3. Your filters are applied, duplicates are removed in monitor mode, and surviving filings are written to the dataset — one charge per delivered filing, never for errors, duplicates, or filtered-out filings.
4. If the run approaches the platform timeout, it stops gracefully and still writes partial results plus the summary row.

### Pricing

Pay-per-event only: **$0.01 per filing record delivered**. There is **no start fee**, no charge for the summary or error rows, and **empty runs are free** — if nothing matches, you pay nothing.

| Apify plan | Price per filing record |
|---|---|
| FREE / BRONZE | $0.0100 |
| SILVER | $0.0085 |
| GOLD | $0.0070 |
| PLATINUM / DIAMOND | $0.0070 |

For scale: a daily monitor run over an unfiltered 2-day window returns roughly 170 filings — about $1.70/day at list price, and most users filter that down to a fraction.

### FAQ

#### How do I get only companies that actually raised money, not just filed intent?

Set `minAmountSold` (for example 100000) and, if you want operating companies only, leave `Pooled Investment Fund` out of the industry filter. Filings with a first sale yet to occur drop out automatically because their amount sold is zero or unstated.

#### How do I run this as a weekly monitor without getting duplicates?

Schedule the Actor to run weekly with `lastNDays: 7` and `onlyNewOnly: true`, and pick any key-value store you own in the state store input. The Actor remembers delivered accession numbers in that store and skips (and never re-charges) them on later runs.

#### How much does it cost to monitor new filings for a week?

A 7-day unfiltered window is roughly 900 filings, about $9 at list price before plan tiers. With typical filters — an industry group, a few states, a minimum amount sold — most users see tens of records per week, so well under $1.

#### Is it legal?

Yes. Form D filings are public federal records published by the SEC for exactly this kind of reuse, and the SEC's data APIs are officially keyless. The details are in the Legal and data section below, including the SEC wording we rely on.

#### Why are there no executive names, phone numbers, or contact details?

Form D filings do contain related-person names (officers, directors, promoters) and the issuer's phone number. We deliberately exclude all of it: this Actor sells company-level funding signals, not personal data. If you need to contact a company, its name, city, and the link to its official filing are the right starting point.

#### What is the SUMMARY record at the end of my dataset?

One row per run with `recordType: "summary"` — the window, counts of delivered/duplicate/filtered/failed filings, and any error details. Filter on `recordType` to separate filings from run bookkeeping.

#### How fresh is the data?

Form D rules require filing within 15 calendar days of the first sale, and most filers file within days. This Actor reads EDGAR directly, so a filing appears here as soon as the SEC publishes it — run it daily and you see yesterday's raises today.

### SEC Form D API

There is no single "Form D API" product from the SEC; there is EDGAR. This Actor combines two official EDGAR services: the full-text search backend behind the SEC's own EDGAR Full Text Search (used to discover new Form D filings by date) and the EDGAR Archives (the canonical filing documents, parsed from the same `primary_doc.xml` that EDGAR itself generates). No API key, account, or login is involved on either side — the Actor sends the declared User-Agent the SEC asks automated users to send, and stays under the SEC's published request-rate ceiling.

### Alternatives

Funding trackers on this Store mix SEC filings with scraped news and startup databases and charge $0.07–0.08 per result; the cheapest pure Form D scraper charges less than us but shows a 1-star rating and roughly one failed or timed-out run in ten. This Actor is the reliability-first option in the middle: one official source, monitor mode with dedupe, no start fee, and a per-record price an order of magnitude under the trackers.

### Legal and data

**Source.** All records come from SEC EDGAR (www.sec.gov), the U.S. Securities and Exchange Commission's public filing system. Form D filings are public federal records.

**Permission.** The SEC's official EDGAR API page states: *"These APIs do not require any authentication or API keys to access."* (source: https://www.sec.gov/search-filings/edgar-application-programming-interfaces). Access follows the SEC's fair-access rules (https://www.sec.gov/os/accessing-edgar-data): declare your User-Agent in request headers — *"Please declare your user agent in request headers"* — and respect the published ceiling, *"Current max request rate: 10 requests/second."* This Actor declares its User-Agent on every request and paces at roughly half that ceiling.

**What is excluded, deliberately.** Company-level data only. Related-person names (officers, directors, promoters), the issuer's phone number, street addresses, and signer names appear in the source filings and are **never** copied into the output.

**Not advice.** Records are delivered as filed, for information and lead-generation use. This Actor does not provide investment, legal, or compliance advice, and a Form D filing is a notice — not an SEC endorsement of the offering.

### Development

```bash
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt pytest httpx
.venv/bin/python -m pytest tests/ -q
```

Tests are network-free: realistic Form D fixtures (investment fund, operating company, amendment), privacy assertions that personal data never reaches a record, filter/window/dedupe coverage, and mocked-SEC discovery and fetch tests.

# Actor input Schema

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

Only return filings claiming at least one of these Regulation D exemptions: 506b (Rule 506(b), the classic private placement), 506c (Rule 506(c), general solicitation allowed), 504 (Rule 504, smaller offerings). Example: \["506c"]. Empty = all exemptions.

## `filedAfter` (type: `string`):

Only filings filed on or after this date, format YYYY-MM-DD, e.g. 2026-10-01. Overrides the start of the Last N days window. Leave empty to use Last N days.

## `filedBefore` (type: `string`):

Only filings filed on or before this date, format YYYY-MM-DD, e.g. 2026-10-28. Overrides the end of the Last N days window. Leave empty to use Last N days.

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

Only return filings whose Form D industry group is one of these — the exact industry group values from the Form D form itself, as they appear in SEC EDGAR filings. Example: \["Pooled Investment Fund"] for fund raises, or \["Other Technology", "Biotechnology"] for operating companies. Note real estate filings use values like "Other Real Estate", "Residential" and "Commercial". Empty = all industries.

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

How many days back to look for new Form D filings, ending today. This is the primary input: with no other settings, the Actor returns the last N days of filings. SEC EDGAR sees roughly 85 Form D filings per business day and none on weekends or US holidays, so the prefill of 7 always spans at least 5 business days and always returns results. Example: 2 for a daily monitor run, 7 for a weekly run.

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

Maximum number of filing records to deliver (and charge for). Error rows and the final SUMMARY record are never charged. Example: 200.

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

Only return filings that have already sold at least this much, in USD. Example: 1000000 for companies/funds that raised $1M+. 0 = no minimum. Filings whose amount sold is not stated are excluded when this is above 0.

## `onlyNewOnly` (type: `boolean`):

When true, filings already delivered by an earlier run are skipped (and never charged again). Requires the Seen-filings state store input below; without a store, dedupe is skipped with a warning and all filings in the window are returned. Designed for scheduled daily/weekly monitor runs.

## `stateStore` (type: `string`):

A key-value store this Actor may read and write to remember which filings it has already delivered (used only when Only new filings is on). Pick any store you own — the Actor keeps one small state record in it. If the store is missing or cannot be opened, the run continues without dedupe.

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

Only return filings whose issuer is based in one of these US states, as two-letter codes. Example: \["NY", "DE", "CA"]. Empty = all states. Note this is the issuer's principal-place-of-business state from the filing, not its state of incorporation.

## Actor input object example

```json
{
  "exemptions": [
    "506c"
  ],
  "filedAfter": "2026-10-01",
  "filedBefore": "2026-10-28",
  "industryGroups": [
    "Pooled Investment Fund"
  ],
  "lastNDays": 2,
  "maxResults": 200,
  "minAmountSold": 1000000,
  "onlyNewOnly": true,
  "states": [
    "NY",
    "DE"
  ]
}
```

# Actor output Schema

## `results` (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 = {
    "lastNDays": 7,
    "maxResults": 200,
    "minAmountSold": 0,
    "onlyNewOnly": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/sec-form-d-monitor").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": 200,
    "minAmountSold": 0,
    "onlyNewOnly": False,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/sec-form-d-monitor").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": 200,
  "minAmountSold": 0,
  "onlyNewOnly": false
}' |
apify call magnova/sec-form-d-monitor --silent --output-dataset

```

## MCP server setup

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

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/hwhXAOkvpW76mwVdz/builds/ZiGGSACkhddMj165H/openapi.json
