# Form D Funding Rounds Tracker for New Startup Raises (`tan-solutions/form-d`) Actor

Get new startup and private company funding rounds from Form D filings: amount raised, investors, executives, address, phone and the company website and domain. Schedule it daily for new rounds only. SEC EDGAR public data. Pay per round. Not affiliated with the U.S. SEC.

- **URL**: https://apify.com/tan-solutions/form-d.md
- **Developed by:** [Tan Solutions](https://apify.com/tan-solutions) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 round delivereds

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

## Form D Funding Rounds Tracker for New Startup Raises

Get new startup and private company funding rounds from Form D filings, every day, as clean rows, with the company
website when we can find it (about 1 in 5 filings). Each row gives the company, the amount raised so far and the amount offered, the
number of investors, the minimum investment, the date of the first sale, the exemptions claimed, the executives and
directors named in the filing (names and roles as filed), the business address and phone as filed, and a direct link
to the filing.

Form D filings are the first public trace of most US startup funding rounds, often weeks before any press release.
Free Form D sites let you browse them; this Actor delivers them to your API, your schedule, your webhooks and your
spreadsheet, with the website and domain added when we can find them, and in monitor mode returns only rounds you have not seen yet.

All data is SEC EDGAR public data, read from the official EDGAR daily index and filing documents. Not affiliated
with, endorsed or approved by the U.S. Securities and Exchange Commission.

### Run it from the API or on a schedule

Get the latest rounds back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token from Console, **Settings**, **API & Integrations**):

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~form-d/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"states":["CA","NY"],"industries":["Technology"],"minSold":1000000,"maxItems":50,"monitorId":"daily-tech","companyName":"Your Company","contactEmail":"you@example.com"}'
```

Put your own company name and contact email in place of `Your Company` and `you@example.com`: the SEC requires them
for automated access. With the examples, or without them, the run returns one free row that says what to add.

Get only new rounds every weekday at 23:00 UTC with an Apify schedule (`2nfycTXXoIIehPgZP` is this Actor's ID). The
same `monitorId` on every run means each run returns only rounds not delivered before:

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name": "form-d-daily", "cronExpression": "0 23 * * 1-5", "timezone": "UTC", "isEnabled": true, "isExclusive": true,
       "actions": [{"type": "RUN_ACTOR", "actorId": "2nfycTXXoIIehPgZP",
         "runInput": {"body": "{\"states\":[\"CA\",\"NY\"],\"industries\":[\"Technology\"],\"minSold\":1000000,\"maxItems\":50,\"monitorId\":\"daily-tech\",\"companyName\":\"Your Company\",\"contactEmail\":\"you@example.com\"}", "contentType": "application/json"}}]}'
```

In Apify Console the same is: **Schedules**, **Create new**, cron `0 23 * * 1-5`, add this Actor with your input.
To push every new round into your CRM, Slack, Google Sheets or Zapier, add a webhook or an integration on the Actor's
**Integrations** tab (event "Run succeeded", then read the run's dataset).

### What it does

- Reads the EDGAR daily index for each day in your date range (default: the last 3 days), newest first, and keeps the
  Form D (new round) and Form D/A (amendment) filings.
- Applies your filters before it opens a filing: new or amendment, pooled investment funds out (on by default), then
  state, industry group and the amounts offered and sold.
- Reads each filing's Form D document and returns one row per round with the business fields.
- Finds the company website and domain: candidate domains from the company name, each homepage checked for the legal
  name and the company's city or state. `websiteConfidence` is `high` (name and location match) or `medium` (exact
  legal name only); rounds without a match are still delivered with `website: null`. Each site's robots.txt is read
  first: a site that asks bots to stay out is never opened, and the row says so with `websiteSkipped: "robots"`.
- Monitor mode (`monitorId`): remembers the rounds it delivered (for 400 days) and skips them on the next run, so a
  daily schedule gives you new rounds only and you never pay twice for the same filing.
- Sends every request with your company name and contact email, as the SEC asks, at most 5 requests per second.
- If the SEC asks it to slow down, it waits 10 minutes once, tries again and otherwise stops cleanly with a clear
  status; rounds it could not fetch cost nothing.
- A state or industry filter has to read every filing in the date range (the SEC daily index has no state), so a
  filtered week takes about 6 minutes. The cost stays low.

### Who it is for

- Venture investors, angels and scouts who want every new round in their sector and state the day it is filed.
- Sales and business development teams selling to newly funded companies (the website and domain are ready for
  enrichment and outreach tools).
- Analysts, journalists and researchers tracking startup funding rounds and private placements.
- Developers and AI agents that need Form D filings as structured data from an API call.

### How to use

Enter your own company name and contact email, not the examples in the form: the SEC's fair-access rule asks every
automated user to say who they are, and with the examples (or blank fields) the run only returns one free row asking
for them.

1. Click **Try for free**.
2. Replace the example company name and email in the two contact fields with your own.
3. Keep the default (the last 3 days, 20 rounds) or pick dates and filters.
4. Click **Start**. Rows appear in the **Output** tab; export them as JSON, CSV or Excel, or read them through the API.

### Input

| Field | Required | What it does |
| --- | --- | --- |
| `companyName` | yes (the SEC requires it) | Your company or your own name. Sent only to the SEC, in the request header. |
| `contactEmail` | yes (the SEC requires it) | An address where the SEC can reach you. Sent only to the SEC, never in the output. |
| `dateFrom`, `dateTo` | no | Filing dates YYYY-MM-DD. Default: the last 3 days. Up to 366 days per run. |
| `states` | no | State codes of the company address, e.g. `["CA","NY"]`. |
| `industries` | no | Words from the industry group as filed, e.g. `Technology`, `Biotechnology`, `Real Estate`. |
| `minOffered`, `maxOffered` | no | Total offering amount in US dollars. |
| `minSold`, `maxSold` | no | Amount sold so far in US dollars. |
| `filingType` | no | `all` (default), `new` (Form D) or `amendment` (Form D/A). |
| `excludePooledFunds` | no | Default `true`: hedge, private equity and venture funds are left out. |
| `maxItems` | no | Rounds per run, newest first. Default 20, up to 50,000. |
| `monitorId` | no | Any name; runs with the same name skip rounds delivered before. |
| `requestsPerSecond` | no | Default 5 (the SEC allows 10 per user). |

Example input:

```json
{
  "dateFrom": "2026-11-10",
  "dateTo": "2026-11-13",
  "states": ["CA"],
  "industries": ["Technology"],
  "filingType": "new",
  "maxItems": 100,
  "companyName": "Your Company Ltd",
  "contactEmail": "you@example.com"
}
```

### Output example

An example row (built from a test filing, so the names are invented; real rows have the same shape):

```json
{
  "status": "ok",
  "issuerName": "Acme Robotics, Inc.",
  "cik": "0001999001",
  "accession": "0001999001-26-000001",
  "filingDate": "2026-11-13",
  "form": "D",
  "isAmendment": false,
  "previousAccession": null,
  "entityType": "Corporation",
  "stateOfIncorporation": "DELAWARE",
  "yearOfIncorporation": "2023",
  "address": { "street1": "1 Main St", "street2": "Suite 200", "city": "SAN FRANCISCO", "state": "CA", "stateName": "CALIFORNIA", "zip": "94107" },
  "phone": "415-555-0100",
  "industryGroup": "Other Technology",
  "fundType": null,
  "revenueRange": "Decline to Disclose",
  "totalOffered": 5000000,
  "offeringIndefinite": false,
  "totalSold": 3000000,
  "remaining": 2000000,
  "remainingIndefinite": false,
  "investorsCount": 12,
  "hasNonAccreditedInvestors": false,
  "minInvestment": 25000,
  "firstSaleDate": "2026-11-01",
  "firstSaleYetToOccur": false,
  "exemptions": ["06b", "3C"],
  "securitiesTypes": ["Equity"],
  "durationMoreThanOneYear": false,
  "isBusinessCombination": false,
  "relatedPersons": [
    { "name": "Janet Quillfeather", "relationships": ["Executive Officer", "Director"], "clarification": "CEO" },
    { "name": "Omar Zellwegerton", "relationships": ["Promoter"], "clarification": null }
  ],
  "website": "https://acmerobotics.com",
  "domain": "acmerobotics.com",
  "websiteConfidence": "high",
  "websiteEvidence": "legal name in copyright, city san francisco",
  "websiteSkipped": null,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1999001/000199900126000001/0001999001-26-000001-index.htm",
  "primaryDocUrl": "https://www.sec.gov/Archives/edgar/data/1999001/000199900126000001/primary_doc.xml",
  "source": "SEC EDGAR public data (Form D)",
  "scrapedAt": "2026-11-14T12:00:00.000Z"
}
```

A filing that could not be read is a free row with `status: "failed"` and an `error` with a code and a message. The
run's key-value store holds a `SUMMARY` record: days read, filings in the index, rounds delivered, rows filtered out
by reason, websites found, and why the run stopped (if it stopped early).

#### When SEC EDGAR cannot be read

- **Nothing could be read:** the run ends as **Failed**, returns no rows and charges nothing. The status line and
  `SUMMARY.secError` say why in plain words (for example `HTTP 503` or `timeout`). Run it again later.
- **Some days could not be read:** the run succeeds with the rounds of the days it read. `SUMMARY.daysMissing` lists
  the days it could not read, and the status line names them: run those days again later.
- **With a `monitorId`:** a filing that could not be read gives one free failed row. Later runs try it again without
  a new row and deliver it as a normal round once it can be read. After 3 failed runs it is not tried again
  (`SUMMARY.permanentlyFailed`).

### Pricing

Pay per round: you pay for each round delivered (`status: "ok"`), never for failed filings, filtered filings, rounds
skipped in monitor mode or the free contact row. The price per round is shown on the **Pricing** tab, with lower
prices on higher Apify plans. `maxItems` caps what one run can cost.

### Limits

- Form D only (new rounds and amendments). Companies that raise money without filing a Form D are not in it.
- Amounts are as filed: `totalSold` is what the company had sold at filing time; an amendment updates it.
- The website match is not perfect: a common name may have no match (`website: null`), and `medium` matches are
  worth a quick check.
- At most 366 days per run; for longer history, run it month by month.
- The SEC limits automated access per user across all machines. Apify servers are shared, so another user's heavy
  traffic can make the SEC slow you down: the Actor then waits 10 minutes once and otherwise stops cleanly.

### FAQ

**Is this a SEC Form D scraper?** It reads Form D filings through the official EDGAR daily index and filing documents,
with your declared contact, at a polite pace. No login, no browser, no proxy.

**How fresh are the rounds?** A filing appears in the EDGAR daily index for the business day it was accepted. A daily
schedule with a `monitorId` picks each round up once, on the first run after it appears.

**Why does it need my email?** The SEC asks every automated user to say who they are. Your name and email go only into
the request header sent to the SEC. They are never in the output, and the email is masked in the log.

**What is `websiteConfidence`?** `high` = the homepage names the legal company and its city or state; `medium` = the
homepage shows the exact full legal name, without a location match.

**Does it return people's addresses?** No. Executives and directors are returned with their names and roles as filed,
never their addresses.

### Related tools by Tan Solutions

- [Company Filings & Financials](https://apify.com/tan-solutions/company-filings): filing history and key financial facts of US public companies.
- [Domain Intelligence](https://apify.com/tan-solutions/domain-intel): DNS, WHOIS/RDAP, SSL and tech stack for the domains you get here.
- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): web pages to clean Markdown for LLMs, RAG pipelines and AI agents.
- [Document to Markdown](https://apify.com/tan-solutions/document-to-markdown): PDF, Word and PowerPoint files to Markdown for LLMs and RAG.
- [SEO Audit Tool](https://apify.com/tan-solutions/seo-audit): on-page SEO checker with PageSpeed for any list of pages.

### Your responsibilities

You are responsible for lawful use of the data you get back, including the names of people in the filings (for
example under privacy and anti-spam law when you contact them), and for following the SEC's fair-access policy in your
own downstream use. The Actor reads only official public EDGAR files, declares your contact, keeps to a polite pace and
stops when asked. Data is provided without warranty (filings can be amended, and website matches can be wrong);
liability is capped at the fees you paid in the last 12 months. Please cite the U.S. SEC (EDGAR) as the source when
you publish the data. Questions and issues are answered within 14 days through the Actor's Issues tab.

Not affiliated with, endorsed or approved by the U.S. Securities and Exchange Commission. SEC and EDGAR are marks of
the U.S. Securities and Exchange Commission.

Made by Tan Solutions.

# Actor input Schema

## `companyName` (type: `string`):

Replace the example with your own. The SEC fair-access policy asks automated tools to declare a company name and a contact email in the User-Agent header. Sent only to the SEC and never stored in the results.

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

Replace the example with an address where the SEC can reach you about your traffic. Sent only to the SEC in the User-Agent header; never stored in the results and masked in the log.

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

Date YYYY-MM-DD. Empty = 3 days before the end date. At most 366 days per run.

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

Date YYYY-MM-DD. Empty = today.

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

State codes of the issuer's address, e.g. CA, NY, TX. Empty = all.

## `industries` (type: `array`):

Words from the industry group as filed, e.g. Technology, Biotechnology, Real Estate, Oil and Gas. Empty = all.

## `minOffered` (type: `integer`):

Keep rounds offering at least this amount.

## `maxOffered` (type: `integer`):

Keep rounds offering at most this amount.

## `minSold` (type: `integer`):

Keep rounds that raised at least this amount so far.

## `maxSold` (type: `integer`):

Keep rounds that raised at most this amount so far.

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

New = the first Form D of a round (D). Amendment = an update (D/A).

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

On by default: skips hedge, private equity and venture funds raising money, so you get operating companies.

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

A safety cap for this run, newest first. You pay only for rounds delivered.

## `monitorId` (type: `string`):

Any name, e.g. daily-ca-tech (letters, digits, - and \_). Runs with the same monitor ID skip rounds delivered before (kept 400 days), so a daily schedule returns only new rounds.

## `requestsPerSecond` (type: `number`):

The SEC allows 10 per second per user; this Actor uses 5 by default and never more.

## Actor input object example

```json
{
  "companyName": "Your Company",
  "contactEmail": "you@example.com",
  "filingType": "all",
  "excludePooledFunds": true,
  "maxItems": 20,
  "requestsPerSecond": 5
}
```

# Actor output Schema

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

One item per Form D filing: issuer, amounts, investors, related persons, website and the filing link.

# 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 = {
    "companyName": "Your Company",
    "contactEmail": "you@example.com",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tan-solutions/form-d").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 = {
    "companyName": "Your Company",
    "contactEmail": "you@example.com",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tan-solutions/form-d").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 '{
  "companyName": "Your Company",
  "contactEmail": "you@example.com",
  "maxItems": 20
}' |
apify call tan-solutions/form-d --silent --output-dataset

```

## MCP server setup

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

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/2nfycTXXoIIehPgZP/builds/T3FbO8b9d23RY4KOJ/openapi.json
