SEC Filing Monitor API

Monitor new SEC filings on EDGAR by company (ticker or CIK), form type (8-K, 10-K, 10-Q, Form 4, S-1, 13F...), or full-text keyword. Each filing comes back as one clean JSON record with links to the filing index and document on sec.gov. No API key, no login, no scraping fragility: the data comes straight from the SEC's official public APIs.

This is a managed monitor, not a one-shot scraper: name the monitor, put it on a schedule, and every run returns only filings it has not delivered before. Runs that find nothing new cost nothing. Output is a stable, documented schema, easy to wire into alerts, dashboards, compliance workflows, and AI agents (MCP-friendly).

What data does this SEC filing monitor return?

One dataset item per filing:

• Accession number (EDGAR's stable unique filing ID)
• Company name, ticker, and CIK
• Form type as filed (8-K, 10-K/A, 4, S-1, ...) and 8-K item codes
• Filing date, period of report, and the exact EDGAR acceptance timestamp (watchlist runs)
• Document description
• Link to the filing index page and direct link to the document
• asOf fetch timestamp

How to monitor SEC filings

1. Enter Tickers (e.g. AAPL) and/or CIK numbers for filers without a ticker (funds, insiders, private filers).
2. Optionally restrict Form types (e.g. 8-K, 10-Q). A base form also matches its amendments (8-K matches 8-K/A).
3. Set a Monitor name and schedule the actor. The first run establishes a baseline; every later run returns only new filings, automatically.
4. Results land in the dataset as JSON, CSV, or Excel; wire a webhook or a Slack/email integration to the run for alerts.

Instead of (or alongside) a watchlist, you can set a Full-text query to search the text of filings across all filers, e.g. "material weakness", "going concern", or a competitor's product name. Quotes make it an exact phrase. With a watchlist set, the query searches only those companies.

Input

Field	Type	Default	Notes
tickers	array	none	Stock tickers, resolved to CIKs via EDGAR's official company list.
ciks	array	none	SEC CIK numbers, padded or not. At least one of tickers/ciks/query.
forms	array	all forms	Form-type filter, e.g. ["8-K", "4"].
query	string	none	EDGAR full-text search (2001+). Quote for exact phrase.
monitorName	string	none	Enables managed monitoring, see below.
sinceDate	string	none	Manual stateless cursor (not needed with monitorName).
sinceAccession	string	none	Manual cursor for single-company monitors.
maxRecords	integer	100	Safety cap per company (or per query), max 1000.
proxyConfiguration	object	Apify Proxy on	Spreads requests across IPs against SEC's fair-access rate limit.

Managed monitoring: set a name, schedule it, done

Set monitorName (e.g. "my-8k-watchlist") and the actor keeps its own delivery state in a small key-value store in your Apify account. Every scheduled run returns each filing exactly once:

• First run with a new name: returns the current baseline (up to maxRecords per company).
• Every later run: only filings not delivered before. Nothing new = empty run = no charge.
• Changing query or forms resets the baseline (the state is per configuration); adding or removing companies does not.

No cursor management, no state of your own. This works for both the watchlist and full-text routes.

Stateless alternative: if you prefer to hold the cursor yourself (e.g. in your own pipeline), skip monitorName and pass sinceDate instead. A date (2026-07-01) returns filings filed on or after that day; a datetime (2026-07-01T12:00:00Z) returns watchlist filings accepted strictly after that instant, using EDGAR's own acceptance timestamps: feed the newest acceptanceDateTime from each run back in. For a single company, sinceAccession (the newest accessionNumber seen) does the same job.

Output example

{
	"accessionNumber": "0001193125-26-258667",
	"cik": "789019",
	"companyName": "MICROSOFT CORP",
	"ticker": "MSFT",
	"form": "8-K",
	"filingDate": "2026-06-05",
	"reportDate": "2026-06-02",
	"acceptanceDateTime": "2026-06-05T14:36:56.000Z",
	"items": ["5.02"],
	"description": "8-K",
	"filingUrl": "https://www.sec.gov/Archives/edgar/data/789019/000119312526258667/0001193125-26-258667-index.htm",
	"primaryDocUrl": "https://www.sec.gov/Archives/edgar/data/789019/000119312526258667/d26760d8k.htm",
	"source": "sec-edgar",
	"asOf": "2026-07-12T08:04:23.447Z"
}

Every field is always present; missing data is null, never an absent key. New fields may be added in future versions; existing fields will not change shape.

Who is this for?

Finance and investor-relations teams watching 8-Ks and ownership filings, legal and compliance teams tracking specific disclosure language, competitive-intelligence analysts watching S-1s and M&A activity, researchers and journalists screening filings by phrase, and AI agents that need SEC filings as clean, stable JSON instead of EDGAR HTML.

How much does it cost to monitor SEC filings?

Pay per event: you are charged per filing returned, nothing else. No subscription, no charge for empty runs. At $5 per 1,000 filings:

• 10 filings (one company's quarter, roughly) = $0.05
• 100 filings (a baseline run on a few companies) = $0.50
• 1,000 filings (a large backfill) = $5.00
• A daily 8-K monitor on five tickers delivering ~1-2 filings a day lands around $0.20-0.30 per month.

maxRecords caps the worst case per company, and Apify's per-run charge limit is respected: the actor stops fetching rather than exceed it.

Using it from code and agents

Python:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("virtual-constructs/sec-filing-monitor").call(run_input={
    "tickers": ["AAPL", "MSFT"],
    "forms": ["8-K"],
    "monitorName": "my-8k-watchlist",
})
for filing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(filing["filingDate"], filing["ticker"], filing["form"], filing["filingUrl"])

JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('virtual-constructs/sec-filing-monitor').call({
	tickers: ['AAPL', 'MSFT'],
	forms: ['8-K'],
	monitorName: 'my-8k-watchlist',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

AI agents can call this actor as an MCP tool via Apify's MCP server (mcp.apify.com). The input and output schemas are stable and fully documented, so a tool call like "return new 8-K filings for these tickers" works without the agent knowing anything about EDGAR's APIs.

Limits, stated plainly

• The data source is the SEC's own free public API. You could call EDGAR yourself. What you are paying for is the monitor: managed delivery state, the incremental contract, ticker resolution, form filtering, pagination, rate-limit etiquette, normalization across EDGAR's two differently-shaped APIs, and a stable schema on a scheduler, not access to the data.
• Metadata and links, not filing bodies. This actor tells you a filing exists and links to it. It does not parse financial statements, XBRL, or document text into fields. That is a deliberate, separate scope.
• Watchlist depth is EDGAR's "recent" window (roughly the last 1,000 filings per company; years of history for most filers, less for very frequent ones). Full-text search covers 2001 onward.
• Freshness: data is as of the asOf timestamp in each record. EDGAR publishes filings within minutes of acceptance, but this is a poll on your schedule, not a push feed, and SEC fair-access limits mean it is not built for sub-minute latency.
• Tickers are EDGAR's mapping. Filers without a listed ticker (funds, insiders, most private companies) come back with ticker: null; watch them by CIK.

FAQ

Why not just use the free EDGAR API directly? For a one-off pull you should; it is free and this actor will not pretend otherwise. The paid value is everything around the call: exactly-once delivery state on a schedule, cursor and pagination handling, EDGAR's per-document search hits deduplicated to filings, ticker-to-CIK resolution, two differently-shaped APIs normalized to one stable schema, fair-access rate etiquette, and a tool an agent or a no-code schedule can use directly.

Do I need an SEC or EDGAR API key? No. EDGAR's APIs are public. The actor identifies itself to the SEC with a proper User-Agent, as SEC fair-access rules require.

Why did I get fewer filings than expected? The usual reasons: a monitor or cursor already delivered them (only NEW filings return), the forms filter excludes them, the full-text index only covers 2001+, or the run hit maxRecords (raise it; undelivered filings are caught up on the next run).

What happens if a run would exceed my spending limit? The actor checks your per-run charge limit before pushing and stops fetching when the budget is exhausted, cleanly. Filings it could not deliver remain undelivered and return on the next run.

Can I monitor insider trades (Form 4)? Yes: put the company's ticker or CIK in the watchlist and set forms to ["4"]. You get one record per Form 4 with a direct document link. Parsing the trade details out of the form body is out of scope for this actor.

Can I watch for a phrase across all companies? Yes, that is the full-text query route: e.g. "cybersecurity incident" with forms: ["8-K"] returns every 8-K mentioning the phrase, and with a monitorName only the new ones each run.

How fresh is the data? EDGAR updates through the day; filings usually appear within minutes of acceptance. A scheduled run picks up whatever is new since the last delivery.

Can I export to CSV or Excel? Yes. The dataset exports as CSV, Excel, JSON, NDJSON, or XML.

Is this legal? Yes. EDGAR is US-government public data, published for exactly this use, via the SEC's official APIs, within their fair-access rate limits.