EDGAR Events Blog Docs Get a key

← Blog

A cheaper sec-api.io alternative for resolved 13D events on a signed webhook

If you watch activist situations, the event you care about is a Schedule 13D landing on a name you trade. A link to the filing barely helps. What you can act on is the resolved cover page: who filed, the target ticker, the percent of class they now hold, and the share count, delivered to your service the moment the filing is accepted, without you parsing XML yourself.

That exact combination, a resolved 13D pushed over a real-time signed HTTP webhook, is the one cell in this market that no vendor fully fills. Some resolve the cover page but only over a polling REST call or a $49 floor. Some push fast but ship filing metadata, not resolved fields. The best free option resolves the fields perfectly and cannot push you anything. EDGAR Events is built to sit in that gap at $29/mo, self-serve. This page lays out who does what, with each vendor's verified prices, so you can decide before you put in a card.

The one cell to compare on

For a 13D-driven workflow there are two questions that matter, and most comparison pages blur them:

  1. Does the API return the resolved cover-page object (holder name, target ticker, percent of class, shares), or just filing metadata and a link to the document you then parse yourself?
  2. Does it push that object to you in real time over a signed HTTP webhook, or do you have to poll, or hold open a WebSocket that carries only metadata?

Resolution and real-time signed push are separate features, and the vendors split on them. sec-api.io resolves the cover page, but its real-time channel is a WebSocket of metadata, so you chain a second non-realtime REST call to get the resolved object, and the floor is $49/mo with 100 lifetime free calls. EdgarKit and edgar.tools push over signed webhooks within seconds, but their parsed product is Form 3/4/5 insider data; for 13D you get metadata and a document pointer, not the cover-page fields. FilingFirehose ships 13D JSON with cover-page fields in the schema, but on the live free endpoint those fields came back empty, and its webhook is unsigned. The free edgartools library resolves 13D fields cleanly and has no webhook at all.

What EDGAR Events covers, exactly

Four event families, parsed into typed JSON:

  • 8-K filings, each item code resolved to a human label and a material flag per item.
  • SC 13D and 13D-A activist stakes, resolved to holder, target ticker, percent of class, and share count from the cover page.
  • S-1 and 424B IPO and prospectus forms.
  • merger proxies and M&A forms (DEFM14A and related).

Delivery is either polling the JSON endpoints or registering an HMAC-SHA256 signed webhook with per-tenant isolation. Everything is sourced live from data.sec.gov and efts.sec.gov, the same primary EDGAR systems the SEC runs.

That list is the whole product. No Form 4 insider transactions, no fundamentals or financial-statement data, no options, no news, no 13F holdings, no ownership data beyond 13D and 13D-A. If you need any of those, one of the vendors below is your tool, and the section after the table says which.

The comparison

The table is scoped to the 13D job: does the vendor resolve the cover-page object, can it push, is the push signed, what does the entry tier cost, and is there a standing free tier. Figures are read off each vendor's own live pages on 2026-06-27. Where a vendor does not publish a number, the cell says so rather than guessing.

Vendor Resolves 13D cover page (holder/ticker/percent/shares) Push delivery Signed HTTP webhook Entry paid price Standing free tier
EDGAR Events yes signed webhook or poll yes (HMAC-SHA256) $29/mo, self-serve via Stripe yes
sec-api.io yes (via a separate REST call, not the real-time channel) WebSocket of metadata no $49/mo annual ($55 monthly) 100 API calls, lifetime
EdgarKit no (Form 3/4/5 parsed; 13D is metadata + document pointer) signed webhook or REST yes (HMAC-SHA256) $19/mo (25,000 calls/mo) $0, 1,000 calls/mo, no card
edgar.tools unknown (its pages describe 8-K events and Form 4 insider data; no claim it parses 13D cover pages) MCP tools over REST, plus webhooks at the $79.99 tier yes (HMAC, Analyst tier) $24.99/mo $0, 100 calls/day
FilingFirehose unknown (schema has the fields; every live free 13D record returned them empty) REST, plus unsigned webhooks on paid no $29/mo developer (Hobbyist) yes, last 72 hours of every form
Intrinio no (does not carry 13D/13G at all) pull: REST and a price WebSocket no $150/mo individual none (2-week trial only)
secfilingdata.com no (13D reachable only via the metadata Query API) poll: REST/JSON only no $45/mo (education/non-profit/gov only); $150/mo for businesses $0, 125 calls
Quantillium unknown (lists 13D under ownership filings as metadata + document links) poll: REST only no $99/mo (250 calls/mo, max 50/day) none
dgunning/edgartools (free library) yes none (pull-only Python library) no free, MIT, no key the whole thing is free

Three notes on reading that table.

EDGAR Events is the only row that answers yes to both "resolves the 13D cover page" and "signed HTTP webhook." sec-api.io resolves the cover page too, and is the strongest broad competitor, but its resolution is a REST query you reach by chaining an accession number from the metadata WebSocket, so the resolved object is not what arrives in real time. EdgarKit and edgar.tools have genuine signed webhooks and undercut on price, but their parsed-JSON product is insider-trading forms; for 13D they hand you a pointer to the document.

Two cells read "unknown" on purpose. edgar.tools never claims on a reachable page to parse Schedule 13D cover pages (its material-events tool is described as 8-K classification, and insider data is a separate tool), and its canonical pricing page was behind a Cloudflare challenge this run, so the figures here come from its live MCP page. FilingFirehose publishes a 13D schema with percent_of_class, cusip, and aggregate_amount, but across roughly fifty live records on its free 13D endpoint every one of those fields was null, leaving only metadata populated, so whether paid endpoints resolve them is not something this page can confirm.

Kaleidoscope (kscope.io) is a real, live SEC and SEDAR data platform, but its API pricing is entirely behind "Contact Sales," so there is no self-serve number to put in the table. Its docs describe a polling REST API and do not document webhooks or cover-page 13D resolution, so it is named here and left out of the row-by-row rather than given a fabricated figure.

The honest free baseline: dgunning/edgartools

If you are deciding whether to pay at all, the strongest free option is the edgartools Python library (MIT licensed, no API key). It resolves 13D cover-page fields cleanly, it reads straight from EDGAR, and for a batch or backtest it is hard to beat at a price of zero.

What it cannot do is push. edgartools is a pull-only library; its "real-time" pattern is a polling loop you run yourself. So if your workflow is "alert my service the moment a 13D crosses 5% on a name I trade," a library cannot deliver that on its own. You would build and host the poller, the dedupe, the cover-page resolver, the retry and backoff, and the signed delivery to your endpoint. That is the work EDGAR Events does for you, and it is the honest reason to pay rather than pip install. If you do not need a push, use edgartools and keep your $29.

When to buy one of the others instead

Buy sec-api.io if you need breadth and a streaming socket. It is the most complete broad option here: filing query and full-text search back to the 1990s, Form 3/4/5 insider data, 13F, XBRL-to-JSON, 8-K item extractors, and a resolved 13D/13G query API. If your product touches insider trades or needs most of what EDGAR holds, and you can chain its WebSocket to a REST call for resolved fields, that coverage is worth the higher floor.

Buy EdgarKit or edgar.tools if your real target is insider trading. EdgarKit's parsed Form 3/4/5 JSON (every transaction, prices, ownership flags, footnotes) is clean and cheap at $19/mo with a no-card free tier, and edgar.tools wraps its data as an MCP server for LLM agents at $24.99/mo. Both ship signed webhooks. Neither resolves a 13D cover page today.

Buy Intrinio if SEC filings are one input among many and you need a licensed, audit-ready platform spanning equity and options prices, US fundamentals, and EOD history under one contract with onboarding support. Note that its filings feed is raw text for 10-K, 10-Q, 8-K, 20-F and 40-F and does not carry 13D or 13G at all, so it is not the tool for activist watching.

Look at secfilingdata.com or Quantillium if you want broad structured EDGAR over REST and are fine polling. secfilingdata covers 150+ form types with parse endpoints for Form 3/4/5, Form D, Form 144 and XBRL, but it has no dedicated 13D parser (13D comes back as metadata), every plan below Enterprise is internal-use-only, and the $45 entry price is restricted to education, non-profit and government, so a commercial buyer starts at $150/mo. Quantillium is clean structured filings over REST with global coverage, but it has no webhook, lists 13D as metadata plus a document link, and its $99 plan caps you at 250 calls a month (50 a day).

When EDGAR Events is the right buy

Pick this if these are all true.

  1. The event you care about is a resolved 13D or 13D-A: holder, target ticker, percent of class, shares, not a link you parse later. EDGAR Events resolves the cover page; the cheap webhook vendors hand you metadata, and the free library cannot push it.
  2. You want it pushed, not polled. A signed POST to your endpoint, HMAC-SHA256 over the raw body, per-tenant isolation, with no long-lived socket to hold open and reconnect.
  3. You also want item-coded 8-K events, fresh S-1s, and merger proxies typed the same way, so one feed covers the four families instead of four parsers.
  4. $29/mo self-serve matters. That is below sec-api.io's $49 floor (which gives you 100 lifetime free calls), and a fraction of Intrinio's $150 entry. Against EdgarKit at $19 or FilingFirehose at $29 the price is close; the difference is the resolved 13D push, which neither of them ships.

One honest caveat on speed. EDGAR Events polls EDGAR on a cycle, so events land within a few minutes of the SEC accepting a filing. That is fine for activist and event-driven workflows, where 13Ds can be filed days after the trade date and the edge is in catching the event at all, not in the millisecond. It is not fine for a latency-arbitrage strategy. sec-api.io's WebSocket indexes new filings in well under a second; if your strategy needs that, the socket is their territory, and you accept the second REST call for the resolved object.

What the requests look like

Material 8-Ks across a watchlist, polled:

curl -s -H "X-API-Key: $EDGAR_KEY" \
  "https://api.edgarevents.com/filings?ticker=NVDA,TSLA,AMD&type=8-K&material=true&hours=24"

A single 8-K event:

{
  "event_type": "8-K",
  "form": "8-K",
  "ticker": "NVDA",
  "company": "NVIDIA CORP",
  "cik": "0001045810",
  "filed_date": "2026-06-18",
  "items": [
    { "code": "8.01", "label": "other events", "material": true },
    { "code": "9.01", "label": "financial statements and exhibits", "material": false }
  ],
  "material": true,
  "accession": "0001193125-26-275783",
  "filing_url": "https://www.sec.gov/Archives/edgar/data/1045810/000119312526275783/d48176d8k.htm"
}

Activist stakes above 5%, resolved from the cover page:

curl -s -H "X-API-Key: $EDGAR_KEY" \
  "https://api.edgarevents.com/activist-stakes?min_percent=5&limit=10"

{
  "event_type": "activist_stake",
  "form": "SCHEDULE 13D/A",
  "filed_date": "2026-06-25",
  "accession": "0000921895-26-001671",
  "target": { "name": "Citi Trends Inc", "ticker": "CTRN", "cik": "0001318484" },
  "holders": [
    { "name": "Fund 1 Investments, LLC", "shares": 1823486, "percent_of_class": 21.9 }
  ],
  "percent_of_class": 21.9,
  "shares": 1823486,
  "security_class": "Common Stock, par value $0.01 per share",
  "filing_url": "https://www.sec.gov/Archives/edgar/data/1959730/000092189526001671/primary_doc.xml"
}

IPO and merger forms by type:

# Fresh S-1s in the last week
curl -s -H "X-API-Key: $EDGAR_KEY" \
  "https://api.edgarevents.com/filings?type=S-1&hours=168"

# Merger proxies for specific names
curl -s -H "X-API-Key: $EDGAR_KEY" \
  "https://api.edgarevents.com/filings?ticker=WBD,PARA,LYV&type=DEFM14A"

Push instead of poll: register a webhook and have matching events POSTed to you, each signed with HMAC-SHA256 in an X-Edgar-Signature: sha256=... header.

curl -s -X POST -H "X-API-Key: $EDGAR_KEY" -H "Content-Type: application/json" \
  -d '{"event_types":["8-K","activist_stake"],"material_only":true,"url":"https://your-app.com/hooks/edgar"}' \
  "https://api.edgarevents.com/webhooks"

import hmac, hashlib

def verify(secret: str, raw_body: bytes, header: str) -> bool:
    expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, header)

The short version

If you want a resolved 13D cover page pushed to a signed webhook the moment it lands, this is the only self-serve $29/mo feed that does it. sec-api.io resolves the fields but at a $49 floor and over a metadata WebSocket plus a second call. EdgarKit ($19) and FilingFirehose ($29) push fast and cheap but ship 13D as metadata, not resolved fields. Intrinio ($150) does not carry 13D. The free edgartools library resolves the fields and cannot push at all. The buy is the resolved-13D push and the item-coded 8-K, S-1 and M&A events that come with it.

Get a key at edgarevents.com. The interactive reference is at api.edgarevents.com/docs.

SEC filings, already parsed.

Typed JSON for 8-K item codes, SC 13D activist stakes, IPO forms and merger proxies. $29/mo, self-serve, cancel anytime.

Get an API key