# SEC EDGAR: Form D Leads, Filing Alerts & Insider Trades (`foresighted_sunset/sec-edgar-toolkit`) Actor

Find SEC Form D funding leads with fund/SPV filters, monitor EDGAR filings by ticker and 8-K item, and parse Form 4 insider transactions. Source-linked output, only-new alerts, budget-safe per-filing billing. No API key; SEC contact supplied, override optional.

- **URL**: https://apify.com/foresighted_sunset/sec-edgar-toolkit.md
- **Developed by:** [Dano Desk](https://apify.com/foresighted_sunset) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $60.00 / 1,000 form d funding leads

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 EDGAR Toolkit: Source-Linked Funding Leads & Filing Alerts

Find operating companies raising capital without treating every fund or SPV as a sales lead. Get SEC Form D offering details, only-new filing alerts, and Form 4 insider transactions with direct filing evidence. No API key, third-party data resale, browser or proxy required.

**Three modes:** `formD` for funding leads; `filings` for watchlist/8-K item/keyword alerts; `insiderTrades` for matching Form 4 transactions. Filter and export JSON, CSV or Excel, or connect the dataset to your own workflow.

### Quick start (under a minute)

1. Run with `{}` to see **three archived real SEC records** from our 2026-10-27 source run. They are labelled `_demo: true`, are not current leads, and incur no custom billing events. No SEC requests are made by the demo.
2. For current data, choose filters and a small `maxResults`, and run. SEC headers use the operator contact by default; optionally set `contactEmail` to your own working address.
3. Open the dataset and the `OUTPUT` summary. Inspect source status and warnings before treating partial results as complete.

Live example:

```json
{"mode":"formD","contactEmail":"ops@yourcompany.com","daysBack":3,"maxResults":5,"excludeFundsAndSpvs":true}
```

The illustrated `contactEmail` is an optional override: replace it with your own working address, or omit it to use the operator contact. Contact information is sent only in HTTPS SEC.gov request headers, including redirects; it is not printed in the listing, logs or results. Example-domain overrides are rejected.

### Who it's for

- **Sales & BD teams** (banking, insurance, payroll, SaaS, recruiting, legal, accounting): companies that just raised money, with the executives' names, the same day it's filed.
- **Investors & analysts:** earnings (8-K 2.02), leadership changes (5.02), restatements (4.02), M\&A (2.01), cyber incidents (1.05) for a watchlist, or any phrase in filing text.
- **Insider-activity screens:** open-market purchases (code P) above $X across the market or for your tickers.

### Input examples

```json
{ "mode": "formD", "contactEmail": "ops@yourcompany.com", "daysBack": 1, "industries": ["technology", "health_care"], "minAmountSold": 500000, "onlyIncorporatedWithinFiveYears": true, "monitor": true }
```

```json
{ "mode": "filings", "contactEmail": "ops@yourcompany.com", "tickers": ["AAPL", "MSFT", "NVDA"], "itemCodes": ["2.02", "5.02"], "daysBack": 2, "monitor": true }
```

```json
{ "mode": "insiderTrades", "contactEmail": "ops@yourcompany.com", "transactionCodes": ["P"], "minTransactionValue": 100000, "daysBack": 1 }
```

### Output

Rows go to the default dataset (table views: *Form D funding leads*, *Filing alerts*, *Insider trades*); every row has `recordType`, `accessionNumber`, the filing index URL and the document/XML URL. The `OUTPUT` record in the key-value store holds the run summary: per-source status (`ok` / `partial` / `failed` with an error code), counts, rows dropped per filter, monitor stats, request stats and warnings.

Sample Form D row (abridged, real filing 2026-10-27):

```json
{ "recordType": "form_d", "issuerName": "Creeda, Inc.", "formType": "D/A", "industryGroup": "Other Technology", "city": "New York", "stateOrCountry": "NY",
  "exemptions": ["Rule 506(b)"], "securityTypes": ["Simple Agreement for Future Equity (SAFE)"], "totalOfferingAmountUsd": 400000, "totalAmountSoldUsd": 175000,
  "percentSold": 43.8, "investorsCount": 3, "executives": ["Harrison Clarke Kirk", "Haojie Jia", "Sean Benjamin May"], "looksLikeFundOrSpv": false }
```

### Monitor mode

`monitor: true` stores the accession numbers already processed in the named key-value store `sec-edgar-toolkit-state` (key derived from mode + filters, or your `monitorKey`). Later runs skip them, so a scheduled run (hourly/daily) plus an Apify integration (Slack, webhook, Zapier, Make) gives you alerts. Filings that failed to download are not remembered and are retried next time. If more filings match than `maxResults`, the rest are sent on the next run. Memory keeps 400 days.

### Data sources & fair access

| Source | Used for |
|---|---|
| `www.sec.gov/files/company_tickers.json` | ticker -> CIK |
| `data.sec.gov/submissions/CIK##########.json` | filings for your companies (recent ~1,000 filings / 1 year each), with acceptance time and 8-K items |
| `efts.sec.gov/LATEST/search-index` (EDGAR full-text search) | market-wide lists by form/date, keyword search, Form D listing |
| `www.sec.gov/Archives/edgar/data/...` | Form D `primary_doc.xml` and Form 4 XML |

SEC asks automated clients to **declare a User-Agent with a contact email** and to stay **under 10 requests/second**. The operator SEC contact is supplied by default, with an optional `contactEmail` override; requests are paced at 5/s by default (`maxRequestsPerSecond`, max 8), and 429/503 responses are retried with backoff and `Retry-After`. A 403 from SEC is reported as `FORBIDDEN` with a hint (missing contact or rate abuse). EDGAR data is public; outreach to people named in filings must follow your local rules (CAN-SPAM, GDPR, TCPA).

### Limits & caveats

- Full-text search covers 2001 onward and returns at most 10,000 documents per query; very wide market-wide windows are scanned newest first (a warning tells you when results were cut).
- Form D: the fund/SPV rule is a heuristic (industry group, pooled-fund security type, names like "Fund", "SPV", "a Series of"); check `fundOrSpvReason`. Real-estate project LLCs are operating issuers under SEC's categories; drop them with `industries`. "Indefinite" offering amounts are `null` and are dropped when you set an amount filter. Form D has no investor names and covers US exempt offerings only.
- Filing alerts by ticker use the submissions API's recent list; if a company has filed more than ~1,000 times inside your window, older ones are not included (warning shown).
- Insider trades: a filing's transactions are kept together, so a run can return a few more rows than `maxResults`. Prices given only in footnotes are `null`.

### Pricing

| Code event | Unit — only delivered matching results | USD per event |
|---|---|---:|
| `form-d-filing` | One Form D operating-company funding lead | $0.06 |
| `filing` | One filing-alert row | $0.00035 |
| `insider-filing` | One distinct Form 4 accession with at least one matching transaction, regardless of transaction count | $0.0018 |

**Worked examples:** 1,000 Form D leads = **$60**; 1,000 filing rows = **$0.35**; 1,000 Form 4 filings = **$1.80**, even if those filings contain 11,000 transaction rows. A filing whose transactions all fail your filters costs no custom event. Duplicates, previously seen filings, empty matches and source errors have no custom event fee. Demo rows have no custom event fee.

The automatic `apify-actor-start` event costs $0.00005 per started GB (minimum one), including empty runs. Worked result examples exclude this start fee and any applicable platform usage, storage, integrations or taxes. No default dataset-row event is priced.

Set Apify's **Maximum charge per run** (`maxTotalChargeUsd` in run options, not input JSON). Before emitting a billable unit we check the active SDK event prices and remaining budget, including any dataset fee, then stop before an unaffordable unit. A Form 4 is kept atomic: no partial transaction output charged as a whole filing. Unsent accessions remain eligible on the next monitor run. Network work may occur before the output budget is reached; use `maxResults` too.

### FAQ

**Does a Form D prove a company raised the offered amount?** No. Offered and sold amounts are distinct; `totalAmountSoldUsd` is the filed amount sold, not an independently verified funding round. Amendments and indefinite amounts are explicitly represented.

**Are investor identities available?** Form D reports investor counts, not a full investor roster. This is US exempt-offering evidence, not global funding-news coverage.

**Will monitoring suppress missed items?** Source failures are not marked seen. Budget-capped output is removed from the seen-state commit so it can be delivered on a later run within the date window. Do not run concurrent writers against the same monitor key.

**Do you contact people or give investment advice?** No. The Actor reads public SEC records only. You are responsible for permitted use and outreach rules; nothing is an investment recommendation.

### Troubleshooting

| Code / symptom | What to do |
|---|---|
| `INVALID_INPUT` | Check dates, tickers, CIKs and any contact override; leave the contact blank to use the operator SEC contact. `{}` is an archived demonstration, not live data. |
| `FORBIDDEN` | Verify the User-Agent contact, stop parallel clients, and retry later; this Actor does not bypass SEC blocking. |
| `RATE_LIMITED`, `TIMEOUT`, `NETWORK_ERROR` | The client retries transient failures and honors Retry-After within its wait budget. Narrow the date window or reduce request rate. |
| `NOT_FOUND`, `PARSE_ERROR`, `BAD_RESPONSE` | Inspect source status and the accession URL; the document may be missing or non-XML. Other documents continue. |
| `BILLING_CAP_REACHED` | Increase the run option cap or reduce output; no unaffordable unit is emitted. |
| `BILLING_EVENT_NOT_CONFIGURED` | Actor owner must configure exactly the documented event names, without a second dataset-row charge. |
| No matches | Check state/date window, fund exclusions and amount filters; an empty successful query is valid, not manufactured leads. |

### Explicit non-goals

No XBRL fundamentals, 13F holdings diffs, paywall bypass, investor roster or AI trading signals in this version. We do not claim better reliability than a rival based on a tiny demo.

# Actor input Schema

## `mode` (type: `string`):

Form D funding leads = companies that just filed a Form D (exempt offering: amount raised, exemption, executives). Filing alerts = new EDGAR filings for your tickers/CIKs or market-wide, filtered by form type, 8-K item code or full-text keyword. Form 4 insider trades = one row per insider transaction.

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

Optional working contact email for SEC fair-access User-Agent headers only. Leave blank to use the operator contact. Never sent to other sources or included in results/logs. Example-domain placeholders are rejected for SEC.

## `tickers` (type: `array`):

Stock tickers (e.g. AAPL, BRK.B), resolved to CIKs via SEC's official ticker list. Leave empty for market-wide results. Used by all modes (Form D issuers rarely have tickers; use CIKs there).

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

SEC Central Index Keys (e.g. 320193 or 0000320193). Combined with Tickers. Max 500 tickers + CIKs per run.

## `formTypes` (type: `array`):

EDGAR form types to include, e.g. 8-K, 10-K, 10-Q, S-1, SC 13D, DEF 14A. Empty = all forms. If you set 8-K item codes and leave this empty, 8-K is used.

## `itemCodes` (type: `array`):

Only 8-Ks that report at least one of these items, e.g. 2.02 (earnings), 5.02 (officer/director change), 1.01 (material agreement), 1.05 (cybersecurity incident), 2.01 (acquisition), 4.02 (non-reliance/restatement).

## `keywords` (type: `string`):

Optional EDGAR full-text search query (exact phrases in double quotes, e.g. "going concern" or "artificial intelligence"). Searches filing text from 2001 on; works in all modes and with tickers/CIKs.

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

Filing-date window ending today (US Eastern), e.g. 3 = today and the two days before. Ignored if "Date from" is set. For daily alerts use 1-3 with Monitor mode on.

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

Optional exact start filing date (YYYY-MM-DD). The window can be at most 1 year.

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

Optional end filing date (YYYY-MM-DD). Default today (US Eastern).

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

Also return amended filings (D/A, 8-K/A, 4/A, ...). Off by default so funding leads and alerts are not duplicated.

## `excludeFundsAndSpvs` (type: `boolean`):

Drop pooled investment funds, SPVs, series LLCs, feeder/aggregator and co-invest vehicles (industry group, security type and name rules) so only operating companies remain. Each row also has looksLikeFundOrSpv + the reason.

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

Form D industry groups to keep: technology (computers, telecom, other tech), health_care (biotech, pharma, ...), financial_services, pooled_investment_fund, real_estate, energy, manufacturing, business_services, retailing, restaurants, agriculture, travel, other. Empty = all.

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

EDGAR 2-character codes of the issuer's principal place of business, e.g. CA, NY, TX (non-US codes like X0 = United Kingdom, A6 = Ontario). Empty = all.

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

Keep only offerings claiming one of these: 506b (Rule 506(b), no general solicitation), 506c (Rule 506(c), accredited-only, may advertise), 504, 4a5, 3c (Investment Company Act 3(c) funds).

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

Keep offerings whose total offering amount is at least this. Offerings marked "Indefinite" are dropped when an amount filter is set.

## `maxOfferingAmount` (type: `integer`):

Keep offerings whose total offering amount is at most this.

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

Keep offerings that have already raised at least this much (totalAmountSold).

## `onlyIncorporatedWithinFiveYears` (type: `boolean`):

Keep only issuers that ticked "incorporated within the last five years" on the Form D (a good young-startup filter).

## `transactionCodes` (type: `array`):

Form 4 transaction codes to keep, e.g. P = open-market purchase, S = sale, A = grant/award, M = option exercise, F = tax withholding, G = gift. Empty = all.

## `minTransactionValue` (type: `integer`):

Keep transactions whose shares x price is at least this. Transactions without a reported price are dropped when set.

## `includeDerivative` (type: `boolean`):

Also return rows from the derivative table (options, RSUs, warrants: exercise price, expiry, underlying shares).

## `monitor` (type: `boolean`):

Remember which filings were already returned (in a named key-value store) and only output new ones on later runs. Schedule the Actor (e.g. hourly or daily) for alerts; connect a webhook/Slack/Zapier integration to the dataset.

## `monitorKey` (type: `string`):

Optional name for this watch's memory (letters, digits, - \_ . ! ' ( )). Default: derived from the mode and filters, so changing filters starts a fresh watch.

## `stateStoreName` (type: `string`):

Named key-value store that keeps monitor memory between runs (letters, digits, dashes).

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

Maximum rows per run (Form D filings, filings, or insider transactions; an insider filing's transactions are kept together, so a few extra rows are possible). Newest first.

## `maxRequestsPerSecond` (type: `integer`):

Pacing for SEC requests. SEC allows at most 10 per second per user; default 5 leaves headroom. 429/5xx responses are retried with backoff.

## Actor input object example

```json
{
  "mode": "formD",
  "daysBack": 3,
  "includeAmendments": false,
  "excludeFundsAndSpvs": true,
  "onlyIncorporatedWithinFiveYears": false,
  "includeDerivative": true,
  "monitor": false,
  "stateStoreName": "sec-edgar-toolkit-state",
  "maxResults": 25,
  "maxRequestsPerSecond": 5
}
```

# Actor output Schema

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

No description

## `summary` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("foresighted_sunset/sec-edgar-toolkit").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("foresighted_sunset/sec-edgar-toolkit").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 '{}' |
apify call foresighted_sunset/sec-edgar-toolkit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foresighted_sunset/sec-edgar-toolkit"
        }
    }
}
```

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/ii3xhfbugTmJmypZD/builds/dMTeBoZOhaM2BKH85/openapi.json