# SEC Form D — Private Fundraise Filings, Amounts & People (`foxlabs/sec-form-d-offerings`) Actor

A fresh, structured feed of companies that just raised private capital via SEC Form D (Reg D): issuer name, HQ, phone, industry, offering amount offered/sold, security type, first sale date and the executives/directors behind it. Official EDGAR data — no API key.

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

## Pricing

$4.00 / 1,000 form d filings

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

## SEC Form D — Private Fundraise Filings, Amounts & People

🎉 A fresh, structured feed of **US companies that just raised private capital** — who raised, **how much**, in what industry, from where, and **which executives and directors signed for it**. Straight from the official [SEC EDGAR](https://www.sec.gov/) Form D (Regulation D) filings. No login, no API key, one row per filing.

Run it on the [Apify platform](https://apify.com) for API access, scheduling, integrations and monitoring.

> Not affiliated with the U.S. Securities and Exchange Commission. EDGAR data is in the public domain.

### 🔍 What is the SEC Form D feed — and when should you use it?

Every company raising money privately in the US files a **Form D** with the SEC, usually within 15 days of the first sale. Several hundred land every business day. The filing is public and authoritative, but it arrives as raw XML, one document per deal, with no search across them and no clean fields.

This Actor turns that stream into rows: the issuer (name, HQ, phone, jurisdiction, year, industry), the offering (amount offered, amount sold, remaining, security type, first-sale date, investor count) and the **related persons** — every executive, director and promoter named, with the role they are filed under and, where the issuer gave one, their title.

**Use it when you need:** newly-funded companies to sell into while the budget is fresh; a daily deal feed for VC, private-credit or capital-markets coverage; decision-maker names at companies that just raised; or a territory list of raises by state and size.

**Use something else when:** you need public-company financials (10-K/10-Q) or SEC enforcement history — those are separate filings, not Form D.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/sec-form-d-offerings`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered filing, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want US companies that just raised private capital, using the Apify Actor
`foxlabs/sec-form-d-offerings`.

Input: `dateFrom` / `dateTo` are filing dates (YYYY-MM-DD; default = the last 7 days).
Optional filters: `state` (issuer's US state, "CA" or "CALIFORNIA"), `minOfferingAmount`
(USD, keeps only offerings at least this large), `maxResults` (cap, 0 = 1000).
`ciks` optionally looks up specific companies instead, by CIK number or company name.
Each row has companyName, cik, filingDate, hqCity, hqState, phone, industryGroup,
totalOfferingAmount, totalAmountSold, totalRemaining, securityTypes, dateOfFirstSale,
investorsAlreadyInvested, relatedPersons (name + relationships + title) and filingUrl.

Start with:
{ "dateFrom": "2026-10-01", "minOfferingAmount": 1000000, "maxResults": 100 }

Ask me which period, state and deal size I care about, run the Actor, then summarise the
companies as a table with the amount raised and the people named on the filing.
```

Things you can ask your agent for:

- "Which California companies raised over $5M in the last two weeks, and who signed?"
- "Every Form D filed yesterday in the software industry, with the officers named."
- "Has this company filed a Form D before, and for how much?"

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/sec-form-d-offerings.md`.

### 📋 Overview

| | |
|---|---|
| **Source** | SEC EDGAR — full-text search for discovery, each filing's `primary_doc.xml` for detail |
| **Coverage** | Every Form D and Form D/A filed in the US; roughly 250 new filings per business day |
| **Freshness** | Read live from EDGAR during your run — filings appear as the SEC publishes them |
| **Access** | Official, public-domain, free. No key, no login, no anti-bot |
| **Modes** | Date-range feed (default) or lookup by company name / CIK |

### ✨ Features

- 🆕 **Fresh capital signal** — a company that just closed a round has budget and a reason to buy.
- 👤 **Decision-makers included** — every executive, director and promoter on the filing, with their role; about 4 in 10 also carry a filed job title.
- 💵 **Real money figures** — amount offered, amount sold and remaining, so you can size the deal.
- 🏛️ **Official and clean** — public-domain SEC data; the simplest terms of any business-data source.
- 🔎 **Filter where it matters** — by filing date, issuer state and minimum offering size.
- 🧩 **Same core schema as the series** — join with the sibling company Actors on `companyName`.
- 💰 **Pay only for results** — per delivered filing; filtered-out and unreadable filings are never billed.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~sec-form-d-offerings/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "dateFrom": "2026-10-01", "minOfferingAmount": 1000000, "maxResults": 100 }'
```

### 🚀 Getting Started (3 steps)

1. Open the **Input** tab. For a feed of new raises, set `dateFrom` / `dateTo` — leave them empty for the last 7 days.
2. *(Optional)* Narrow by `state` or `minOfferingAmount`; or put company names / CIK numbers in `ciks` to look up specific issuers instead.
3. Click **Start**, then download as JSON, CSV, Excel or HTML.

### 📥 Input

| Field | Type | Description |
|---|---|---|
| `dateFrom` / `dateTo` | string | Filing date range (`YYYY-MM-DD`). Default: the last 7 days. |
| `ciks` | array | Specific companies by CIK number or name. Switches to lookup mode; the date range is then ignored. |
| `state` | string | Keep only issuers in this US state (`CA` or `CALIFORNIA`). |
| `minOfferingAmount` | integer | Keep only offerings at least this large, in USD. Filings with an indefinite amount are left out. |
| `maxResults` | integer | Maximum filings to deliver (0 = 1000). |

### 📤 Output

One row per filing, saved to the dataset.

```json
{
  "companyName": "Curiosity Brewing Co LLC",
  "cik": 2159000,
  "filingDate": "2026-10-07",
  "formType": "D",
  "entityType": "Limited Liability Company",
  "jurisdictionOfInc": "MASSACHUSETTS",
  "yearOfIncorporation": "2023",
  "hqCity": "Medford",
  "hqState": "MASSACHUSETTS",
  "phone": "7815551234",
  "industryGroup": "Other",
  "totalOfferingAmount": 900000,
  "totalAmountSold": 245000,
  "totalRemaining": 655000,
  "securityTypes": ["equity"],
  "dateOfFirstSale": "2025-11-02",
  "investorsAlreadyInvested": 8,
  "relatedPersons": [
    { "name": "Nicolas DeFae", "relationships": ["Executive Officer", "Director"], "title": "CEO" }
  ],
  "signedBy": "Nicolas DeFae",
  "signerTitle": "CEO",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/2159000/000.../primary_doc.xml",
  "source": "SEC EDGAR Form D",
  "scrapedAt": "2026-10-11T18:00:00.000Z"
}
```

| Group | Fields |
|---|---|
| Issuer | `companyName`, `cik`, `entityType`, `jurisdictionOfInc`, `yearOfIncorporation`, `hqStreet`, `hqCity`, `hqState`, `hqZip`, `phone`, `industryGroup`, `revenueRange` |
| Offering | `totalOfferingAmount`, `totalAmountSold`, `totalRemaining`, `minimumInvestment`, `securityTypes`, `dateOfFirstSale`, `hasNonAccreditedInvestors`, `investorsAlreadyInvested` |
| People | `relatedPersons[]` (name, relationships, title), `signedBy`, `signerTitle` |
| Meta | `filingDate`, `formType`, `isAmendment`, `accession`, `filingUrl`, `edgarUrl` |

A field the issuer did not file comes back as `null` — never as a zero or a guess. Offerings filed as "indefinite" therefore have `totalOfferingAmount: null` while `totalAmountSold` still carries the real figure.

### 💼 Use cases

**1. Sell to newly-funded companies**
*Input:* `dateFrom` = yesterday, `minOfferingAmount: 1000000`, scheduled daily. *Output:* companies that just raised, with officers and phone. *Use:* reach them while the budget is new.

**2. Private-market deal feed**
*Input:* a weekly date range, no filters. *Output:* every raise with amount and industry. *Use:* track deal flow and size by sector.

**3. Territory list for a regional team**
*Input:* `state: "TX"`, last 30 days. *Output:* Texas issuers with HQ and people. *Use:* hand a rep a list of local companies with fresh capital.

**4. Company watch**
*Input:* the company's name or CIK in `ciks`. *Output:* its Form D history with amounts. *Use:* see whether and how often a target has raised.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/sec-form-d-offerings').call({
  dateFrom: '2026-10-01', minOfferingAmount: 1000000, maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/sec-form-d-offerings').call(
    run_input={'dateFrom': '2026-10-01', 'minOfferingAmount': 1000000, 'maxResults': 100}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule a daily run for yesterday's filings → handle the JSON dataset → push new raises straight into your CRM or a sheet.

### 📊 Pricing

Pay-per-event: **$0.004 per filing delivered**. Filings filtered out by your `state` or `minOfferingAmount`, and filings whose document cannot be read, are never billed. Example: a day's feed of 250 filings costs $1.00. [View current pricing.](https://apify.com/foxlabs/sec-form-d-offerings)

### ❓ FAQ

**Is this legal?** EDGAR is public-domain US government data, published by the SEC for exactly this kind of use. You remain responsible for how you use personal data (officer names) under the law that applies to you.

**Why is the offering amount sometimes empty?** Some issuers file an **indefinite** offering amount. That is returned as `null` rather than invented; `totalAmountSold` is still there.

**Are the people fields personal contact details?** No. They are the names and roles of officers, directors and promoters as filed (a title only when the issuer filed one — roughly 4 in 10), plus the issuer's own business address and phone.

**How fresh is it?** The Actor reads EDGAR during your run, so a filing is available as soon as the SEC publishes it. Form D is normally filed within 15 days of the first sale.

**Does it include amendments?** Yes — Form D/A filings come through with `isAmendment: true`.

### 🐛 Troubleshooting

- **Fewer rows than expected** — `minOfferingAmount` drops indefinite-amount filings, and `state` matches the issuer's state as filed (a Delaware-incorporated company usually has its HQ elsewhere; `state` filters the HQ).
- **A date range with no results** — EDGAR has no filings on weekends and US federal holidays.
- **A filing could not be read** — the run reports the count and never charges for it; re-run the same range to pick it up.

### ⚠️ Trademark

"SEC" and "EDGAR" are used only to describe the public data source. This Actor is not affiliated with, endorsed by or sponsored by the U.S. Securities and Exchange Commission.

### ⚖️ Is it legal to scrape this data?

This Actor reads only official, public-domain filings that the SEC publishes for public use, through EDGAR's documented access rules (a descriptive user agent and a request rate under the published limit). It collects no private or login-gated data. Your results can contain personal data — the names and titles of officers and directors — which remains protected by laws such as the GDPR and the CCPA; you are responsible for having a lawful basis for processing it.

### 🤝 Support & contact

Found a bug or a field you need? Open an issue on the **Issues** tab — it reaches us directly.

### Changelog

#### 0.1.1 — 2026-10-14 — pricing

- Pay-per-event charging: **$0.004 per filing delivered**. Filings filtered out by `state` or `minOfferingAmount`, and filings whose document cannot be read, are free.
- README expanded: AI-agent usage, quick start, integration snippets, use cases and pricing.

#### 0.1.0 — 2026-10-11

- Initial release: EDGAR Form D feed + per-company lookup, with issuer, offering and related-person fields.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/sec-form-d-offerings/changelog.md

# Actor input Schema

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

Earliest filing date. Defaults to 7 days ago. Ignored when specific companies are given below.

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

Latest filing date. Defaults to today.

## `ciks` (type: `array`):

Look up Form D filings for specific companies by SEC CIK number or company name, instead of the date-range feed.

## `state` (type: `string`):

Only keep issuers headquartered in this US state (name or 2-letter code, e.g. "CA" or "CALIFORNIA").

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

Only keep offerings whose total offering amount is at least this. Filings with an indefinite/undisclosed amount are dropped when this is set.

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

Maximum filings to deliver (0 = default 1000).

## Actor input object example

```json
{
  "ciks": [],
  "maxResults": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `report` (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 = {
    "ciks": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/sec-form-d-offerings").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 = { "ciks": [] }

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

```

## MCP server setup

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

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/3imzdSQOFIMUGHGhJ/builds/N1BYUQnGmk2UGPi0R/openapi.json