# SEC EDGAR Search (`nexgendata/sec-edgar-search`) Actor

Search SEC EDGAR for company filings — 10-K, 10-Q, 8-K, S-1, and more. Get financial statements, insider trades, and regulatory documents.

- **URL**: https://apify.com/nexgendata/sec-edgar-search.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

## SEC EDGAR Filing Search by nexgendata

Search the SEC EDGAR database for company filings, 10-K annual reports, 10-Q quarterly filings, 8-K current reports, and every other document type the Securities and Exchange Commission archives. This actor queries the EDGAR full-text search system and returns structured data for each filing including company name, CIK number, form type, filing date, and direct links to the filing documents.

The SEC maintains one of the largest repositories of corporate financial data in the world. Every publicly traded company in the United States must file regular reports with the Commission, and those filings contain the raw financial data that drives investment decisions, academic research, and competitive analysis. Accessing this data programmatically has traditionally required custom EDGAR API integrations or expensive financial data terminals. This actor eliminates that friction by wrapping the EDGAR search APIs into a simple input-output workflow that returns clean, structured JSON.

### How It Works

Provide a search query — a company name, ticker symbol, or any keyword that appears in filing documents. Optionally filter by form type to narrow results to specific document categories. The actor searches the EDGAR full-text search index, which covers all filings since 1996. Each result includes the company name, CIK (Central Index Key), form type, filing date, and a direct URL to the filing on sec.gov. The data arrives ready to load into spreadsheets, databases, or analytical tools.

Form types give you precise control over what comes back. Use 10-K for annual reports containing full financial statements and management discussion. Use 10-Q for quarterly updates. 8-K filings capture material events like acquisitions, leadership changes, or earnings surprises as they happen. S-1 filings reveal the financials of companies preparing to go public. DEF 14A proxy statements expose executive compensation and governance structures. You can combine multiple form types in a single search or leave the field empty to search across everything.

### Who Uses This

Investment analysts use EDGAR searches to monitor portfolio companies and identify material changes before they hit mainstream financial news. Quantitative researchers build historical datasets of financial statements for factor analysis and backtesting. Corporate development teams track competitor filings for strategic intelligence — new debt issuances, acquisitions, or changes in revenue mix often surface in filings before earnings calls. Compliance officers monitor their own company's filing history and track regulatory correspondence. Law firms conducting due diligence on potential acquisitions use EDGAR data to verify financial representations and identify undisclosed risks.

Academic researchers rely on EDGAR data for studies spanning corporate governance, financial reporting quality, executive compensation, and market microstructure. The structured output from this actor feeds directly into Python notebooks, R scripts, and database pipelines without manual reformatting.

### What You Get Back

Each filing record contains the company name as registered with the SEC, the CIK number (the unique identifier the SEC assigns to each filer), the form type (10-K, 10-Q, 8-K, etc.), the filing date, a text description when available, and a direct URL to the filing document on sec.gov. The search query that produced the result is included for reference when running multiple queries in batch.

### Pricing

This actor runs at $5 per 1,000 results. A single search returning 40 filings costs $0.20. Monitoring 50 companies weekly with 20 results each (1,000 filings/week) costs $5/week. Building a research dataset of 10,000 historical filings costs $50 — significantly less than Bloomberg Terminal access ($24,000/year) or similar financial data services.

All data comes directly from the SEC's public EDGAR system. There are no API keys to manage, no rate limit negotiations, and no usage caps beyond your Apify subscription. The SEC requires a User-Agent header identifying the requester, which this actor handles automatically.

### Use Cases

Financial research teams building factor models need historical filing data spanning years or decades. Rather than maintaining custom EDGAR scrapers and handling the SEC's various response formats, this actor delivers clean JSON that feeds directly into pandas DataFrames or database tables.

M&A due diligence requires rapid access to a target company's full filing history. Search by company name, filter to 10-K and 10-Q forms, and get every annual and quarterly report filed since 1996 in a single run.

Event-driven investors track 8-K filings for real-time signals. New 8-K filings disclose acquisitions, earnings surprises, executive departures, and other material events. Combine this actor with scheduled runs to create a monitoring pipeline that surfaces new filings within hours.

Regulatory compliance teams need to verify filing history and identify any SEC correspondence or comment letters. This actor enables systematic searches across filing types that would take hours to perform manually through the EDGAR web interface.

# Actor input Schema

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

Company name, ticker symbol, or keyword to search for in SEC filings.
## `formTypes` (type: `string`):

Comma-separated SEC form types to filter by (e.g. 10-K, 10-Q, 8-K, S-1, DEF 14A). Leave empty for all types.
## `dateFrom` (type: `string`):

Start date for filing search in YYYY-MM-DD format. Leave empty for no date filter.
## `dateTo` (type: `string`):

End date for filing search in YYYY-MM-DD format. Leave empty for no date filter.
## `maxResults` (type: `integer`):

Maximum number of filings to return (1-100).

## Actor input object example

```json
{
  "query": "Tesla",
  "formTypes": "10-K,10-Q",
  "maxResults": 20
}
````

# 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 = {
    "query": "Tesla",
    "formTypes": "10-K,10-Q"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sec-edgar-search").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 = {
    "query": "Tesla",
    "formTypes": "10-K,10-Q",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sec-edgar-search").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 '{
  "query": "Tesla",
  "formTypes": "10-K,10-Q"
}' |
apify call nexgendata/sec-edgar-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Search",
        "description": "Search SEC EDGAR for company filings — 10-K, 10-Q, 8-K, S-1, and more. Get financial statements, insider trades, and regulatory documents.",
        "version": "0.0",
        "x-build-id": "2NJY3KPHcpuU5tjmY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sec-edgar-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sec-edgar-search",
                "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/nexgendata~sec-edgar-search/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sec-edgar-search",
                "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/nexgendata~sec-edgar-search/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sec-edgar-search",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Company name, ticker symbol, or keyword to search for in SEC filings."
                    },
                    "formTypes": {
                        "title": "Form Types",
                        "type": "string",
                        "description": "Comma-separated SEC form types to filter by (e.g. 10-K, 10-Q, 8-K, S-1, DEF 14A). Leave empty for all types."
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Start date for filing search in YYYY-MM-DD format. Leave empty for no date filter."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "End date for filing search in YYYY-MM-DD format. Leave empty for no date filter."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of filings to return (1-100).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
