# SEC EDGAR Scraper — SEC Filings Data & Regulatory Monitor (`scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor`) Actor

Extract SEC filings data from any US public company by ticker. Get 10-K, 10-Q, 8-K, 13F, S-1, and all SEC EDGAR filing types — filing ID, date, form type, and direct document link. Demo mode included. No login. $18.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$18.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

## 📊 SEC EDGAR Scraper — SEC Filings Data & Regulatory Intelligence

> **The most reliable SEC EDGAR Scraper on Apify.** Extract SEC filings data from any public company — 10-K, 10-Q, 8-K, S-1, 13F, and all other SEC form types — by ticker symbol. Get filing ID, form type, filing date, direct SEC document link, and filing title for every submission. Demo mode included. No login. Instant structured output.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This SEC EDGAR Scraper?](#why-use-this-sec-edgar-scraper)
- [Supported Form Types](#supported-form-types)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Demo Mode](#demo-mode)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**SEC EDGAR Scraper** is a production-ready Apify actor that extracts complete **SEC filings data** from the US Securities and Exchange Commission's official public registry — for any publicly traded company, by ticker symbol and form type.

Enter any US stock ticker — `AAPL`, `TSLA`, `MSFT`, `NVDA` — select a form type or leave it blank for all filings, and receive back a clean, structured dataset of every matching SEC EDGAR filing: filing ID, company ticker, form type, filing date, direct SEC document link, and filing title.

Whether you are a financial analyst monitoring earnings filings, a compliance officer tracking material event disclosures, a researcher building a regulatory dataset, or an investor watching insider ownership changes — this **SEC EDGAR scraper** delivers structured **SEC filings data** from the official source in seconds.

---

### 🚀 Why Use This SEC EDGAR Scraper?

| Feature | This Actor | Manual EDGAR Search | Bloomberg / FactSet | Other Scrapers |
|---|---|---|---|---|
| **SEC filings data — any ticker** | ✅ Instant | ✅ Slow | ✅ Expensive | ⚠️ |
| **All SEC form types** | ✅ | ✅ | ✅ | ⚠️ |
| **Direct filing document link** | ✅ | ✅ | ⚠️ | ⚠️ |
| **Filing date + filing ID** | ✅ | ✅ | ✅ | ⚠️ |
| **Bulk results — up to 100/run** | ✅ | ❌ | ✅ | ⚠️ |
| **Structured JSON — export-ready** | ✅ | ❌ | ❌ PDF | ❌ |
| **CSV / Excel export** | ✅ Via Apify | ❌ | ❌ | ❌ |
| **Demo mode for instant preview** | ✅ | N/A | N/A | ❌ |
| **No subscription or API key** | ✅ | ✅ | ❌ | ❌ |
| **Scheduled runs for monitoring** | ✅ | ❌ | ✅ | ❌ |

> **Bottom line:** This **SEC EDGAR scraper** delivers structured **SEC filings data** from the official government source — faster than manual EDGAR search, cheaper than financial data platforms, and more reliable than generic scrapers.

---

### 📋 Supported Form Types

This **SEC EDGAR scraper** supports all SEC filing form types. Enter any form type code in the `form_type` input — or leave it blank to return all filings for a company.

#### 📈 Most Common Forms

| Form Type | Description |
|---|---|
| `10-K` | Annual report — full year financial statements and business overview |
| `10-Q` | Quarterly report — financial statements for Q1, Q2, Q3 |
| `8-K` | Current report — material events (earnings, mergers, executive changes) |
| `S-1` | IPO registration statement |
| `DEF 14A` | Proxy statement — shareholder voting and executive compensation |
| `13F` | Institutional investment manager quarterly holdings report |
| `13D` | Beneficial ownership report — 5%+ stake disclosure |
| `13G` | Passive beneficial ownership report |
| `4` | Insider transaction report — officer and director trades |
| `SC 13D` | Acquisition of beneficial ownership above 5% |
| `424B4` | Final prospectus for securities offering |

> Leave `form_type` blank to retrieve all filing types for the target company in a single run.

---

### 🎯 Use Cases

#### 📈 Investment Research & Financial Analysis
- Monitor **SEC filings data** for portfolio companies — track 10-K and 10-Q submissions automatically
- Watch for 8-K filings to catch material event disclosures as soon as they are filed
- Extract S-1 registration statements for IPO research and pre-offering analysis

#### ⚖️ Compliance & Regulatory Monitoring
- Track insider transaction filings (Form 4) for key executives at target companies
- Monitor 13D and 13G filings to detect large ownership changes and activist investor activity
- Build automated compliance watchlists by scheduling this **SEC EDGAR scraper** on multiple tickers

#### 🏦 Institutional & Hedge Fund Intelligence
- Scrape 13F filings to track institutional portfolio holdings on a quarterly basis
- Monitor large beneficial ownership disclosures for merger arbitrage and event-driven strategies
- Build structured **SEC EDGAR filings** datasets for quantitative investment research

#### 🤖 FinTech & Data Pipeline Integrations
- Feed **SEC filings data** into financial research platforms, AI tools, or risk management systems
- Build automated filing alert pipelines that notify your team when a specific company files a new 8-K
- Integrate structured SEC EDGAR data into dashboards, Bloomberg alternatives, or research databases

#### 📰 Financial Journalism & Research
- Monitor SEC filings for specific companies to catch breaking corporate events before earnings calls
- Source regulatory filing details for investigative financial journalism
- Build structured databases of **SEC EDGAR filings** for academic finance research

#### 🎓 Academic & Policy Research
- Build large-scale datasets of SEC filings for empirical accounting and finance research
- Study disclosure timing patterns across industries using structured filing date data
- Analyze form type frequency and filing volume as indicators of corporate activity

---

### ⚙️ Input Parameters

```json
{
  "company_ticker": "AAPL",
  "form_type":      "10-K",
  "max_results":    20,
  "demo_mode":      false,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `company_ticker` | string | `"AAPL"` | US stock ticker symbol — e.g. `"TSLA"`, `"MSFT"`, `"NVDA"`, `"GOOGL"`. Automatically converted to uppercase |
| `form_type` | string | `""` | SEC form type to filter — e.g. `"10-K"`, `"8-K"`, `"13F"`. Leave blank to return all filing types |
| `max_results` | integer | `20` | Maximum number of SEC filings to return |
| `demo_mode` | boolean | `false` | When `true`, returns realistic sample SEC filings instantly without making a live query |
| `proxyConfiguration` | object | Optional | Apify proxy config — residential proxy recommended for reliable SEC EDGAR access |

> **Tip:** Leave `form_type` blank to get a complete filing history across all form types for a company. Set `form_type` to `"8-K"` to watch only material event disclosures.

***

### 📋 Output Fields

Every record from this **SEC EDGAR scraper** includes complete **SEC filings data**:

| Field | Type | Description | Example |
|---|---|---|---|
| `filing_id` | string | Unique SEC EDGAR filing accession number | `"0000320193-26-000006"` |
| `company` | string | Company ticker symbol | `"AAPL"` |
| `form_type` | string | SEC form type | `"10-Q"`, `"8-K"`, `"10-K"` |
| `date` | string | Filing submission date (ISO format) | `"2024-03-27"` |
| `link` | string | Direct SEC EDGAR document index URL | `"https://www.sec.gov/Archives/edgar/..."` |
| `title` | string | Official filing title from SEC EDGAR | `"Quarterly report [Sections 13 or 15(d)]"` |
| `source` | string | Data source identifier | `"SEC EDGAR"` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "company_ticker": "TSLA",
  "form_type":      "8-K",
  "max_results":    5,
  "demo_mode":      false
}
```

**Output (one record):**

```json
{
  "filing_id": "0001193125-24-045123",
  "company":   "TSLA",
  "form_type": "8-K",
  "date":      "2024-03-20",
  "link":      "https://www.sec.gov/Archives/edgar/data/1318605/000119312524045123-index.htm",
  "title":     "Current report pursuant to Section 13 or 15(d)",
  "source":    "SEC EDGAR"
}
```

The full run returns up to `max_results` records — each with the same clean structure, ready for export to CSV, Excel, or direct integration into your research workflow.

***

### 🧪 Demo Mode

Want to preview the output before running a live query? Enable **Demo Mode** to instantly generate realistic sample **SEC filings data** — in the exact same structure as a live run.

```json
{ "demo_mode": true }
```

Demo mode is ideal for testing your downstream data pipeline, evaluating the output format, or demonstrating the tool to a client without consuming a live EDGAR query.

> Switch to live data at any time by setting `demo_mode: false` and entering your target ticker.

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $18.99 / month | Unlimited runs, any ticker, all SEC form types |

#### Everything included in every plan:

- ✅ Complete SEC filings data — all 7 output fields per filing
- ✅ All SEC form types supported — 10-K, 10-Q, 8-K, S-1, 13F, Form 4, and more
- ✅ Any US publicly traded company by ticker symbol
- ✅ Up to 100 filings per run
- ✅ Demo mode for instant output preview
- ✅ Direct SEC EDGAR document links in every record
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for automated filing monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Filings | Estimated Time |
|---|---|---|
| Demo mode | 2 sample records | ~2 seconds |
| Single ticker — any form | up to 20 | ~5–10 seconds |
| Single ticker — all forms | up to 100 | ~10–20 seconds |
| Scheduled monitoring run | any count | Configurable interval |

- Results pushed to the Apify dataset in real time as each filing is processed
- Data is sourced directly from the official SEC EDGAR government registry
- Lightweight and fast — no browser, no JavaScript rendering overhead
- Residential proxy recommended for consistent access at higher volumes

***

### ❓ FAQ

**Q: Where does the SEC filings data come from?**
A: All data is sourced directly from **SEC EDGAR** — the official Electronic Data Gathering, Analysis, and Retrieval system operated by the US Securities and Exchange Commission. This is the same source used by financial professionals, regulators, and researchers worldwide.

**Q: Can I retrieve all filing types for a company at once?**
A: Yes. Leave the `form_type` field blank and the actor returns all filing types for the target company — 10-K, 10-Q, 8-K, and every other form submitted to EDGAR — up to `max_results`.

**Q: How current is the data?**
A: **SEC EDGAR filings** data is retrieved live at the time of each run. The `date` field reflects the actual filing submission date as recorded by the SEC.

**Q: Can I monitor a company for new filings automatically?**
A: Yes. Set up an Apify scheduled task to run this **SEC EDGAR scraper** on a daily or weekly basis for any ticker. New filings appear in each run's output as soon as they are submitted to EDGAR.

**Q: What is the `filing_id` field?**
A: The `filing_id` is the SEC EDGAR accession number — a unique identifier in the format `XXXXXXXXXX-YY-ZZZZZZ` that permanently identifies every filing in the EDGAR system. You can use this to look up the full filing directly on the SEC website.

**Q: Can I use this for non-US companies?**
A: This actor works for any company that files with the SEC — primarily US-listed public companies. Some foreign private issuers that trade on US exchanges also file with the SEC and are supported.

**Q: What is Demo Mode for?**
A: Demo Mode returns pre-loaded sample records instantly — useful for testing your pipeline or previewing the output format without running a live EDGAR query.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run completes.

***

### 📜 Changelog

#### v2.0.0 (Current)

- ✅ Live SEC EDGAR filings data from official SEC government source
- ✅ Any US ticker symbol and any SEC form type
- ✅ Filing ID (accession number), form type, date, direct link, and title per record
- ✅ Demo mode with realistic sample SEC EDGAR filings
- ✅ Up to 100 filings per run
- ✅ Proxy support for reliable EDGAR access
- ✅ Real-time dataset push as each filing is processed
- ✅ Key-value store output for downstream integrations

#### v1.0.0

- Initial release with basic ticker search and core filing field extraction

***

### 🏷️ Tags

`sec edgar scraper` `sec filings data` `sec edgar filings` `sec scraper` `edgar filings` `financial data scraper` `10-k scraper` `8-k scraper` `sec data extractor` `regulatory filings` `investment research data` `compliance monitoring`

***

### ⚖️ Legal & Terms of Use

This actor retrieves publicly available regulatory filing data from SEC EDGAR — the official US government securities disclosure system operated by the Securities and Exchange Commission.

**Please note:**

- SEC EDGAR data is in the public domain — it is freely available for research, commercial, and educational use per SEC policy
- Always cite SEC EDGAR as the original data source in any publication, report, or application
- Do not present extracted filing data as current or verified without confirming directly on SEC EDGAR — records may be amended after your run
- This tool is not intended for trading decisions — always consult qualified financial professionals before making investment choices
- The actor developer is not responsible for decisions made based on extracted SEC filings data

***

### 🤝 Support & Feedback

- **Bug report or issue?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Using it for financial research?** We'd love to hear your use case!
- **Loving it?** Please leave a ⭐ review — it helps other researchers find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify · Powered by SEC EDGAR Official Registry</strong><br/>
  <em>The most reliable SEC EDGAR Scraper — any ticker, any form type, instant SEC filings data</em><br/><br/>
  <strong>💰 $18.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `demo_mode` (type: `boolean`):

Turn ON to see sample records instantly without using proxies or searching SEC. Great for testing!

## `company_ticker` (type: `string`):

Enter Stock Ticker (e.g., AAPL, TSLA, NVDA).

## `form_type` (type: `string`):

Specify form (e.g., 10-K, 10-Q, 8-K). Leave empty for ALL.

## `max_results` (type: `integer`):

Number of recent filings to extract (1-100).

## `proxyConfiguration` (type: `object`):

Residential proxy is highly recommended to avoid SEC rate limiting.

## Actor input object example

```json
{
  "demo_mode": false,
  "company_ticker": "AAPL",
  "max_results": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "company_ticker": "AAPL",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor").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 = {
    "company_ticker": "AAPL",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor").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 '{
  "company_ticker": "AAPL",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilot/sec-edgar-scraper----sec-filings-data-regulatory-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Scraper — SEC Filings Data & Regulatory Monitor",
        "description": "Extract SEC filings data from any US public company by ticker. Get 10-K, 10-Q, 8-K, 13F, S-1, and all SEC EDGAR filing types — filing ID, date, form type, and direct document link. Demo mode included. No login. $18.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "S2opDV1xIqPslx7Cd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~sec-edgar-scraper----sec-filings-data-regulatory-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-sec-edgar-scraper----sec-filings-data-regulatory-monitor",
                "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/scrapepilot~sec-edgar-scraper----sec-filings-data-regulatory-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-sec-edgar-scraper----sec-filings-data-regulatory-monitor",
                "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/scrapepilot~sec-edgar-scraper----sec-filings-data-regulatory-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-sec-edgar-scraper----sec-filings-data-regulatory-monitor",
                "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",
                "required": [
                    "company_ticker"
                ],
                "properties": {
                    "demo_mode": {
                        "title": "Enable Demo Mode",
                        "type": "boolean",
                        "description": "Turn ON to see sample records instantly without using proxies or searching SEC. Great for testing!",
                        "default": false
                    },
                    "company_ticker": {
                        "title": "Stock Ticker",
                        "type": "string",
                        "description": "Enter Stock Ticker (e.g., AAPL, TSLA, NVDA)."
                    },
                    "form_type": {
                        "title": "Form Type (Optional)",
                        "type": "string",
                        "description": "Specify form (e.g., 10-K, 10-Q, 8-K). Leave empty for ALL."
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of recent filings to extract (1-100).",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is highly recommended to avoid SEC rate limiting."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
