# SEC Form D Leads Scraper (`devilscrapes/sec-form-d-leads`) Actor

Scrape US SEC Form D filings — Regulation D private offerings — with issuer, offering amount, related persons, industry, state, and date filed. We handle EDGAR's pagination, retries, and rate-limit pacing. Typed rows ready for a B2B lead pipeline.

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

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

<img src=".actor/icon.svg" width="160" alt="SEC Form D Leads Scraper" />

## SEC Form D Leads Scraper

_We do the dirty work so your dataset stays clean._ 😈

**$5.05 / 1,000 rows** — Turn the U.S. SEC EDGAR Form D filing stream into a structured B2B lead list. Every U.S. company raising private capital under Regulation D must file Form D with the SEC within 15 days of the first sale, making this a real-time feed of "we just raised money" announcements. Every row carries the issuer's legal name, address, phone number, industry group, offering amount, investor count, and the named officers / directors / promoters. No API key, no login, no browser automation — the data is U.S. government public domain.

The Apify Store has exactly one active competitor for Form D (`logiover/sec-edgar-form-d-scraper` — 9 monthly active users, zero reviews, no state or raise-size filters). This Actor ships the same primary source with deeper extraction (officers and addresses, not just headline numbers), proper amendment handling, post-filters for state and minimum raise size, and the EDGAR rate-limit + User-Agent compliance baked in.

### 🎯 What this scrapes
One `ResultRow` per qualifying Form D filing. Each row has 27 top-level fields plus a nested `related_persons` list of officers, directors, and promoters. Data is U.S. government public domain — there are no terms-of-service restrictions on redistribution.

| Field | Type | Description |
|---|---|---|
| `accession_number` | string | SEC accession number with dashes |
| `cik` | string | Zero-padded 10-character Central Index Key |
| `entity_name` | string | Issuer legal name |
| `entity_type` | string \| null | `Corporation`, `Limited Liability Company`, `Limited Partnership`, etc. |
| `jurisdiction_of_incorporation` | string \| null | Full state / country name of incorporation |
| `year_of_incorporation` | integer \| null | Null when issuer reports `overFiveYears=true` |
| `issuer_street_1` / `_2` / `city` / `state_or_country` / `zip_code` | strings \| null | Issuer postal address |
| `issuer_phone_number` | string \| null | Issuer phone as filed (raw) |
| `industry_group_type` | string \| null | E.g. `Other Technology`, `Pooled Investment Fund`, `Biotechnology` |
| `total_offering_amount_usd` | number \| null | Null when issuer reports `Indefinite` |
| `total_amount_sold_usd` | number \| null | Amount sold to date in USD |
| `total_remaining_usd` | number \| null | Null when `Indefinite` |
| `is_indefinite_amount` | boolean | True when issuer reported `Indefinite` |
| `total_number_already_invested` | integer \| null | Investor count to date |
| `minimum_investment_usd` | number \| null | Null when no minimum (raw `"0"`) |
| `exemption_claimed` | string[] | Federal exemption codes (e.g. `["06B", "3C", "3C.1"]`) |
| `is_new_notice` | boolean | True for new D, False for D/A amendment |
| `date_of_first_sale` | string \| null | ISO date; null when `yetToOccur=true` |
| `related_persons` | object[] | Officers / directors / promoters with names and locations |
| `filing_date` | string | EDGAR acceptance date (ISO) |
| `filing_url` | string | Canonical EDGAR company-filings page |
| `scraped_at` | string | ISO 8601 UTC timestamp |

### 🔥 Features
- Real-time SEC EDGAR Form D feed — every Reg D capital raise in the U.S. lands here within 15 days of the first sale.
- 27-field extraction including the structured B2B contact fields (phone, address, named officers) that the general `sec-edgar-filings-scraper` does not surface.
- Free-text query, date range, U.S. state filter, and minimum-raise-size filter — all four input axes optional, all four post-filtered before the per-row charge so you pay only for kept rows.
- Amendment toggle: `includeAmendments=false` (default) skips Form D/A entries before fetching the XML — saves both bandwidth and rate-limit budget.
- XML schema quirks handled correctly — `"Indefinite"` offering amounts, `overFiveYears` year-of-inc, `yetToOccur` first-sale flag, raw `"0"` minimum investment → null.
- EDGAR Fair Access Policy compliant — mandatory `User-Agent` header set on every request; 0.1 s inter-fetch sleep keeps the run under the 10 req/s/IP limit.
- Exponential backoff with `Retry-After` for `429` / `503` responses; max 5 attempts.
- Pydantic v2 input validation: ISO date shape checked before any network call, `start_date <= end_date` enforced, state filter normalised to uppercase.
- `curl-cffi` with Chrome 131 TLS impersonation (ADR-0002 house default) — robust against any future EDGAR fingerprint tightening.
- Apify Proxy support via the `BUYPROXIES94952` group (opt-in via `useProxy`). Off by default because EDGAR does not block datacenter IPs when the User-Agent is set.

### 💡 Use cases
- **B2B sales prospecting** — pull every Form D filed in the last 7-30 days in your target state (e.g. `stateFilter=CA`, `minOfferingAmountUsd=1000000`) for fresh inbound to SaaS / professional-services teams selling to newly-funded startups.
- **VC deal-flow tracking** — query `industryGroupType=Biotechnology` and filter by state to surface every Series A-and-earlier biotech raise in your geography.
- **Compete-monitoring** — pass a `query` term matching a competitor's domain category to detect new entrants raising private capital.
- **Journalism + research** — bulk-export Form D over a multi-month window to measure private-market capital flow by state, industry, or exemption code.
- **Crunchbase / PitchBook alternative for early-stage** — Form D is the original-source filing every paid private-markets database derives from, available here at $5/1,000 rows vs $299-999/month.
- **Compliance + KYC** — verify a counterparty's Reg D filing history by issuer name or CIK before signing a master service agreement.

### ⚙️ How to use it
1. Open the Actor input form on the Apify Console.
2. (Optional) Set `query` to a free-text search term (e.g. `"artificial intelligence"`) — passes through to EDGAR Full-Text Search.
3. (Optional) Set `startDate` and `endDate` (ISO `YYYY-MM-DD`). Defaults: last 30 days.
4. (Optional) Set `stateFilter` to a U.S. state ISO-2 code (e.g. `CA`, `NY`, `TX`) to keep only matching issuers.
5. (Optional) Set `minOfferingAmountUsd` to filter out small raises (indefinite-amount filings always pass).
6. Set `maxResults` (1-5000). Default 100.
7. Leave `includeAmendments=false` to skip Form D/A entries; set `true` to include them with `is_new_notice=false`.
8. Toggle `useProxy=true` if you see `429` / `403` (rare — EDGAR does not currently rate-limit datacenter IPs).
9. Click **Start**. Results stream into the default dataset as JSON / CSV / Excel / XML.

#### California raises ≥ $1M in the last 30 days

```json
{
  "stateFilter": "CA",
  "minOfferingAmountUsd": 1000000,
  "maxResults": 500
}
````

#### Last week's biotech filings nationally

```json
{
  "query": "biotechnology",
  "startDate": "2026-05-09",
  "endDate": "2026-05-16",
  "maxResults": 200
}
```

#### Every Form D + amendments filed today

```json
{
  "startDate": "2026-05-16",
  "endDate": "2026-05-16",
  "includeAmendments": true,
  "maxResults": 5000
}
```

### 📥 Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `query` | string | no | — | Free-text EDGAR search (1-200 chars) |
| `startDate` | string | no | 30 days ago | Inclusive lower bound, ISO `YYYY-MM-DD` |
| `endDate` | string | no | today | Inclusive upper bound, ISO `YYYY-MM-DD` |
| `stateFilter` | string | no | — | Issuer state ISO-2 code (uppercased) |
| `minOfferingAmountUsd` | integer | no | — | Discard filings below this amount (USD) |
| `maxResults` | integer | no | `100` | Cap on emitted rows (1-5000) |
| `includeAmendments` | boolean | no | `false` | Include Form D/A amendments |
| `useProxy` | boolean | no | `false` | Route via Apify Proxy (`BUYPROXIES94952`) |

`startDate` and `endDate` are validated for ISO shape *and* ordering before any network call — invalid input raises immediately and the run exits non-zero.

### 📤 Output

One row per qualifying Form D filing, pushed to the default dataset and available as JSON, CSV, Excel, or XML.

```json
{
  "accession_number": "0002122627-26-000001",
  "cik": "0002122627",
  "entity_name": "AM-0304 Fund II, a series of Delk-SPV, LP",
  "entity_type": "Limited Partnership",
  "jurisdiction_of_incorporation": "DELAWARE",
  "year_of_incorporation": 2026,
  "issuer_street_1": "2006 196TH ST SW",
  "issuer_street_2": "SUITE 114",
  "issuer_city": "LYNNWOOD",
  "issuer_state_or_country": "WA",
  "issuer_zip_code": "98036",
  "issuer_phone_number": "2068016359",
  "industry_group_type": "Pooled Investment Fund",
  "total_offering_amount_usd": 577807.0,
  "total_amount_sold_usd": 577807.0,
  "total_remaining_usd": 0.0,
  "is_indefinite_amount": false,
  "total_number_already_invested": 35,
  "minimum_investment_usd": 1000.0,
  "exemption_claimed": ["06B", "3C", "3C.1"],
  "is_new_notice": true,
  "date_of_first_sale": "2026-05-14",
  "related_persons": [
    {
      "first_name": "N/A",
      "last_name": "Fund GP, LLC",
      "city": "Wilmington",
      "state_or_country": "DE",
      "relationships": ["Director"]
    }
  ],
  "filing_date": "2026-05-15",
  "filing_url": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0002122627&type=D",
  "scraped_at": "2026-05-16T12:00:00.000000+00:00"
}
```

#### Export formats

- **JSON** — full fidelity, newline-delimited.
- **CSV** — flat; nested `related_persons` serialised as JSON string per Apify convention.
- **Excel** — `.xlsx` via the Apify dataset converter.
- **XML** — structured per-item.

All formats are available via the Apify API: `GET /datasets/{id}/items?format=csv&clean=true`.

### 💰 Pricing

Pay-Per-Event (PPE) — you pay only for what you use:

| Event | Price (USD) | When |
|---|---|---|
| `actor-start` | $0.05 | Once per run, at boot |
| `result-row` | $0.005 | Per Form D row written to dataset (after filters) |

#### Example costs

| Run | Rows | Cost |
|---|---|---|
| 7-day default scan, ~50 filings | 50 | $0.30 |
| California ≥$1M, 30 days, ~200 filings | 200 | $1.05 |
| AI keyword, 90 days, ~500 filings | 500 | $2.55 |
| 1,000 filings | 1,000 | $5.05 |
| Maximum cap, 5,000 filings | 5,000 | $25.05 |

At scale, the per-row charge dominates: ~$5 per 1,000 Form D rows. Crunchbase, PitchBook, and DealRoom expose the same underlying SEC data inside subscriptions priced $299-999/month with annual contracts — this Actor delivers the raw filings on a pay-as-you-go basis with no minimums.

### 🚧 Limitations

- **Public EDGAR Full-Text Search only.** No EDGAR Online, no authenticated EDGAR features, no premium SEC data products.
- **Form D and Form D/A only.** Forms 3/4/5 (insider transactions), Form 10-K/Q (public-company financials), and Form S-1/424 (public offerings) are out of scope — use `sec-edgar-filings-scraper` for those.
- **No email address extraction.** Form D does not contain email addresses; only the issuer phone and the named officers' city + state are filed.
- **No use-of-proceeds narrative.** Free-text fields beyond the structured XML elements listed above are out of scope.
- **No sales-compensation extraction.** Broker / finder fee data is present in the XML but excluded — out of scope for lead generation.
- **No cross-run deduplication.** Overlapping date ranges may surface the same filing multiple times across separate runs.
- **EDGAR rate limit applies.** The Actor enforces a 0.1 s inter-fetch sleep, capping the practical throughput at ~10 filings/second / ~600 filings/minute / 5,000 cap → ~9 minutes for a full run.
- **7-day default storage retention** on the Apify FREE plan. Export the dataset immediately after the run or move to a paid plan for longer retention.
- **U.S. government public domain.** SEC EDGAR data has no copyright; attribution is optional but appreciated.

### ❓ FAQ

**Do I need an API key?**

No. The EDGAR Full-Text Search endpoint at `https://efts.sec.gov/LATEST/search-index?forms=D` and the `https://www.sec.gov/Archives/edgar/data/...` static archive are both fully public. The Actor sends a `User-Agent` header identifying Devil Scrapes per EDGAR Fair Access Policy §2.4 — this is required by SEC ToS, not an authentication step.

**Why does the `cik` URL not have leading zeros?**

The EDGAR Archives URL path requires the *integer* form of the CIK (no padding), while the JSON / search APIs return the zero-padded 10-character form. The Actor normalises both — every output row's `cik` is the canonical zero-padded form (`"0002122627"`), and the internal URL builder strips the leading zeros for the XML fetch. Pre-padding the URL returns HTTP 404.

**What's the difference between Form D and Form D/A?**

Form D is the initial notice of a Reg D offering; Form D/A is an amendment (typically to update the total amount sold, add investors, or correct an error). When `includeAmendments=false` (default), only new D notices are returned. When `true`, amendments are included with `is_new_notice=false`.

**Why is `total_offering_amount_usd` sometimes null?**

The issuer reported the literal string `"Indefinite"` (common for evergreen funds and certain real-estate offerings). The `is_indefinite_amount` flag is `True` on those rows, and `total_offering_amount_usd` + `total_remaining_usd` are both null. Indefinite-amount rows always pass the `minOfferingAmountUsd` filter — we never throw them away on a numeric comparison they can't satisfy.

**Why is `year_of_incorporation` sometimes null?**

The issuer reported `overFiveYears=true` in the XML — the SEC does not require an exact year when the entity is more than 5 years old. Issuers younger than 5 years report `withinFiveYears=true` and the specific `<value>YYYY</value>` we parse to an integer.

**Can I redistribute the data?**

Yes. SEC EDGAR data is U.S. government public domain — there are no licensing restrictions on redistribution or commercial use. Attribution to the U.S. Securities and Exchange Commission is optional but recommended.

### 💬 Your feedback

Found a bug, hit a rate limit, or need a new field on the output row? Open an issue on the Actor's Apify Store page or contact the Devil Scrapes team at [apify.com/DevilScrapes](https://apify.com/DevilScrapes). We ship updates within days of validated reports.

#### Funding Intelligence Suite

Cross-link this Actor with the rest of the Devil Scrapes funding + research vertical:

- **SEC EDGAR Filings Scraper** — general EDGAR filings across all form types (10-K, 10-Q, 8-K, 4, etc.) for established public-company coverage.
- **EU CORDIS Grants Scraper** — Horizon Europe + Horizon 2020 grant projects (EU public R\&D funding).
- **arXiv Papers Scraper** — preprint metadata across all arXiv categories.
- **PubMed Papers Scraper** — biomedical literature from the NIH PubMed index.
- **USPTO Patents Scraper** — U.S. patent metadata for IP landscape work.

All suite Actors share consistent PPE pricing ($0.001-$0.005 per row, $0.01-$0.05 per run) and `scraped_at` ISO 8601 UTC timestamps so cross-source joins work cleanly.

# Actor input Schema

## `query` (type: `string`):

Optional free-text filter passed to EDGAR Full-Text Search (e.g. <code>artificial intelligence</code> or <code>biotechnology</code>). 1-200 chars.

## `startDate` (type: `string`):

Inclusive lower bound on filing date in <code>YYYY-MM-DD</code> form. Defaults to 30 days ago when omitted.

## `endDate` (type: `string`):

Inclusive upper bound on filing date in <code>YYYY-MM-DD</code> form. Defaults to today when omitted.

## `stateFilter` (type: `string`):

Optional post-filter: keep only rows where the issuer's state matches this ISO 3166-1 alpha-2 code (e.g. <code>CA</code>, <code>NY</code>, <code>TX</code>). Lower-case is normalised to upper.

## `minOfferingAmountUsd` (type: `integer`):

Optional post-filter: discard filings whose total offering is below this amount. Indefinite-amount filings always pass through. Use <code>1000000</code> for $1M+ raises.

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

Maximum rows emitted (1-5000). The Actor stops fetching once this many rows survive every filter.

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

When <code>false</code> (default), only new Form D notices are returned. When <code>true</code>, amendments (Form D/A) are included with <code>is\_new\_notice = false</code>.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy (<code>BUYPROXIES94952</code>). EDGAR does not currently rate-limit datacenter IPs when the User-Agent header is set; leave off unless you see <code>403</code> or <code>429</code>.

## Actor input object example

```json
{
  "query": "artificial intelligence",
  "startDate": "2026-05-01",
  "endDate": "2026-05-16",
  "stateFilter": "CA",
  "minOfferingAmountUsd": 1000000,
  "maxResults": 100,
  "includeAmendments": false,
  "useProxy": false
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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("devilscrapes/sec-form-d-leads").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/sec-form-d-leads").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 devilscrapes/sec-form-d-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=devilscrapes/sec-form-d-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form D Leads Scraper",
        "description": "Scrape US SEC Form D filings — Regulation D private offerings — with issuer, offering amount, related persons, industry, state, and date filed. We handle EDGAR's pagination, retries, and rate-limit pacing. Typed rows ready for a B2B lead pipeline.",
        "version": "0.1",
        "x-build-id": "V7vgUevug33jVGfBC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~sec-form-d-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-sec-form-d-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/devilscrapes~sec-form-d-leads/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-sec-form-d-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/devilscrapes~sec-form-d-leads/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-sec-form-d-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Free-text search",
                        "type": "string",
                        "description": "Optional free-text filter passed to EDGAR Full-Text Search (e.g. <code>artificial intelligence</code> or <code>biotechnology</code>). 1-200 chars."
                    },
                    "startDate": {
                        "title": "Start date (inclusive)",
                        "type": "string",
                        "description": "Inclusive lower bound on filing date in <code>YYYY-MM-DD</code> form. Defaults to 30 days ago when omitted."
                    },
                    "endDate": {
                        "title": "End date (inclusive)",
                        "type": "string",
                        "description": "Inclusive upper bound on filing date in <code>YYYY-MM-DD</code> form. Defaults to today when omitted."
                    },
                    "stateFilter": {
                        "title": "Issuer state (ISO-2)",
                        "type": "string",
                        "description": "Optional post-filter: keep only rows where the issuer's state matches this ISO 3166-1 alpha-2 code (e.g. <code>CA</code>, <code>NY</code>, <code>TX</code>). Lower-case is normalised to upper."
                    },
                    "minOfferingAmountUsd": {
                        "title": "Minimum offering amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional post-filter: discard filings whose total offering is below this amount. Indefinite-amount filings always pass through. Use <code>1000000</code> for $1M+ raises."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum rows emitted (1-5000). The Actor stops fetching once this many rows survive every filter.",
                        "default": 100
                    },
                    "includeAmendments": {
                        "title": "Include amendments (D/A)",
                        "type": "boolean",
                        "description": "When <code>false</code> (default), only new Form D notices are returned. When <code>true</code>, amendments (Form D/A) are included with <code>is_new_notice = false</code>.",
                        "default": false
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy (<code>BUYPROXIES94952</code>). EDGAR does not currently rate-limit datacenter IPs when the User-Agent header is set; leave off unless you see <code>403</code> or <code>429</code>.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```