# Form D Funding Leads: Newly Funded Companies & Executives (`datagleaner/form-d-funding-leads`) Actor

Companies that just raised money, from SEC Form D filings: amount raised, phone, address and named executives. $0.01 per filing with executives. Filter by keyword, state, industry or amount; filings appear the same day.

- **URL**: https://apify.com/datagleaner/form-d-funding-leads.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 filing with executives

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 Leads: Newly Funded Companies & Executives

**Companies that just raised money, from SEC Form D filings: amount raised, phone, address and named executives. $0.01 per filing with executives.** Answers "recently funded startups", "companies that raised money", "startup funding leads", "sec form d" and "sec form d executives", and agent questions like "who just raised money in fintech in Texas" or "which biotech companies raised over $5M this week". Each US private raise filed with SEC EDGAR becomes one lead: the company, how much it raised and is raising, its phone and address, its industry, and the executives and directors named on the filing. New filings appear the same day SEC accepts them. No login, no API key.

Built for sales teams, agencies, lenders, recruiters and AI agents: one row per filing, the same fields every time, and you pay only for filings that name a person to contact.

### Use cases

- **Sales prospecting:** companies that just closed a round have budget and are hiring vendors. Pull every software company that filed this week, with the CEO's name and the company phone.
- **Agencies and consultants:** reach founders in the weeks after a raise, filtered by state and industry.
- **Lenders and financial services:** venture debt, banking and insurance offers to freshly funded companies, sized by `totalAmountSold`.
- **Recruiters:** funded companies hire next. Filter by state for local searches.
- **Investors and analysts:** track who is raising in a sector, how much, from how many investors, and under which exemption.
- **AI agents:** "list companies in Texas that raised money in the last 30 days" as one tool call.

### What you get

From each Form D filing (the notice a US company files within 15 days of first selling securities in a private raise):

- **Company:** name, SEC CIK, entity type, state of incorporation, year of incorporation.
- **Contact:** phone (E.164, e.g. `+18014018625`) and principal business address.
- **The raise:** total offering size, amount already sold, amount remaining, number of investors, minimum investment, date of first sale, securities offered (equity, debt, options, SAFE-style rights), exemption claimed (Rule 506(b), 506(c) and others), industry group, revenue range when disclosed.
- **People:** every executive officer, director and promoter named on the filing, with their relationships and city; the person who signed the filing with their title (usually the CEO); brokers paid to sell the round.
- **Links:** the filing on EDGAR, the raw XML, and the company's Form D history.

### How it works

1. Your keywords, states, industries or company names become EDGAR full-text searches over Form D filings in the date window, newest day first.
2. Each matching filing's `primary_doc.xml` is read from SEC EDGAR and turned into one row.
3. Funds, LPs and SPVs (most Form D volume, and useless as sales leads) are dropped by default, and so are amendments (Form D/A), so each raise appears once.

Plain HTTP, no browser. Every request declares itself to SEC as SEC's fair-access policy asks, and the Actor stays at or under 5 requests a second (SEC allows 10). Results are deduplicated by accession number.

**Keywords and sectors.** Form D has no business description; the only sector field is a Form D industry group. So a keyword that names a sector (`software`, `saas`, `ai`, `fintech`, `biotech`, `healthcare`, `real estate`, `energy`, `insurance` and more) also matches the industry groups that sector files under: `software` matches Other Technology, Computers and Telecommunications. Every keyword is also searched as plain text, which finds company names, people and cities. `matchedBy` says which search found each row.

### Input

| Field | Meaning |
|---|---|
| `keywords` | Keywords or sectors, e.g. `software`, `fintech`, `Austin`. Each one is searched separately. |
| `states` | Two-letter US state codes, e.g. `TX`, `CA`, matched on the company's place of business in EDGAR. |
| `industries` | Form D industry groups to keep, e.g. `Other Technology`, `Biotechnology`, `Other Banking and Financial Services`, `Commercial` (real estate). |
| `companies` | Company names or SEC CIK numbers. Without a From date, the company's whole Form D history is searched. |
| `daysBack` | How many days back to search (default 7). |
| `dateFrom`, `dateTo` | An exact filing-date window instead of `daysBack`. |
| `minAmountSold` | Keep raises with at least this much sold, in USD, e.g. `1000000`. |
| `excludeFunds` | Drop pooled investment funds, LPs and SPVs (default true). |
| `includeAmendments` | Also return amended filings, Form D/A (default false). |
| `maxFilings` | Stop after this many rows, newest first (default 100). |
| `maxRequestsPerSecond`, `requestTimeoutSecs`, `proxyConfiguration` | Pacing and network options. No proxy by default. |

Leave every search field empty to run a built-in example: the 5 newest non-fund filings from the last 3 days (5 x $0.01 = $0.05 at most), stated in the run's status message.

```json
{
  "keywords": ["software", "fintech"],
  "states": ["TX", "CA"],
  "daysBack": 14,
  "minAmountSold": 1000000,
  "maxFilings": 200
}
```

### Output

One row per filing. Fields the filing leaves blank are empty, never invented.

```json
{
  "companyName": "Oliver Software, Inc.",
  "cik": "1980218",
  "accessionNumber": "0001980218-26-000003",
  "formType": "D",
  "isAmendment": false,
  "filingDate": "2026-10-06",
  "entityType": "Corporation",
  "jurisdictionOfIncorporation": "Delaware",
  "yearOfIncorporation": 2022,
  "phone": "+18014018625",
  "address": {"street": "2701 N. Thanksgiving Way, STE 100", "city": "Lehi", "state": "UT", "zip": "84043", "country": "US"},
  "city": "Lehi",
  "state": "UT",
  "industryGroup": "Business Services",
  "revenueRange": "Decline to Disclose",
  "totalOfferingAmount": 2075000,
  "isOfferingAmountIndefinite": false,
  "totalAmountSold": 2075000,
  "totalRemaining": 0,
  "minimumInvestment": 0,
  "numberOfInvestors": 3,
  "hasNonAccreditedInvestors": false,
  "dateOfFirstSale": "2026-09-21",
  "firstSaleYetToOccur": false,
  "securitiesTypes": ["Equity"],
  "durationMoreThanOneYear": false,
  "federalExemptions": ["Rule 506(b)"],
  "salesCommissions": 0,
  "findersFees": 0,
  "firstExecutive": "Stephen Lytle",
  "firstExecutiveTitle": "Chief Executive Officer",
  "executives": [
    {"name": "Stephen Lytle", "relationships": ["Executive Officer", "Director"], "title": "Chief Executive Officer", "city": "Lehi", "state": "UT"},
    {"name": "Tyler Bowers", "relationships": ["Director"], "title": null, "city": "Lehi", "state": "UT"},
    {"name": "Shaun Sorensen", "relationships": ["Director"], "title": null, "city": "Lehi", "state": "UT"}
  ],
  "executiveCount": 3,
  "salesCompensation": [],
  "signerName": "Stephen Lytle",
  "signerTitle": "Chief Executive Officer",
  "hasExecutives": true,
  "isFund": false,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1980218/000198021826000003/0001980218-26-000003-index.htm",
  "xmlUrl": "https://www.sec.gov/Archives/edgar/data/1980218/000198021826000003/primary_doc.xml",
  "edgarCompanyUrl": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0001980218&type=D&dateb=&owner=include&count=40",
  "matchedBy": ["keyword:software"],
  "status": "ok",
  "error": null,
  "input": "keyword:software",
  "scrapedAt": "2026-10-09T15:33:13+00:00"
}
```

`firstExecutive` is the executive who signed the filing when they are listed, else the first named executive or director; `firstExecutiveTitle` is their signed title, else their Form D relationship. Form D gives titles only for the signer, so other people carry their relationships (Executive Officer, Director, Promoter). `totalOfferingAmount` is null when the filing says the offering is indefinite (`isOfferingAmountIndefinite: true`). A filing SEC did not return gets a row with `status: "error"`, free.

The dataset has two views: **Funding leads** (company, date, amount sold, industry, state, phone, first executive) and **Executives** (one row per named person, with the company and its phone), ready to export as CSV or Excel.

### Pricing

Pay per lead, one event:

- **`filing-with-executives`: $0.01** for each Form D filing returned with the company's phone, address, offering amounts and at least one named executive or director.
- A filing with **no named executive or director** (or no usable phone) is returned **free**. Error rows are free. There is no start fee.

**Worked example.** A week of `software` filings returned 99 companies, 98 with a named executive: 98 x $0.01 = **$0.98**. The one with a placeholder phone cost nothing.

**Compared with the alternatives.** Funding-round Actors on the Store charge $0.07 to $0.08 per round, so the same 98 leads cost about $7 there: this is 7 to 8 times cheaper, straight from the SEC source.

Set a maximum total charge on the run and the Actor stops cleanly when it is reached.

### What to expect

Measured on 9 October 2026: `software` over the last 7 days returned 99 filings in 49 seconds (131 SEC requests), 98 with a named executive and an E.164 phone. About 250 to 300 Form D filings arrive on a working day; roughly two thirds are funds and SPVs, which are filtered out by default, leaving 80 to 100 operating companies a day. Biotechnology with at least $1M sold returned 10 companies from one week; fintech in Texas over 30 days returned 10 within the cap.

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/form-d-funding-leads`

Minimal input:

```
{"keywords": ["software"], "daysBack": 7, "maxFilings": 20}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/form-d-funding-leads` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/form-d-funding-leads`. Without a token, an agent can still find Actors with the `search-actors` tool, but running this one needs your Apify account. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/form-d-funding-leads"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "List software startups that filed a Form D this week with their CEO and phone, and flag any that raised more than $5 million."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/form-d-funding-leads")
result = tool.invoke({"run_input": json.loads('{"keywords": ["software"], "daysBack": 7, "maxFilings": 20}')})
```

### Limits

- Form D covers US private raises under Regulation D and Section 4(a)(5). Companies that raised without filing, or that file late, are not included until they file. Public offerings and Regulation CF crowdfunding (Form C) are not Form D.
- Form D gives no email, website or business description. Pair the company name or phone with an enrichment tool (see the FAQ).
- Titles are given only for the person who signed the filing; others carry their Form D relationship.
- The industry group is chosen by the filer and is coarse: most startups file as Other Technology, Business Services or Other.
- EDGAR full-text search covers filings from 2001 onward. Each search window is capped at 10,000 filings; the Actor splits long ranges into day or week windows to stay under it.

### FAQ

**What is Form D?** The notice a company files with the SEC within 15 days after it first sells securities in a private placement exempt from registration (most startup seed, Series A and later rounds, and private funds). It lists the issuer, its address and phone, the raise's size and the people who run it. It is public on SEC EDGAR.

**Why is there no email?** Form D does not ask for one. To get emails, find the company's website, then run the domain through [Company Enrichment by Domain](https://apify.com/datagleaner/company-enrichment-by-domain) or [Website Contact Details Scraper](https://apify.com/datagleaner/website-contact-details-scraper) from Data Gleaner for its public emails, socials and more phones.

**How fresh is it?** Filings appear on EDGAR the same day SEC accepts them, and this Actor reads EDGAR live, so a run returns filings from today. Run it daily with `daysBack: 1` for a steady feed of new leads.

**Why are funds excluded?** About two thirds of Form D filings are pooled investment funds, LPs and SPVs: vehicles, not companies you can sell to. Turn off `excludeFunds` (or choose the Pooled Investment Fund industry) to include them.

**Does "amount sold" mean the round is closed?** It is what had been sold when the filing was made. `totalRemaining` shows what the company still plans to raise; an open round may later appear again as an amendment (Form D/A).

**What happens if I start it with no input?** It runs the built-in example, the 5 newest non-fund filings from the last 3 days, and says so in the status message.

### Responsible use

Form D filings are public US government records, free to reuse. This Actor reads public data only, from SEC EDGAR, within SEC's fair-access limits. Names, phones and addresses of company officers can still be personal data: you are responsible for lawful use, including GDPR, CCPA, TCPA, CAN-SPAM and do-not-call rules, honoring opt-outs, and sending relevant, individual outreach rather than bulk messages.

# Actor input Schema

## `keywords` (type: `array`):

Search Form D filings by keyword, for example `software`, `fintech`, `biotech` or a city or person's name. Each keyword runs as an EDGAR full-text search (company names, people, places). Form D has no business description, so a keyword that names a sector (software, saas, ai, fintech, biotech, real estate, energy and more) also matches the Form D industry groups that sector files under. Leave every search field empty to run a 5-filing example.

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

Two-letter US state codes, for example `TX` or `CA`, matched on the company's principal place of business in EDGAR.

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

Keep only filings in these Form D industry groups, such as Other Technology, Biotechnology, Other Banking and Financial Services or Commercial (real estate). Choosing Pooled Investment Fund turns off the fund filter.

## `companies` (type: `array`):

Company names or SEC CIK numbers, for example `Anthropic` or `1980218`. Without a From date, a company's whole Form D history is searched.

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

How many days back from today to search. Ignored when From date is set, and for Companies.

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

Earliest filing date (YYYY-MM-DD). Overrides Days back.

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

Latest filing date (YYYY-MM-DD). Defaults to today.

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

Keep only filings that report at least this much already sold, for example `1000000` for raises of $1M or more.

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

Drop pooled investment funds, limited partnerships and SPVs, which are most Form D volume and of little use as sales leads.

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

Also return amended filings (Form D/A). Off by default, so each raise appears once as its original filing.

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

Stop after this many filings are returned, newest first.

## `maxRequestsPerSecond` (type: `number`):

Pacing toward SEC. SEC's fair-access rule allows 10 a second; this Actor never goes above 5.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each SEC response before retrying.

## `proxyConfiguration` (type: `object`):

Optional. Defaults to no proxy, which works: SEC EDGAR is public and serves Apify's servers.

## Actor input object example

```json
{
  "keywords": [
    "software"
  ],
  "daysBack": 7,
  "excludeFunds": true,
  "includeAmendments": false,
  "maxFilings": 100,
  "maxRequestsPerSecond": 5,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "keywords": [
        "software"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/form-d-funding-leads").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 = { "keywords": ["software"] }

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/form-d-funding-leads").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 '{
  "keywords": [
    "software"
  ]
}' |
apify call datagleaner/form-d-funding-leads --silent --output-dataset

```

## MCP server setup

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

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/tYiRY3kkf8ecxMyLr/builds/ntgw6cQRWWTKE4GvT/openapi.json