DEV Community: Forecite

Which SEC Filings Actually Move Stock Prices — and How to Get the 8-Ks That Matter in Real Time

Forecite — Mon, 24 Aug 2026 20:09:44 +0000

A practical ranking of SEC filing types by short-term price impact, and how to get 8-K filing alerts in real time, scored for actionability instead of raw EDGAR noise.

The SEC receives thousands of filings on a normal trading day. A small fraction of them precede a meaningful price move within the next hour. The rest are routine filings such as prospectus supplements and ownership housekeeping, or amendments that restate what the market already knew. If you want to know which SEC filings move stock prices, the useful answer has two parts: a ranking by filing type, and a warning that the type alone is a weak filter, because the highest-impact form is also the noisiest one.

Filing types ranked by short-term price impact

A rough ordering, from most likely to move a stock in the near term to least:

8-K (current reports). This is where material events appear first: earnings results under Item 2.02, entry into or termination of material agreements under Item 1.01, executive departures under Item 5.02, bankruptcy under Item 1.03, delisting notices, impairments. When a stock gaps on news, an 8-K is very often the source document.

Schedule 13D and amendments. A 13D discloses that someone has crossed 5% ownership with activist intent. New 13Ds from known activists routinely reprice a stock within minutes. Schedule 13G, the passive equivalent, matters far less.

Form 4 (insider transactions). Open-market purchases by a CEO or a cluster of officers can move a small-cap. Routine option exercises and scheduled 10b5-1 sales generally do nothing.

S-1s, S-3s, and 424B prospectuses. These signal dilution or an upcoming offering. The reaction is usually negative and often fast, especially for smaller issuers.

10-K and 10-Q (annual and quarterly reports). The headline numbers are typically pre-announced in an 8-K, so the periodic report itself moves prices less than people expect. The exceptions are in the text itself: going-concern language, newly disclosed litigation, and changes to the risk factors.

Amendments, 13F holdings reports, and administrative filings. 13Fs arrive up to 45 days after quarter end. A 10-Q/A correcting a typo is noise. This bottom tier makes up much of EDGAR's daily volume.

The complication is that the ranking holds only on average. Most 8-Ks are Item 7.01 or 8.01 disclosures, press-release attachments, and other boilerplate filings that no one trades on. The form type with nearly all of the short-horizon signal also produces the most non-events, so an alert on every 8-K will quickly train you to ignore your own alerts.

Problems with polling EDGAR directly

The obvious build is to poll EDGAR's public feeds and push everything matching your watchlist. Teams that try this hit the same problems. Polling intervals add latency on top of dissemination time, and by the time your parser has fetched the document, extracted the item codes, and run whatever filtering logic you wrote, faster participants have already read the filing. Then there is classification. An Item 1.01 tag indicates that a material agreement exists, but not whether it is a transformative licensing deal or a routine credit-facility extension. You end up writing keyword rules, and those rules stop working well over time.

A SEC EDGAR real-time API fixes the delivery mechanics but does not decide which filings matter. You still receive a hundred 8-Ks to find the one worth acting on.

Forecite addresses both problems. The feed ingests directly from sources (SEC EDGAR, wire services, exchanges, central banks) with no aggregator in the middle, one hop from the publisher, processing 180,000+ items weekly. Each event reaches subscribers with a scored verdict in under 50 milliseconds from publication. The company publishes per-event latency telemetry and a 99.97% trailing uptime figure, which makes the sub-50 ms claim verifiable.

How actionability scoring works

The scoring layer is the Verdict Engine, a single-pass NLP model trained on 1.2M+ labeled headlines. The training labels come from what the market actually did: scores are calibrated to the realized 1-hour return following each event, and the model retrains weekly. Forecite describes this as headlines "labelled by the market, not by humans," which is the practical difference from generic sentiment tools. A generic model reads "material definitive agreement" and scores the language. A market-calibrated model has seen thousands of Item 1.01 filings and learned which phrasings, contexts, and issuers historically preceded a real move.

Every event gets two numbers. Actionability runs from 0 to 1 and estimates whether the event is worth reacting to at all. The combined verdict runs from −1.0 to +1.0 and adds direction. In practice, this collapses the filing-type ranking above into a single filter: rather than subscribing to specific form types, you subscribe to a ticker universe and set an actionability threshold. A boilerplate Item 7.01 filing scores low and is filtered out before it reaches you. An Item 2.02 with a guidance cut scores high and arrives while the market is still reading it.

Getting 8-K filing alerts in real time

Delivery depends on how you trade. The WebSocket stream fits desks and bots that maintain a persistent connection. Webhooks push high-actionability events into whatever you already run, from an execution system to a Slack channel. REST covers queries and search across the scored corpus. SDKs exist for Python, Node.js/TypeScript, and Rust, and there is an MCP server (@forecite/mcp) so AI agents can consume scored filings as a native tool without custom integration work.

A minimal setup for filings alerting looks like this: subscribe to your tickers over WebSocket, filter for events sourced from EDGAR, and act only above your actionability cutoff. The Starter tier at $39/month includes the scored realtime feed with 5,000 feeds per day, which covers a focused watchlist. Pro at $119/month removes the feed cap and extends the historical API to 30 days for active desks. Quant at $399/month adds unlimited API keys, a 1-year historical API, and 1,000 daily artifact-scoring requests for systematic teams.

Validating the signal before you trade it

A scored feed should be tested before you rely on it. Most alerting products make this difficult, because the alerts were never stored in a form you can backtest. Forecite provides historical backfill and deterministic replay: the same event stream, with the scores as they existed at the time, in a form the company calls point-in-time honest. You can replay the last year of scored 8-Ks against your strategy and measure what an actionability threshold of 0.7 versus 0.5 would have done to your hit rate.

There is also a public benchmark. Forecite runs a live desk of three real-money Alpaca accounts trading US equities, where an autonomous bot uses one decision input: the Forecite feed. Equity curves have run since January 1, 2026, so the track record is short, and the standard caveat applies (past performance is not indicative of future results). Still, publishing a real-money bot is more accountability than most signal vendors offer.

Start with the feed

The Free tier costs $0, requires no card, and includes the unscored realtime feed with 50 feeds per day, which is enough to watch EDGAR events arrive in real time before you commit to scoring. When you are ready to see which of those filings the market would actually trade, upgrade to a scored tier and set your first actionability threshold. Create a free Forecite API key and point it at your watchlist.

Building a WebSocket Market News Consumer in Python: From First Event to Threshold-Gated Signals

Forecite — Mon, 24 Aug 2026 19:51:23 +0000

Building a WebSocket Market News Consumer in Python: From First Event to Threshold-Gated Signals

Subscribe to Forecite's scored WebSocket market news feed in Python, survive disconnects, and gate events into a clean signal queue.

If you're building a trading bot, raw headlines are a liability. What you want from a websocket market news feed is not more events — it's fewer, scored ones, arriving fast enough to act on. Forecite delivers exactly that: 180,000+ news items a week ingested one hop from the publisher (SEC EDGAR, wire services, exchanges, central banks, macro releases), each scored by the Verdict Engine and pushed to subscribers in under 50 milliseconds.

This tutorial walks through a production-shaped consumer using the Python SDK: first event on screen, then reconnects, backpressure, threshold gating into a signal queue, and REST catch-up so a dropped connection doesn't become a blind spot.

What you're consuming

Every event on the feed carries two numbers you'll build your logic around:

Actionability (0 to 1): how likely this headline is to move price in the short term. This is the noise filter — boilerplate filings score low.
Verdict (−1.0 to +1.0): combined directional score, calibrated to realized 1-hour return. Headlines are labelled by the market, not by humans, and the model retrains weekly.

That calibration detail matters for bot builders: you're not filtering on whether language sounds positive, you're filtering on what historically moved price. Generic sentiment models score language; this scores market reaction.

Setup and first event

Install the Python SDK and export your API key. The Free tier needs no card and gives you the unscored realtime feed to test connectivity; you'll want Starter or above for scored events.

pip install forecite

The minimal consumer is a few lines:

import asyncio
from forecite import ForeciteClient

client = ForeciteClient(api_key="fc_live_...")

async def main():
    async for event in client.stream():
        print(
            f"{event.published_at} "
            f"act={event.actionability:.2f} "
            f"verdict={event.verdict:+.2f} "
            f"{event.headline}"
        )

asyncio.run(main())

Run it during US market hours and events arrive continuously. Note the timestamps: Forecite publishes per-event latency telemetry, so you can measure publication-to-you delay yourself rather than taking "sub-50 ms" on faith.

Reconnects: assume the socket will die

Any long-lived WebSocket connection will drop — deploys, network blips, laptop sleep. The consumer's job is to reconnect with backoff and remember where it left off, because the gap is where you miss the thing.

Wrap the stream in a supervisor loop:

import asyncio
import logging

log = logging.getLogger("consumer")

async def run_forever(client, handler):
    backoff = 1
    last_event_id = None

    while True:
        try:
            async for event in client.stream():
                last_event_id = event.id
                backoff = 1  # healthy connection resets backoff
                await handler(event)
        except ConnectionError as exc:
            log.warning("stream dropped: %s — reconnecting in %ss", exc, backoff)
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, 30)
            if last_event_id:
                await catch_up(client, since_id=last_event_id, handler=handler)

Two deliberate choices here. Backoff is capped at 30 seconds — on a feed where latency is the edge, minutes-long backoff defeats the purpose. And we record the last event ID before handling, so the catch-up call (below) can close the gap exactly.

Catch-up over REST

Forecite exposes the same scored corpus over REST, which turns "we were disconnected for 40 seconds" from an unknown into a bounded query:

async def catch_up(client, since_id, handler):
    missed = await client.history(since_id=since_id)
    log.info("replaying %d missed events", len(missed))
    for event in missed:
        await handler(event)

How far back you can reach depends on tier: Starter covers a 48-hour historical window, Pro 30 days, Quant a full year. For gap-filling after a disconnect, even the Starter window is far more than you'll ever need; the longer windows matter when you graduate to backtesting, where the same historical API supports deterministic replay — point-in-time honest data, so your backtest sees exactly what the feed would have shown at that moment.

If your infrastructure can't hold a socket open at all (serverless, restrictive networks), the platform also delivers over webhooks — same scored events, pushed to an HTTPS endpoint you control. A reasonable production posture is WebSocket as primary and a webhook endpoint as an independent fallback path writing into the same queue, deduplicated by event ID.

Backpressure and the signal queue

The Verdict Engine sustains thousands of verdicts per second at peak (the platform quotes 6.4k/second throughput). Your strategy code almost certainly can't — and shouldn't — process every event synchronously in the stream handler. If your handler blocks, you stall the socket read loop and your "real-time" feed quietly becomes a delayed one.

The fix is the standard producer–consumer split, with the threshold gate applied at the cheapest possible point — before the queue:

import asyncio

ACTIONABILITY_FLOOR = 0.7   # tune against your strategy's backtest
QUEUE_MAX = 1000

signal_queue: asyncio.Queue = asyncio.Queue(maxsize=QUEUE_MAX)

async def gate(event):
    """Fast path: score check only. Never block here."""
    if event.actionability < ACTIONABILITY_FLOOR:
        return  # boilerplate filings and low-impact noise die here
    try:
        signal_queue.put_nowait(event)
    except asyncio.QueueFull:
        # Explicit policy beats silent stalling. Here: drop oldest.
        _ = signal_queue.get_nowait()
        signal_queue.put_nowait(event)
        log.warning("queue full — dropped oldest signal")

async def strategy_worker():
    while True:
        event = await signal_queue.get()
        if abs(event.verdict) >= 0.5:
            await place_or_adjust(event)   # your execution logic
        signal_queue.task_done()

Three patterns worth stealing even if you change everything else:

Gate on actionability first, direction second. Actionability answers "is this worth compute at all?" — it's your volume filter. The verdict's sign and magnitude answer "which way, and how confidently?" Keeping the checks separate makes each threshold independently tunable.

Make the overflow policy explicit. A bounded queue with drop-oldest means that during an event storm — a Fed release, a cluster of filings — your bot acts on the freshest signals rather than working through a stale backlog. For news-driven strategies, a 90-second-old headline is usually worth less than the one that just landed. If your strategy disagrees, choose drop-newest or block — but choose.

Keep the socket loop non-blocking. The gate coroutine does one comparison and one queue operation. Everything slow — order placement, position checks, logging to disk — lives in the worker.

Wiring it together

async def main():
    client = ForeciteClient(api_key="fc_live_...")
    await asyncio.gather(
        run_forever(client, handler=gate),
        strategy_worker(),
    )

asyncio.run(main())

That's the whole skeleton: a supervised stream feeding a bounded queue through a score gate, with REST catch-up sealing the gaps. From here, the natural next steps are tuning your actionability floor against the historical API (Quant's 1-year window and deterministic replay exist for exactly this), and — if you're building AI agents rather than classic bots — pointing them at the @forecite/mcp server so they consume scored events natively.

One honest caveat: nothing above is investment advice, and a scored feed doesn't make a strategy — it makes the input to one trustworthy. Forecite is confident enough in that input to run a public live desk: three real-money accounts trading US equities with one decision input, the Forecite feed. Past performance is not indicative of future results, but the telemetry is there to inspect.

Start streaming

The Free tier takes no card and gets you connected to the realtime feed today; Starter ($39/month, billed annually) adds the scored feed and the 48-hour historical API this tutorial leans on. Grab an API key, run the twenty-line consumer above, and see what a Python SDK for financial news looks like when the headlines arrive already judged — signal, not volume.