# US Form D Funding Signals (`asunoki/us-new-funding-monitor`) Actor

Monitor new U.S. Form D filings and amendments for company-level private offering signals, reported securities sales, and source links.

- **URL**: https://apify.com/asunoki/us-new-funding-monitor.md
- **Developed by:** [Seisuke Nagahara](https://apify.com/asunoki) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 billable offering notices

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

## US Form D Funding Signals

Get a daily feed of US companies that just reported raising money in a private offering. The Actor reads the official, public **Form D** notices that companies file with the SEC when they sell securities under an exemption (Regulation D, Rule 506(b) / 506(c) and others). It returns only the useful signals:

- **New Form D notices** that already report money raised: first sale has happened and the total amount sold is above $0.
- **Form D/A amendments** whose total amount sold went **up** compared with the latest earlier notice for the same offering.

Each result includes the company, its location, industry, amounts and dates, the change since the last notice, plain reason codes, and links back to the original filing.

Pooled investment funds (hedge funds, PE/VC funds, real estate funds) make up about two thirds of all Form D notices. They are excluded by default, so you mostly get operating companies.

### Who uses it

- **B2B sales and business development**: reach companies right after they raise new money and start spending it, for example on software, hiring, offices, insurance or banking.
- **Fractional CFOs, accounting and finance outsourcing firms**: find growing private companies that now have investors to report to.
- **Banks, lenders, insurance brokers, wealth and payroll providers**: a steady list of freshly funded businesses by state and industry.
- **Analysts and researchers**: a clean, structured private-offering dataset with source links.

### What a Form D does and does not tell you

Form D is a short **notice** filed by the issuer. It is not a press release and not an audited figure.

- The amounts are as reported by the issuer.
- The SEC does not review or approve Form D filings.
- A notice does **not** guarantee that a funding round closed, that the company received the money, or what it plans to do next.

Use the results as a sales or research signal and check anything important against the linked filing.

**This Actor is not affiliated with, endorsed by or approved by the U.S. Securities and Exchange Commission (SEC).** It uses public SEC data, which the SEC provides without warranty, and adds no guarantee of its own about completeness or accuracy.

### How fresh is the data?

The SEC publishes each business day's filing index after that day ends, so **a notice normally appears in this Actor on the next business day** (T+1).

Form D is due within 15 days of the first sale, and some companies file late. Each result shows `daysSinceFirstSale`. Use the **Max. days from first sale to filing** filter, for example 90, to drop notices that are already old news.

### Pricing

This Actor uses pay-per-event pricing.

| Event | Price |
|---|---|
| Actor start | $0.00005 per run |
| Chargeable funding signal (one result) | **$0.03** |

**Only these results are charged:**

- New notices with the first sale already made **and** a total amount sold above $0.
- Amendments that report a higher total amount sold than the latest earlier notice for the same offering.

**These are free:**

- Notices before the first sale, or with $0 or no amount sold.
- Amendments with an unchanged or lower amount sold.
- Pooled investment funds. They are excluded by default; with **Include pooled investment funds** on, they are returned free of charge.
- Notices that could not be fully checked because an SEC request failed (they are retried on the next run).
- Duplicates, and anything the Actor already delivered to the same watch key.

Free results are only returned when **Also return non-billable notices** is on.

As a rough guide, the whole US without filters produced about **1,300 chargeable signals per month** in Q3 2026 (about 60 per business day), which is about $39 per month. A state or industry filter reduces this a lot.

### Spending limits: safe by default

Two limits protect you, and the lower one wins:

1. **Max. charged results per run** (input `maxChargedResults`): **100 by default, which is at most $3.00 per run** plus the start fee. Raise it on purpose when you want more, up to 10,000. With the default limit, a single run returns at most 100 paid results, so getting every notice for the whole US (for example a first run, a busy week or a long date range without filters) can take several runs or a higher limit.
2. **Maximum cost per run** (Apify run option, `maxTotalChargeUsd` in the API): set it in the run or task options in Apify Console. The Actor checks it **before** each chargeable result, so chargeable results never take a run over it.

When a limit is reached:

- The run stops before the next chargeable result. That result is **not** charged and **not** marked as delivered.
- The run's status message and the `RUN_SUMMARY` record in the default key-value store say which limit stopped the run, and how many index rows and filing days were not checked yet.
- **Run the same input again** (same watch key) to continue. Already delivered notices are skipped and never charged twice.

### Modes

**Watch mode** (default): returns notices filed since the last run of the same **watch key**. The first run looks back **First watch run: days back** days (3 by default). Schedule it daily, for example on weekday mornings US time, to get a continuous feed.

**Range mode**: returns notices for a fixed filing-date range of up to 31 days, for example to backfill last month.

Both modes remember what each watch key already delivered. Re-running the same range does not charge you again unless you turn on **Deliver already delivered notices again**.

Use a separate watch key for each separate list, for example `california-tech` and `texas-all`. A watch key is any text up to 200 characters. It is case-sensitive, and only leading and trailing spaces are ignored, so `my_list`, `my-list` and `My_List` are three separate watches.

Only one run per watch key runs at a time. A second run started with the same key while another is running stops immediately and charges no notices (only the tiny start fee). If a run with that key crashed or was aborted, its key can stay locked for up to 5 minutes, so wait up to 5 minutes before retrying.

### Filters

| Input | What it does |
|---|---|
| `states` | Two-letter codes of the issuer's principal place of business, e.g. `CA`, `NY`, `TX`. Empty = all. |
| `industryGroups` | Exact Form D industry group names, e.g. `Other Technology`, `Biotechnology`, `Computers`, `Pharmaceuticals`, `Other Health Care`, `Commercial`, `Residential`, `Business Services`, `Manufacturing`, `Retailing`, `Restaurants`, `Oil and Gas`. Empty = all. |
| `minTotalOfferingAmount` | Minimum offering size in USD. Offerings with an indefinite size are kept. |
| `minTotalAmountSold` | Minimum total amount sold in USD. |
| `minAmountSoldIncrease` | For amendments: minimum increase in amount sold in USD. |
| `maxDaysSinceFirstSale` | For new notices: skip notices filed more than this many days after the first sale. |
| `includeFunds` | Include pooled investment funds, free of charge (off by default). |
| `includeNonBillable` | Also return the free, non-chargeable notices (off by default). |
| `maxResults` | Stop after this many results in one run, charged and free together. |

### Input example

```json
{
  "mode": "watch",
  "watchStateKey": "us-tech-1m",
  "lookbackDays": 3,
  "states": ["CA", "NY", "MA", "TX", "WA"],
  "industryGroups": ["Other Technology", "Computers", "Biotechnology"],
  "minTotalAmountSold": 1000000,
  "maxDaysSinceFirstSale": 90,
  "maxChargedResults": 100
}
```

Range example (backfill one month):

```json
{
  "mode": "range",
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "watchStateKey": "backfill-sept",
  "maxChargedResults": 1500
}
```

### Task ideas

1. **Nationwide daily funding feed**
   - Watch mode, default settings, watch key `us-daily`.
   - Schedule every weekday morning.
   - Keep `maxChargedResults` at 100 (about 60 signals a day nationwide), or raise it to 200 for busy days.
2. **B2B sales: freshly funded tech companies**
   - Watch mode with `states: ["CA", "NY", "MA", "TX", "WA"]` and `industryGroups: ["Other Technology", "Computers"]`.
   - `minTotalAmountSold: 1000000`, `maxDaysSinceFirstSale: 90`.
   - Send the dataset to your CRM or a Google Sheet through an Apify integration.
3. **Fractional CFO and finance services leads**
   - Watch mode with `states: ["TX", "FL", "GA", "NC"]`.
   - `minTotalAmountSold: 250000` and `minAmountSoldIncrease: 500000`, so you get new raises and companies that keep selling.
   - Run weekly with `maxChargedResults: 300`.

### Output

Results are stored in the default dataset. Download them as JSON, CSV, Excel or XML, or connect them to other tools with Apify integrations and the API.

Main fields:

| Field | Meaning |
|---|---|
| `category` | `NEW_NOTICE_FIRST_FOR_ISSUER`, `NEW_NOTICE_ADDITIONAL_OFFERING` or `AMENDMENT_SOLD_INCREASED` for chargeable results. Free categories are explained in `summary`. |
| `billable` | `true` if this result was charged. |
| `companyName`, `companyCik`, `companyCity`, `companyState`, `companyZipCode` | Issuer details from the notice. |
| `industryGroup`, `entityType`, `yearOfIncorporation`, `revenueRange` | Company profile as reported. |
| `filingDate`, `dateOfFirstSale`, `daysSinceFirstSale` | Timing. |
| `totalOfferingAmount`, `totalAmountSold`, `totalRemaining`, `totalNumberAlreadyInvested`, `minimumInvestment` | Offering amounts. |
| `previousTotalAmountSold`, `amountSoldDelta`, `comparedWithAccessionNumber` | For amendments: what the result was compared with and by how much the amount sold rose. |
| `offeringId` | SEC file number of the offering. Several notices of one offering share it. |
| `securityTypes`, `federalExemptions` | E.g. `equity`, `debt`; `06b`, `06c`. |
| `reasonCodes`, `caveats`, `summary` | Why the result got its category and anything to watch out for. |
| `sourceFilingUrl`, `sourceComparedFilingUrl`, `sourceIndexUrl`, `sourceIssuerHistoryUrl` | Links to the SEC source documents. |
| `retrievedAt`, `dataNotice` | When the data was read, and the Form D notice text. |

Illustrative result (company details replaced, fields shortened):

```json
{
  "accessionNumber": "0000000000-26-000001",
  "formType": "D",
  "filingDate": "2026-10-15",
  "category": "NEW_NOTICE_FIRST_FOR_ISSUER",
  "billable": true,
  "summary": "New offering notice; no earlier Form D from this issuer in the SEC history read.",
  "companyName": "Example Technologies Inc.",
  "companyCity": "SEATTLE",
  "companyState": "WA",
  "industryGroup": "Other Technology",
  "entityType": "Corporation",
  "yearOfIncorporation": "2024",
  "securityTypes": ["equity"],
  "federalExemptions": ["06b"],
  "dateOfFirstSale": "2026-09-30",
  "daysSinceFirstSale": 15,
  "totalOfferingAmount": 2000000,
  "totalAmountSold": 1650000,
  "totalNumberAlreadyInvested": 17,
  "reasonCodes": ["INITIAL_NOTICE", "NO_EARLIER_FORM_D_IN_HISTORY_READ"],
  "sourceFilingUrl": "https://www.sec.gov/Archives/edgar/data/<cik>/<accession>/primary_doc.xml"
}
```

### How amendments are compared

An amendment is compared with the **latest earlier notice of the same offering** (same SEC file number), not with the "previous accession number" written in the form. The written one often points to the original notice. Comparing with it would count an increase that an earlier amendment already reported, and you would be charged for the same money twice.

If the earlier notice cannot be read, the amendment is not charged and is checked again on the next run.

### Fair access to SEC data

The Actor follows the SEC's fair-access rules for automated access:

- It sends a declared User-Agent with a contact address.
- It stays at or below 5 requests per second.
- It reads only the public daily index and the filings it needs.

If the SEC answers with a rate limit (HTTP 429) or a refusal, the run stops at once, keeps what it already delivered, charges nothing for the rest, and reports the reason. It never retries around a block or switches proxies.

### Limitations

- Coverage is limited to what companies file on Form D. Many private raises are never filed, are filed late, or are filed by a fund rather than the company.
- "First for issuer" is based on the issuer's recent SEC filing history. For companies with a very long filing history, older notices may not be read.
- Company details are as reported in the notice and can be outdated.
- Results are delivered on the next business day after filing.

### FAQ

**Is this the same as a funding-round database?**
No. It is built only from official Form D notices: it does not cover news, press releases or investor names. In exchange, every result links to a primary public source.

**Can I get older history?**
Yes, with range mode, 31 days per run. Repeat with the next date range for a longer backfill.

**What if a run is interrupted?**
Delivered results are remembered after each result. If a run is cut off right after a charge, that notice is delivered again in the next run **without a second charge**. It is marked with the reason code `NOT_CHARGED_AGAIN_AFTER_INTERRUPTED_RUN`.

**Questions or a missing filter?**
Open an issue on the Actor's Issues tab.

# Actor input Schema

## `mode` (type: `string`):

watch: notices filed since the last run of this watch key (schedule it daily). range: a fixed filing-date range (max 31 days). Both modes skip notices this watch key already delivered, so they are never charged twice.

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

YYYY-MM-DD

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

YYYY-MM-DD

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

Only used the first time a watch key runs.

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

Two-letter codes of the issuer's principal place of business, e.g. CA, NY. Empty = all.

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

Exact Form D industry group names, e.g. Other Technology, Biotechnology. Empty = all.

## `minTotalOfferingAmount` (type: `integer`):

Offerings with an indefinite size are kept.

## `minTotalAmountSold` (type: `integer`):

Keep only notices whose reported total amount sold is at least this amount.

## `minAmountSoldIncrease` (type: `integer`):

For amendments: keep only increases in amount sold of at least this amount.

## `maxDaysSinceFirstSale` (type: `integer`):

Skip new notices filed long after the first sale, e.g. 90. Empty = keep all. Amendments are not affected.

## `includeFunds` (type: `boolean`):

Pooled investment funds (about two thirds of all notices) are excluded unless this is on. Funds are never charged.

## `includeNonBillable` (type: `boolean`):

Notices before the first sale or with no amount sold, amendments with unchanged or lower amount sold, and notices that could not be fully checked. Free of charge.

## `maxChargedResults` (type: `integer`):

Safety cap. The run stops before the next chargeable notice once this many were charged (100 x $0.03 = $3.00). Raise it on purpose for larger runs. The maximum cost per run in the run options also applies; whichever is lower stops the run. Notices not delivered because of a cap are not remembered and come in the next run.

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

Stop after this many results (charged and free) in one run.

## `watchStateKey` (type: `string`):

Remembers what was already delivered, so nothing is charged twice. Use a different key for each separate list. Any text up to 200 characters; it is case-sensitive and only surrounding spaces are ignored. Only one run per key runs at a time: a second run with the same key stops at once without charging notices (a crashed run's key is free again within 5 minutes).

## `deliverAgain` (type: `boolean`):

Off (recommended): notices this watch key already delivered are skipped and never charged twice. On: they are delivered and charged again, e.g. to rebuild a dataset.

## Actor input object example

```json
{
  "mode": "watch",
  "lookbackDays": 3,
  "includeFunds": false,
  "includeNonBillable": false,
  "maxChargedResults": 100,
  "maxResults": 1000,
  "watchStateKey": "default",
  "deliverAgain": false
}
```

# Actor output Schema

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

Form D notices delivered by this run (default dataset, overview view).

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

Counts, stop reason and limits of this run (RUN_SUMMARY record).

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

// Run the Actor and wait for it to finish
const run = await client.actor("asunoki/us-new-funding-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 = { "maxChargedResults": 100 }

# Run the Actor and wait for it to finish
run = client.actor("asunoki/us-new-funding-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 '{
  "maxChargedResults": 100
}' |
apify call asunoki/us-new-funding-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,asunoki/us-new-funding-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/N9HE8LCmEX6uzQqXH/builds/pf7N3dlEP4gLpXxum/openapi.json