# SEC EDGAR MCP Server - Filings, Financials & Insider Trades (`gazidev/sec-edgar-mcp`) Actor

MCP server for official SEC EDGAR data: XBRL financial statements, 10-K/10-Q/8-K filings, full-text search, section reader (risk factors, MD\&A), cross-company metric screens and Form 4 insider trades. Works with Claude, Cursor, ChatGPT and any MCP client.

- **URL**: https://apify.com/gazidev/sec-edgar-mcp.md
- **Developed by:** [Cemal Atakli](https://apify.com/gazidev) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 data 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SEC EDGAR MCP Server: Filings, XBRL Financials and Insider Trades for AI Agents

Give Claude, Cursor, ChatGPT, VS Code Copilot or your own AI agent **live access to SEC EDGAR**, the official US database of public company filings. Your agent can pull **financial statements** for any US-listed company, search **every 10-K, 10-Q and 8-K since 2001** by keyword, read **Risk Factors or MD\&A** as clean text, rank companies on any XBRL metric, and track **insider buying and selling (Form 4)**.

No SEC API key, no scraping and no parsing on your side. The server returns compact JSON that LLMs handle well, and you pay only for tool calls that succeed.

- **Official data**: comes straight from `data.sec.gov` and `efts.sec.gov` (SEC EDGAR APIs). US government data is public domain.
- **8 tools built for agents**: clear descriptions, typed arguments, structured output and helpful error messages.
- **Fast**: responses are cached, requests are throttled to the SEC fair-access limit and retried automatically.
- **Pay per tool call**: from **$0.01 per call**, with no subscription and no monthly minimum.

### What can you ask it?

- *"Show Nvidia's last 8 quarters of revenue, gross margin and free cash flow."*
- *"Which 10-K filings from 2026 mention 'going concern' and 'tariffs'? Group them by industry."*
- *"Summarize the new risk factors in Tesla's latest 10-K compared with the previous one."*
- *"Rank the top 25 US companies by net income in CY2025."*
- *"Have Apple insiders bought or sold stock in the open market recently?"*
- *"Compare R\&D spend of AMD, Intel and Nvidia over 5 years."*
- *"What did Microsoft disclose in its latest 8-K?"*

### Tools

| Tool | What it does | Price |
|---|---|---|
| `search_companies` | Finds a company by name or ticker and returns its CIK, ticker and exchange | $0.01 |
| `get_company_filings` | Returns the company profile (SIC industry, fiscal year end, address, former names) and its filings, filtered by form type and date, with direct document URLs | $0.01 |
| `search_filings_full_text` | Full-text search across all EDGAR filings and exhibits since 2001. Supports exact phrases, OR and exclusions, plus form, date and company filters | $0.01 |
| `get_financial_statements` | Revenue, gross profit, operating income, net income, EPS, operating cash flow, capex, free cash flow, cash, assets, liabilities, debt, equity and margins, annual or quarterly | $0.01 |
| `get_xbrl_concept` | Full time series of any XBRL line item (for example `InventoryNet` or `NumberOfEmployees`). Leave out `concept` to discover which concepts the company reports | $0.01 |
| `compare_companies_metric` | Ranks all ~6,000 reporting companies, or your own peer list, on one metric for a period. Aliases such as `revenue` or `net_income` merge the different XBRL tags that companies use | $0.01 |
| `read_filing` | Reads any filing as clean text, either whole or one section: `business`, `risk_factors`, `mdna`, `financial_statements`, `legal_proceedings`, `cybersecurity`, `market_risk`, `controls`, `properties`, `executive_compensation`. Long documents are paged | $0.02 |
| `get_insider_transactions` | Parses recent Form 4 filings: insider name and role, buy or sell, shares, price, value, holdings after the trade and the 10b5-1 flag, plus a buy/sell summary | $0.02 |

Every tool accepts a **ticker** (`AAPL`), a **CIK** (`320193`) or a **company name** (`Apple`).

### How to connect (MCP)

The server uses the MCP **Streamable HTTP** transport at:

```
https://gazidev--sec-edgar-mcp.apify.actor/mcp
```

Authenticate with your Apify API token, which you can find under [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations):

```
Authorization: Bearer YOUR_APIFY_TOKEN
```

#### Claude Code

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

#### Claude Desktop

Edit `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "sec-edgar": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://gazidev--sec-edgar-mcp.apify.actor/mcp",
        "--header", "Authorization: Bearer YOUR_APIFY_TOKEN"
      ]
    }
  }
}
```

#### Cursor

Edit `~/.cursor/mcp.json`, or `.cursor/mcp.json` in your project:

```json
{
  "mcpServers": {
    "sec-edgar": {
      "url": "https://gazidev--sec-edgar-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

#### VS Code (GitHub Copilot agent mode)

Edit `.vscode/mcp.json`:

```json
{
  "servers": {
    "sec-edgar": {
      "type": "http",
      "url": "https://gazidev--sec-edgar-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

#### Windsurf, Cline, Zed and other MCP clients

Add a remote or HTTP MCP server with the URL above and the `Authorization` header. For clients that only support stdio, wrap the server with `npx mcp-remote <url> --header "Authorization: Bearer <token>"`.

#### Python (FastMCP client)

```python
import asyncio
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

transport = StreamableHttpTransport(
    "https://gazidev--sec-edgar-mcp.apify.actor/mcp",
    headers={"Authorization": "Bearer YOUR_APIFY_TOKEN"},
)

async def main():
    async with Client(transport) as client:
        result = await client.call_tool("get_financial_statements", {"company": "NVDA", "period": "quarterly"})
        print(result.data)

asyncio.run(main())
```

### Batch mode (no MCP client needed)

You can also start the Actor as a normal run from the Apify Console, the API, a schedule or an integration such as Make, Zapier or n8n. Pick a tool, give its arguments as JSON, and the results go to the dataset:

```json
{
  "tool": "get_financial_statements",
  "arguments": { "company": "MSFT", "period": "annual", "limit": 5 }
}
```

To run several calls at once, use `calls`:

```json
{
  "calls": [
    { "tool": "get_insider_transactions", "arguments": { "company": "AAPL", "open_market_only": true } },
    { "tool": "search_filings_full_text", "arguments": { "query": "\"material weakness\"", "form_types": ["10-K"], "date_from": "2026-01-01" } }
  ]
}
```

Batch runs cost the same per tool call as MCP calls.

### Example output (`get_financial_statements`, trimmed)

```json
{
  "company": { "cik": 320193, "name": "Apple Inc.", "ticker": "AAPL" },
  "period": "annual",
  "periods": [
    {
      "period_end": "2025-09-27",
      "revenue": 416161000000,
      "gross_profit": 195201000000,
      "operating_income": 133050000000,
      "net_income": 112010000000,
      "eps_diluted": 7.46,
      "operating_cash_flow": 111482000000,
      "capital_expenditures": 12715000000,
      "free_cash_flow": 98767000000,
      "total_assets": 359241000000,
      "stockholders_equity": 73733000000,
      "gross_margin_pct": 46.91,
      "net_margin_pct": 26.92,
      "source_form": "10-K",
      "source_accession": "0000320193-25-000079"
    }
  ]
}
```

### Pricing

This Actor uses **pay-per-event** pricing. You pay only for tool calls that succeed:

| Event | Price |
|---|---|
| Data tool call (search, filings, full-text search, financials, XBRL concept, compare) | **$0.01** |
| Document tool call (`read_filing`, `get_insider_transactions`) | **$0.02** |
| Actor start (once per Standby session) | $0.005 |

- **Failed calls are free.** A call that errors (for example, an unknown ticker) is not charged.
- A typical research session of 10 tool calls costs about **$0.10 to $0.15**.
- Apify's free plan includes monthly credits, so you can try the server at no cost.
- You can set a maximum charge per run in Apify. When the limit is reached, the tools return a clear message instead of charging more.

### FAQ

**Is this the official SEC API?**
The data comes from the SEC's official public EDGAR APIs. This Actor is an independent project and is not affiliated with or endorsed by the U.S. Securities and Exchange Commission.

**Do I need an SEC API key?**
No. EDGAR does not require keys. The server handles the SEC's User-Agent and rate-limit requirements (10 requests/second) for you.

**How fresh is the data?**
The data is live. New filings appear in EDGAR within minutes of acceptance. The server caches responses briefly: 10 minutes for filing lists, 1 hour for XBRL facts and 15 minutes for full-text search.

**Which companies are covered?**
All SEC filers. Name and ticker search covers the roughly 10,000 companies with an exchange ticker. For any other filer, including private companies that file Form D, use the CIK. XBRL financials cover filings since about 2009. Full-text search covers filings since 2001.

**Can it handle foreign companies (20-F filers)?**
Yes. `get_company_filings`, `read_filing` and full-text search work for all filers. Companies that report under IFRS, such as TSMC, have no US-GAAP statements, so use `get_xbrl_concept` with `taxonomy: "ifrs-full"`. The tool tells you when this applies.

**Why is a metric missing for a company?**
Companies choose which XBRL elements to tag. `get_financial_statements` already falls back through common alternatives, for example `Revenues`, then `RevenueFromContractWithCustomerExcludingAssessedTax`, then `SalesRevenueNet`. For anything else, call `get_xbrl_concept` without a concept to list what the company reports.

**Are quarterly numbers accurate for Q4 and cash flow?**
10-Qs report cash flow year-to-date, and most companies never tag Q4 on its own. The server derives these quarters from year-to-date differences, for example FY minus 9 months, and lists them in `derived_fields`. Derived EPS is approximate.

**Can I use the data commercially?**
Yes. SEC EDGAR content is US government work and is not subject to copyright. Filings may contain third-party material, such as exhibits, so check with your own counsel for edge cases.

**Is this investment advice?**
No. The server provides raw regulatory data. Always verify important figures against the original filing; every result includes source URLs or accession numbers.

**Something is broken or missing?**
Open an issue on the Actor's Issues tab. Feature requests are welcome, for example 13F holdings or XBRL segment data.

### Keywords

SEC EDGAR API, SEC filings MCP, 10-K API, 10-Q, 8-K, XBRL financial statements API, company fundamentals API, EDGAR full-text search, insider trading Form 4 API, risk factors extraction, MD\&A, financial data for LLMs, MCP server for finance, Claude MCP finance, Cursor MCP, AI agent stock research.

# Actor input Schema

## `tool` (type: `string`):

Which tool to run in batch mode.

## `arguments` (type: `object`):

Arguments for the tool, e.g. {"company": "AAPL", "period": "annual", "limit": 5}. See the README for each tool's arguments.

## `calls` (type: `array`):

Run several tool calls in one run: \[{"tool": "get\_financial\_statements", "arguments": {"company": "MSFT"}}, ...]

## Actor input object example

```json
{
  "tool": "get_financial_statements",
  "arguments": {
    "company": "AAPL",
    "period": "annual",
    "limit": 5
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "arguments": {
        "company": "AAPL",
        "period": "annual",
        "limit": 5
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("gazidev/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 = { "arguments": {
        "company": "AAPL",
        "period": "annual",
        "limit": 5,
    } }

# Run the Actor and wait for it to finish
run = client.actor("gazidev/sec-edgar-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "arguments": {
    "company": "AAPL",
    "period": "annual",
    "limit": 5
  }
}' |
apify call gazidev/sec-edgar-mcp --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GJiiWJLNybR09gLfF/builds/lQARyDEgEcGX3NwQT/openapi.json