MCP: SEC EDGAR Intel - AI Agents Filings Insider

Model Context Protocol (MCP) server wrapper around seibs.co/sec-edgar-intel. Built for AI agents serving hedge funds, fintech teams, and due-diligence research workflows.

Public SEC EDGAR data, exposed as six clean MCP tools your agent can call directly. No XML wrangling, no SEC fair-access rate-limit headaches, no insider-pattern detection you have to write yourself.

What this actor does

It is a thin, fast wrapper. The heavy lifting (EDGAR fetch, 8-K trigger classification, Form 4 cluster-buy detection, 13F QoQ delta, Form D parsing, earnings transcript extraction) lives in the upstream actor. This wrapper:

1. Advertises a stable MCP tool catalog so any agent can discover capabilities via mode=list_tools.
2. Validates tool arguments with Pydantic and rejects bad inputs with a structured error (rather than a 500).
3. Calls the upstream actor with the right input shape and reshapes the response into compact, agent-ready JSON (drops nulls, drops XML, drops megabyte text blobs unless explicitly requested).
4. Charges a flat $0.005 per tool call. Upstream filing_record, intelligence_enrichment, earnings_transcript_charge, and full_text_charge events pass through unchanged.

Tools

Tool	Purpose	Key args
get_company_filings	Recent filings by ticker or CIK.	ticker, form_types[], limit
get_8k_triggers	8-Ks categorized by material-event trigger (M&A, exec change, going concern, impairment, restatement, etc).	ticker, days_back
get_form4_insider_activity	Form 4 insider trades with cluster-buy + unusual-size flags.	ticker, days_back
get_13f_positions_change	Latest 13F-HR for a manager (by CIK) with QoQ position deltas.	manager_cik, vs_quarter
get_recent_form_d	Recent Form D private-placement filings (startup raises).	industry, min_amount
get_earnings_transcript	Earnings call transcript from a recent 8-K Exhibit 99.1/99.2.	ticker, quarter

Every tool returns the same envelope: { tool, args, ok, count, items, summary, error }. Agents key off summary for natural-language framing and items for structured downstream use.

Pricing

• $0.005 per MCP tool call (the wrapper).
• Upstream sec-edgar-intel PPE events pass through directly:
  • filing_record: $0.005 per filing
  • intelligence_enrichment: $0.010 per 8-K trigger / Form 4 flag / going-concern detection
  • earnings_transcript_charge: $0.010 per transcript extracted
  • full_text_charge: $0.015 per filing with raw text embedded

A typical get_8k_triggers call against one ticker over 90 days costs around $0.005 (wrapper) + ~$0.05 (10 filings) + ~$0.02 (2 trigger enrichments) = roughly $0.075 total.

mode=list_tools is free.

Hedge-fund and due-diligence use cases

• Catalyst monitoring. Schedule get_8k_triggers daily across your watchlist. Trigger an alert (or a follow-up agent) whenever a new going_concern, restatement, m_and_a, or executive_change category appears.
• Insider conviction screen. Run get_form4_insider_activity weekly. Filter for flags.cluster_buy = true and flags.c_suite_only = true to surface high-conviction insider buying clusters.
• Smart-money tracking. Pipe a list of manager CIKs through get_13f_positions_change. Aggregate the new_positions and increased_positions across managers to spot consensus accumulation.
• Pre-IPO and private-market intel. Schedule get_recent_form_d with industry="software" and min_amount=10_000_000 to surface mid-stage venture raises in your coverage universe.
• Earnings season agent. Run get_earnings_transcript post-print for every name in your portfolio; pipe transcripts into your LLM summarization step for guidance changes, segment commentary, and CFO Q&A tone.
• Pre-deal due diligence. Run get_company_filings + get_8k_triggers + get_form4_insider_activity on the target in one batch; pipe the combined output into your DD memo template.

AI agent integration

Anthropic Claude (tool use)

import anthropic
from apify_client import ApifyClient

apify = ApifyClient(token="APIFY_TOKEN")

# Discover tools (free).
cat_run = apify.actor("seibs.co/mcp-sec-edgar-intel").call(run_input={
    "mode": "list_tools",
    "user_agent_contact": "MyFundResearch contact@myfund.com",
})
catalog = next(apify.dataset(cat_run["defaultDatasetId"]).iterate_items())
tools = [
    {"name": t["name"], "description": t["description"], "input_schema": t["input_schema"]}
    for t in catalog["tools"]
]

# Hand the tool list to Claude.
client = anthropic.Anthropic()
resp = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=2048,
    tools=tools,
    messages=[{"role": "user", "content": "What 8-K triggers fired at NVDA in the last 30 days?"}],
)

# When Claude returns a tool_use block, dispatch it back through the actor.
for block in resp.content:
    if block.type == "tool_use":
        result = apify.actor("seibs.co/mcp-sec-edgar-intel").call(run_input={
            "mode": "call_tool",
            "tool": block.name,
            "args": block.input,
            "user_agent_contact": "MyFundResearch contact@myfund.com",
        })
        items = list(apify.dataset(result["defaultDatasetId"]).iterate_items())
        print(items[0]["summary"])  # natural-language summary
        print(items[0]["items"])    # structured rows

OpenAI Responses API

from openai import OpenAI
from apify_client import ApifyClient

apify = ApifyClient(token="APIFY_TOKEN")
openai = OpenAI()

def call_edgar_tool(name: str, args: dict) -> dict:
    run = apify.actor("seibs.co/mcp-sec-edgar-intel").call(run_input={
        "mode": "call_tool",
        "tool": name,
        "args": args,
        "user_agent_contact": "MyFundResearch contact@myfund.com",
    })
    return next(apify.dataset(run["defaultDatasetId"]).iterate_items())

resp = openai.responses.create(
    model="gpt-5",
    input="Pull the latest 13F change for Berkshire Hathaway (CIK 1067983).",
    tools=[{
        "type": "function",
        "name": "get_13f_positions_change",
        "parameters": {"type": "object", "properties": {
            "manager_cik": {"type": "string"}, "vs_quarter": {"type": "string"}
        }, "required": ["manager_cik"]},
    }],
)
# Iterate resp.output -> dispatch tool calls to call_edgar_tool(...).

LangChain

from langchain_core.tools import StructuredTool
from apify_client import ApifyClient

apify = ApifyClient(token="APIFY_TOKEN")

def _make_tool(tool_name: str):
    def _run(**kwargs):
        run = apify.actor("seibs.co/mcp-sec-edgar-intel").call(run_input={
            "mode": "call_tool", "tool": tool_name, "args": kwargs,
            "user_agent_contact": "MyFundResearch contact@myfund.com",
        })
        return next(apify.dataset(run["defaultDatasetId"]).iterate_items())
    return _run

edgar_8k = StructuredTool.from_function(
    func=_make_tool("get_8k_triggers"),
    name="get_8k_triggers",
    description="SEC 8-K filings with material-event trigger classification.",
)

Batch mode (one run, multiple tool calls)

Useful for due-diligence sweeps where you want the whole report in one billable run.

{
  "mode": "batch",
  "user_agent_contact": "DDFirm research@ddfirm.com",
  "calls": [
    {"tool": "get_company_filings",         "args": {"ticker": "TSLA", "limit": 5}},
    {"tool": "get_8k_triggers",             "args": {"ticker": "TSLA", "days_back": 180}},
    {"tool": "get_form4_insider_activity",  "args": {"ticker": "TSLA", "days_back": 90}},
    {"tool": "get_earnings_transcript",     "args": {"ticker": "TSLA", "quarter": "latest"}}
  ]
}

Output shape

Tool catalog (mode=list_tools):

{
  "record_type": "tool_catalog",
  "server_name": "mcp-sec-edgar-intel",
  "upstream_actor": "seibs.co/sec-edgar-intel",
  "tool_count": 6,
  "tools": [ { "name": "...", "description": "...", "input_schema": { ... } } ]
}

Tool call result (mode=call_tool / batch):

{
  "record_type": "tool_call_result",
  "tool": "get_8k_triggers",
  "args": {"ticker": "NVDA", "days_back": 90},
  "ok": true,
  "count": 4,
  "items": [ { "ticker": "NVDA", "form_type": "8-K", "trigger_categories": ["material_definitive_agreement"], "...": "..." } ],
  "summary": "4 8-K filings in last 90d for NVDA; top triggers: material_definitive_agreement(2), executive_change(1).",
  "error": null
}

SEC fair-access compliance

SEC EDGAR requires every request to include a User-Agent header with a real contact email. The wrapper enforces @ in user_agent_contact and passes the value through to the upstream actor on every call. Use your real contact - SEC will IP-ban honest-looking-but-fake identifiers.

Limits and caveats

• get_recent_form_d filters by industry keyword via EDGAR full-text search; the SEC full-text index covers filings since 2001 but lags real time by ~24 hours.
• get_13f_positions_change requires the manager's CIK (not a ticker). Use the SEC EDGAR company search to find it (e.g. Berkshire Hathaway = 1067983).
• get_earnings_transcript only finds transcripts that companies explicitly attach as Exhibit 99.x to an 8-K. Some issuers post earnings text only on their IR site; those won't appear here.
• Free Apify plan: sub-actor calls require credit. If your platform credit is exhausted, the wrapper will return ok: false with a clear upstream-call-failed error.

Repo

Source: portfolio repo, actors/mcp-sec-edgar-intel/. Upstream: actors/sec-edgar-intel/.

Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click Run with your input fully configured.
2. Click the Save as task button at the top of the run page.
3. Name the task something memorable (e.g. Saved SEC query for agent - on-demand).
4. Reload the task page and click Start anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click Create new schedule.
3. Pick your Task and set the cron expression. Common patterns:
   • Daily at 9am UTC: 0 9 * * *
   • Weekly on Mondays at 9am: 0 9 * * 1
   • Monthly on the 1st: 0 9 1 * *
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks.

Schedules are unusual for MCP wrappers because AI agents invoke them on-demand. Use Tasks for saved configs but skip the cron schedule unless you have a specific batch-run use case.

Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

• When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
• Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
• A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
• Optional: provide a Slack or email webhook URL in the monitor_webhook_url input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
• Cost: a single scheduled_delta_run event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/mcp-sec-edgar-intel#reviews