# SEC EDGAR Filings Intelligence (`gloamy_hamster/sec-edgar-filings-intelligence`) Actor

Pull SEC EDGAR filings (10-K, 10-Q, 8-K, Form 4 insider trades, Form D funding rounds) straight from the official SEC data API, or full-text search across all EDGAR filings by keyword. No scraping, no blocks, always fresh.

- **URL**: https://apify.com/gloamy\_hamster/sec-edgar-filings-intelligence.md
- **Developed by:** [Alex Roitman](https://apify.com/gloamy_hamster) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SEC EDGAR Filings Intelligence

Get SEC filings — 10-K annual reports, 10-Q quarterlies, 8-K material events, Form 4 insider trades, Form D private funding rounds, S-1 IPO registrations, and more — straight from the **official SEC EDGAR data API**. No scraping, no browser, no CAPTCHAs, no blocks: this Actor talks directly to `data.sec.gov` and `efts.sec.gov`, the same public JSON API that SEC itself publishes for developers. That means it never breaks when SEC redesigns their website, and it fully complies with SEC's terms of use.

### What it does

Two modes, one Actor:

- **Lookup mode** — give it a list of companies (stock ticker, CIK, or company name) and it returns their recent filings, filtered by form type and date range, each with a direct link to the filing index and the primary document.
- **Search mode** — give it a keyword and it full-text searches across *every* filing on EDGAR (millions of documents), optionally restricted to specific form types and a date range. Great for finding every Form D that mentions a specific investor, product category, or competitor — a live feed of newly-funded companies.

### Who this is for

- **Investors & analysts** tracking insider buying/selling (Form 4) or new 10-K/10-Q releases for a watchlist of tickers.
- **Sales & lead-gen teams** monitoring Form D filings for newly-funded startups matching a keyword (e.g. "SaaS", "biotech", a specific investor name) — a fresh, low-competition source of outbound leads.
- **Researchers & journalists** who need structured access to specific filings without hand-navigating EDGAR's search UI.
- **Fintech / data products** that need a reliable, ToS-compliant filings feed to build on top of, without maintaining their own SEC scraper.

### Input

| Field | Description | Default |
|---|---|---|
| `mode` | `lookup` (by company) or `search` (full-text keyword) | `lookup` |
| `identifiers` | Tickers, CIKs, or company names (lookup mode) | `["AAPL", "TSLA", "NVDA"]` |
| `formTypes` | Form types to include, e.g. `10-K`, `10-Q`, `8-K`, `4`, `D`, `S-1`. Empty = all types | `["10-K","10-Q","8-K","4","D"]` |
| `keyword` | Full-text search phrase (search mode) | — |
| `dateFrom` / `dateTo` | `YYYY-MM-DD` filing-date bounds | none |
| `maxItemsPerCompany` | Cap per company in lookup mode | `20` |
| `maxItems` | Hard cap on total results for the run | `200` |
| `contactEmail` | **Required.** Your email, used only in the outgoing `User-Agent` header, as required by [SEC's fair-access policy](https://www.sec.gov/os/webmaster-faq#developers). Never stored or shared beyond that request. | — |

The default input runs out of the box (once you fill in `contactEmail`) and returns real filings for Apple, Tesla, and NVIDIA.

### Output example

```json
{
  "mode": "lookup",
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "formType": "4",
  "filingDate": "2026-09-17",
  "reportDate": "2026-09-15",
  "accessionNumber": "0001140361-26-037020",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126037020/0001140361-26-037020-index.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126037020/xslF345X06/form4.xml",
  "matchedIdentifier": "AAPL",
  "matchedBy": "ticker"
}
```

### Pricing

Pay-per-event:

- **Actor start** — flat fee per run.
- **Filing result** — small fee per filing returned (lookup or search mode).

No charge for companies that don't resolve, empty searches, or failed lookups — you only pay for filings actually delivered. See the Actor's Pricing tab for exact rates.

### FAQ

**Do I need a SEC API key?** No — SEC's EDGAR data API is free and keyless. You only need to provide your own contact email, which SEC requires in the User-Agent header of every request (this is SEC's rule, not ours — see their [developer FAQ](https://www.sec.gov/os/webmaster-faq#developers)).

**Why is this more reliable than a browser-based EDGAR scraper?** Because it doesn't scrape HTML at all — it calls the same JSON API SEC provides for machine access. There's nothing to break when EDGAR's front-end changes, and no risk of IP blocks or CAPTCHAs.

**Can I search filings from before 2001?** Full-text search only covers filings from 2001 onward (SEC's own limitation). Lookup mode returns each company's most recent filings as listed in their submissions history.

**Does this only cover annual/quarterly reports?** No — set `formTypes` to any SEC form: `10-K`/`10-Q`/`8-K` (reports), `4` (insider trades), `D` (private funding rounds / Reg D offerings), `S-1` (IPO registration), `13F` (institutional holdings), and more. Leave `formTypes` empty to get everything.

**Is this legal?** Yes. SEC EDGAR is public U.S. government data, explicitly published via a free API for third-party use. No login walls, no ToS prohibiting automated access to this API.

# Actor input Schema

## `mode` (type: `string`):

LOOKUP: get recent filings for specific companies (by ticker, CIK, or company name). SEARCH: full-text keyword search across all EDGAR filings (e.g. find every Form D that mentions a specific product or investor).

## `identifiers` (type: `array`):

Used in LOOKUP mode. Stock ticker (e.g. AAPL), 10-digit CIK (e.g. 0000320193), or company name (e.g. "Tesla"). Mixing types is fine.

## `formTypes` (type: `array`):

SEC form types to include, e.g. 10-K (annual report), 10-Q (quarterly), 8-K (material events), 4 (insider trade), D (private funding round/exempt offering), S-1 (IPO registration). Leave empty to include all form types.

## `keyword` (type: `string`):

Used in SEARCH mode. Phrase to search for across full text of EDGAR filings, e.g. "artificial intelligence" or a competitor/investor name.

## `dateFrom` (type: `string`):

Only include filings filed on or after this date. Leave empty for no lower bound.

## `dateTo` (type: `string`):

Only include filings filed on or before this date. Leave empty for no upper bound (today).

## `maxItemsPerCompany` (type: `integer`):

Cap on how many matching filings to return per company in LOOKUP mode.

## `maxItems` (type: `integer`):

Hard cap on total dataset items for this run, across all companies / search pages. Protects you from runaway charges.

## `contactEmail` (type: `string`):

Required by SEC's fair-access policy: every request to their API must send a real contact email in the User-Agent header (SEC does not store or publish it, and this Actor never sends it anywhere else). Example: you@company.com

## Actor input object example

```json
{
  "mode": "lookup",
  "identifiers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K",
    "4",
    "D"
  ],
  "keyword": "",
  "dateFrom": "",
  "dateTo": "",
  "maxItemsPerCompany": 20,
  "maxItems": 200,
  "contactEmail": ""
}
```

# Actor output Schema

## `results` (type: `string`):

All filings returned by the run, shown in the overview table.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gloamy_hamster/sec-edgar-filings-intelligence").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("gloamy_hamster/sec-edgar-filings-intelligence").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 '{}' |
apify call gloamy_hamster/sec-edgar-filings-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gloamy_hamster/sec-edgar-filings-intelligence"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/a8B034zI2BgOUfdsM/builds/n8yg2Z9At7Tsuq7yW/openapi.json