# SEC EDGAR Full-Text Search MCP Server (`rl1987/sec-edgar-mcp`) Actor

MCP server exposing SEC EDGAR full-text search (https://www.sec.gov/edgar/search/#) as tools: keyword search with every form filter, company lookup, and filing document retrieval.

- **URL**: https://apify.com/rl1987/sec-edgar-mcp.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** Lead generation, News, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 mcp tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does SEC EDGAR Full-Text Search MCP Server do?

This **[Model Context Protocol](https://modelcontextprotocol.io)** server gives any MCP-compatible AI client (Claude, Cursor, etc.) direct access to [SEC EDGAR Full-Text Search](https://www.sec.gov/edgar/search/#) — the SEC's search engine over the full text of filings submitted since 2001. It mirrors every filter available on the search form: keyword query, company/ticker/CIK, filing form type, filed-date range, principal-executive-office or state-of-incorporation location, and SIC industry code. Once a matching filing is found, the server can also list every document inside it and fetch the actual document text, so an agent can go from "find filings mentioning X" all the way to reading the filing itself without leaving the conversation.

Running on the Apify platform means the server is always on ([Standby mode](https://docs.apify.com/platform/actors/development/programming-interface/standby)), billed per tool call, and benefits from Apify's monitoring, logging, and scheduling.

### Why use SEC EDGAR Full-Text Search MCP Server?

- **Research and due diligence** — search across all companies' 10-Ks, 10-Qs, 8-Ks and other filings for specific language (risk factors, litigation, contract terms).
- **Competitive and market intelligence** — track what companies in a given industry (SIC code) or state are disclosing.
- **Financial and legal analysis pipelines** — feed an LLM agent structured filing search results plus the actual document text for summarization or extraction.
- **No scraping infrastructure to maintain** — the server handles SEC's required User-Agent header, pagination, and result parsing for you.

### How to use SEC EDGAR Full-Text Search MCP Server

1. Deploy this Actor to Apify (or link this Git repository) and start a run in Standby mode.
2. Connect your MCP client to `https://<your-actor>.apify.actor/mcp` using the [Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http), passing your Apify API token as a Bearer token in the `Authorization` header.

   Add this Actor as an MCP server to Claude Code CLI:

   ```bash
   claude mcp add --transport http sec-edgar https://rl1987--sec-edgar-mcp.apify.actor/mcp \
     --header "Authorization: Bearer $APIFY_API_TOKEN"
````

Replace `$APIFY_API_TOKEN` with your [Apify API token](https://console.apify.com/account/integrations). Verify it connected with `claude mcp list`.

3. Call `search_edgar_filings` with a keyword query and any combination of filters (forms, date range, location, SIC code, entity).
4. Optionally call `lookup_edgar_company` first to resolve a fuzzy company name/ticker to the exact entity string or CIK.
5. Use `get_edgar_filing_index` and `get_edgar_filing_document` to list and read the actual documents behind a search hit.

### Input

Configure via the **Input** tab:

- **userAgent** *(optional)* — SEC requires a descriptive `User-Agent` header identifying your app and contact info (e.g. `"MyApp contact@example.com"`), per the [EDGAR developer FAQ](https://www.sec.gov/os/webmaster-faq#developers). If left blank, a generic default is used.

### Tools

#### `search_edgar_filings`

Full-text search with every form filter: `query`, `entity`, `ciks`, `forms`, `date_range` (`all`/`10y`/`5y`/`1y`/`custom` + `start_date`/`end_date`), `location_type` + `location_code`, `sic`, `sort` (`asc`/`desc`/relevance), `page`, and an optional `max_results` to auto-paginate beyond the 100-hits-per-page API limit.

#### `lookup_edgar_company`

Company/ticker/CIK autocomplete, identical to the typeahead box on the search form.

#### `get_edgar_filing_index`

Lists every document contained in a filing (given its CIK and accession number).

#### `get_edgar_filing_document`

Fetches a specific filing document by URL and returns its content as Markdown by default (tables — financial statements, beneficial-ownership tables — render as proper Markdown tables, not flattened prose), or raw markup. Supports `find`/`occurrence` to jump straight to a section and `offset`/`nextOffset` to page through large filings instead of reading from the start.

### Output

Each tool call returns structured JSON. Example `search_edgar_filings` result (truncated):

```json
{
  "totalHits": 698,
  "results": [
    {
      "accessionNumber": "0000320193-23-000106",
      "cik": "0000320193",
      "displayNames": ["Apple Inc.  (AAPL)  (CIK 0000320193)"],
      "form": "10-K",
      "fileDate": "2023-11-03",
      "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/a10-kexhibit21109302023.htm",
      "indexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/0000320193-23-000106-index.htm"
    }
  ],
  "facets": { "entities": [], "forms": [], "sics": [], "bizStates": [] }
}
```

### Pricing / Cost estimation

This Actor uses [Pay Per Event](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing-model) pricing: a flat fee per tool call (see `.actor/pay_per_event.json`). There is no charge just for keeping the server in Standby.

### Tips

- Wrap multi-word queries in double quotes (`"revenue recognition"`) for exact-phrase matching, matching EDGAR's own search syntax.
- Full-text search only covers filings from **2001 onward**; older filings aren't indexed.
- Use `max_results` sparingly — each page of 100 results is one upstream request; the tool-call fee still applies once per call regardless of how many pages it fetches internally.

### FAQ, disclaimers, and support

This Actor scrapes only publicly available data from sec.gov. It is not affiliated with or endorsed by the U.S. Securities and Exchange Commission. Data accuracy depends entirely on SEC EDGAR; always verify against the primary filing before relying on it for legal or financial decisions. Report issues via the Issues tab.

# Actor input Schema

## `userAgent` (type: `string`):

SEC EDGAR requires a descriptive User-Agent identifying your app and contact info, e.g. 'MyApp contact@example.com'. See https://www.sec.gov/os/webmaster-faq#developers

## Actor input object example

```json
{}
```

# 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("rl1987/sec-edgar-mcp").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("rl1987/sec-edgar-mcp").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 rl1987/sec-edgar-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Full-Text Search MCP Server",
        "description": "MCP server exposing SEC EDGAR full-text search (https://www.sec.gov/edgar/search/#) as tools: keyword search with every form filter, company lookup, and filing document retrieval.",
        "version": "0.0",
        "x-build-id": "MCd78D6YwKUG3FZtf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rl1987~sec-edgar-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rl1987-sec-edgar-mcp",
                "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/rl1987~sec-edgar-mcp/runs": {
            "post": {
                "operationId": "runs-sync-rl1987-sec-edgar-mcp",
                "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/rl1987~sec-edgar-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-rl1987-sec-edgar-mcp",
                "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": {
                    "userAgent": {
                        "title": "User-Agent header",
                        "type": "string",
                        "description": "SEC EDGAR requires a descriptive User-Agent identifying your app and contact info, e.g. 'MyApp contact@example.com'. See https://www.sec.gov/os/webmaster-faq#developers"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```