# Query SEC filings from inside Claude Desktop — Filingrail is now MCP-enabled

> Source: <https://dev.to/hudsonenterprises/query-sec-filings-from-inside-claude-desktop-filingrail-is-now-mcp-enabled-1dnk>
> Published: 2026-07-09 12:34:20+00:00

Filingrail now ships a first-party MCP server on PyPI: `pip install filingrail-mcp`

. One install, one config block, and Claude Desktop — or Cursor, or Continue, or any MCP-compatible client — can query SEC filings as tools. No glue code.

That's worth naming directly. Most SEC-data APIs ship a REST endpoint and stop. You write the agent integration yourself: parse the response, wire up the tool schema, handle auth headers. Filingrail ships the integration as a maintained package with the same update cadence as the underlying REST API.

This post covers the setup, what you can ask once it's wired in, and the honest limits. I built both the API and the MCP server — I'll be upfront about that throughout.

This post covers a data API that returns SEC-registered financial information. Nothing here is investment advice.

**Option 1 — pip install filingrail-mcp (recommended)**

Install the package, add one block to your Claude Desktop config, restart. Filingrail's endpoints appear as tools. No separate service to run, no background daemon.

**Option 2 — RapidAPI MCP Playground tab (no local install)**

The [Filingrail listing on RapidAPI](https://rapidapi.com/hudson-enterprises-llc-hudson-enterprises-llc-default/api/filingrail) has an MCP tab that generates a ready-to-paste config block. Same endpoints, same auth, zero install step.

Either path gives Claude the same tools. Pick the one that fits your setup.

`pip install`

path
You'll need Python 3.10+ and a RapidAPI key.

**1. Subscribe to Filingrail**

Go to the [Filingrail RapidAPI listing](https://rapidapi.com/hudson-enterprises-llc-hudson-enterprises-llc-default/api/filingrail) and subscribe. Free tier is 50 calls/day, no credit card. Copy your `X-RapidAPI-Key`

from the RapidAPI dashboard.

**2. Install the server**

```
pip install filingrail-mcp
```

**3. Add Filingrail to your Claude Desktop config**

On macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`

On Windows: `%APPDATA%\Claude\claude_desktop_config.json`

```
{
  "mcpServers": {
    "filingrail": {
      "command": "filingrail-mcp",
      "env": {
        "RAPIDAPI_KEY": "your_rapidapi_key_here"
      }
    }
  }
}
```

**4. Restart Claude Desktop**

Filingrail's endpoints appear as available tools. Your key lives in the `env`

block — you don't pass it per-call; the server handles the `X-RapidAPI-Key`

and `X-RapidAPI-Host`

headers for you.

The same config pattern works in Cursor and Continue — point their MCP config at `filingrail-mcp`

the same way.

All seven v1.0 endpoints are available as tools. Here's what that looks like in practice:

**Company search**

"Find the CIK for Berkshire Hathaway"

Claude calls `/v1/search/companies`

. Over 8,200 SEC-registered issuers are indexed by ticker, CIK, or name fragment.

**Financials**

"What was Apple's operating margin for the most recent quarter? Show me the source filing."

Claude calls `/v1/companies/AAPL/financials`

, pulls the normalized income statement from the most recent 10-Q or 10-K, and surfaces the `meta.source_filing_url`

— a direct `sec.gov`

link to the filing the numbers came from. Every response carries it.

The difference between "Claude says revenue was $X" and "Apple's 10-Q filed 2025-10-31 says revenue was $X — here's the filing" is meaningful if you need the primary source, not the model's recall.

**Financial history**

"Pull Amazon's quarterly revenue for the last 3 years and show me the trend"

Claude calls `/v1/companies/AMZN/financials/history`

with `period=Q&limit=12`

. Multiple periods per call, spanning the XBRL history available for each company.

**Filings stream**

"List the most recent 10-K filings for Microsoft"

Claude calls `/v1/filings/recent`

. Filterable by CIK, form type, and date range. Each record includes the accession number and a `filing_url`

pointing to the document on `sec.gov`

.

**Insider trades**

"What Form 4 transactions has Nvidia's CEO filed in the last 6 months?"

Claude calls `/v1/companies/NVDA/insider-trades`

. Continuously refreshed from SEC EDGAR.

**8-K material events**

"Show me every 8-K with item code 5.02 — executive changes — that Tesla has filed"

Claude calls `/v1/companies/TSLA/8k-events`

. Item codes are preserved as structured fields (1.01 for material agreements, 2.01 for acquisitions, 5.02 for director/officer changes, etc.), so Claude can filter and reason over them in the same conversation.

**13F institutional holdings**

"What are Berkshire Hathaway's top 10 equity positions by dollar value?"

Claude calls `/v1/institutions/{cik}/13f-holdings`

. Returns positions in whole-dollar USD. Continuously updated from EDGAR filings.

`meta.source_filing_url`

field
Every endpoint — financials, insider trades, 8-K events, 13F holdings — returns a `meta.source_filing_url`

. It's the direct `sec.gov`

URL for the filing that produced the data in that response.

In an MCP context this matters: when Claude answers a financial question, it can attach the source filing as a citation in the same response. Research workflows that need the answer *and* the primary source get both without a second lookup.

**You still need a RapidAPI key.** `filingrail-mcp`

is the integration layer, not a separate data source. It calls the same RapidAPI-hosted endpoints. Subscribe, pass your `X-RapidAPI-Key`

via the `env`

block, done.

**Rate limits apply to every tool call Claude makes.** Free tier is 50 calls/day. A long research session with many back-and-forth questions can burn through that. Budget accordingly or upgrade to Pro ($9/mo for 5,000 calls/month).

**Not real-time.** Data is refreshed daily from EDGAR. New filings appear within approximately 6–24 hours of EDGAR acceptance. Yesterday's 8-K disclosures, not this morning's.

**EDGAR only.** US SEC filings. Non-US issuers (SEDAR, FCA, etc.) are out of scope for v1.

Most financial data APIs were designed for servers calling servers. The MCP layer shifts how you interact: instead of writing code to call an endpoint and parse the response, you describe what you want and the model routes the tool call, parses the JSON, and reasons over the result in the same context window.

That works for research-style questions — the ones that aren't really REST queries but aren't pure reasoning either. "What did Berkshire buy or sell in their most recent 13F compared to Q4?" is awkward to write as two sequential API calls stitched together; it's a natural question when Claude has both tools available.

The citation layer — `meta.source_filing_url`

on every response — keeps that convenience from floating free of primary sources.

`filingrail-mcp`

tracks the REST API. As new endpoints ship (expanded ratio coverage, screening endpoints, broader company coverage), the MCP tools surface them too. Updates arrive through `pip install --upgrade filingrail-mcp`

.

If you'd rather call the API directly from Python, there's also a typed SDK: `pip install filingrail`

— sync and async clients, typed dataclasses, all seven endpoints. The MCP server is built on the same client.

| Tier | Price | Calls/month |
|---|---|---|
| Free | $0 | 1,500 (50/day) |
| Pro | $9/mo | 5,000 |
| Ultra | $49/mo | 50,000 |
| Mega | $199/mo | 500,000 |

Subscribe on the [Filingrail RapidAPI listing](https://rapidapi.com/hudson-enterprises-llc-hudson-enterprises-llc-default/api/filingrail).

Questions: `support@hudsonenterprisesllc.com`

*Built by Hudson Enterprises LLC, an Indiana software studio.*