# SEC Form D: Private Placement Funding Rounds and Amounts (`yadroo/sec-form-d-offerings`) Actor

Private funding rounds as rows from official SEC Form D notices: issuer, state, industry group, amount offered and sold, minimum investment, investor count, first-sale date and exemption claimed. Filter by state, industry, amount or Rule 506(c), skip funds, watch only new filings. UTC dates.

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

## Pricing

from $2.80 / 1,000 form d offerings

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

When a US company or fund sells securities privately, it has fifteen days to tell the Securities and Exchange
Commission about it on **Form D** — and the SEC publishes that notice as a structured document the same day. This
actor turns those notices into rows: who is raising, where they sit, which industry they ticked, how much they offered,
how much they have already sold, the smallest cheque they accept, how many investors are in, under which exemption,
and when the first money arrived. The source is EDGAR itself, so there is no key, no account, no login and no browser —
and the figures are the issuer's own filing rather than someone's editorial summary.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/sec-form-d-offerings/issues) and describe what you need — we read every request and adapt the actor.

### Use cases

- **Deal flow for investors**: every operating company that filed a Form D in the last seven days, funds and SPVs left
  out, sorted newest first — the closest thing to a weekly list of fresh private rounds from an official source.
- **Territory and sector lists for sales teams**: Californian technology issuers, New York issuers of any kind, or
  health-care issuers only, with the city and the amount already sold next to the name.
- **Size screens**: only notices reporting at least ten million dollars sold, or only seed-sized ones between one and
  five million, to separate growth rounds from first cheques.
- **Rule 506(c) watch for lawyers, journalists and fundraising platforms**: the offerings an issuer may advertise
  publicly, which is a question no company directory can answer.
- **LP and placement-agent view**: new venture, private-equity and hedge funds filing their first notice, with the
  minimum investment and how many investors have already committed.
- **A daily or weekly schedule into a CRM or an agent**: turn on `onlyNew` and each run carries only the notices that
  appeared since the previous one, cut down to the columns you need with `fields`.
- **Research tables**: amounts offered and sold, investor counts, sales commissions and finders fees across hundreds of
  notices, for a market report or a model.

### Input

Nothing is required: with an empty input the run covers the last seven days of notices. Dates and windows are UTC.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `sinceHours` | integer | `168` | 1–8760. Rolling window on the filing date. 24 = yesterday and today, 168 = a week, 720 ≈ a month. Ignored when `filedSince` is set. Form D is filed on business days, so a window under 72 hours can be empty over a weekend. |
| `filedSince` | string | — | `YYYY-MM-DD`, inclusive. A fixed window instead of the rolling one. Electronic Form D starts in September 2008. |
| `filedUntil` | string | — | `YYYY-MM-DD`, inclusive. Empty = today. Used together with `filedSince`; on its own it is ignored. |
| `onlyNew` | boolean | `false` | Remember the accession numbers this run writes and, next time, write only notices that were not written before. The memory is shared by every run of this actor and keyed by the filter values, so two tasks with different filters keep separate memories and the same task (or an identical input run again) continues where it stopped. |
| `issuerNameContains` | string | — | A name fragment EDGAR matches itself: `labs`, `ventures`, `capital`. Case is ignored. |
| `ciks` | string\[] | — | Up to 50 EDGAR central index keys, leading zeros optional: `2159178`, `0002159178`. Not tickers — a Form D filer is almost never listed. |
| `states` | string\[] | — | Up to 56 values, combined with OR: two-letter US codes or full state names (`CA`, `California`, `New York`). Case, spaces and accents are ignored; a value that is neither a known state nor a two-character code is refused with the closest matches named. Any other two-character value is passed to EDGAR as typed, which is how its country codes work. See [States](#states). |
| `stateMatch` | string (select) | `located` | `located` (issuer's business address) or `incorporated` (state or country of incorporation). Strict: the platform refuses any other value before the run starts. |
| `industryGroups` | string\[] | — (prefill `["Computers"]`) | Up to 20 values, combined with OR: the industry the issuer ticked, or a sector heading that stands for all of its groups. Short spellings such as `tech`, `software`, `biotech`, `pharma`, `telecom`, `real estate` and `fund` are matched; anything else is refused with suggestions. Needs the filing itself — see `maxFilingsScanned`. Full list under [Industry groups](#industry-groups). |
| `excludeFunds` | boolean | `false` (prefill `true`) | Drop pooled investment vehicles — funds, SPVs, series LLCs — and keep operating companies. A notice counts as a vehicle when its industry group is `Pooled Investment Fund`, it names a fund type, or it claims an Investment Company Act section 3(c) exclusion. |
| `investmentFundTypes` | string\[] | — | The opposite job: keep only vehicles of a kind — `Venture Capital Fund`, `Private Equity Fund`, `Hedge Fund`, `Other Investment Fund`. `vc`, `venture`, `pe` and `hedge` are matched. Setting this together with `excludeFunds` is refused as a contradiction. |
| `exemptions` | string\[] | — | Up to 20 rules, combined with OR, written as on the form or in short: `506(b)`, `506b`, `Rule 506(c)`, `504(b)(1)(i)`, `4(a)(5)`, `3(c)(1)`. Answered by the search index, so it costs no extra reading. See [Exemptions](#exemptions). |
| `noticeType` | string (select) | `any` | `any`, `new` (first notice, form D) or `amendment` (form D/A). Strict: the platform refuses any other value before the run starts. |
| `minAmountSold` | integer | — | Keep notices reporting at least this much already sold (`amountSoldUsd`). Notices that report no figure are dropped by this filter. Needs the filing itself. |
| `maxAmountSold` | integer | — | Keep notices reporting at most this much sold. Combined with `minAmountSold` as a range. |
| `firstSaleSince` | string | — | `YYYY-MM-DD`. Filter on `dateOfFirstSale`, not on the filing date. Notices that report no first sale yet are dropped. Needs the filing itself. |
| `maxFilingsScanned` | integer | `400` | 25–3000. How many notices this run may open and read. Date, state, issuer, CIK, exemption and notice-type filters are answered by the search index and cost nothing here; industry, fund type, amounts and the first-sale date live inside the filing, so each candidate has to be read. |
| `maxItems` | integer | `50` | 1–1000. Hard cap on the rows this run writes, and so on what it costs. Newest filing first. |
| `fields` | string\[] | all | Keep only these columns, **in this order**. `accessionNumber`, `issuerName`, `cik`, `filingDate`, `url` and `fetchedAt` are always kept — they come first unless you list one of them, in which case it moves to the position you gave it. Unknown names are reported in the run's status message instead of being dropped in silence. |

Which filters are cheap and which cost a document read:

| Answered by the search index (free) | Needs the notice to be read (counts against `maxFilingsScanned`) |
|---|---|
| filing window, `states` + `stateMatch`, `ciks`, `issuerNameContains`, `exemptions`, `noticeType`, and most funds when `excludeFunds` is on (their 3(c) code is in the index) | `industryGroups`, `investmentFundTypes`, `minAmountSold`, `maxAmountSold`, `firstSaleSince`, and the final fund test |

### Reference

#### Industry groups

Item 4 of the form. The value in the row is the group the issuer ticked; `industrySector` is the heading the printed
form puts above it. Both are accepted in `industryGroups`, and a heading stands for every group under it.

| Sector heading | Industry groups |
|---|---|
| Agriculture | Agriculture |
| Banking & Financial Services | Commercial Banking · Insurance · Investing · Investment Banking · Pooled Investment Fund · Other Banking and Financial Services |
| Business Services | Business Services |
| Energy | Coal Mining · Electric Utilities · Energy Conservation · Environmental Services · Oil and Gas · Other Energy |
| Health Care | Biotechnology · Health Insurance · Hospitals and Physicians · Pharmaceuticals · Other Health Care |
| Manufacturing | Manufacturing |
| Real Estate | Commercial · Construction · REITS and Finance · Residential · Other Real Estate |
| Retailing | Retailing |
| Restaurants | Restaurants |
| Technology | Computers · Telecommunications · Other Technology |
| Travel | Airlines and Airports · Lodging and Conventions · Tourism and Travel Services · Other Travel |
| Other | Other |

The notices spell these labels with "and" where the printed form prints "&", so the row says `Oil and Gas`; both
spellings are accepted in the input. Other spellings that resolve: `tech`, `technologies` → Technology; `software`,
`saas`, `hardware`, `computer`, `it` → Computers; `telecom`, `telco` → Telecommunications; `biotech`,
`life sciences` → Biotechnology; `pharma`, `drugs` → Pharmaceuticals; `healthcare`, `health` → Health Care;
`fund`, `funds`, `spv`, `pooled fund` → Pooled Investment Fund; `banking`, `finance`, `financial services` → Banking &
Financial Services; `fintech` → Other Banking and Financial Services; `real estate`, `property` → Real Estate;
`reit`, `reits` → REITS and Finance; `proptech` → Other Real Estate; `retail`, `ecommerce` → Retailing;
`manufacturer`, `industrials` → Manufacturing; `oil`, `gas` → Oil and Gas; `cleantech`, `energy efficiency` → Energy
Conservation; `hotels`, `lodging` → Lodging and Conventions; `aviation`, `airlines` → Airlines and Airports;
`tourism` → Tourism and Travel Services. Case, extra spaces and accents never matter. Anything else is refused before
the run with the closest values named, so a misspelling costs one edit instead of a silently wider result set.

#### Fund types

Only a notice whose industry group is `Pooled Investment Fund` carries one: `Venture Capital Fund`,
`Private Equity Fund`, `Hedge Fund`, `Other Investment Fund`. Short spellings: `vc`, `venture`, `venture capital`,
`pe`, `private equity`, `buyout`, `hedge`, `other fund`.

#### Exemptions

Item 6 of the form. The row carries both the raw codes (`exemptionCodes`) and their rules (`exemptions`), plus
`primaryExemption` — the Securities Act rule the offering itself relies on, with Rule 506(c) ahead of 506(b), the
Rule 504 variants and Section 4(a)(5). The section 3(c) entries are Investment Company Act exclusions, which is what
marks a pooled vehicle, so they never become the primary exemption.

| Code | Rule | Write it as |
|---|---|---|
| `04` | Rule 504(b)(1), none of the (i)–(iii) variants | `504`, `504(b)(1)`, `Rule 504` |
| `04.1` / `04.2` / `04.3` | Rule 504(b)(1)(i) / (ii) / (iii) | `504(b)(1)(i)`, `504b1ii`, … |
| `06B` | Rule 506(b) — the quiet round that may not be advertised | `506(b)`, `506b`, `Rule 506(b)` |
| `06C` | Rule 506(c) — may be advertised publicly, every investor must be verified as accredited | `506(c)`, `506c`, `Rule 506(c)` |
| `4A5` | Securities Act Section 4(a)(5) | `4(a)(5)`, `4a5` |
| `3C` | Investment Company Act Section 3(c) | `3(c)`, `3c` |
| `3C.1` … `3C.14` | Section 3(c)(1) … 3(c)(14) | `3(c)(1)`, `3c7`, … |

#### States

`states` takes two-letter codes or full names for: Alabama AL, Alaska AK, Arizona AZ, Arkansas AR, California CA,
Colorado CO, Connecticut CT, Delaware DE, District of Columbia DC, Florida FL, Georgia GA, Hawaii HI, Idaho ID,
Illinois IL, Indiana IN, Iowa IA, Kansas KS, Kentucky KY, Louisiana LA, Maine ME, Maryland MD, Massachusetts MA,
Michigan MI, Minnesota MN, Mississippi MS, Missouri MO, Montana MT, Nebraska NE, Nevada NV, New Hampshire NH,
New Jersey NJ, New Mexico NM, New York NY, North Carolina NC, North Dakota ND, Ohio OH, Oklahoma OK, Oregon OR,
Pennsylvania PA, Rhode Island RI, South Carolina SC, South Dakota SD, Tennessee TN, Texas TX, Utah UT, Vermont VT,
Virginia VA, Washington WA, West Virginia WV, Wisconsin WI, Wyoming WY, Puerto Rico PR, Virgin Islands VI, Guam GU,
American Samoa AS, Northern Mariana Islands MP.

EDGAR also keeps two-character location codes for issuers outside the United States. Such a value is passed on as
typed and named in the run's status message, so a foreign location works even though it is not in the list above.

#### Issuer size bands

`revenueRange` (operating companies) and `aggregateNetAssetValueRange` (funds) are pass-through text, because the
bands the form prints have changed over the years — `$25,000,001 - $50,000,000` on older notices and
`$25,000,001 - $100,000,000` on newer ones. Both can also say `Decline to Disclose`, `Not Applicable`,
`No Revenues` or `No Aggregate Net Asset Value`. There is no input filter on them for the same reason.

### Examples

**New private funding rounds of the last week, no funds**

```json
{ "sinceHours": 168, "excludeFunds": true, "maxItems": 20, "maxFilingsScanned": 300 }
```

**Californian technology issuers of the last two weeks**

```json
{ "sinceHours": 336, "states": ["California"], "industryGroups": ["Technology"], "excludeFunds": true, "maxItems": 10, "maxFilingsScanned": 600 }
```

**Rule 506(c) offerings — the raises that may be advertised**

```json
{ "sinceHours": 336, "exemptions": ["506(c)"], "maxItems": 15, "maxFilingsScanned": 300 }
```

**Raises above ten million dollars already sold, last month**

```json
{ "sinceHours": 720, "minAmountSold": 10000000, "excludeFunds": true, "maxItems": 10, "maxFilingsScanned": 600 }
```

**New venture capital funds closing**

```json
{ "sinceHours": 336, "investmentFundTypes": ["Venture Capital Fund"], "maxItems": 10, "maxFilingsScanned": 500 }
```

**A New York watch list for a CRM, few columns, only what is new since the last run**

```json
{ "sinceHours": 336, "states": ["NY"], "onlyNew": true, "maxItems": 20, "fields": ["issuerState", "industryGroup", "amountSoldUsd", "dateOfFirstSale"] }
```

### Output

One Form D notice = one row. A real row from a cloud run (run `1HOl7AG6w3vL7bc94`):

```json
{
  "accessionNumber": "0002159178-26-000001",
  "issuerName": "Luminal AI, Inc.",
  "cik": "0002159178",
  "filingDate": "2026-10-07",
  "url": "https://www.sec.gov/Archives/edgar/data/2159178/000215917826000001/0002159178-26-000001-index.htm",
  "fetchedAt": "2026-10-08T21:23:23.256Z",
  "formType": "D",
  "isAmendment": false,
  "issuerStreet": "360 POST ST., SUITE 701",
  "issuerCity": "SAN FRANCISCO",
  "issuerState": "CA",
  "issuerStateName": "CALIFORNIA",
  "issuerZip": "94108",
  "entityType": "Corporation",
  "jurisdictionOfInc": "DELAWARE",
  "yearOfInc": 2025,
  "incorporatedWithinFiveYears": true,
  "industryGroup": "Computers",
  "industrySector": "Technology",
  "investmentFundType": null,
  "isPooledInvestmentFund": false,
  "is40Act": null,
  "revenueRange": "Decline to Disclose",
  "aggregateNetAssetValueRange": null,
  "exemptions": [
    "Rule 506(b)"
  ],
  "exemptionCodes": [
    "06B"
  ],
  "primaryExemption": "Rule 506(b)",
  "offeringAmountUsd": 29163244,
  "offeringAmountIndefinite": false,
  "amountSoldUsd": 29163244,
  "amountRemainingUsd": 0,
  "amountRemainingIndefinite": false,
  "minimumInvestmentUsd": 0,
  "investorCount": 84,
  "hasNonAccreditedInvestors": false,
  "nonAccreditedInvestorCount": null,
  "salesCommissionsUsd": 0,
  "findersFeesUsd": 0,
  "proceedsToRelatedPersonsUsd": 0,
  "securityTypes": [
    "Equity"
  ],
  "otherSecurityDescription": null,
  "isBusinessCombination": false,
  "dateOfFirstSale": "2026-09-22",
  "firstSaleYetToOccur": false,
  "offeringLongerThanOneYear": false,
  "relatedPersonCount": 3,
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/2159178/000215917826000001/primary_doc.xml",
  "filedByCiks": [
    "0002159178"
  ]
}
```

| Field | Type | Always filled | Meaning |
|---|---|---|---|
| `accessionNumber` | string | yes | EDGAR's id of the notice, e.g. `0002159178-26-000001`. The row key for `onlyNew`. |
| `issuerName` | string | yes | Issuer as typed on the form. |
| `cik` | string | yes | Issuer's EDGAR central index key, 10 digits. |
| `filingDate` | string | yes | Date EDGAR received the notice, `YYYY-MM-DD` UTC. |
| `url` | string | yes | The filing page a person can open. |
| `fetchedAt` | string | yes | When this run read the notice, ISO 8601 UTC. |
| `formType` | string | yes | `D` (first notice) or `D/A` (amendment). |
| `isAmendment` | boolean | yes | Same thing as a flag. |
| `issuerStreet` | string | no | Business street address, street2 appended after a comma. |
| `issuerCity` | string | no | Business city. |
| `issuerState` | string | no | Business state or EDGAR location code. |
| `issuerStateName` | string | no | Its name as EDGAR writes it (`CALIFORNIA`). |
| `issuerZip` | string | no | Business postal code. |
| `entityType` | string | no | `Corporation`, `Limited Partnership`, `Limited Liability Company`, … |
| `jurisdictionOfInc` | string | no | Where the issuer is incorporated — usually `DELAWARE`, whatever the address says. |
| `yearOfInc` | number | no | Year of incorporation. |
| `incorporatedWithinFiveYears` | boolean | no | What the issuer ticked for "within the last five years". |
| `industryGroup` | string | no | Item 4 as filed, e.g. `Computers`. |
| `industrySector` | string | no | The heading above it on the printed form, e.g. `Technology`. |
| `investmentFundType` | string | no | Only for a pooled vehicle: `Venture Capital Fund`, `Private Equity Fund`, `Hedge Fund`, `Other Investment Fund`. |
| `isPooledInvestmentFund` | boolean | yes | True when the industry group is `Pooled Investment Fund`, a fund type is named, or a section 3(c) exclusion is claimed. This is exactly the test `excludeFunds` applies. |
| `is40Act` | boolean | no | Whether the fund is registered as an investment company under the 1940 Act. |
| `revenueRange` | string | no | Item 5 revenue band, as filed. |
| `aggregateNetAssetValueRange` | string | no | Item 5 net-asset band, for funds, as filed. |
| `exemptions` | string\[] | yes | The rules of item 6 in words. |
| `exemptionCodes` | string\[] | yes | The same, as EDGAR's codes. |
| `primaryExemption` | string | no | The Securities Act rule the offering relies on. |
| `offeringAmountUsd` | number | no | Total offering amount. **Null when the issuer answered `Indefinite`** — see the next column. |
| `offeringAmountIndefinite` | boolean | yes | True when item 13 says `Indefinite` instead of a figure (common for open-ended funds). |
| `amountSoldUsd` | number | no | Total already sold to investors. Zero on a notice filed before the first sale. |
| `amountRemainingUsd` | number | no | What is left to sell; null when it is indefinite. |
| `amountRemainingIndefinite` | boolean | yes | True when the remainder says `Indefinite`. |
| `minimumInvestmentUsd` | number | no | Smallest investment accepted from an outside investor; `0` means none stated. |
| `investorCount` | number | no | How many investors have already invested. |
| `hasNonAccreditedInvestors` | boolean | no | Whether the offering has been or may be sold to non-accredited investors. |
| `nonAccreditedInvestorCount` | number | no | How many of them have invested — only present when the box above is ticked. |
| `salesCommissionsUsd` | number | no | Sales commissions of item 15. |
| `findersFeesUsd` | number | no | Finders fees of item 15. |
| `proceedsToRelatedPersonsUsd` | number | no | Gross proceeds used or proposed for payments to the executive officers, directors and promoters named on the form (item 16). |
| `securityTypes` | string\[] | yes | Item 9: `Equity`, `Debt`, `Pooled Investment Fund Interests`, `Option, Warrant or Other Right to Acquire Another Security`, `Security to be Acquired Upon Exercise of Option, Warrant or Other Right`, `Tenant-in-Common Securities`, `Mineral Property Securities`, `Other`. |
| `otherSecurityDescription` | string | no | The issuer's own words when `Other` is ticked. |
| `isBusinessCombination` | boolean | no | Whether the offering is part of a merger, acquisition or exchange offer. |
| `dateOfFirstSale` | string | no | When the first investor money arrived, `YYYY-MM-DD`. Null when no sale has happened yet. |
| `firstSaleYetToOccur` | boolean | yes | True when the notice says the first sale is still to come. |
| `offeringLongerThanOneYear` | boolean | no | Whether the issuer intends the offering to last more than a year. |
| `relatedPersonCount` | number | yes | How many executive officers, directors and promoters the notice names. Their names, titles and addresses are **not** published — see Limits & FAQ. |
| `documentUrl` | string | yes | The notice document itself (`primary_doc.xml`). |
| `filedByCiks` | string\[] | yes | Every filer CIK of the submission, as the search index lists them. |

Dataset views: **Form D offerings** (who raised what, where, when), **Round sizes** (the money columns),
**Issuers** (company identity, sector, fund type, exemptions).

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~sec-form-d-offerings/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sinceHours":168,"excludeFunds":true,"maxItems":20,"maxFilingsScanned":300}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/sec-form-d-offerings').call({
    sinceHours: 336,
    states: ['California'],
    industryGroups: ['Technology'],
    excludeFunds: true,
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/sec-form-d-offerings").call(run_input={
    "sinceHours": 720,
    "minAmountSold": 10000000,
    "excludeFunds": True,
    "maxItems": 10,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/sec-form-d-offerings` tool
with the same JSON input. For an agent, `fields` keeps the answer small — a good set is
`["issuerName", "issuerState", "industryGroup", "amountSoldUsd", "investorCount", "dateOfFirstSale", "primaryExemption"]`,
which still arrives with `accessionNumber`, `cik`, `filingDate`, `url` and `fetchedAt`.

### Pricing

Pay per event: **$0.001 per run start + $0.004 per row**. Every run is charged the start event, even one that finds
nothing. Every row written to the dataset is charged once; this actor writes no placeholder rows, so a run that matches
nothing costs the start event alone.

| Run | Rows | What it costs |
|---|---|---|
| A weekly deal-flow list | 20 | $0.001 + 20 × $0.004 = **$0.081** |
| A typical run of this actor | 40 | $0.001 + 40 × $0.004 = **$0.161** |
| A full default run | 50 | $0.001 + 50 × $0.004 = **$0.201** |
| A monthly research table | 500 | $0.001 + 500 × $0.004 = **$2.001** |

Apify's plan discounts apply to the row event (Bronze −10 %, Silver −20 %, Gold and above −30 %); the start event is
the same on every plan. The run also stops at the **Maximum cost per run** you set on the platform and keeps every row
you already paid for — the status message then says "Stopped at your spending limit: N rows delivered".

### Limits & FAQ

**Measured speed (2026-10-08, Apify cloud).** The actor never sends more than **5 requests per second** to sec.gov —
half the 10 per second the SEC's access page allows — counted in one token bucket shared by every sec.gov host, which
the retries wait in as well. Requests go out one after another, so the pace measured over thirteen cloud runs was
**100–302 sec.gov requests per minute (97–299 notices read per minute)** — latency, not the bucket, is usually the
limit. The longest single session we ran, 500 notices in one go, held the full **5 requests per second for 506
requests in 103 seconds and was never throttled or blocked**: the SEC's fair-access limit counts the client address,
and this pace stays under it. In practice the default scan of 400 notices takes 85–152 seconds, and a run with no
industry filter delivered 20 rows in 7 seconds because almost every notice read becomes a row. A narrow industry
filter is the slow case — the Computers prefill reads 400 notices for 3 rows.

**The largest allowed scan does not always fit the run timeout.** `maxFilingsScanned: 3000` needs roughly 10–30
minutes at that pace, which can be more than the 15-minute default run timeout. The run then stops by itself, keeps every row it
has, and ends successfully with "Stopped before the run timeout: N rows saved" — but if you want all 3 000 notices
read, raise the run timeout on the platform or split the window into shorter ones.

**A run that stops early says so.** Before the run timeout, the spending limit or `maxItems`, the actor stops starting
new work, keeps everything it has read, and ends successfully with a status message naming the reason and the row
count. Nothing is lost and nothing is charged twice.

**Form D is a notice, not a round announcement.** There is no round name ("Series A"), no lead investor and no
valuation anywhere in this source, because the form does not ask for them. What it does ask for is in every row:
amount offered, amount sold, remainder, minimum investment, investor count and the first-sale date.

**Amounts are what the issuer wrote.** Many notices are filed before the first sale and report `0` sold with
`firstSaleYetToOccur: true`. Open-ended funds answer `Indefinite` instead of a figure for the offering amount and the
remainder, which arrives as `null` plus `offeringAmountIndefinite` / `amountRemainingIndefinite`. The SEC does not
check these numbers and neither do we.

**Roughly half of all notices come from funds and SPVs** — series LLCs set up for one deal, venture and
private-equity funds, hedge funds. `excludeFunds` removes them, `investmentFundTypes` keeps only them.

**An amendment is a separate row.** A topped-up or corrected offering is filed again as form D/A with its own
accession number, so `onlyNew` delivers it as a new row. Use `noticeType` to take only first notices or only
amendments.

**Coverage starts in September 2008**, when Form D became an electronic EDGAR filing; it was mandatory from March
2009\. Anything earlier exists on paper only and returns nothing.

**Wide windows are read in slices.** EDGAR's full-text search answers at most 10 000 hits per query. A window with
more Form D notices than that is automatically cut into shorter date windows, newest first; the log says when that
happens. Only a single day with more than 10 000 notices could not be read completely, and no day comes near it
(2026 runs at about 200 notices a day).

**If the SEC throttles the run**, the actor says so instead of burning the time: a 403 or 429 on the first request
ends the run with "The SEC refuses this server" or "The SEC is throttling this server" and the advice to start again in
a few minutes. The limit counts the client address, so it clears by itself. Later in a run a refused notice is logged
and skipped, and the rows already saved are kept.

**No people and no phone numbers.** Every Form D names its executive officers, directors and promoters with their
addresses, and the issuer's phone number is on the form as well. None of that is written to the dataset — only
`relatedPersonCount`, so you can see how many signatories a filing has without us publishing a private address or a
one-person company's mobile number.

**`industryGroups` and the amount filters cost reading.** They live inside the notice, not in the search index, so
every candidate has to be opened. `maxFilingsScanned` is the budget for that, and the status message says when the
budget, not the data, ended the run — raise it or narrow the window.

**Questions or problems:** open an issue on the Issues tab of this actor.

***

Made by **Yadroo**. More actors on official sources:
[sec-edgar-filings](https://apify.com/yadroo/sec-edgar-filings) (filing lists and EDGAR full-text search, including
Form D as metadata — this actor is the one that opens the document),
[sec-company-financials](https://apify.com/yadroo/sec-company-financials) (XBRL financial facts),
[sec-form4-insider-trades](https://apify.com/yadroo/sec-form4-insider-trades) (insider transactions),
[federal-register-documents](https://apify.com/yadroo/federal-register-documents) (rules and notices of US agencies),
[data-gov-datasets](https://apify.com/yadroo/data-gov-datasets) (the US open-data catalogue).

# Actor input Schema

## `sinceHours` (type: `integer`):

Rolling window on the filing date, counted in UTC: 24 is yesterday and today, 168 the last seven days, 720 roughly a month. Ignored when `filedSince` is set. Form D is filed on business days only, so a window under 72 hours can be empty over a weekend or a US holiday.

## `filedSince` (type: `string`):

Earliest filing date, inclusive, UTC. Set it for a fixed historical window instead of the rolling `sinceHours`. Electronic Form D filing opened on EDGAR in September 2008 and became mandatory in March 2009, so earlier dates return nothing.

## `filedUntil` (type: `string`):

Latest filing date, inclusive, UTC. Empty means today. Used together with `filedSince`; on its own it is ignored.

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

Remember every accession number this run writes and, next time, write only notices that were not written before. Made for a schedule: each run then holds the rounds that appeared since the last one. An amended notice (form D/A) carries its own accession number, so a corrected or topped-up round comes through as a new row. The memory is shared by every run of this actor and keyed by the filter values, so two tasks with different filters keep separate memories.

## `issuerNameContains` (type: `string`):

Keep filings whose issuer name contains this text, matched by EDGAR itself: `labs`, `ventures`, `acme`. Case is ignored. Form D issuers are private companies and funds, so a name fragment is usually the only way to find one; most of them have no ticker and no SIC code.

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

EDGAR central index keys of the issuers to follow, up to ten digits, leading zeros optional: `2159178`, `0002159178`. A CIK is the stable identifier of a filer - use it to watch the same issuer or fund family across years, because issuer names are typed by hand and change. Tickers are not accepted here: a Form D filer is almost never listed on an exchange.

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

Two-letter US state codes or full state names, combined with OR: `CA`, `California`, `New York`, `TX`, `PR`. Case, spaces and accents are ignored; a value that is neither a known state nor a two-character code is refused with the closest matches named, never widened silently. Any other two-character value goes to EDGAR as typed, which is how its codes for non-US issuers work. `stateMatch` picks the business address or the state of incorporation. Full list in the README reference.

## `stateMatch` (type: `string`):

Form D carries two different places: the issuer's business address and the jurisdiction it was incorporated in. They disagree for most startups, because a company that works in California is usually incorporated in Delaware - `located` gives you the operating address, `incorporated` the legal home. Both are written to every row (`issuerState`, `jurisdictionOfInc`) whichever one you filter on.

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

The industry the issuer ticked, combined with OR. A sector heading stands for all of its groups: `Technology` = Computers, Telecommunications, Other Technology. Labels are as filed, with `and`: `Oil and Gas`, `REITS and Finance`; the form's printed `&` spellings and short ones such as `tech` are accepted too, anything else is refused with the closest values named. Full list in the README reference. The industry is in the filing, not in the index, so it costs a read - see `maxFilingsScanned`.

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

Drop notices filed by pooled investment vehicles - venture, private-equity and hedge funds, SPVs and series LLCs for a single deal - and keep operating companies raising money. Roughly half of all Form D notices come from such vehicles, so this switch turns the stream into a deal-flow list. A notice counts as a vehicle when its industry group is `Pooled Investment Fund` or it claims an Investment Company Act section 3(c) exclusion; most are skipped before their filing is read.

## `investmentFundTypes` (type: `array`):

The opposite job: keep only pooled investment vehicles of a given kind, as ticked on the form - `Venture Capital Fund`, `Private Equity Fund`, `Hedge Fund`, `Other Investment Fund`. Short spellings (`vc`, `venture`, `pe`, `hedge`) are matched; anything else is refused with the valid values named. Use this to watch new funds closing instead of companies raising, for example a limited partner tracking first-time VC funds. Setting this together with `excludeFunds` is refused as a contradiction.

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

The rule the offering relies on, combined with OR, written as on the form or in short: `506(b)`, `506b`, `Rule 506(c)`, `504(b)(1)(i)`, `4(a)(5)`, `3(c)(1)`. Brackets, spaces, case and a leading `rule` are ignored; an unknown rule is refused with the valid values named. Rule 506(b) is the quiet round that may not be advertised and Rule 506(c) the one that may be advertised publicly. These codes are in the search index, so this filter costs no extra reading.

## `noticeType` (type: `string`):

An offering is announced once as form D and then filed again as form D/A, often because more money came in. `new` is the first notice, which is the closest thing in this source to a freshly announced round; `amendment` is the follow-up, which is where a round that grew shows up. The flag is in every row as `isAmendment`.

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

Keep notices reporting at least this much sold to investors so far (`amountSoldUsd`): `1` for offerings where money has actually changed hands, `10000000` for raises of ten million and up. Many notices are filed before the first sale and report zero, and a few report no figure at all - both are dropped by this filter. The amount is what the issuer wrote on the form, not an estimate.

## `maxAmountSold` (type: `integer`):

Keep notices reporting at most this much sold, for example `5000000` to look at seed-sized rounds only. Combined with `minAmountSold` as a range.

## `firstSaleSince` (type: `string`):

Filter on the date the issuer took the first investor money (`dateOfFirstSale`), not on the filing date. A notice is due within fifteen days of that first sale, and amendments can be filed years later, so this is the field that separates rounds that closed recently from paperwork about an old one. Notices that report no first sale yet are dropped by this filter.

## `maxFilingsScanned` (type: `integer`):

How many notices this run may open and read, newest first. Date, state, issuer, CIK and exemption filters are answered by the search index and cost nothing here; industry, fund type, amounts and the first-sale date live inside the filing, so each candidate has to be read, and a narrow industry filter reads many notices per row it keeps. The run stops at this cap, at `maxItems` or at the run timeout, whichever comes first, and the status says which. 400 filings take about a minute and a half.

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

Hard cap on the rows this run writes, and so on what it costs. Rows are written newest filing first, which means a small cap still gives you the most recent rounds. The run also stops at the maximum cost per run you set on the platform.

## `fields` (type: `array`):

Keep only the named columns, in the order given - for example `issuerName, issuerState, amountSoldUsd, dateOfFirstSale`. Empty = every column. `accessionNumber`, `issuerName`, `cik`, `filingDate`, `url` and `fetchedAt` are always present; name one of them here and it moves to the position you gave it. Unknown names are reported in the run's status message instead of being dropped in silence.

## Actor input object example

```json
{
  "sinceHours": 168,
  "onlyNew": false,
  "stateMatch": "located",
  "industryGroups": [
    "Computers"
  ],
  "excludeFunds": true,
  "noticeType": "any",
  "maxFilingsScanned": 400,
  "maxItems": 50
}
```

# 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 = {
    "industryGroups": [
        "Computers"
    ],
    "excludeFunds": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/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 = {
    "industryGroups": ["Computers"],
    "excludeFunds": True,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/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/KAbLxpVeewJHPFz3J/builds/Uy0MMpeJ1GV94dzi2/openapi.json