# US Company Filings & Financials MCP Server (`mrbridge/us-company-filings-mcp`) Actor

MCP server for US company filings and financials in Claude, ChatGPT, Cursor and VS Code. 11 read-only tools read SEC EDGAR data: find a company by ticker or CIK, list its 10-K, 10-Q and 8-K filings, track reported figures over time, rank companies and search filing text since 2001.

- **URL**: https://apify.com/mrbridge/us-company-filings-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Developer tools
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 📑 US Company Filings & Financials MCP Server

US Company Filings & Financials MCP Server is an MCP server that gives Claude, ChatGPT, Cursor, VS Code and other MCP clients the public filings of US-listed companies. Its 11 read-only tools look up a company by name, ticker or CIK, list its filings with a link to every document, return reported financial figures over time, rank all reporting companies on one figure and search the text of filings back to 2001. The data comes from SEC EDGAR, and this server is independent from the SEC.

Ask Claude "How did Apple's net income change over the last five fiscal years, and which 10-K reported each figure?" It calls `filings_get_concept` with the `NetIncomeLoss` tag and answers with one value per year, the form and filing date behind each value, and the link to check it. No ticker-to-CIK lookup, no JSON parsing, no digging through a filing index by hand.

### What this server exposes

This server gives an AI client 11 read-only tools over the public EDGAR data of the U.S. Securities and Exchange Commission. You can look up a company by name, ticker or CIK, read its registrant profile, list its filings with links to the documents, and open the exhibits of one filing. The XBRL tools return what a company reports (revenue, net income, assets, EPS and hundreds of other concepts), as a snapshot from the latest annual report or as a series over time, and rank every reporting company on one figure for a calendar period. Full-text search covers filings since 2001. A `search` and `fetch` pair makes the server usable from ChatGPT deep research. No SEC account or API key is needed. The SEC is cited as the source in every answer, and this server is not affiliated with it.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `filings_find_company` | Find a company and its CIK | `tool-read` |
| `filings_get_company` | Get a company profile | `tool-read` |
| `filings_list_filings` | List a company's filings | `tool-read` |
| `filings_get_filing_documents` | List the documents of a filing | `tool-read` |
| `filings_get_key_financials` | Get key financials from the latest annual report | `tool-action` |
| `filings_list_concepts` | List the financial concepts a company reports | `tool-read` |
| `filings_get_concept` | Get a financial concept over time | `tool-read` |
| `filings_compare_companies` | Rank companies on one financial concept | `tool-action` |
| `filings_search_full_text` | Search the text of filings | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-action` |

#### `filings_find_company`: Find a company and its CIK

Use this when you need the SEC CIK number, tickers or exchanges of a US-listed company from its name, ticker or CIK. Do not use for company details or filings, use filings_get_company or filings_list_filings with the CIK it returns. Parameters: `query` (company name, ticker or CIK, e.g. "Berkshire"), `limit` (1-100, default 20), `offset` (default 0), `response_format` ("concise" or "detailed"). Covers companies with a listed ticker in the SEC ticker file.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"Berkshire"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, matches[], pagination, source }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `filings_get_company`: Get a company profile

Use this when you need the SEC registrant profile of a company: name, tickers, exchanges, industry (SIC), fiscal year end, state of incorporation, filer category and latest filing. Do not use for the list of filings (filings_list_filings) or financial figures (filings_get_key_financials). Parameters: `company` (ticker or CIK, e.g. "AAPL"), `response_format` ("concise" default, or "detailed" to add former names and cache information). Addresses and phone numbers are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ cik, name, tickers[], exchanges[], entity_type, sic, sic_description, fiscal_year_end, state_of_incorporation, category, recent_filings_count, latest_filing, former_names[], url, source }`. Upstream: SEC EDGAR. Cache: intraday (5 minutes). Read-only.

#### `filings_list_filings`: List a company's filings

Use this when you need a company's recent SEC filings (10-K, 10-Q, 8-K, proxy, Form 4 and others) with dates and links to the documents. Do not use for the documents inside one filing (filings_get_filing_documents) or for searching filing text (filings_search_full_text). Parameters: `company` (ticker or CIK, e.g. "MSFT"), `forms` (optional list, e.g. \["10-K","10-Q"]), `since` and `until` (optional YYYY-MM-DD filing dates), `limit` (1-100, default 20), `offset` (default 0), `response_format` ("concise" default, or "detailed" to add description, act, file number, size and XBRL flag). Covers the recent window the SEC publishes (at least one year or 1,000 filings), and says when older filings exist.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `forms` | array of string | no | `["10-K","10-Q"]` |
| `since` | string | no | `"2024-01-01"` |
| `until` | string | no | `"2024-12-31"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ company, filings[], older_filings_not_listed, pagination, source }`. Upstream: SEC EDGAR. Cache: intraday (5 minutes). Read-only.

#### `filings_get_filing_documents`: List the documents of a filing

Use this when you need the documents and exhibits inside one SEC filing, with their sizes and links. Do not use for finding filings, use filings_list_filings to get the accession number first. Parameters: `company` (ticker or CIK, e.g. "AAPL"), `accession_number` (format 0000320193-24-000123), `limit` (1-100, default 50), `offset` (default 0), `response_format` ("concise" or "detailed" to add cache information).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `accession_number` | string | yes | `"0000320193-24-000123"` |
| `limit` | integer | no | `50` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ accession_number, index_url, documents[], pagination, source }`. Upstream: SEC EDGAR. Cache: reference (30 days). Read-only.

#### `filings_get_key_financials`: Get key financials from the latest annual report

Use this when you need a quick financial snapshot of a company: revenue, net income, operating income, EPS, assets, liabilities, equity, cash, operating cash flow and shares outstanding from its latest annual report. Do not use for history over several years (filings_get_concept) or for comparing companies (filings_compare_companies). Parameters: `company` (ticker or CIK, e.g. "KO"), `response_format` ("concise" default, or "detailed" to add the XBRL tag, form, filing date and accession used). Reads US GAAP figures in USD. IFRS filers answer NOT_FOUND, use filings_list_concepts with taxonomy "ifrs-full" for them.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ company, metrics[], missing[], note, source }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `filings_list_concepts`: List the financial concepts a company reports

Use this when you need to know which XBRL financial concepts (tags) a company reports, to pick one for filings_get_concept. Do not use for the values themselves, use filings_get_concept or filings_get_key_financials. Parameters: `company` (ticker or CIK, e.g. "NVDA"), `taxonomy` (optional: "us-gaap", "ifrs-full", "dei" or "srt"), `search` (optional text matched in tag names and labels, e.g. "revenue"), `limit` (1-100, default 20), `offset` (default 0), `response_format` ("concise" default, or "detailed" to add descriptions).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `taxonomy` | "us-gaap" or "ifrs-full" or "dei" or "srt" | no | `"us-gaap"` |
| `search` | string | no | `"revenue"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ company, concepts[], pagination, source }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `filings_get_concept`: Get a financial concept over time

Use this when you need the history of one reported financial figure of a company, for example annual revenue or quarterly net income. Do not use for a one-shot summary of the main figures (filings_get_key_financials) or for comparing companies (filings_compare_companies). Parameters: `company` (ticker or CIK, e.g. "AMZN"), `tag` (XBRL concept, e.g. "Revenues"), `taxonomy` ("us-gaap" default, "ifrs-full", "dei", "srt"), `unit` (optional, e.g. "USD" or "USD/shares", default USD when present), `period` ("annual" default, "quarterly" or "all"), `limit` (1-100, default 20), `offset` (default 0), `response_format` ("concise" default, or "detailed" to add start date, form, filing date and accession). Values are as filed, one per calendar period as aligned by the SEC (frame), from the latest filing that reports the period, newest first.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `company` | string | yes | `"AAPL"` |
| `tag` | string | yes | `"NetIncomeLoss"` |
| `taxonomy` | "us-gaap" or "ifrs-full" or "dei" or "srt" | no | `"us-gaap"` |
| `unit` | string | no | `"USD"` |
| `period` | "annual" or "quarterly" or "all" | no | `"annual"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ company, taxonomy, tag, label, unit, available_units[], series[], pagination, note, source }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `filings_compare_companies`: Rank companies on one financial concept

Use this when you need to compare or rank all reporting companies on one financial figure for a calendar period, for example the highest revenue in 2024. Do not use for one company's history (filings_get_concept). Parameters: `tag` (XBRL concept, e.g. "Revenues"), `taxonomy` ("us-gaap" default, "ifrs-full", "dei", "srt"), `unit` ("USD" default, or e.g. "USD/shares", "shares"), `period` (calendar period: "CY2024" for a year, "CY2024Q4" for a quarter, "CY2024Q4I" for a point in time such as a balance sheet date), `order` ("desc" default or "asc"), `limit` (1-100, default 20), `offset` (default 0), `response_format` ("concise" default, or "detailed" to add period end, location and accession).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `tag` | string | yes | `"NetIncomeLoss"` |
| `taxonomy` | "us-gaap" or "ifrs-full" or "dei" or "srt" | no | `"us-gaap"` |
| `unit` | string | no | `"USD"` |
| `period` | string | yes | `"CY2024"` |
| `order` | "desc" or "asc" | no | `"desc"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ taxonomy, tag, label, unit, period, total_companies, companies[], pagination, source }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `filings_search_full_text`: Search the text of filings

Use this when you need filings that mention words or phrases, for example 10-Ks mentioning "tariff" this year. Covers filings and exhibits since 2001. Do not use for one company's filing list (filings_list_filings). Parameters: `query` (words, "exact phrase" in quotes, OR, -exclusion), `forms` (optional list, e.g. \["10-K"]), `start_date` and `end_date` (optional YYYY-MM-DD), `limit` (1-100, default 20), `offset` (0-9999, default 0), `response_format` ("concise" default, or "detailed" to add CIKs, period ending and file numbers). Hits can name individuals (insiders filing Forms 3, 4 and 5).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"\"supply chain\" tariff"` |
| `forms` | array of string | no | `["10-K","10-Q"]` |
| `start_date` | string | no | `"2024-01-01"` |
| `end_date` | string | no | `"2024-12-31"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, total, hits[], pagination, note, source }`. Upstream: SEC EDGAR. Cache: intraday (5 minutes). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find a US-listed company in SEC EDGAR data by name, ticker or CIK. Do not use for filing text search, use filings_search_full_text. Parameter `query` (string), e.g. "Apple".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"example query"` |

Returns `{ results[], notices[] }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs the full summary of one company returned by search: profile, key financials from the latest annual report and latest filings with links. Do not use for ids that did not come from search. Parameter `id` (CIK from search), e.g. "0000320193".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"example-id"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: SEC EDGAR. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--us-company-filings-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Contact e-mail for SEC EDGAR

SEC EDGAR asks every caller for a contact e-mail. The tools that call it need yours, and answer `INVALID_INPUT` without a charge until you add it to the connection:

- Claude Code: add `--header "X-Contact-Email: you@example.com"` to the `claude mcp add` command.
- Cursor, VS Code, other JSON configurations and the OpenAI Responses API: add `"X-Contact-Email": "you@example.com"` to `headers`.
- claude.ai, Claude Desktop and ChatGPT: add `&contact_email=you@example.com` at the end of the URL, after the token.
- Anthropic Messages API: add `?contact_email=you@example.com` to the server `url`.

The address is sent only to SEC EDGAR, in the User-Agent of its requests, and is never stored or logged. Every other source gets the application URL only.

#### Claude Code

```bash
claude mcp add --transport http us-company-filings "https://mrbridge--us-company-filings-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "us-company-filings": {
      "type": "http",
      "url": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--us-company-filings-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add US Company Filings & Financials MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=US%20Company%20Filings%20%26%20Financials%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--us-company-filings-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--us-company-filings-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "us_company_filings",
  "server_url": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp",
      "name": "us-company-filings",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "us-company-filings"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/us-company-filings-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use US Company Filings & Financials MCP Server?

The SEC publishes company data through several JSON APIs, an archive index and a full-text search page with no documented API. This server wraps the useful parts in tools that an assistant can call from a plain question.

- **Tickers work everywhere.** Pass `AAPL` or a CIK to any company tool. When you only have a name, `filings_find_company` resolves it.
- **Filings and financials side by side.** A snapshot from the latest annual report, the history of any reported concept and a ranking of every reporting company on one figure, next to the filing list and the documents of each filing.
- **Answers you can check.** Filings and documents come back with their sec.gov links, and every answer names the SEC as its source.
- **ChatGPT deep research ready.** The `search` and `fetch` pair returns a company summary with profile, key financials and latest filings.
- 🔌 **Model Context Protocol over Streamable HTTP** at a single endpoint, `https://mrbridge--us-company-filings-mcp.apify.actor/mcp`, for Claude, ChatGPT, Cursor, VS Code and the OpenAI and Anthropic APIs.
- ⚡ **Apify Standby mode.** The first call after a quiet spell starts the server in about 4 seconds (measured on the platform on 2026-10-05). Later calls skip that wait until the server has been idle for 5 minutes.
- **Your e-mail is not kept.** The contact address the SEC asks automated tools to declare travels to the SEC only, inside the User-Agent, and is never logged, cached or returned.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Source and attribution.** Data comes from SEC EDGAR, the public filing system of the U.S. Securities and Exchange Commission. The SEC treats it as public information and asks users to cite it, so every answer carries `source: "U.S. Securities and Exchange Commission, EDGAR"`. This server is independent and not endorsed by the SEC.
- **Rate limit.** The SEC allows 10 requests per second in total per user, whatever the number of machines. Each instance of this server keeps to 5. Past that, calls answer `UPSTREAM_RATE_LIMITED` with a retry delay.
- **Filing window.** `filings_list_filings` covers the recent filings the SEC publishes per company: at least one year, or the last 1,000 filings. The answer says when older filings exist.
- **Full-text search.** The endpoint behind the SEC's own search page is not documented and can change without notice. It covers filings since 2001, returns at most 10,000 hits per query, and hits on Forms 3, 4 and 5 can name individual insiders.
- **Financial figures.** Values are as filed in XBRL. A series shows one value per calendar period, taken from the latest filing that reports it, so a restated figure replaces the original. `filings_get_key_financials` picks the latest annual-report value of each metric in US GAAP and USD, a selection made by this server rather than an official SEC figure. Companies that file no XBRL data (many funds, individuals, older filers) answer `NOT_FOUND` on the financial tools, and so do IFRS filers on `filings_get_key_financials`: their figures are reachable through `filings_list_concepts` with the `ifrs-full` taxonomy.
- **Personal data.** Insiders have their own CIK, so a person's name and filings list can come back exactly as EDGAR publishes them. No address or phone number is ever returned.
- **Freshness.** Company profiles, filing lists and full-text results are cached for 5 minutes, financial data and the ticker list for one day, and the document list of a filing for 30 days.

### Use cases

**Earnings notes.** "Give me Microsoft's revenue, net income and operating cash flow from its latest annual report, then the five-year net income trend." The assistant combines `filings_get_key_financials` and `filings_get_concept`, and cites the filing behind each number.

**Filing watch.** "List Tesla's 8-K filings since July and open the exhibits of the latest one." `filings_list_filings` filters by form and date, then `filings_get_filing_documents` lists the exhibits with their links.

**Peer screens.** "Which companies reported the highest net income for calendar year 2024?" `filings_compare_companies` ranks every reporting company on `NetIncomeLoss` for `CY2024`, 20 at a time.

**Topic research across filings.** "Find this year's 10-K filings that mention tariffs and the supply chain." `filings_search_full_text` searches filings and exhibits since 2001, up to 10,000 hits per query.

**Counterparty checks.** Before a contract, ask for the state of incorporation, industry code, fiscal year end and latest filing of a listed company. `filings_get_company` answers from the registrant profile, without addresses or phone numbers.

### More company and economic data tools

- [LEI search MCP server](https://apify.com/mrbridge/business-identity-mcp): legal entity identifiers by name or register number, parents and subsidiaries, ISIN and BIC lookups.
- [exchange rates and inflation data for AI](https://apify.com/mrbridge/global-economy-mcp): GDP, inflation and debt for about 200 countries, Eurostat statistics and ECB exchange rates.
- [national debt and federal register data](https://apify.com/mrbridge/us-gov-data-mcp): the US national debt since 1790, federal spending by agency or recipient and Federal Register rules.
- [UK public data for AI](https://apify.com/mrbridge/uk-open-data-mcp): police-recorded crime near a point, MPs, bills and Commons votes from UK open data.
- [investment memo in minutes](https://apify.com/mrbridge/ai-dealflow-analysis): a full investment memo from a pitch deck: unit economics, valuation, market sizing and red flags.

### Frequently asked questions

#### Do I need an SEC account or API key?

No. The data is public and needs no key. You need an Apify account with an API token, plus a contact e-mail added to the connection, as explained below.

#### Why does the server ask for my e-mail?

The SEC's fair-access policy asks automated tools to declare a contact in their User-Agent. Add your address once to the connection: an `X-Contact-Email` header in Claude Code, Cursor, VS Code and the APIs, or `&contact_email=you@example.com` at the end of the URL in claude.ai, Claude Desktop and ChatGPT. A call without it answers `INVALID_INPUT` and costs nothing. The address goes to the SEC only and is never stored.

#### How much does it cost to research company filings?

Two things are billed to your Apify account. First, the tool calls: $0.01 per successful call to `filings_get_key_financials`, `filings_compare_companies` or `fetch` (actions) and $0.005 per successful call to any other tool (reads). These are the prices on the Apify Free plan, and the discounts of paid plans lower them. Errors, invalid input, the spending-limit refusal and protocol traffic (initialize, tool lists, pings) are never charged. Second, the platform usage of your own Standby run, on top of the events: the memory set for the run (256 MB) for as long as the server is up, idle time included, until it stops 5 minutes after your last call, plus a small start event per new run. A 10-minute session of 30 calls, 6 of them actions, comes to $0.18 in tool calls on the Free plan plus 1 to 2 cents of platform usage. Live prices for your Apify plan are on the [Pricing tab](https://apify.com/mrbridge/us-company-filings-mcp/pricing), and `maxTotalChargeUsd` caps the event charges of one run.

#### Which companies and filings are covered?

Name lookups cover companies with a listed ticker. Filing lists hold the recent window the SEC publishes per company, at least one year or the last 1,000 filings, and say when older ones exist. Full-text search goes back to 2001. The financial tools need structured financial data, so many funds and older filers answer `NOT_FOUND`, and companies reporting under IFRS are reached through `filings_list_concepts` with the `ifrs-full` taxonomy.

#### How fresh is the data?

Profiles, filing lists and full-text results are cached for 5 minutes. Financial data and the ticker list are cached for a day, and the document list of a filing for 30 days.

#### Are the figures exactly what companies filed?

Yes, as the SEC publishes them. A series keeps one value per calendar period from the latest filing that reports it, so a restatement replaces the original figure. The key-financials snapshot is a selection made by this server. Check the linked filing before you rely on a number, and treat nothing here as investment advice.

#### Why is my first call slow?

Cold start. After 5 idle minutes the server stops, and the next call waits about 4 seconds while Apify starts a new run.

#### Is this server affiliated with the SEC?

No. It is an independent server that reads the SEC's public data and cites the SEC in every answer. "SEC" and "EDGAR" are trademarks of the U.S. Securities and Exchange Commission.

#### Your feedback

Found a wrong figure or a broken tool? Open an issue on the [Issues tab](https://apify.com/mrbridge/us-company-filings-mcp/issues/open) and it will be looked at. More MCP servers, scrapers and data studies from the same team are on [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.2: pricing events tool-read and tool-action. `filings_get_key_financials`, `filings_compare_companies` and `fetch` bill one `tool-action` event, every other tool one `tool-read` event
- 0.1.1: server name aligned with the Store title
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/us-company-filings-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 = { "mcpEndpoint": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/us-company-filings-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 '{
  "mcpEndpoint": "https://mrbridge--us-company-filings-mcp.apify.actor/mcp"
}' |
apify call mrbridge/us-company-filings-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/us-company-filings-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/yycXZH4CkeKtmTD9W/builds/wA74Y5gj73gaxLak2/openapi.json
