# SEC EDGAR Filing Monitor (`mooseandraven/sec-edgar-filing-monitor`) Actor

Monitors SEC EDGAR for new company filings (10-K/10-Q/8-K/Form 4) and full-text search matches, via the official data.sec.gov and efts.sec.gov APIs — no API key, no account, no scraping.

- **URL**: https://apify.com/mooseandraven/sec-edgar-filing-monitor.md
- **Developed by:** [Moose & Raven](https://apify.com/mooseandraven) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 filing records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 EDGAR Filing Monitor

Monitors SEC EDGAR for new company filings (10-K, 10-Q, 8-K, Form 4 insider transactions, or any
other form type) and full-text search matches, via the official `data.sec.gov` and `efts.sec.gov`
APIs — no API key, no account, no scraping. Optional incremental monitor mode tracks new filings
across scheduled runs.

### What makes this different

**Zero account friction.** SEC EDGAR requires no API key and no account at all — the only
requirement is a descriptive `User-Agent` header identifying the requester, which SEC's own
fair-access policy publishes and this actor sends on every request (`Moose and Raven
support@mooseandraven.com`). SEC EDGAR is the canonical, industry-relied-upon source for U.S.
public company filings, with a strong operational track record.

**Bundles what's normally scattered across separate tools**: company filings (10-K/10-Q/8-K),
insider Form 4 transactions, and full-text search across all of EDGAR, in one actor with
incremental new-filing monitoring for scheduled runs.

### How it works

- **No API key needed.** Nothing to register, nothing to configure beyond `companies`.
- Supply `companies` as ticker symbols (e.g. `"AAPL"`) or raw numeric CIKs — tickers are resolved
  via SEC's own official ticker-to-CIK mapping file. A ticker/CIK that doesn't resolve is reported
  as an explicit `company-not-found` record, never silently skipped.
- Choose which `formTypes` to watch (default: `10-K`, `10-Q`, `8-K`, `4`) or leave empty for every
  filing type on record.
- Optional `fullTextSearchQuery` runs a one-shot keyword search across EDGAR's full-text search
  index (all companies, not just the ones being watched), optionally restricted by
  `fullTextSearchForms`. Automatically paginates up to `maxSearchResults` (default 1,000). If
  EDGAR's real total exceeds that cap, an explicit `search-truncated` record surfaces the true
  total — a capped search is never reported as if it were exhaustive.
- Optional **incremental monitor mode**: remembers which filings it has already delivered per
  company (by accession number, via Apify key-value store) and only reports genuinely NEW filings
  on later runs. Charges one `monitor-run` event in addition to per-filing/per-search-result
  events.
- **A failed lookup/fetch is never silently treated as "nothing new."** Ticker-resolution,
  submissions, and full-text-search failures each push an explicit `fetch-failed` (or
  `rate-limited`, if SEC's fair-access limit was tripped) status record naming which company and
  stage failed. `monitor-run` is not billed on a run containing any such compromised result.
- **An unexpectedly-shaped submissions response is treated as an anomaly, not a clean empty
  result.** SEC's own filing-list structure isn't a versioned, guaranteed-stable contract — if it
  is ever missing the expected fields, this actor flags it rather than silently reporting zero
  filings for that company.
- **SEC's 10 requests/second fair-access limit is respected by design**: every request this actor
  makes to `*.sec.gov` is client-side throttled with a minimum spacing, so a multi-company run
  should never trip the limit. If it is tripped anyway, that surfaces as an explicit
  `rate-limited` record, not a silent gap.

### ⚠️ Limitations

- **Only the most recent ~1,000 filings per company** are available via the submissions API used
  here (SEC's own documented ceiling on the `filings.recent` window) — a company with a longer
  history has older filings in separate paginated files this actor does not fetch. This is
  sufficient for monitor mode (which only needs the newest filings since the last checkpoint) but
  is a real ceiling for a one-time deep historical pull.
- **Full-text search is not deduplicated across monitor runs** — it's a one-shot query each run,
  independent of the per-company monitor checkpoint.
- **Full-text search is capped at `maxSearchResults` (default 1,000), not exhaustive by
  default** — a broad query can match 10,000+ filings (EDGAR's own count). Set `maxSearchResults`
  higher for a broader pull; either way, if the real total exceeds what was fetched, a
  `search-truncated` record surfaces the true total so this is never silent. Note EDGAR itself
  sometimes reports only "at least 10,000" (`totalRelation: "gte"`) rather than an exact count for
  very broad queries — that's EDGAR's own reporting behavior, passed through honestly, not this
  actor rounding.
- **Form 4 (and other structured filings) are delivered as metadata + a link to the primary
  document**, not with the underlying transaction details (shares, price, insider name) parsed out
  — that would require fetching and parsing each filing's own XML/HTML document individually,
  out of scope for v1.

### Pricing

Pay per event:
- `filing-record` — per new filing delivered
- `search-result` — per full-text search hit delivered
- `monitor-run` — per scheduled monitor-mode run, in addition to per-record charges

### Input

Key fields (see the Input tab for the full form): `companies`, `formTypes`, `monitorMode`,
`fullTextSearchQuery`, `fullTextSearchForms`, `maxSearchResults`. Provide at least one of
`companies` or `fullTextSearchQuery`.

### Output

Each dataset item has a `recordType` of `"company-info"`, `"filing"`, `"search-result"`,
`"search-truncated"`, `"company-not-found"`, `"fetch-failed"`, or `"rate-limited"`. See the
Output tab for the full field reference.

### Local development

````

npm install
npm test                # recorded-fixture unit tests, no network needed
npx apify-cli run       # local end-to-end run — works immediately, no key/account needed

````

### Support

Built and maintained by Moose & Raven. Questions or issues: support@mooseandraven.com.

# Actor input Schema

## `companies` (type: `array`):

Ticker symbols (e.g. "AAPL") or numeric CIK identifiers (e.g. "320193" or "0000320193") to watch. Tickers are resolved via SEC's own official ticker-to-CIK mapping. A ticker/CIK that doesn't resolve is reported as an explicit 'company-not-found' record, never silently skipped. Leave empty if you only want to run a full-text search via fullTextSearchQuery below — at least one of companies or fullTextSearchQuery must be set.
## `formTypes` (type: `array`):

SEC form types to include (e.g. "10-K", "10-Q", "8-K", "4" for Form 4 insider transactions). Leave empty to include all filing types on record for each company.
## `monitorMode` (type: `boolean`):

When on, the actor remembers which filings (by accession number) it has already delivered per company (Apify key-value store) and only reports genuinely NEW filings on later runs. Designed for scheduled runs watching for new filings/insider transactions. Charges one monitor-run PPE event in addition to per-filing events.
## `fullTextSearchQuery` (type: `string`):

Optional keyword/phrase to search across EDGAR's full-text search index (all companies, not just the ones in `companies`). Runs once per invocation as a one-shot search — not deduplicated across monitor runs. Leave empty to skip full-text search entirely.
## `fullTextSearchForms` (type: `array`):

Optional form-type filter applied only to the full-text search (has no effect if fullTextSearchQuery is empty). Leave empty to search across all form types.
## `maxSearchResults` (type: `integer`):

A broad full-text search query can match thousands of filings (EDGAR's own result count, not guessed). This caps how many are actually fetched (paginated automatically). If the real total exceeds this cap, the actor emits an explicit 'search-truncated' record with the true total — a capped search is never reported as if it were exhaustive.

## Actor input object example

```json
{
  "companies": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K",
    "4"
  ],
  "monitorMode": false,
  "fullTextSearchForms": [],
  "maxSearchResults": 1000
}
````

# 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("mooseandraven/sec-edgar-filing-monitor").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("mooseandraven/sec-edgar-filing-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 mooseandraven/sec-edgar-filing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mooseandraven/sec-edgar-filing-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Filing Monitor",
        "description": "Monitors SEC EDGAR for new company filings (10-K/10-Q/8-K/Form 4) and full-text search matches, via the official data.sec.gov and efts.sec.gov APIs — no API key, no account, no scraping.",
        "version": "0.1",
        "x-build-id": "9PrpQ3IDZUeN5906S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mooseandraven~sec-edgar-filing-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mooseandraven-sec-edgar-filing-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mooseandraven~sec-edgar-filing-monitor/runs": {
            "post": {
                "operationId": "runs-sync-mooseandraven-sec-edgar-filing-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mooseandraven~sec-edgar-filing-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-mooseandraven-sec-edgar-filing-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "title": "Companies to watch (ticker or CIK)",
                        "type": "array",
                        "description": "Ticker symbols (e.g. \"AAPL\") or numeric CIK identifiers (e.g. \"320193\" or \"0000320193\") to watch. Tickers are resolved via SEC's own official ticker-to-CIK mapping. A ticker/CIK that doesn't resolve is reported as an explicit 'company-not-found' record, never silently skipped. Leave empty if you only want to run a full-text search via fullTextSearchQuery below — at least one of companies or fullTextSearchQuery must be set.",
                        "default": [
                            "AAPL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "formTypes": {
                        "title": "Filing types to watch",
                        "type": "array",
                        "description": "SEC form types to include (e.g. \"10-K\", \"10-Q\", \"8-K\", \"4\" for Form 4 insider transactions). Leave empty to include all filing types on record for each company.",
                        "default": [
                            "10-K",
                            "10-Q",
                            "8-K",
                            "4"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "monitorMode": {
                        "title": "Incremental monitor mode",
                        "type": "boolean",
                        "description": "When on, the actor remembers which filings (by accession number) it has already delivered per company (Apify key-value store) and only reports genuinely NEW filings on later runs. Designed for scheduled runs watching for new filings/insider transactions. Charges one monitor-run PPE event in addition to per-filing events.",
                        "default": false
                    },
                    "fullTextSearchQuery": {
                        "title": "Full-text search query (optional)",
                        "type": "string",
                        "description": "Optional keyword/phrase to search across EDGAR's full-text search index (all companies, not just the ones in `companies`). Runs once per invocation as a one-shot search — not deduplicated across monitor runs. Leave empty to skip full-text search entirely."
                    },
                    "fullTextSearchForms": {
                        "title": "Full-text search: restrict to these form types",
                        "type": "array",
                        "description": "Optional form-type filter applied only to the full-text search (has no effect if fullTextSearchQuery is empty). Leave empty to search across all form types.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSearchResults": {
                        "title": "Full-text search: max results to fetch",
                        "minimum": 1,
                        "type": "integer",
                        "description": "A broad full-text search query can match thousands of filings (EDGAR's own result count, not guessed). This caps how many are actually fetched (paginated automatically). If the real total exceeds this cap, the actor emits an explicit 'search-truncated' record with the true total — a capped search is never reported as if it were exhaustive.",
                        "default": 1000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```