# SEC Filings API — Who Mentions What in EDGAR (`spool/sec-filings-api`) Actor Find which public companies name a product, vendor or competitor in their SEC filings, with the sentence around each mention as proof. - **URL**: https://apify.com/spool/sec-filings-api.md - **Developed by:** [Spool](https://apify.com/spool) (community) - **Categories:** Business, Lead generation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per event This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## SEC Filings API — Who Mentions What in EDGAR **Find every public company that names a product, vendor or competitor in its SEC filings — with the sentence around each mention, so you can see it's real.** ``` "Databricks" in 10-K filings → 110 filings across 49 companies Informatica INFA "pushdown optimization to AWS Redshift … Snowflake, Oracle and Databricks" Teradata TDC "Participants include AWS, Databricks, Google Cloud, Mic…" DOMO DOMO "Domo can sit on top of major cloud data platforms including … Databricks" Health Catalyst HCAT "Plan and schedule Databricks, Azure Data Factory…" ``` A company writing a name into an SEC filing is under legal obligation to be accurate. That makes it a stronger signal than a website scan or a job ad. *** ### Why the quotes matter more than the search Raw EDGAR search is a commodity — several libraries wrap it. The hard part is that a keyword hit means almost nothing on its own. Search `Snowflake` and you get **Arizona Public Service** and **Hormel Foods**, because Snowflake is also a town in Arizona. Search `Databricks` and you get a pharmaceutical holding company — which turns out to hold it as a **fund investment**, not use it. A list containing those rows is worse than no list, because the reader can't tell which are real without opening every filing themselves. So this reads the filing and returns the surrounding sentence: | Without context | With context | |---|---| | `Dominari Holdings — match` | *"Investment in Aeon Partners Fund Series DB (Databricks, Inc.)"* → an investor | | `Teradata — match` | *"Participants include AWS, Databricks…"* → a competitor naming them | | `DOMO — match` | *"Domo can sit on top of … Databricks"* → an integration | Three identical hits. Three completely different relationships. Only the words around them tell you which — so the Actor reads them and tells you. *** ### It tells you what kind of relationship it is Every company gets a `relationship`, read from the sentence around the mention: | Label | The filing is saying | |---|---| | `user` | it uses or runs the thing — *"we migrated our warehouse to Snowflake"* | | `partner` | an integration — *"we work with AWS, Snowflake, Databricks"* | | `competitor` | competition — *"participants include AWS, Databricks…"* | | `customer_of_ours` | it is one of **their** customers | | `investor` | it holds equity or debt — *"1st Lien Delayed Draw Term Loan"* | | `acquisition` | an acquisition or merger | | `vendor` | named as a supplier | | `mentioned` | named, but the sentence does not say how | | `place` | a town of the same name, not the thing at all | Searching **Databricks** across 10-K filings, 20 companies come back as: ``` investor 10 credit funds holding Databricks debt partner 8 Alteryx, Informatica, DOMO, Talend, C3.ai, Health Catalyst… competitor 1 Teradata, naming them in risk factors mentioned 1 an advisor bio ``` Set `relationships` to keep only the ones you want. `["user", "partner"]` is a sales list; `["competitor"]` is competitive research; `["investor"]` is a cap-table map. Same search, three different products. *** ### Quick start ```json { "terms": ["Snowflake"], "forms": ["10-K"], "verifyContext": true } ``` That's it. Everything else has sensible defaults. *** ### What you get back ```json { "term": "Databricks", "company": "Informatica Inc.", "ticker": "INFA", "cik": "0001868778", "industry": "Prepackaged software", "location": "Redwood City, CA", "state": "CA", "incorporatedIn": "DE", "filingCount": 4, "formTypes": ["10-K"], "firstFiledAt": "2022-03-24", "lastFiledAt": "2025-02-25", "mentionCount": 6, "contextVerified": true, "mentions": [ "…third party compute platforms leveraging advanced pushdown optimization to AWS Redshift, Microsoft Azure Synapse, Google Cloud Big Query, Snowflake, Oracle and Databricks…" ], "filings": [ { "form": "10-K", "filedAt": "2025-02-25", "documentUrl": "…", "filingPage": "…" } ] } ``` `mentionCount` is the count inside the most recent filing. A company naming a vendor **once** in a 300-page annual report is a different signal from one naming it **forty times** — `minMentions` lets you draw that line yourself. Four dataset views ship with it: **Overview**, **Evidence**, **Filings** and **Failures**. *** ### Recipes — copy, paste, run **Companies that actually use or integrate with a product — a sales list** ```json { "terms": ["Snowflake"], "forms": ["10-K"], "relationships": ["user", "partner"], "excludePlaceNames": true } ``` **Who is funding a private company — equity and debt holders** ```json { "terms": ["Databricks"], "relationships": ["investor"] } ``` **Who names your competitor in their annual report** ```json { "terms": ["Datadog"], "forms": ["10-K"], "relationships": ["competitor"] } ``` **Which software companies mention a data platform — a partner list** ```json { "terms": ["Snowflake", "Databricks"], "forms": ["10-K"], "industries": ["Prepackaged software", "Computer services"], "minMentions": 2 } ``` **Who started talking about a theme this year** ```json { "terms": ["generative AI", "AI agents"], "forms": ["10-K", "10-Q"], "dateFrom": "2026-01-01" } ``` **Material events naming a vendor — the fastest signal there is** ```json { "terms": ["Palantir"], "forms": ["8-K"], "dateFrom": "2026-01-01" } ``` *** ### Every option | Option | Default | What it does | |---|---|---| | **`terms`** | — | **Required.** Exact phrases to find. Each searched separately | | `forms` | *(all)* | `10-K`, `10-Q`, `8-K`, `S-1`, `DEF 14A`, `20-F`, `13F-HR`, `4`, `SC 13D/G` | | `dateFrom` / `dateTo` | — | `YYYY-MM-DD`. EDGAR full-text covers **2001 onward** | | **`verifyContext`** | `true` | **Read the filing and quote the mention.** The whole point | | `maxSnippets` | `3` | Quotes returned per company | | `minMentions` | `1` | Evidence threshold inside the filing | | `excludeSelfMentions` | `true` | Drop the company that shares the name — never a lead | | **`relationships`** | *(all)* | **Keep only `user`, `partner`, `competitor`, `investor`…** The filter that makes it a lead list | | `excludePlaceNames` | `false` | Drop matches that are a town of the same name | | `maxCompaniesPerTerm` | `50` | Cap per term, most-filings-first | | `industries` | *(all)* | From the SEC's own SIC classification | | `states` | *(all)* | Two-letter state of the business address | | `userAgentContact` | — | Your email. **The SEC requires it** — see below | *** ### What it covers, honestly **EDGAR full-text search covers filings from 2001 onward.** Anything older is outside the index — that's the SEC's boundary, not this Actor's. **Paging stops at 10,000 hits per query.** A very common phrase will hit that ceiling; narrow the date range to get underneath it. **`mentionCount` reflects the most recent filing only**, not every filing the company has ever made. `filingCount` tells you how many filings matched. **Relationship labels are read from language, not certainty.** Filings use conventional phrasing for each kind of relationship, which is what makes this work — but a company writing something unusual will land in `mentioned`, and the quotes are always returned so you can judge for yourself. On a Databricks search, 19 of 20 companies get a specific label; the twentieth is an advisor bio that genuinely fits no category. **Phrase, not fuzzy.** `Palo Alto Networks` matches that phrase, not every filing containing "networks". It also won't catch misspellings or a company referring to a product by a different name. **The SEC requires identification.** Every request carries a `User-Agent` with a contact address, which is their stated condition of access. Requests are rate-limited to 8/second, below their published 10/second ceiling. Put your own email in `userAgentContact`. **This is public government data.** EDGAR is published by the SEC for exactly this purpose, and `robots.txt` permits it. *** ### When something fails | `error` | Meaning | |---|---| | `no_filings_found` | No filing contains that phrase in the range and form types given | | `document_unavailable` | The filing is indexed but its document couldn't be fetched. The company is still returned, with `contextVerified: false` | | `rate_limited` | The SEC throttled the request | | `network_error` | Timeout or connection failure | A breakdown is saved to the key-value store as `RUN_SUMMARY`. *** ### FAQ **How is this different from just searching EDGAR myself?** EDGAR's own search returns filings, not companies, and gives you no context. It also can't exclude the company that shares the name, filter by industry, count mentions, or check whether a hit is genuine. This groups by company, quotes the evidence, and lets you filter on it. **Can I find who uses a particular software vendor?** For **public** companies, yes — filings name vendors, platforms and integration partners. Private companies don't file with the SEC, so they never appear. **Why did I get a company that has nothing to do with my search?** Because a word can mean two things. That's exactly why the quotes are returned — read the sentence and you'll see immediately. Raise `minMentions` to cut most of it automatically. **Does it cover insider trading or institutional holdings?** Yes — set `forms` to `4` for insider transactions or `13F-HR` for institutional holdings. Those are filings like any other and are full-text searchable. **Is this legal?** EDGAR is a public database published by the US Securities and Exchange Commission for public use. This follows their access rules: identified User-Agent, rate limited below their ceiling, `robots.txt` respected. *** ### Support Open an issue on the **Issues** tab and you'll get a reply, usually the same day. Requests for extra fields or form types are welcome — tell me what you need. # Actor input Schema ## `terms` (type: `array`): The exact phrase to find in SEC filings. Each term is searched separately. • A vendor — `Snowflake`, `Databricks`, `Salesforce` • A competitor — `Palantir`, `Datadog` • A risk or theme — `generative AI`, `supply chain disruption`, `cybersecurity incident` • A person or fund — `BlackRock`, `Elliott Management` Each is searched as a **phrase**, so `Palo Alto Networks` matches that name and not every filing containing the word "networks". ## `forms` (type: `array`): Leave empty to search every filing type. The common ones: • **10-K** — annual report, the richest source of vendor and risk mentions • **10-Q** — quarterly • **8-K** — material events, the fastest signal • **S-1** — IPO registration • **DEF 14A** — proxy statement, executive pay and governance • **13F-HR** — institutional holdings • **4** — insider transactions ## `dateFrom` (type: `string`): `YYYY-MM-DD`. EDGAR full-text search covers filings from **2001 onward**. Narrowing the range is also how you get past the 10,000-hit paging ceiling on a very common term. ## `dateTo` (type: `string`): `YYYY-MM-DD`. Leave empty for today. ## `verifyContext` (type: `boolean`): **This is the difference between a lead list and a keyword dump.** On by default. A search hit for `Snowflake` also matches Arizona Public Service and Hormel Foods — because Snowflake is a town in Arizona. With this on, the filing is fetched and the sentence around each mention is returned, so you can see whether it says *"migrated our warehouse to Snowflake"* or *"our facility in Snowflake, Arizona"*. It costs one extra request per company, so a large scan is slower with it on. ## `maxSnippets` (type: `integer`): How many surrounding-sentence quotes to return per company. Three is usually enough to judge whether a mention is genuine. ## `minMentions` (type: `integer`): A company that names a vendor once in a 300-page annual report is different from one that names it forty times. Raise this to keep only substantive mentions. Only applies when the filing is actually read, above. ## `excludeSelfMentions` (type: `boolean`): Searching for a vendor returns that vendor's own filings first, and they are never a sales lead. On by default. ## `excludePlaceNames` (type: `boolean`): Some product names are also towns. Searching **Snowflake** returns a paper mill in Snowflake, Arizona and a solar farm of the same name. With this on, a company is dropped when *every* quoted mention looks like a place — followed by a state, or sitting among words like mill, county or solar. Off by default, because it is a heuristic. Left off, those rows still arrive but carry `likelyPlaceName: true` and a `placeNameMentions` count, so you can filter them yourself. ## `relationships` (type: `array`): Leave empty to keep every match. This is what turns a mention list into a lead list — read from the words around each mention. • **user** — the filer says it uses or runs the thing • **partner** — an integration or partnership • **competitor** — the filer names it as competition • **customer\_of\_ours** — the filer names it as one of *their* customers • **investor** — the filer holds it as an investment • **acquisition** — an acquisition or merger • **vendor** — named as a supplier or third-party provider • **mentioned** — named, but the sentence does not say how • **place** — a town or facility of the same name Each company gets the most specific label its quotes support. ## `maxCompaniesPerTerm` (type: `integer`): Cap on companies returned for each search term, most-filings-first. Start at 50 to see the shape of the results, then raise it. ## `industries` (type: `array`): Leave empty for all. Derived from the SEC's own SIC classification on each filer. ## `states` (type: `array`): Two-letter state codes of the filer's business address, e.g. `CA`, `NY`, `TX`. Leave empty for everywhere. ## `userAgentContact` (type: `string`): The SEC requires every automated request to identify its sender, and blocks callers that do not. This address goes in the `User-Agent` header on requests to sec.gov and nowhere else. Put your own in — it is a condition of their access policy, not an optional courtesy. ## Actor input object example ```json { "terms": [ "Snowflake", "Databricks" ], "forms": [], "verifyContext": true, "maxSnippets": 3, "minMentions": 1, "excludeSelfMentions": true, "excludePlaceNames": false, "relationships": [], "maxCompaniesPerTerm": 50, "industries": [], "states": [], "userAgentContact": "medboufnouz@gmail.com" } ``` # Actor output Schema ## `companies` (type: `string`): Every company found, with filings, mention counts and quoted context. ## `leadList` (type: `string`): Just the identifying columns — company, ticker, industry and location. ## `evidence` (type: `string`): The quoted sentences behind each match, for checking a mention is genuine. ## `runSummary` (type: `string`): Companies returned, self-mentions excluded, and any errors by type. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "terms": [ "Snowflake", "Databricks" ] }; // Run the Actor and wait for it to finish const run = await client.actor("spool/sec-filings-api").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "terms": [ "Snowflake", "Databricks", ] } # Run the Actor and wait for it to finish run = client.actor("spool/sec-filings-api").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "terms": [ "Snowflake", "Databricks" ] }' | apify call spool/sec-filings-api --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,spool/sec-filings-api" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/fLcAniuR1D1DOfd1w/builds/5ZMuitgvdRchPIeSr/openapi.json