# Form D Funding Watch: Newly Funded US Companies (`glaciological_huddle/form-d-funding-watch`) Actor

Daily leads on US companies that just raised private capital: new Form D filings as flat rows with industry, state, amount sold, investors and executives.

- **URL**: https://apify.com/glaciological_huddle/form-d-funding-watch.md
- **Developed by:** [Clark Scroggin](https://apify.com/glaciological_huddle) (community)
- **Categories:** Business, Lead generation, Automation
- **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 filing rows

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

## Form D Funding Watch: Newly Funded US Companies

> **Unofficial; not affiliated with or endorsed by the U.S. Securities and Exchange Commission.** This Actor reads public Form D filings from the SEC's EDGAR archive (daily index files and each filing's XML document) with a declared User-Agent at a polite request rate.

**Daily leads on US companies that just raised private capital.** When a company sells securities in a private placement (a seed round, a Series A, a bridge note, a fund closing), it files a Form D within 15 days of the first sale. Form D Funding Watch turns each new filing into one flat, CSV-friendly row: issuer name and address, industry group, state, amount offered and amount already sold, number of investors, the exemption claimed (506(b), 506(c), 504, 3(c)(1), 3(c)(7)...), the executives and directors as filed, the date of first sale and a direct link to the filing. Run it on a schedule with **Only new** on and every run outputs just the filings you have not seen before.

Real-estate offerings are not included: filings in the form's real-estate industry groups and real-estate pooled funds are left out of every run.

### Who uses it

- **B2B sales and agencies** prospecting companies that just closed a round and are about to hire, buy software, rent offices, run campaigns or need accountants, lawyers, insurance and banking.
- **Investors and analysts** tracking which companies and funds are raising, how much has been sold so far and under which exemption.
- **Service providers to funds** (administrators, auditors, compliance, placement) watching new fund formations by type (hedge, PE, VC).
- **Researchers and journalists** following private-market activity by industry, state or amount.

### What you get

One row per filing. Flat fields, so CSV and spreadsheet exports look right out of the box. Below is a real row from a test run (filing of 2026-10-16; the related persons are the executive officers and directors exactly as the issuer filed them):

```json
{
  "accessionNumber": "0002159256-26-000001",
  "formType": "D",
  "isAmendment": false,
  "previousAccessionNumber": null,
  "filedDate": "2026-10-16",
  "cik": "2159256",
  "issuerName": "1921 Technologies Inc.",
  "previousNames": null,
  "entityType": "Corporation",
  "jurisdictionOfInc": "DELAWARE",
  "yearOfInc": 2026,
  "incorporatedWithinFiveYears": true,
  "issuerStreet": "282 11TH AVENUE",
  "issuerCity": "NEW YORK",
  "issuerState": "NY",
  "issuerStateDescription": "NEW YORK",
  "issuerZip": "10001",
  "issuerPhone": "312-222-0800",
  "industryGroup": "Other Technology",
  "isPooledFund": false,
  "investmentFundType": null,
  "is40ActFund": null,
  "revenueRange": "Decline to Disclose",
  "netAssetValueRange": null,
  "federalExemptions": ["06b"],
  "federalExemptionsText": "Rule 506(b)",
  "dateOfFirstSale": "2026-10-02",
  "firstSaleYetToOccur": false,
  "isEquity": true,
  "isDebt": false,
  "securityTypes": "Equity",
  "durationMoreThanOneYear": false,
  "isBusinessCombination": false,
  "totalOfferingAmount": 10000000,
  "offeringAmountIndefinite": false,
  "totalAmountSold": 3000000,
  "totalRemaining": 7000000,
  "minimumInvestment": 0,
  "totalInvestors": 3,
  "nonAccreditedInvestors": 0,
  "salesCommissions": 0,
  "findersFees": 0,
  "salesCompensationRecipients": null,
  "relatedPersons": [
    { "name": "Luke Charest", "relationships": ["Executive Officer", "Director"], "clarification": null, "city": "New York", "state": "NY" },
    { "name": "Felix Levine", "relationships": ["Executive Officer", "Director"], "clarification": null, "city": "New York", "state": "NY" },
    { "name": "Christopher Chu", "relationships": ["Director"], "clarification": null, "city": "New York", "state": "NY" }
  ],
  "relatedPersonsText": "Luke Charest (Executive Officer, Director), New York, NY; Felix Levine (Executive Officer, Director), New York, NY; Christopher Chu (Director), New York, NY",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2159256/000215925626000001/0002159256-26-000001-index.htm",
  "xmlUrl": "https://www.sec.gov/Archives/edgar/data/2159256/000215925626000001/primary_doc.xml",
  "isNew": true,
  "fetchedAt": "2026-10-18T17:12:21.833Z",
  "source": "www.sec.gov Archives, Form D XML (public filing data)"
}
```

Notes on the columns:

- Amounts are **US dollars as whole numbers**. When the form says *Indefinite* (open-ended offerings, mostly funds), `totalOfferingAmount` and `totalRemaining` are `null` and `offeringAmountIndefinite` is `true`.
- `federalExemptions` holds the form's item 6 codes (`06b`, `06c`, `04`, `3C.1`, `3C.7`...); `federalExemptionsText` spells them out.
- `relatedPersons` is an array (name, relationships, optional clarification such as "CEO" or "General Partner", city, state); `relatedPersonsText` is the same list as one string for CSV.
- `revenueRange` is filled for operating companies, `netAssetValueRange` for pooled funds. Many issuers choose "Decline to Disclose".
- `nonAccreditedInvestors` is `0` when the issuer answered "no" to the non-accredited question, otherwise the number reported.
- Empty values are `null`, never empty strings.

A `RUN_SUMMARY` record in the run's key-value store has the counts: index days read and missing, Form D entries seen, details fetched, real-estate filings excluded (`excludedRealEstate`), rows filtered out by which filter, errors, requests used and why the run stopped.

### How to use it

1. **Pick filters.** Leave everything empty to get every new Form D of the last 3 business days (up to **Max items**). Narrow by industry group, issuer state, exemption, minimum offering or minimum amount already sold, or issuer-name keywords. Turn on **Exclude pooled investment funds** for operating companies only.
2. **Name the watch.** `watchName` is the memory key. Use one name per saved search ("saas", "biotech-ca"). The first run of a new watch returns everything that matches (up to **Max items**); from the second run on, only filings not seen before.
3. **Schedule it.** Add a daily schedule in Apify. Set `daysBack` to 1 or 2 for daily runs. Each day's index file appears in the evening (US Eastern), so a morning run picks up yesterday's filings.
4. **Connect the output.** Push the dataset to Google Sheets, Slack, email, webhooks, Zapier, Make, n8n or your CRM with Apify integrations. Quiet runs push nothing.

#### Example 1: Technology companies (operating companies only)

```json
{
  "daysBack": 2,
  "industryGroups": ["Computers", "Telecommunications", "Other Technology"],
  "excludePooledFunds": true,
  "watchName": "saas-software",
  "maxItems": 200
}
```

#### Example 2: Health care with at least $1M already sold

```json
{
  "daysBack": 5,
  "industryGroups": ["Biotechnology", "Pharmaceuticals", "Hospitals & Physicians", "Health Insurance", "Other Health Care"],
  "minAmountSold": 1000000,
  "excludePooledFunds": true,
  "watchName": "biotech-healthcare",
  "maxItems": 200
}
```

#### Example 3: Texas issuers raising under Rule 506(c), including amendments

```json
{
  "daysBack": 3,
  "states": ["TX"],
  "exemptions": ["06c"],
  "includeAmendments": true,
  "watchName": "texas-506c",
  "maxItems": 100
}
```

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `daysBack` | int 1–30 | 3 | Past business days of daily index files to read, plus today's index if already published. Weekends and holidays are skipped. |
| `includeAmendments` | bool | false | Also output amended filings (form D/A). Off = original filings only, i.e. new offerings. |
| `states` | string\[] | \[] | Two-letter codes of the issuer's business address (TX, CA, NY...). Any match counts. |
| `industryGroups` | enum\[] | all | Form D item 4 industry group. The five real-estate groups are not selectable. |
| `minOfferingAmount` | int USD | none | Minimum total offering amount. *Indefinite* offerings pass. |
| `minAmountSold` | int USD | none | Minimum amount already sold at filing time. |
| `exemptions` | enum\[] | all | Keep filings claiming any of these codes: `06b`, `06c`, `04`, `04.1`–`04.3`, `4a5`, `3C`, `3C.1`, `3C.5`, `3C.7`, `3C.9`–`3C.14`. |
| `issuerNameKeywords` | string\[] | \[] | Case-insensitive substring match on the issuer name. Applied from the index before any download, so it also saves requests. |
| `excludePooledFunds` | bool | false | Skip hedge, private-equity, venture and other pooled investment funds. |
| `onlyNew` | bool | true | Output only filings this watch has not processed before. |
| `watchName` | string | "default" | Memory key; one per saved search. Stored in the named key-value store `form-d-watch-<name>`. |
| `maxItems` | int 1–5000 | 100 | Hard cap on rows per run; the rest is left for the next run. |
| `userAgentContact` | string | none | Optional contact (your e-mail) for the User-Agent header sent to www.sec.gov. Sent only in that header; masked (e.g. `j***@e***.com`) in logs and `RUN_SUMMARY`. |

### Pricing

Pay per event. You pay only for rows actually delivered, plus a small start fee.

| Event | Price | When |
|---|---|---|
| Actor start | **$0.005** | Once per run, even when nothing is new |
| `filing` | **$0.004** | Per row in the dataset (one Form D filing) |

**What a typical watch costs.** A daily watch that averages 40 new filings a day: 40 × $0.004 + $0.005 = **about $0.17 a day, around $5 a month**. A quiet day costs $0.005. A one-off backfill of 500 filings costs $2.005. Compute is included, there are no proxy charges, and the run stops itself before exceeding the spending limit you set on the run (`Maximum cost per run` in Apify). Filings that are excluded or filtered out are never charged.

There is no subscription. Several watches cost the same as one watch with the same total number of rows.

### Data source and how the Actor behaves

**Source: U.S. Securities and Exchange Commission, EDGAR Form D filings (public information).** The SEC states that information presented on sec.gov is public information that may be copied or further distributed, and asks for appropriate citation of the SEC as the source.

The Actor reads only two kinds of documented, machine-readable files: the **daily form index** (`/Archives/edgar/daily-index/YYYY/QTRn/form.YYYYMMDD.idx`, one request per business day) and each Form D filing's **`primary_doc.xml`** (one request per filing it needs to look at). It does not crawl web pages, does not log in and does not use a browser. Requests carry a declared User-Agent (`FormDFundingWatch/0.1 ...`, with your contact if you provide one), are spaced at **5 per second** (half the SEC's published ceiling of 10), time out after 30 s, and transient errors (429, 5xx, network) are retried at most 3 times with backoff. If the site's automated-traffic guard answers, the run stops cleanly, keeps the rows already pushed and tells you to wait before the next run.

If one filing's XML does not look like a Form D, that filing is skipped and counted in `errors`; the run continues. If the daily index itself no longer matches the documented layout, the run fails with a clear message instead of emitting empty results.

**Real-estate exclusion.** Filings whose industry group is Commercial, Construction, REITS & Finance, Residential or Other Real Estate, and pooled investment funds of type Real Estate Fund, are always left out and counted as `excludedRealEstate` in the run summary. This cannot be switched on.

**People named in filings.** Related persons (executive officers, directors, promoters) are names and business addresses the issuer itself filed publicly. The Actor outputs them exactly as filed and nothing more. If you contact anyone listed in a filing, **you are responsible for complying with applicable outreach laws** such as CAN-SPAM, the TCPA and state laws, and with the terms of any platform you use.

### Limitations

- Form D is a notice, not a press release: it is filed within 15 days of the first sale, some issuers file late, and amounts are as of the filing date. Issuers may choose "Decline to Disclose" for size fields.
- The industry group is the issuer's own choice from the form's fixed list; the exclusion of real-estate offerings relies on it.
- Each day's index is published in the evening (US Eastern). A run early in the day reads up to `daysBack` previous business days and reports today as "not available" until the index exists.
- The daily index lists original filings before amendments. With `maxItems` set low and `includeAmendments` on, a run may stop before reaching the amendments of a busy day; they are picked up by the next run.
- The first run of a new `watchName` reports everything in the window as new. That is expected; set `maxItems` to taste.
- The watch memory lives in a named key-value store in your account called `form-d-watch-<watchName>`. Deleting it resets the watch. Filings not seen for 180 days are forgotten automatically.
- Filings by issuers outside the US carry a country or region code in `issuerState`.

### Integrations and automation

Works with every Apify integration: schedules, webhooks, Google Sheets, Slack, email, Zapier, Make, n8n, LangChain and the Apify API and MCP server. Because the output is already the delta, a "new dataset items" trigger maps one-to-one to "newly filed offerings".

Typical pipelines:

- **Sales alerts in Slack:** schedule daily at 8 am, post `issuerName`, `industryGroup`, `issuerCity`/`issuerState`, `totalAmountSold` and `filingIndexUrl`.
- **Prospect list in Sheets or Airtable:** append rows, enrich `issuerName` with your data provider, assign owners by `issuerState`.
- **CRM:** create a company record per `isNew` row, attach `relatedPersonsText` as a note, set deal size from `totalAmountSold`.

### FAQ

**Is this data legal to use?** Form D filings are public records published by the SEC, which states the information may be copied and further distributed with appropriate citation. You remain responsible for how you use the data, including compliance with outreach laws when contacting people named in filings.

**Why is a company I know raised money missing?** It may not have filed yet (filing is due 15 days after the first sale), it may have filed under a different legal name, it may be in a real-estate industry group (not included), or your filters or `maxItems` excluded it. Check `RUN_SUMMARY` for the counts.

**What happens to the e-mail I put in `userAgentContact`?** It is sent only in the User-Agent header of requests to www.sec.gov, as the SEC asks of automated tools. Everywhere else (the run log, error messages, the status message and `RUN_SUMMARY`) it appears masked, for example `j***@e***.com`. It is not stored in the watch memory or the dataset.

**What is the difference between D and D/A?** A Form D is the original notice of a new offering. A D/A amends an earlier notice (for example to report more money sold or an annual update of a continuous offering). Amendments are off by default so each row signals a new offering; turn `includeAmendments` on to track updates.

**Why did my first run return so many rows?** A new watch has no memory, so everything in the window counts as new. From the second run on you get only the delta. Lower `daysBack` or `maxItems` for the first run if you prefer.

**Does it include fund formations?** Yes, pooled investment funds (hedge, private equity, venture, other) are included by default, with `isPooledFund`, `investmentFundType` and `netAssetValueRange`. Set `excludePooledFunds` for operating companies only. Real-estate funds are never included.

**Can I track several searches?** Yes. Give each its own `watchName`; each keeps its own memory.

### Support

Open an issue on the Actor's **Issues** tab in Apify Console with your input and run ID. Feature requests welcome, especially new filters or output fields.

# Actor input Schema

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

How many past business days of daily filing index files to read, plus today's if it has been published (each day's index appears in the evening, US Eastern time). Weekends and holidays without an index are skipped. 1 or 2 is right for a daily schedule.

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

Also output amended filings (form D/A), for example when an issuer reports more money sold a year later. Off by default: only original Form D filings, which signal a NEW offering.

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

Two-letter codes of the issuer's principal business address, e.g. TX, CA, NY. Leave empty for all. Filings by issuers outside the US carry a country code here (e.g. X0 for the UK region codes used in the form); those are kept only if you list that code.

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

Industry group the issuer chose on the form (item 4). Leave empty for all. Real-estate groups (Commercial, Construction, REITS & Finance, Residential, Other Real Estate) are not available: those filings are always excluded.

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

Keep only offerings of at least this size (item 13, total offering amount). Offerings declared 'Indefinite' (open-ended, mostly funds) always pass this filter. Leave empty for no minimum.

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

Keep only filings that report at least this much already sold (item 13, total amount sold). Useful to skip offerings with no money raised yet. Leave empty for no minimum.

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

Keep filings claiming ANY of these exemptions (item 6). Leave empty for all. 506(b) is the classic private placement; 506(c) allows general solicitation to accredited investors; 3(c)(1) and 3(c)(7) mark private funds.

## `issuerNameKeywords` (type: `array`):

Keep only issuers whose name contains ANY of these words (case-insensitive substring), e.g. 'Robotics', 'Bio', 'Energy'. Applied before any detail download, so it also saves requests.

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

Skip hedge funds, private equity, venture capital and other pooled investment funds, leaving operating companies only. Real-estate funds are excluded regardless.

## `onlyNew` (type: `boolean`):

Remember every filing this watch has processed and output only filings not seen before. Quiet runs output nothing and cost only the start fee. Turn off to re-output everything in the window.

## `watchName` (type: `string`):

Name of the saved watch. Each watch keeps its own memory of processed filings (named key-value store form-d-watch-<name>), so several watches ('saas', 'biotech-ca') can run side by side.

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

Hard cap on output rows per run. The run also stops early if your Apify spending limit for this run would be exceeded. Filings beyond the cap are left for the next run.

## `userAgentContact` (type: `string`):

www.sec.gov asks automated tools to identify themselves with contact details. If you enter your e-mail address, requests are sent as 'FormDFundingWatch/0.1 <your e-mail>'; otherwise the Actor's default identification is used. Sent only in the User-Agent header of requests to www.sec.gov; masked (e.g. j\*\*\*@e\*\*\*.com) in logs and the run summary.

## Actor input object example

```json
{
  "daysBack": 3,
  "includeAmendments": false,
  "states": [],
  "industryGroups": [],
  "exemptions": [],
  "issuerNameKeywords": [],
  "excludePooledFunds": false,
  "onlyNew": true,
  "watchName": "default",
  "maxItems": 100
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "states": [],
    "industryGroups": [],
    "exemptions": [],
    "issuerNameKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("glaciological_huddle/form-d-funding-watch").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 = {
    "states": [],
    "industryGroups": [],
    "exemptions": [],
    "issuerNameKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("glaciological_huddle/form-d-funding-watch").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 '{
  "states": [],
  "industryGroups": [],
  "exemptions": [],
  "issuerNameKeywords": []
}' |
apify call glaciological_huddle/form-d-funding-watch --silent --output-dataset

```

## MCP server setup

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

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/V197DpCB0og2OQAhS/builds/et2bSJYkHWETVXyzj/openapi.json