Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@filingrail-mcp What was Apple's revenue last quarter?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Give your AI agent live SEC EDGAR data: company financials, insider trades, 8-K events, 13F holdings, and the raw filings stream — all normalized to clean JSON, every number traceable back to its sec.gov source filing.
One pip install, one API key, and your agent can answer "What was Apple's cash position last quarter?" or "List Berkshire Hathaway's top 10 holdings as of 2026-Q1" — against real filings, not its training data.
pip install filingrail-mcpLive on PyPI: pypi.org/project/filingrail-mcp · MIT licensed · Python 3.10+
Every number a public company reports to the SEC is free and open on EDGAR. The bottleneck isn't access — it's the XBRL parser, the tag-drift normalizer, the rate-limit governor, and the dedup layer you'd have to write before you get the one figure you actually wanted. filingrail-mcp hands your agent the finished JSON instead.
Source-traceable. Every financial response carries the originating source_filing_url. Click it, see the exact 10-K / 10-Q on sec.gov. No "trust us."
Normalized. revenue is revenue, whether the filer tagged it us-gaap:Revenues, SalesRevenueNet, or RevenueFromContractWithCustomerExcludingAssessedTax. 1.8M+ XBRL rows back to 2006.
Zero plumbing. No EDGAR User-Agent config, no local parser, no rate-limit governor. The API handles all of it.
Related MCP server: Aegis Gov SEC Filings MCP
Filingrail is a REST API on RapidAPI. The free tier is 50 calls/day, no credit card:
→ Subscribe to Filingrail on RapidAPI and copy your X-RapidAPI-Key.
The end user brings their own key — set it as RAPIDAPI_KEY in your MCP client config (below).
Edit %APPDATA%/Claude/claude_desktop_config.json (Windows) or ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"filingrail": {
"command": "filingrail-mcp",
"env": { "RAPIDAPI_KEY": "your-rapidapi-key-here" }
}
}
}Restart Claude Desktop. The Filingrail tools (search_companies, get_financials, get_insider_trades, …) appear in the tool list. Then just ask a question in plain English.
Point the client at filingrail-mcp as the stdio command and pass RAPIDAPI_KEY as an environment variable. Same shape as above.
If your client only accepts a raw command, use:
{ "command": "filingrail-mcp", "env": { "RAPIDAPI_KEY": "your-rapidapi-key-here" } }Tool | What it does |
| Resolve ticker / CIK / name fragment to a company (8,000+ SEC issuers, fuzzy match) |
| Recent filings firehose — filter by form ( |
| Latest 10-K / 10-Q normalized line items + |
| Historical quarterly or annual series |
| Form 4 transactions — who bought/sold, when, how much |
| 8-K material events with SEC item codes (5.02, 2.01, …) |
| Institutional holdings (e.g. Berkshire = CIK 1067983) |
| API liveness check |
After installing and configuring, ask your agent:
"What was Apple's revenue and operating income last quarter, and link me the filing."
"Show me insider sells at NVIDIA in the last 30 days."
"What 8-K events did Tesla file this month?"
"List Berkshire Hathaway's 10 largest 13F positions for 2026-Q1."
Honest caveats:
Not real-time. New filings appear within ~24h of EDGAR acceptance (fair-access policy).
Not Bloomberg. No intraday prices, options chains, non-US issuers, or analyst estimates.
Structured SEC data, traced to source — that's the whole product.
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 |
Keys and billing are handled by RapidAPI. Get yours →
Python SDK (sync + async) — pip install filingrail
Questions / issues: support@hudsonenterprisesllc.com
MIT © Hudson Enterprises LLC
Get 13F-HR institutional holdings for an investment manager.
Args: institution_cik: institution's CIK (e.g. 1067983 for Berkshire Hathaway) quarter: YYYY-Qn format (e.g. "2026-Q1"), default latest limit: max holdings (1-5000, default 100)
Returns: list of holdings — issuer_name, CUSIP, value_usd, shares, plus filing_url: a direct link to the 13F-HR on sec.gov that the position came from, so each holding can be traced to the quarter's filing it was reported in.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| quarter | No | ||
| institution_cik | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it partially does so: it discloses the quarter default (latest), the 1-5000 limit range, and the provenance guarantee that each row links back to its source filing. It omits operational traits such as auth requirements, behavior when a quarter has no filing, and the ~45-day reporting lag that governs 13F data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well front-loaded: the one-line purpose precedes structured Args and Returns blocks, so scanning is easy. The Returns block is somewhat redundant given an output schema exists, and the filing_url explanation runs longer than needed, but nothing is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Parameters are fully covered and the return shape is spelled out, so the agent has enough to invoke correctly for a three-parameter retrieval tool. The remaining gap is guidance on edge cases (unknown CIK, quarters with no holdings, stale data) rather than anything about the call mechanics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does completely: institution_cik gets a concrete example (1067983, Berkshire Hathaway), quarter gets both a format and an example ("2026-Q1") plus the 'latest' default, and limit gets its range and default. Every parameter is documented with more detail than the schema offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: fetching 13F-HR institutional holdings for a named investment manager. The 13F-HR scope cleanly separates it from siblings like get_insider_trades (Form 4) and get_8k_events, so an agent can route without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use or when-not-to-use guidance is given. It never mentions alternatives such as get_recent_filings or get_insider_trades, nor a prerequisite such as knowing the institution's CIK. The agent must infer that this is for institutional long-position lookups.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get 8-K material events with SEC item codes for a company.
Args: ticker_or_cik: company ticker or CIK since: ISO date — only events on or after this date limit: max events (1-200, default 10)
Returns: list of events — event_date, item_codes (e.g. ["5.02", "9.01"]), descriptions, plus filing_url: a direct link to the 8-K on sec.gov that the event came from, so the event can be read in full rather than taken on trust.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| since | No | ||
| ticker_or_cik | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden; it implies a read operation ('Get') but never states auth or rate-limit behavior. It does add real value by disclosing that events include SEC item codes and a filing_url so results can be verified, which is provenance context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the purpose sentence and then lists args and returns compactly, with no filler. The Returns section partially re-states what the output schema already carries, but it is short and adds provenance framing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values needn't be explained, yet the description gives an accurate sketch plus the filing_url trust angle. For a 3-param read tool with no annotations, the only real gap is the absence of usage/routing guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description compensates by documenting all three params: ticker_or_cik meaning, ISO date format for since, and the 1-200 range plus default for limit. It stops short of saying what happens on invalid input or how ticker vs CIK resolution behaves.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get 8-K material events with SEC item codes for a company'), which is far more precise than a generic filings tool. It does not explicitly distinguish itself from the sibling get_recent_filings, which could plausibly also surface 8-Ks, so an agent must infer the boundary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use, when-not-to-use, or alternative-routing guidance is given. The date and limit notes describe parameter mechanics rather than selection criteria against siblings like get_recent_filings or get_financials.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get latest XBRL-normalized financial statements (balance sheet, income, cash flow).
Args: ticker_or_cik: company ticker (e.g. "AAPL") or CIK (e.g. "320193") limit: number of statements to return (1-50, default 4)
Returns: {statements: [{statement_type, period_end, line_items: {total_assets, revenue, ...}}], source_filing_url}
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| ticker_or_cik | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does disclose the response shape (statement_type, period_end, line_items, source_filing_url), which is genuinely useful since there is no output schema, but it says nothing about auth needs, rate limits, or how XBRL normalization affects missing/estimated line items.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the purpose, then Args and Returns sections. Every line carries information and nothing is redundant, though the returns block could be trimmed slightly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description adequately covers purpose, both parameters, and the return structure. It is nearly complete for an agent to invoke correctly; the missing pieces are error behavior and the sibling-routing rule.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does: it documents both parameters, gives concrete formats ('AAPL' / '320193'), and states the limit range (1-50) and default (4) beyond what the bare schema shows. Only minor gaps remain, such as what happens on an invalid or ambiguous ticker.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Get latest XBRL-normalized financial statements' with the covered statement types (balance sheet, income, cash flow). The word 'latest' implicitly separates it from the sibling get_financials_history, but it never names that sibling or draws the distinction explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied through 'latest', which suggests a current-snapshot tool. There is no explicit when-to-use guidance, no mention of the get_financials_history alternative, and no prerequisites for ticker vs CIK resolution.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get historical quarterly or annual financial-statement series.
Args: ticker_or_cik: company ticker or CIK period: "Q" (quarterly) or "A" (annual), default Q limit: max periods (1-100, default 12) statement_type: filter to one of "balance_sheet" / "income_statement" / "cash_flow" line_item: filter to a single line-item key (e.g. "revenue", "total_assets")
Returns: list of statements oldest-to-newest
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| period | No | Q | |
| line_item | No | ||
| ticker_or_cik | Yes | ||
| statement_type | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that results are ordered oldest-to-newest, but says nothing about read-only semantics, authentication, rate limits, data source, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The purpose is front-loaded in a single line, followed by a compact Args list and a Returns line. Every sentence earns its place, and the Args section is justified because the schema carries no field descriptions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a five-parameter financial-history tool the parameter documentation is thorough, and the return order is stated (the output schema covers the return shape itself). The remaining gap is the absence of guidance about when this tool should be chosen over get_financials and other siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate and it does: it documents all five parameters with meaning, allowed values ('Q'/'A'), defaults (limit 12, period Q), a range (1-100), enumerated statement types, and example line-item keys. This adds substantial meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening sentence states a specific verb and resource ('Get historical quarterly or annual financial-statement series'), which is clear enough to distinguish a time-series endpoint from a snapshot endpoint. However, it never names or contrasts with the sibling get_financials, leaving the boundary to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says what the tool returns but gives no when-to-use guidance or exclusions. With a sibling named get_financials, an agent must guess which one to call for a historical series versus a current snapshot.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get insider transactions (Form 4) for a company.
Args: ticker_or_cik: company ticker or CIK since: ISO date (YYYY-MM-DD) — only trades on or after this date limit: max trades (1-500, default 25)
Returns: list of trades — insider_name, transaction_date, code, shares, price, USD value, plus filing_url: a direct link to the Form 4 on sec.gov that the trade came from, so any figure can be verified against the original filing.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| since | No | ||
| ticker_or_cik | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return shape and a verifiability affordance (filing_url back to the Form 4), which is genuinely useful, but says nothing about sourcing/EDGAR freshness, rate limits, or whether derivative and non-open-market transactions are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded, followed by a clean Args/Returns structure with no wasted sentences. The Returns block is somewhat long relative to the existence of an output schema, though the filing_url rationale justifies its length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-param, single-required-param tool with no annotations, the description covers inputs thoroughly and flags the data source via Form 4. Gaps remain around data freshness, coverage of transaction types, and how this differs from the 13F sibling, but the core call contract is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates: ticker_or_cik is defined as ticker or CIK, since is given an explicit ISO YYYY-MM-DD format with inclusive "on or after" semantics, and limit is bounded (1-500) with its default (25). This is more than the schema alone conveys for all three parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Get insider transactions (Form 4) for a company"), which is immediately distinguishable from financials, 8-K events, and recent filings siblings. It does not, however, explicitly differentiate itself from get_13f_holdings, another ownership-data tool, leaving the agent to infer insiders vs. institutions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this tool versus alternatives, no prerequisites, and no exclusions. The Form 4 framing implies the use case but gives the agent nothing explicit to route on.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent SEC filings, optionally filtered by form type or CIK.
Args: form_type: filter by form (e.g. "10-K", "10-Q", "8-K", "4", "13F-HR") cik: filter by company CIK limit: max results (1-500, default 25)
Returns: list of filings, newest first
| Name | Required | Description | Default |
|---|---|---|---|
| cik | No | ||
| limit | No | ||
| form_type | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose some behavior: results are a list sorted 'newest first' and limit is bounded 1-500. It is silent on pagination/cursors for getting past the limit, authentication requirements, and rate limits — meaningful gaps for a data-retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded purpose sentence followed by a compact Args block and a one-line return note. Every line adds information and there is no redundant prose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Return values need not be explained since an output schema exists, yet the description still notes sort order, which helps. The main residual gap is the no-filter case (does it return filings across all companies?), which affects how an agent calls it with no args.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does: it gives concrete form_type examples ('10-K', '10-Q', '8-K', '4', '13F-HR'), defines cik as a company CIK filter, and states the limit range and default (1-500, default 25). Only cik's format (zero-padded vs integer) is left ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get recent SEC filings') plus the filtering dimensions, so the agent knows exactly what it retrieves. It does not, however, distinguish itself from siblings like get_8k_events, get_13f_holdings, or get_insider_trades, which are effectively pre-filtered subsets of the same filing data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'optionally filtered by form type or CIK' implies when the filters are useful, but there is no explicit when-to-use guidance or comparison to the sibling tools that cover specific form types (8-K, 13F, Form 4). An agent must infer whether this is a general fallback or the preferred entry point.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check Filingrail API health. Returns {status: 'ok'} if live.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It usefully discloses the success return shape ({status: 'ok'} if live), which is real value beyond structured fields. It does not, however, describe the failure mode (error vs. a non-ok status), auth requirements, or whether the call has any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and followed by the expected response. Every clause earns its place with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter probe with no output schema, the description is nearly sufficient: it names the check and the success payload. The only meaningful gap is the non-live/error behavior, which an agent would need in order to interpret a failure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline of 4 applies, and no parameter-related deficiency exists.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Check') and resource ('Filingrail API health'), which is unambiguous and instantly distinguishable from the sibling data-retrieval tools (get_financials, search_companies, get_recent_filings). No agent could confuse this diagnostic probe with a data fetch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than stated: a health endpoint is intuitively used to verify connectivity before or during other calls, but the description gives no explicit when-to-use trigger, no when-not, and no named alternative. Adequate context for a zero-argument probe, but nothing instructive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search SEC-registered companies by ticker, CIK, or name fragment.
Args: q: search term (e.g. "AAPL", "Apple", "320193") limit: max results (1-100, default 10)
Returns: list of {cik, ticker, name, ...}
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | ||
| limit | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does disclose the return shape and the accepted identifier types, and the parameter bounds, but says nothing about result ordering, case sensitivity, fuzzy vs exact matching, or whether inactive/delisted registrants are included. Adequate for a benign read-only search, but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose sentence is front-loaded, followed by a compact Args block and a one-line Returns. Every element earns its place, though restating param names in Args is slightly redundant with the schema; the examples justify the space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the Returns line is a bonus rather than a necessity. With no annotations and a simple two-parameter read, the description covers inputs, bounds, and return shape well enough to call the tool correctly; only matching semantics and result ordering are unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does: it gives concrete example values for q across all three lookup modes ("AAPL", "Apple", "320193") and spells out the limit range and default (1-100, default 10). Only minor gaps remain (no explicit 'required' flag or empty-result behavior).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (search SEC-registered companies) plus the three lookup keys (ticker, CIK, name fragment), which is concrete and unambiguous. It does not explicitly position itself against the siblings (all get_* data fetchers), but the search-vs-fetch distinction is clear from the name and phrasing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than stated: an agent can infer this is the discovery step before calling get_financials or get_recent_filings, since those need a CIK/ticker. No explicit when-to-use, when-not-to-use, or named alternative is given, so it falls at the 'implied usage' level.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.3get_13f_holdingsget_8k_eventsget_financialsget_financials_historyget_insider_tradesget_recent_filingshealthsearch_companiesScored across 8 tools
Each tool maps to a distinct SEC filing type or resource (financials, Form 4, 8-K, 13F, filings). The only mild overlap is get_financials vs get_financials_history, but the former returns a latest snapshot and the latter a filterable time series, so the descriptions keep them separable.
Nearly all tools use a consistent get_<resource> snake_case pattern, with search_companies as a readable verb_noun variant. health is the lone outlier lacking a verb prefix, but it is self-evident as a healthcheck.
Eight tools is well-scoped for an SEC filings data API, with each tool covering a distinct data type and no redundant entries. The single health tool is a minor but justifiable addition.
Core SEC datasets are covered: filings, XBRL financials (latest + history), insider trades, 8-K events, 13F holdings, and company search. Gaps remain for proxy statements (DEF 14A), ownership forms (13D/13G), and full-text filing search, but these are minor for typical workflows.
SEC EDGAR financials, insider trading, and economic data for AI agents. US GAAP + IFRS.
SEC EDGAR filings for AI agents: company lookup, filings, financials, insider trades. No keys.
SEC EDGAR filings for AI agents: company lookup, filings, financials, insider trades. No keys.
Normalized SEC EDGAR data for AI agents: XBRL financials, 10-K risk diffs, Form 4 insider trades.
