DEV Community: Caleb Love

How to pull SEC filings, insider trades and XBRL financials into your app in 5 minutes

Caleb Love — Sat, 24 Oct 2026 16:01:39 +0000

If you've ever tried to build something on top of SEC data, you know the feeling. EDGAR has everything: every 10-K, every 8-K, every Form 4 insider trade, and years of XBRL financials for U.S. public companies. It's free and public. But getting from "I want Apple's recent insider sales" to a clean JSON array takes a surprising amount of glue code.

I built a small API to skip that glue. This post shows what it does, how to call it in a few minutes, and four real use cases with copy-paste examples. All the data comes from SEC EDGAR's public data. The API isn't affiliated with the SEC, and nothing here is investment advice.

What it does

The SEC EDGAR Insider Trading & Financials API runs on Cloudflare Workers and exposes these endpoints:

Endpoint	What you get
`GET /v1/filings/{tickerOrCik}`	Company profile + filings (10-K, 10-Q, 8-K with item numbers, S-1, 4…) with document URLs. Filters: `forms`, `since`, `until`, `limit`
`GET /v1/insider-trades/{tickerOrCik}`	Parsed Form 4 transactions, one row per trade, with buy/sell totals. Filters: `limit`, `side`, `codes`, `since`, `includeDerivative`
`GET /v1/insider-buys`	Market-wide open-market insider purchases grouped by company, with cluster-buy detection. Filters: `days`, `minInsiders`, `minValue`, `role`, `limit`
`GET /v1/company/{tickerOrCik}/snapshot`	Revenue, margins, net income, EPS, cash flow, balance sheet and debt, with YoY growth
`GET /v1/company/{tickerOrCik}/facts`	Raw XBRL `companyfacts`, passed through
`GET /v1/company/{tickerOrCik}/concept/{taxonomy}/{tag}`	History of a single XBRL tag, e.g. `us-gaap/NetIncomeLoss`
`GET /v1/search`	EDGAR full-text search (`q`, `forms`, `ciks`, `startdt`, `enddt`, `from`)
`GET /v1/resolve/{tickerOrCik}`	Ticker ↔ CIK

You can pass a ticker (AAPL, BRK.B) or a CIK (320193) anywhere an ID is expected.

Quick start

The /v1 endpoints are served through RapidAPI. Calling the Worker directly gets you a 403 that points you to the listing.

Open the RapidAPI listing and subscribe to the free Basic plan.
Copy your key from the RapidAPI dashboard.
Make a call:

curl "https://sec-edgar-insider-trading-financials-api.p.rapidapi.com/v1/resolve/NVDA" \
  -H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
  -H "X-RapidAPI-Host: sec-edgar-insider-trading-financials-api.p.rapidapi.com"

{ "cik": "0001045810", "ticker": "NVDA", "name": "NVIDIA CORP" }

For the rest of the post I'll use this setup:

export RAPIDAPI_KEY=YOUR_RAPIDAPI_KEY
export HOST=sec-edgar-insider-trading-financials-api.p.rapidapi.com

You can check that the backend is up without a key: https://sec-edgar-api.kidriahx.workers.dev/health returns {"ok": true, ...}, and the OpenAPI spec is at /openapi.yaml.

Use case 1: Latest 10-K and 8-K filings for a company

Say you want a "recent filings" panel on a stock page.

curl "https://$HOST/v1/filings/MSFT?forms=10-K,8-K&limit=3" \
  -H "X-RapidAPI-Key: $RAPIDAPI_KEY" -H "X-RapidAPI-Host: $HOST"

Response (trimmed):

{
  "company": {
    "cik": "0000789019",
    "name": "MICROSOFT CORP",
    "tickers": ["MSFT"],
    "sicDescription": "Services-Prepackaged Software",
    "fiscalYearEnd": "0630"
  },
  "count": 3,
  "filings": [
    {
      "accessionNumber": "0001193125-26-380280",
      "form": "8-K",
      "filingDate": "2026-09-02",
      "items": "7.01,9.01",
      "documentUrl": "https://www.sec.gov/Archives/edgar/data/789019/000119312526380280/d291965d8k.htm"
    },
    {
      "accessionNumber": "0001193125-26-323660",
      "form": "10-K",
      "filingDate": "2026-07-29",
      "reportDate": "2026-06-30",
      "documentUrl": "https://www.sec.gov/Archives/edgar/data/789019/000119312526323660/msft-20260630.htm"
    }
  ]
}

The items field on 8-Ks is useful: 2.02 is results of operations (earnings), 5.02 is officer/director changes, and so on. You can filter on it without opening the document.

Use case 2: Insider trades for a ticker (Form 4)

Form 4s are XML documents, and every filing can hold several transactions. The API parses them into flat rows.

JavaScript (fetch, Node 18+ or browser):

const HOST = "sec-edgar-insider-trading-financials-api.p.rapidapi.com";

async function insiderTrades(ticker) {
  const res = await fetch(`https://${HOST}/v1/insider-trades/${ticker}?limit=5`, {
    headers: {
      "X-RapidAPI-Key": process.env.RAPIDAPI_KEY, // YOUR_RAPIDAPI_KEY
      "X-RapidAPI-Host": HOST,
    },
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

const data = await insiderTrades("AAPL");
console.log(data.summary);
for (const t of data.transactions.filter((t) => t.side === "sell")) {
  console.log(t.transactionDate, t.insiderName, t.shares, t.pricePerShare, t.is10b51Plan);
}

Python (requests):

import os
import requests

HOST = "sec-edgar-insider-trading-financials-api.p.rapidapi.com"
HEADERS = {
    "X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],  # YOUR_RAPIDAPI_KEY
    "X-RapidAPI-Host": HOST,
}

r = requests.get(f"https://{HOST}/v1/insider-trades/AAPL",
                 params={"limit": 5}, headers=HEADERS, timeout=30)
r.raise_for_status()
data = r.json()
print(data["summary"])
for t in data["transactions"]:
    if t["side"] == "sell":
        print(t["transactionDate"], t["insiderName"], t["shares"], t["pricePerShare"])

Response (trimmed):

{
  "query": { "id": "AAPL", "cik": "0000320193", "ticker": "AAPL", "name": "Apple Inc." },
  "filingsParsed": 5,
  "summary": {
    "transactions": 23,
    "openMarketBuys": 0,
    "openMarketSells": 13,
    "openMarketSellShares": 9869,
    "openMarketSellValue": 3361318.27,
    "distinctInsiders": 3
  },
  "transactions": [
    {
      "insiderName": "Newstead Jennifer",
      "insiderRole": "SVP, GC and Government Affairs",
      "transactionDate": "2026-10-20",
      "transactionCode": "S",
      "transactionType": "Open-market or private sale",
      "side": "sell",
      "shares": 2399,
      "pricePerShare": 339.62,
      "totalValue": 814748.38,
      "sharesOwnedAfter": 34795,
      "is10b51Plan": true,
      "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126040540/form4.xml"
    }
  ]
}

Use side=buy or side=sell to keep only open-market purchases (code P) or sales (code S). Use codes=P,S,M for finer control.

Use case 3: Market-wide cluster buys

When several insiders buy the same stock in the open market within a short window, people call it a "cluster buy." The API keeps a rolling store of recent Form 4 purchases (it scans EDGAR every 10 minutes) and groups them by company:

curl "https://$HOST/v1/insider-buys?days=7&minInsiders=2&limit=5" \
  -H "X-RapidAPI-Key: $RAPIDAPI_KEY" -H "X-RapidAPI-Host: $HOST"

r = requests.get(f"https://{HOST}/v1/insider-buys",
                 params={"days": 7, "minInsiders": 2, "limit": 5},
                 headers=HEADERS, timeout=30)
for c in r.json()["results"]:
    print(c["ticker"], c["insiderCount"], c["totalValue"])

Response (trimmed, from the morning of Oct 24, 2026):

{
  "window": { "days": 7, "from": "2026-10-17", "to": "2026-10-24" },
  "clusterBuys": 10,
  "results": [
    {
      "ticker": "RAPP",
      "issuerName": "Rapport Therapeutics, Inc.",
      "insiderCount": 6,
      "isClusterBuy": true,
      "totalShares": 61694,
      "totalValue": 1664824.35,
      "avgPrice": 26.9852,
      "firstTransactionDate": "2026-10-21",
      "lastTransactionDate": "2026-10-23",
      "insiders": [
        { "name": "PAUL STEVEN M", "role": "Director", "value": 974277.92 },
        { "name": "Ignelzi Troy A.", "role": "Chief Financial Officer", "value": 143550 }
      ]
    }
  ]
}

One caveat: this feed only covers filings since the scanner started running, so it's a recent-activity feed, not a historical database.

Use case 4: Financial snapshot from XBRL

Pulling "revenue" from XBRL sounds simple, but companies use different tags (Revenues, RevenueFromContractWithCustomerExcludingAssessedTax, …), and annual and quarterly facts are mixed together. The snapshot endpoint picks the tags and lines up the periods for you:

const snap = await fetch(`https://${HOST}/v1/company/AAPL/snapshot`, {
  headers: { "X-RapidAPI-Key": process.env.RAPIDAPI_KEY, "X-RapidAPI-Host": HOST },
}).then((r) => r.json());

const rev = snap.metrics.revenue;
console.log(rev.latestAnnual.value, rev.annualGrowthPct);

{
  "company": { "cik": "0000320193", "ticker": "AAPL", "name": "Apple Inc.", "fiscalYearEnd": "0926" },
  "metrics": {
    "revenue": {
      "tag": "us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax",
      "unit": "USD",
      "latestAnnual": { "value": 416161000000, "periodEnd": "2025-09-27", "fiscalYear": 2025, "form": "10-K" },
      "priorAnnual": { "value": 391035000000, "periodEnd": "2024-09-28" },
      "annualGrowthPct": 6.43,
      "latest": { "value": 109417000000, "periodEnd": "2026-06-27", "fiscalPeriod": "Q3", "form": "10-Q" }
    }
  }
}

Each metric includes the exact XBRL tag and accession number, so you can trace any number back to the filing. If you need a metric that isn't in the snapshot, use /v1/company/AAPL/concept/us-gaap/NetIncomeLoss.

Bonus: full-text search. /v1/search?q="share repurchase"&forms=8-K wraps EDGAR full-text search. When I ran it, it reported 5,661 matching 8-Ks from the past year, returned 100 per page.

Why not just call EDGAR directly?

You can, and for a one-off script you probably should. The SEC's APIs are free. Here's what this API handles for you:

User-Agent rules. SEC asks every client to declare who it is (a name and contact email) in the User-Agent header. Requests without one can be blocked.
Rate limits. SEC's fair-access limit is 10 requests per second. Parsing insider trades means one request per Form 4, and a snapshot uses several XBRL lookups. The API spaces out its SEC calls globally and caches results.
CIK lookups. Most SEC endpoints want a zero-padded CIK, not a ticker.
Messy formats. Form 4s are XML with separate derivative and non-derivative tables. The submissions JSON stores filings as parallel arrays. companyfacts can run to megabytes per company, with duplicate facts across filings.

If you only need one company's 10-K list, go direct. If you're building a feature on top of insider trades or fundamentals, a wrapper saves you a few evenings.

Pricing

RapidAPI has four plans. Basic is free and covers every endpoint, which is enough to try things out. Paid tiers add more requests per month. Current quotas and prices are on the pricing page.

If you'd rather work in batches (pull every 8-K in a date range into a dataset, or schedule a run), the same kind of data is also available as an Apify actor: SEC EDGAR Filings & Financials on Apify. It's billed per result.

Give your AI agent SEC EDGAR data: a free remote MCP server for insider trades and XBRL financials

Caleb Love — Sat, 24 Oct 2026 04:48:09 +0000

MCP (Model Context Protocol) is an open standard that lets an AI client such as Claude, Cursor or VS Code call external tools through one common interface.

This post walks through a free, MIT-licensed MCP server for U.S. SEC EDGAR data. It runs remotely, so there's nothing to install and no API key. I'll show how to connect it, three real calls with their actual output, how it works inside, and where it falls short.

Endpoint (Streamable HTTP, no key): https://sec-edgar-api.kidriahx.workers.dev/mcp
Source: https://github.com/monriah-studio/sec-edgar-mcp-remote
MCP Registry name: io.github.monriah-studio/sec-edgar-mcp

Why EDGAR needs a wrapper

EDGAR is one of the best free financial datasets around: every insider trade, 10-K, 8-K and XBRL financial fact that U.S. public companies file. It's also awkward to use, especially for an agent:

The User-Agent rule. SEC's fair-access policy asks every client to send a declared User-Agent with a contact email and to stay under 10 requests per second. Requests that skip this get 403s. An LLM making fetches on its own won't know that.
CIK lookup. Most endpoints want a 10-digit Central Index Key (0000320193), not a ticker (AAPL). You have to look it up in a roughly 1 MB company_tickers.json file first.
Form 4 is XML. Insider trades come as one XML document per filing, full of transaction codes (P, S, A, M, F, G), derivative tables and footnotes.
XBRL is messy. The companyconcept JSON repeats the same period across many filings and mixes 3-month, 9-month and 12-month durations. Getting "net income by fiscal year" out of it means filtering and de-duplicating.

The server does all of this and returns compact JSON.

The seven tools

Tool	What it returns
`get_insider_trades`	Form 4 transactions for a company or an insider, with buy/sell totals and a 10b5-1 flag
`get_market_insider_buys`	Open-market insider purchases across the market, grouped by company, with cluster-buy detection (2+ insiders)
`get_company_filings`	Latest 10-K, 10-Q, 8-K (with item numbers) and other filings, with document links
`get_company_snapshot`	Revenue, margins, net income, EPS, cash flow, balance sheet and YoY growth from XBRL
`get_company_concept`	Annual or quarterly history of any XBRL tag
`search_filings`	EDGAR full-text search with phrase, form and date filters
`resolve_company`	Ticker â†” CIK lookup

Every tool takes a ticker or a CIK, and all of them are marked read-only.

Connect a client

Cursor: add this to ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "sec-edgar": {
      "url": "https://sec-edgar-api.kidriahx.workers.dev/mcp"
    }
  }
}

VS Code (Copilot agent mode): add this to .vscode/mcp.json:

{
  "servers": {
    "sec-edgar": {
      "type": "http",
      "url": "https://sec-edgar-api.kidriahx.workers.dev/mcp"
    }
  }
}

Claude Desktop: on plans that support custom connectors, add the URL under Settings â†’ Connectors. You can also bridge it through claude_desktop_config.json with the mcp-remote package (needs Node.js):

{
  "mcpServers": {
    "sec-edgar": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://sec-edgar-api.kidriahx.workers.dev/mcp"]
    }
  }
}

Claude Code: claude mcp add --transport http sec-edgar https://sec-edgar-api.kidriahx.workers.dev/mcp

Then try prompts like "Show NVIDIA's last insider sales and whether they were under 10b5-1 plans" or "Which companies had cluster insider buying this week?"

Three real calls with curl

The server is stateless, so you don't need an SDK to test it. Every request is a single JSON-RPC POST. Start with initialize:

URL=https://sec-edgar-api.kidriahx.workers.dev/mcp
curl -s $URL \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'

{"result":{"protocolVersion":"2025-06-18","capabilities":{"tools":{}},"serverInfo":{"name":"sec-edgar-mcp","title":"SEC EDGAR Insider Trades & Financials","version":"1.0.0"}, ...},"jsonrpc":"2.0","id":1}

Each tool result comes back as JSON text in result.content[0].text. The outputs below are pretty-printed and trimmed (...). I ran them on October 23, 2026, so your numbers will differ.

1. NVIDIA insider trades

curl -s $URL -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_insider_trades","arguments":{"ticker_or_cik":"NVDA","filings":5,"max_rows":5}}}'

{
 "company": {"id": "NVDA", "cik": "0001045810", "ticker": "NVDA", "name": "NVIDIA CORP"},
 "filingsParsed": 5,
 "summary": {"transactions": 8, "openMarketBuys": 0, "openMarketSells": 5,
             "sellShares": 1396460, "sellValueUsd": 306933627.99, "distinctInsiders": 5},
 "returned": 5,
 "transactions": [
  {"date": "2026-09-21", "insider": "Teter Timothy S.", "role": "EVP, General Counsel and Sec",
   "code": "S", "shares": 12483, "price": 222.1932, "valueUsd": 2773637.72,
   "ownedAfter": 2705637, "plan10b51": true, "filed": "2026-09-23",
   "url": "https://www.sec.gov/Archives/edgar/data/1045810/000169684126000014/wk-form4_1790196985.xml"},
  ...
 ]
}

On a cold cache, that call made 7 requests to SEC: the ticker map, the company's submissions index and five Form 4 XML files. The response header x-sec-requests: 7 reports the count.

2. Apple net income from XBRL

curl -s $URL -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_company_concept","arguments":{"ticker_or_cik":"AAPL","concept":"NetIncomeLoss","period":"annual","limit":4}}}'

{
 "company": {"name": "Apple Inc.", "cik": "0000320193"},
 "concept": "us-gaap:NetIncomeLoss",
 "label": "Net Income (Loss) Attributable to Parent",
 "unit": "USD", "period": "annual", "totalPeriods": 19,
 "values": [
  {"value": 112010000000, "start": "2024-09-29", "end": "2025-09-27", "fy": 2025, "form": "10-K", "filed": "2025-10-31"},
  {"value": 93736000000,  "start": "2023-10-01", "end": "2024-09-28", "fy": 2025, "form": "10-K", "filed": "2025-10-31"},
  {"value": 96995000000,  "start": "2022-09-25", "end": "2023-09-30", "fy": 2025, "form": "10-K", "filed": "2025-10-31"},
  ...
 ]
}

Look at fy. It's SEC's fiscal year of the filing that reported the value, not of the period, so the FY2024 figure shows fy: 2025. Use start/end to know which period a value belongs to.

3. Cluster buys across the market

curl -s $URL -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"get_market_insider_buys","arguments":{"days":7,"min_insiders":2,"limit":3}}}'

{
 "window": {"days": 7, "from": "2026-10-17", "to": "2026-10-24"},
 "dataUpdatedAt": "2026-10-24T04:40:38.877Z",
 "issuers": 3, "clusterBuys": 3,
 "results": [
  {"ticker": "RAPP", "issuer": "Rapport Therapeutics, Inc.", "insiderCount": 6, "clusterBuy": true,
   "totalValueUsd": 1664824.35, "totalShares": 61694, "avgPrice": 26.9852,
   "firstDate": "2026-10-21", "lastDate": "2026-10-23",
   "insiders": [{"name": "Ignelzi Troy A.", "role": "Chief Financial Officer", "valueUsd": 143550}, ...]},
  {"ticker": "CHCO", "issuer": "CITY HOLDING CO", "insiderCount": 4, "totalValueUsd": 68222.4, ...},
  {"ticker": "RENT", "issuer": "Rent the Runway, Inc.", "insiderCount": 3, "totalValueUsd": 6120515.95, ...}
 ],
 "note": "Open-market, non-derivative purchases only. Not investment advice."
}

This call made zero SEC requests because it reads from a pre-built store (more on that below). Dates are UTC, which is why the window ends on the 24th.

How it works

The whole thing is one Cloudflare Worker on the free plan:

MCP transport. /mcp uses the official MCP TypeScript SDK's web-standard Streamable HTTP transport in stateless JSON mode. There are no sessions and no Durable Object per client. Each POST stands alone, and GET/DELETE return 405. Each tool maps to one REST endpoint, and a compact() function trims the REST JSON down to fewer fields and capped rows so it doesn't fill the model's context. The same Worker also serves that REST API (/v1/..., documented in openapi.yaml).
SEC etiquette. Every request to SEC carries a declared User-Agent with a contact email. Requests are spaced at least 115 ms apart, and a global Durable Object rate limiter hands out time slots so that all Worker isolates together stay near 8.7 req/s, under SEC's 10 req/s ceiling. On 429/5xx the Worker backs off (honoring Retry-After) and retries up to three times. A 403 gets one retry and then a clear error.
Caching. Lookups go through three layers: isolate memory, then the Cloudflare Cache API, then KV for selected keys. TTLs follow how often the data changes. The ticker map and resolutions are cached for 24 h, parsed Form 4s for 30 days (filings don't change), submissions for 10 min, XBRL snapshots and concepts for 6 h, and full-text search for 15 min.
Market-wide buys. A cron runs every 10 minutes. It queries EDGAR full-text search for new Form 4s, parses up to 40 per run, and keeps open-market purchases (code P, non-derivative) in a KV store. get_market_insider_buys groups that store by issuer.
Ticker resolution. The ticker file is searched with a regex instead of JSON.parse, which keeps it inside the free plan's CPU budget.

Limits and caveats

Shallow per-call history. get_insider_trades parses at most 25 recent Form 4 filings per call (default 5). The free plan allows about 50 subrequests per invocation, so this isn't a tool for pulling ten years of history.
Market scan coverage. The cluster-buy data covers at most 30 days and only starts from when the store was first populated. During a burst of filings the cron can fall behind.
XBRL is only as clean as the filings. Companies choose different tags (Revenues vs. RevenueFromContractWithCustomerExcludingAssessedTax), and some metrics will come back null. Check the tag field in the snapshot.
Shared free endpoint. The public instance has no key and no SLA. Under heavy load you'll queue behind the global SEC limit or get a 503 asking you to retry. For anything important, deploy your own copy (the README covers it: a KV namespace, your own SEC_USER_AGENT, then wrangler deploy). You can protect /mcp with MCP_API_KEYS.
Not investment advice, not affiliated with the SEC. The data is public domain and comes straight from EDGAR. Interpreting it is up to you. A 10b5-1 sale means something very different from a discretionary open-market buy.