# SEC Form D Private Raises Feed (`bigdavidson/sec-form-d-raises`) Actor

Daily feed of new private capital raises from SEC Form D filings: new vs amended, first-time issuers, funds dropped, normalized amounts, industry, state, executives and issuer phone as filed.

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

## Pricing

from $20.00 / 1,000 form d raise records

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 Raises Feed

A daily feed of **private capital raises** taken from **SEC Form D** filings. It returns one clean JSON record per filing: who is raising, how much, how much is already sold, the industry, the state, the executives and promoters named on the form, and the issuer's phone number as filed.

The feed does the filtering that makes raw Form D data usable:

- **Funds are removed by default.** About two-thirds of Form D filings come from private funds and SPVs, and `excludeFunds` is on unless you turn it off.
- **Real estate can go too.** Real estate syndications are about a third of what is left. `excludeIndustries: ["Real Estate", "Investing"]` leaves operating companies only.
- **New raises are split from amendments.** Form D is a new raise and Form D/A is an amendment, and each record says which.
- **First-time issuers are flagged.** A company filing its first Form D ever gets `first_time_issuer: true`, checked against its full EDGAR filing history.
- **Amounts are normalized.** Dollar amounts come back as numbers, with a flag when the offering size is "Indefinite".

Data comes straight from the SEC's public EDGAR systems. There is no login, no API key and no scraping of other sites.

**Who uses it:** VC and angel scouts, startup-lending and SaaS sales teams (new raises are fresh budget), fund administrators and law firms watching competitors, journalists covering local funding, and AI agents that need "who raised money this week in Texas biotech".

### What you get

One record per Form D filing that matches your filters. The main fields:

| Field | Example | Notes |
|---|---|---|
| `record_type` | `raise` | `raise` for filings. A `notice` row is a free explanation, e.g. when nothing matched |
| `accession_number` | `0002153849-26-000001` | SEC accession number, the unique filing ID |
| `form` | `D` | `D` = new notice, `D/A` = amendment |
| `filing_type` | `new` | `new` or `amendment` |
| `amends_accession` | `null` | for D/A, the filing it amends |
| `filed_date` | `2026-09-18` | EDGAR filing date |
| `first_time_issuer` | `true` | no earlier Form D or D/A by this issuer on EDGAR (`false` for every D/A, `null` if the history lookup failed) |
| `cik` | `2153849` | SEC company ID |
| `issuer_name` | `SovAI, Inc.` | |
| `entity_type`, `jurisdiction_of_inc`, `year_of_inc`, `incorporation_age` | `Corporation`, `DELAWARE`, `2026`, `within 5 years` | |
| `issuer_street`, `issuer_city`, `issuer_state`, `issuer_zip` | `Dana Point`, `CA` | principal place of business as filed (`issuer_state` is a US state or EDGAR country code) |
| `issuer_location` | `CALIFORNIA` | state or country name as filed (early 2009-era filings leave it out, so it is filled from the EDGAR code, e.g. `E9` = `CAYMAN ISLANDS`) |
| `issuer_phone` | `949-836-3389` | issuer phone number exactly as filed |
| `industry_group` / `industry_sector` | `Other Technology` / `Technology` | Form D industry group and its sector |
| `is_fund`, `fund_type` | `false`, `null` | `true` when the industry is "Pooled Investment Fund", the filing claims the 3(c)(1) / 3(c)(7) private-fund exclusion, or the securities offered include "Pooled investment fund interests"; `fund_type` e.g. `Venture Capital Fund`, `Hedge Fund` |
| `offering_amount_usd` | `6000000` | total offering size (`null` when Indefinite) |
| `offering_amount_indefinite` | `false` | `true` when the issuer filed "Indefinite" |
| `amount_sold_usd` / `amount_remaining_usd` | `1500000` / `4500000` | cumulative for the whole offering so far. On a D/A this is the lifetime total, not new money since the last filing |
| `percent_sold` | `25.0` | sold ÷ offering × 100 (also cumulative) |
| `minimum_investment_usd`, `investors_count` | `50000`, `1` | |
| `has_non_accredited_investors`, `non_accredited_investors_count` | `false`, `null` | |
| `date_of_first_sale`, `first_sale_yet_to_occur`, `more_than_one_year` | `2026-08-21`, `false`, `false` | |
| `securities_offered` | `["Equity", ...]` | security types checked on the form |
| `exemptions` | `["Rule 506(b)"]` | Reg D rule / Investment Company Act exclusions claimed |
| `revenue_range` | `No Revenues` | revenue range (funds: net asset value range) |
| `sales_commissions_usd`, `finders_fees_usd`, `proceeds_to_related_persons_usd` | `0`, `0`, `110000` | |
| `sales_agents` | `["H.C. Wainwright & Co., LLC"]` | placement agents / brokers paid for sales |
| `related_persons` | list | executives, directors and promoters as filed: `name`, `relationships`, `clarification`, `city`, `state` |
| `related_persons_text` | `Joe David Doyle (Executive Officer, Director, Promoter); ...` | the same list flattened for CSV/Sheets |
| `co_issuers` | `[]` | other issuers on the same filing |
| `signer_name`, `signer_title`, `signature_date` | `Mark Waldron`, `President` | |
| `filing_url` | link | the human-readable form on sec.gov |
| `filing_index_url`, `xml_url` | links | filing index page and raw XML |
| `source` | `efts` | `efts` (EDGAR full-text search) or `daily-index` (fallback) |

Every row, including notice rows, has the same columns, so CSV and Excel exports stay aligned. Street addresses of individuals are left out. Only their city and state are kept, and the full filing is one click away via `filing_url`.

#### Example record (real output, run of 2026-09-24)

```json
{
  "record_type": "raise",
  "accession_number": "0002153849-26-000001",
  "form": "D",
  "filing_type": "new",
  "is_amendment": false,
  "amends_accession": null,
  "filed_date": "2026-09-18",
  "first_time_issuer": true,
  "cik": "2153849",
  "issuer_name": "SovAI, Inc.",
  "entity_type": "Corporation",
  "jurisdiction_of_inc": "DELAWARE",
  "year_of_inc": 2026,
  "incorporation_age": "within 5 years",
  "issuer_street": "32565 Golden Lantern St, Ste B PMB 3007",
  "issuer_city": "Dana Point",
  "issuer_state": "CA",
  "issuer_location": "CALIFORNIA",
  "issuer_zip": "92629",
  "issuer_phone": "949-836-3389",
  "industry_group": "Other Technology",
  "industry_sector": "Technology",
  "is_fund": false,
  "fund_type": null,
  "offering_amount_usd": 6000000,
  "offering_amount_indefinite": false,
  "amount_sold_usd": 1500000,
  "amount_remaining_usd": 4500000,
  "percent_sold": 25.0,
  "minimum_investment_usd": 50000,
  "investors_count": 1,
  "has_non_accredited_investors": false,
  "non_accredited_investors_count": null,
  "date_of_first_sale": "2026-08-21",
  "first_sale_yet_to_occur": false,
  "more_than_one_year": false,
  "securities_offered": ["Equity", "Option, warrant or other right to acquire", "Security to be acquired upon exercise"],
  "exemptions": ["Rule 506(b)"],
  "revenue_range": "No Revenues",
  "business_combination": false,
  "sales_commissions_usd": 0,
  "finders_fees_usd": 0,
  "proceeds_to_related_persons_usd": 110000,
  "sales_agents": [],
  "related_persons": [
    {"name": "Joe David Doyle", "relationships": ["Executive Officer", "Director", "Promoter"], "clarification": null, "city": "Dana Point", "state": "CA"},
    {"name": "Mark William Waldron", "relationships": ["Executive Officer", "Director", "Promoter"], "clarification": null, "city": "West Hartford", "state": "CT"}
  ],
  "related_persons_text": "Joe David Doyle (Executive Officer, Director, Promoter); Mark William Waldron (Executive Officer, Director, Promoter)",
  "co_issuers": [],
  "signer_name": "Mark Waldron",
  "signer_title": "President",
  "signature_date": "2026-09-18",
  "filing_url": "https://www.sec.gov/Archives/edgar/data/2153849/000215384926000001/xslFormDX01/primary_doc.xml",
  "filing_index_url": "https://www.sec.gov/Archives/edgar/data/2153849/000215384926000001/0002153849-26-000001-index.htm",
  "xml_url": "https://www.sec.gov/Archives/edgar/data/2153849/000215384926000001/primary_doc.xml",
  "source": "efts",
  "message": null
}
```

### Input

Every field is optional. Empty input `{}` returns up to 20 non-fund raises from the last 2 business days (at most $0.405).

| Field | Type | Default | What it does |
|---|---|---|---|
| `dateFrom` | date | 2 business days ago | First filing date, `YYYY-MM-DD`. Also accepts `7 days` (= 7 days ago) or `yesterday` |
| `dateTo` | date | today | Last filing date. Range is capped at 366 days |
| `filingType` | `all` / `new` / `amendments` | `all` | `new` = Form D only (new raises), `amendments` = Form D/A only |
| `excludeFunds` | boolean | `true` | Drop pooled investment funds and SPVs: industry "Pooled Investment Fund", a 3(c)(1) / 3(c)(7) private-fund exclusion, or securities offered marked "Pooled investment fund interests". Other 3(c) items alone (3(c)(5) real estate lenders, 3(c)(6), 3(c)(9) oil and gas programs) do not make a filing a fund |
| `firstTimeOnly` | boolean | `false` | Only issuers filing their first-ever Form D (implies `new`) |
| `minAmount` | integer (USD) | none | Minimum total offering size. For "Indefinite" offerings the amount already sold is used |
| `states` | list | all | `CA`, `New York`, `US`, `foreign`, an EDGAR country code (`E9`), or a country or province such as `Canada`, `Israel`, `Cayman Islands`, `Ontario`. Unknown entries are skipped with a warning; if none is known, the run explains and charges nothing |
| `industries` | list | all | Sectors (`Technology`, `Health Care`, `Real Estate`, `Energy`, ...) or Form D groups (`Biotechnology`, `Oil and Gas`, ...). `tech` works too, and `biotech` means Biotechnology + Pharmaceuticals. Form D has no fintech group, so `fintech` means Other Banking and Financial Services + Other Technology |
| `excludeIndustries` | list | none | Sectors or groups to drop, same names as `industries`. `["Real Estate", "Investing"]` leaves operating companies only. If it removes everything `industries` asked for, the run explains and charges nothing |
| `maxRecords` | integer | `20` | Stop after this many matches. Filing days are read newest first, but within one day the order is EDGAR's search order, not time of day. Use `0` (no limit) to get complete days |
| `contactEmail` | string | none | Optional. Added to the User-Agent sent to SEC (SEC asks automated clients to declare a contact), and used for nothing else |

Examples:

```json
{ "dateFrom": "2026-09-14", "dateTo": "2026-09-18", "states": ["CA"], "industries": ["Technology"], "maxRecords": 0 }
```

```json
{ "firstTimeOnly": true, "minAmount": 5000000, "dateFrom": "2026-09-01" }
```

```json
{ "dateFrom": "1 day", "dateTo": "1 day", "excludeIndustries": ["Real Estate", "Investing"], "maxRecords": 0 }
```

**Daily feed:** schedule the actor Tuesday to Saturday at about 7:00 US Eastern (cron `0 7 * * 2-6`) with `{"dateFrom": "1 day", "dateTo": "1 day", "maxRecords": 0}`. Each run reads exactly the previous weekday, so consecutive runs never overlap and no filing is paid for twice. Don't use the default window for this: it covers yesterday and today, so consecutive runs overlap and you would pay for the overlap twice.

One gap to know about: EDGAR occasionally gives a filing an earlier filing date than the day it was accepted. For example, `0001294202-26-000004` was accepted on 2026-09-21 but carries filing date 2026-09-18; it was the only such case among the roughly 700 Form D filings we checked for 2026-09-21..23. The daily run for 09-18 happened before that filing existed, and later daily runs don't cover 09-18, so the feed misses it. Search lists it under its filing date, so any later run whose range includes 2026-09-18 does return it.

### Pricing

Pay per event. There is no subscription and no compute charge on top of the events below.

| Event | Price | When |
|---|---|---|
| `actor-start` | $0.005 | once per run, only after SEC has answered |
| `raise-record` | $0.02 | per matching filing returned |

Filtered-out filings (funds, excluded industries, other states, amounts below your minimum) and notice rows are **never charged**.

Worked examples (volumes measured on September 2026 data):

| Run | Records | Cost |
|---|---|---|
| Empty input (default: 2 business days, max 20) | 20 | $0.005 + 20 × $0.02 = **$0.405** |
| One week, California tech companies, no limit | 17 | $0.005 + 17 × $0.02 = **$0.345** |
| Three weeks, first-time issuers raising $5M+, max 40 | 40 | $0.005 + 40 × $0.02 = **$0.805** |
| Daily feed of all non-fund raises, one business day | 72–77 | $0.005 + 72 × $0.02 = **$1.445** on 2026-09-23; about $32 per month (21 weekdays) |
| Same, operating companies only (`excludeIndustries: ["Real Estate", "Investing"]`) | 46 | $0.005 + 46 × $0.02 = **$0.925** on 2026-09-23 |
| Same, funds included (`excludeFunds: false`) | ~230–275 | about **$4.60–5.50** per day (694 records for 2026-09-21..23 = $13.885) |

Set a **maximum charge per run** in Apify and the actor stops cleanly at that budget, keeping what it already delivered.

### How it works

1. For each business day in your range (newest first), the actor lists Form D and D/A filings from EDGAR full-text search (`efts.sec.gov`). If that fails, it falls back to the EDGAR daily form index.
2. Most funds are identified up front by their Investment Company Act 3(c)(1)/3(c)(7) exemptions and skipped without downloading the filing.
3. Each remaining filing's `primary_doc.xml` is parsed. That file is the structured Form D exactly as the issuer submitted it. The remaining fund checks (industry "Pooled Investment Fund", "Pooled investment fund interests") and the state, industry and amount filters run on this filed data. The search index's own location field disagrees with the filed address on a dozen or more filings a day, so it is not used to skip filings.
4. For new filings, the issuer's EDGAR filing history (`data.sec.gov/submissions`) decides `first_time_issuer`.

Requests are paced to 5 per second, half of SEC's published fair-access limit. They use a declared User-Agent. Failures (429/5xx, timeouts, connection errors, corrupt response bodies) get bounded retries that honor `Retry-After` (seconds or an HTTP date) and stop when the run is close to its timeout. A filing that still cannot be read is skipped with a warning and never charged; a day whose search listing fails is read from the EDGAR daily index instead. Measured locally, including about 10 seconds of startup:

- the empty-input run takes about 20 seconds;
- one full day of non-fund raises takes about 40 seconds;
- one week filtered to California tech takes about 2 minutes, because every non-fund filing in the week is read;
- a full unfiltered week (about 1,370 filings, funds included) takes about 8 minutes.

### FAQ

#### What is a Form D?

Companies raising money privately under Regulation D (or Section 4(a)(5)) must file a short notice with the SEC within 15 days of the first sale. It lists the offering size, amount sold, industry, executives and exemptions. Startups raising seed or Series A rounds, real estate syndications, oil and gas programs and private funds all file one.

#### Why are funds excluded by default?

Roughly two-thirds of Form D filings are pooled investment funds: VC funds, hedge funds and single-deal SPVs, which often appear as "X, a Series of Y LLC". They are rarely what people mean by "who raised money". A filing counts as a fund when its industry is "Pooled Investment Fund", it claims the 3(c)(1) or 3(c)(7) private-fund exclusion, or the issuer marks the securities offered as "Pooled investment fund interests". That last check catches bond funds, SPV series, real estate fund feeders and some Delaware statutory trusts filed under other industries: 8 of 157 otherwise non-fund filings on 2026-09-22..23. A 3(c)(5), 3(c)(6) or 3(c)(9) claim alone (real estate lenders, oil and gas programs) does not make a filing a fund. Set `excludeFunds: false`, or ask for `industries: ["Pooled Investment Fund"]`, to get funds too.

The rule follows what the issuer filed, so a few pooled vehicles still get through. An example is a bank collective trust filed under "Investing" whose securities are "Other: Units of Participation". Add `excludeIndustries: ["Investing"]` if you want those out as well.

#### How do I get operating companies only?

Use `excludeIndustries: ["Real Estate", "Investing"]`. Even with funds removed, real estate syndications (property LLCs, DSTs, opportunity-zone vehicles) and investment holding LLCs are about a third of what is left: 26 of 72 records on 2026-09-23. Excluded filings are never charged. Form D has no "startup" flag. `firstTimeOnly: true` and `industries: ["Technology", "Health Care"]` narrow it further.

#### Can I add up amounts across records?

Not across amendments. `amount_sold_usd` and `percent_sold` are cumulative totals for the offering. A Form D/A repeats the lifetime total sold so far, so adding a D/A to the original D (or to earlier D/As) counts the same money twice. To measure new money, compare a D/A with the filing named in `amends_accession`, or sum only `filing_type: "new"` records.

#### In what order do records come?

Filing days come newest first. Within one day, records follow EDGAR full-text search order, which is not the time of acceptance. If `maxRecords` stops partway through a day, you get part of that day, not its latest filings. Set `maxRecords: 0` to get whole days.

#### What counts as a first-time issuer?

An issuer with no earlier Form D or D/A under its SEC CIK. The check reads the issuer's complete EDGAR filing history and orders same-day filings by acceptance time. Amendments are never first-time. If the history lookup fails, the flag is `null`, and `firstTimeOnly` leaves that filing out.

#### Is "Indefinite" an amount?

No. Funds and some continuous offerings file "Indefinite". In that case `offering_amount_usd` is `null`, `offering_amount_indefinite` is `true`, and `amount_sold_usd` is still reported.

#### How fresh is the data?

EDGAR full-text search lists filings within minutes of acceptance. The actor includes today's filings (US Eastern date) by default.

#### Can it return data from years ago?

Yes. Any range from 2001 onward works, up to 366 days per run. Electronic Form D XML exists from 2009.

#### Is the phone number / person data allowed?

All fields are public records the issuer filed with the SEC, reproduced as filed. Street addresses of individuals are omitted. Follow applicable law (e.g. TCPA / telemarketing rules) if you contact anyone.

#### Is this affiliated with the SEC?

**Unofficial — not affiliated with, endorsed by, or connected to the U.S. Securities and Exchange Commission.** It reads the SEC's public EDGAR data. Always check important decisions against the filing itself (`filing_url`).

### Use with AI agents (MCP)

Connect your agent to the Apify MCP server (`https://mcp.apify.com`) with this actor as a tool (`bigdavidson/sec-form-d-raises`). Then ask things like "which Texas health care companies filed a new Form D this week?" or "first-time issuers raising over $10M since Monday". The agent fills the input itself.

The input is forgiving for agents:

- Aliases work: `limit`, `type: "D/A"`, `industry: "biotech"`, `exclude_sectors: "real estate"`, `state: "Texas, FL"`, `days: 7`, `min_amount: "1M"`.
- Case and extra spaces don't matter, and unknown fields are ignored with a warning.
- Output is flat and stable: filter on `record_type == "raise"`, and read any `notice` row for an explanation.
- Filters that cannot match anything (only unknown industries or places, a date range before 2001 or with no business days) get a free explanation, and nothing is charged.
- Costs: $0.005 per run + $0.02 per record. `maxRecords` caps spend; the default of 20 costs at most $0.405.

### Changelog

- **0.1 (2026-09-24)** — First version:
  - EDGAR full-text search with a daily-index fallback.
  - Fund filter (industry, 3(c)(1)/3(c)(7), pooled fund interests), first-time issuer flag, normalized amounts, industry sectors, state and country filters.
  - `excludeIndustries` for an operating-companies-only feed; `biotech` covers Biotechnology + Pharmaceuticals.
  - Related persons and phone as filed.
  - Free notice rows, including for filters that cannot match (nothing charged).
  - State filters use the filed address only.
  - Retries honor `Retry-After` (seconds or HTTP date) and stop near the run timeout.
  - Malformed search hits, corrupt or looping responses and documents without an issuer are skipped (never charged) without ending the run; a failed search listing falls back to the daily index.

# Actor input Schema

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

First filing date to include, YYYY-MM-DD (also accepts '7 days' = 7 days ago, 'yesterday'). Empty = the last 2 business days (today included). Max range 366 days. Cost is $0.005 per run + $0.02 per matching filing, so wide ranges mainly cost time, not money, when you set maxRecords.

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

Last filing date to include, YYYY-MM-DD (also 'today'). Empty = today (US Eastern).

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

new = original Form D notices only (a new raise), amendments = Form D/A only (updates to an earlier raise, e.g. annual renewals or more money sold), all = both.

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

Drop filings by private funds and SPVs: industry 'Pooled Investment Fund', a claim of the Investment Company Act 3(c)(1) or 3(c)(7) private-fund exclusion, or securities offered marked 'Pooled investment fund interests'. Other 3(c) items alone (3(c)(5) real estate lenders, 3(c)(6), 3(c)(9) oil and gas programs) do not make a filing a fund. About two-thirds of all Form D filings are funds, so this is on by default. Excluded filings are never charged.

## `firstTimeOnly` (type: `boolean`):

Keep only issuers filing their first-ever Form D (no earlier Form D or D/A on EDGAR). Implies new filings only.

## `minAmount` (type: `integer`):

Keep only offerings whose total offering amount is at least this many US dollars (for 'Indefinite' offerings the amount already sold is used). Leave empty for no minimum.

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

Filter by the issuer's principal address as filed: 2-letter state codes or names (CA, New York, TX), EDGAR country codes (E9 = Cayman Islands), 'US', 'foreign', or a country/province name (Canada, Israel, Cayman Islands, Ontario). Unknown entries are skipped with a warning; if none is known the run explains and charges nothing. Empty = everywhere.

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

Form D industry groups or sectors, case-insensitive: sectors Technology, Health Care, Real Estate, Energy, Banking & Financial Services, Travel, Agriculture, Business Services, Manufacturing, Retailing, Restaurants, Other; or groups like Biotechnology, Pharmaceuticals, Other Technology, Computers, Oil and Gas, Residential, Commercial. Aliases work: 'tech', 'biotech' (= Biotechnology + Pharmaceuticals). Form D has no fintech group: 'fintech' means Other Banking and Financial Services + Other Technology. Empty = all.

## `excludeIndustries` (type: `array`):

Drop these sectors or industry groups (same names as Industries). For operating companies only, use \["Real Estate", "Investing"]: real estate syndications and investment holding LLCs are about a third of non-fund filings (26 of 72 on 2026-09-23). Excluded filings are never charged. Empty = exclude nothing.

## `maxRecords` (type: `integer`):

Stop after this many matching filings. Days are read newest first; within one filing day the order is EDGAR search order, not time of day, so use 0 to get complete days. 0 = no limit (your run's max charge still applies). Each record costs $0.02; the default 20 costs at most $0.405 per run.

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

SEC asks automated clients to declare a contact in the User-Agent. If you give an email it is added to the User-Agent of this run's requests to SEC and nowhere else. Optional — runs work without it.

## Actor input object example

```json
{
  "filingType": "all",
  "excludeFunds": true,
  "firstTimeOnly": false,
  "maxRecords": 20
}
```

# Actor output Schema

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

No description

## `overview` (type: `string`):

No description

## `contacts` (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 = {
    "maxRecords": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigdavidson/sec-form-d-raises").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 = { "maxRecords": 20 }

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

```

## MCP server setup

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

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/d7dxmW6JvywWI7qNf/builds/NyrbMdBD0bL1ddURL/openapi.json