# SEC EDGAR Filing Monitor - Search + New-Filing Alerts (`gratifying_graph/edgar-filing-monitor`) Actor

Search and monitor SEC filings via EDGAR's official free APIs. Track a company's filings by ticker or CIK with new-since-last-run alerts, or run full-text search across all filings. Returns filing metadata and the canonical SEC document URL. Official data, no API key.

- **URL**: https://apify.com/gratifying\_graph/edgar-filing-monitor.md
- **Developed by:** [Jimmy A](https://apify.com/gratifying_graph) (community)
- **Categories:** News, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 filing results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 - Search + New-Filing Alerts

Search and monitor **SEC filings** through EDGAR's official free JSON APIs. Track any company's filings by ticker or CIK with **new-since-last-run alerts**, or run **full-text search** across every filing in EDGAR. Each result is clean filing metadata plus the canonical SEC document URL.

No API key, no scraping. These are the SEC's own data endpoints, so the actor is fast, accurate, and stable. Tickers resolve to CIK automatically.

### Two modes

**Company mode** - pass `tickers` and/or `ciks`. You get each company's recent filings, filtered by form type and date. Turn on `monitor` and run on a schedule to get only the filings that are new since the last run (`isNew: true`).

**Full-text mode** - pass a `query`. You get matching filings from EDGAR's full-text index, across all companies, with optional form and date filters.

The two can be combined in one run.

### What you get

Company-mode filing:

```json
{
  "type": "filing",
  "company": "Apple Inc.",
  "cik": "0000320193",
  "ticker": "AAPL",
  "form": "8-K",
  "filingDate": "2026-04-30",
  "reportDate": "2026-04-30",
  "accessionNumber": "0000320193-26-000011",
  "primaryDocument": "aapl-20260430.htm",
  "primaryDocDescription": "8-K",
  "isXBRL": true,
  "isNew": true,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000011/aapl-20260430.htm",
  "source": "SEC EDGAR (official submissions API)",
  "fetchedAt": "2026-06-11T02:18:00.000Z"
}
````

Full-text search hit:

```json
{
  "type": "search-hit",
  "query": "artificial intelligence risk factors",
  "company": "D-Wave Quantum Inc. (QBTS) (CIK 0001907982)",
  "cik": "0001907982",
  "form": "10-K",
  "filingDate": "2026-02-24",
  "accessionNumber": "0001193125-26-027198",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1907982/000119312526027198/...",
  "source": "SEC EDGAR full-text search"
}
```

### Inputs

- **tickers** / **ciks**: companies to pull filings for (company mode).
- **query**: full-text search phrase (full-text mode).
- **forms**: restrict to form types like `10-K`, `10-Q`, `8-K`, `S-1`. Empty = all.
- **sinceDate**: company mode, only filings on or after this date (`YYYY-MM-DD`).
- **maxFilingsPerCompany** / **maxHits**: output caps.
- **monitor**: flag filings not seen in the previous run.
- **snapshotGroup**: namespace so separate watchlists track independently.

### Use cases

- **Filing alerts**: 8-K and 10-Q watch on a portfolio - schedule daily, alert on new filings
- **Event-driven research**: catch S-1s, M\&A 8-Ks, or 13D/G filings as they hit
- **Theme screening**: full-text search across all filings for a topic or phrase
- **Data pipelines**: a clean, deduped filing feed with canonical document URLs
- **AI agents**: ask "latest 10-K for AAPL" or "who filed about X" through the standby API

### API / Standby mode for AI agents

Call the actor as a synchronous HTTP endpoint:

```
GET /?ticker=AAPL&forms=10-K
GET /?cik=320193
GET /?q=artificial%20intelligence
```

Returns the result immediately. Works as a tool for agent frameworks that support Apify actors.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Actor start | $0.0005 |
| Per filing / search hit | $0.001 |
| Per new-filing alert | $0.01 |
| API call (standby) | $0.02 |

Monitoring 50 tickers daily for new filings is roughly $5-15/month depending on filing volume.

### FAQ

**Do I need an API key?**
No. EDGAR's APIs are free and open. The actor identifies itself with a descriptive User-Agent per the SEC's fair-access policy.

**Do you return personal data?**
No. The actor outputs corporate filing metadata (company, form, dates, accession, document URL) and does not fetch filing document bodies. It links to the public SEC document rather than extracting its contents.

**How do tickers map to filings?**
The actor loads the SEC's official ticker-to-CIK map (refreshed weekly) and resolves each ticker automatically. You can also pass CIKs directly.

**How does new-filing detection work?**
With `monitor` on, the actor remembers the accession numbers it has seen per company and flags any it has not. Run it on a schedule and you get a clean stream of new filings.

**CSV export?**
Every Apify dataset exports as CSV, JSON, Excel, or via API.

# Actor input Schema

## `tickers` (type: `array`):

Stock tickers to pull filings for (e.g. AAPL, MSFT). Resolved to CIK automatically.

## `ciks` (type: `array`):

SEC Central Index Keys, if you prefer them over tickers (e.g. 320193).

## `query` (type: `string`):

Search phrase across all EDGAR filings. Use instead of (or alongside) tickers/CIKs.

## `forms` (type: `array`):

Filter to these form types (e.g. 10-K, 10-Q, 8-K, S-1). Empty = all forms.

## `sinceDate` (type: `string`):

Company mode: skip filings before this date.

## `maxFilingsPerCompany` (type: `integer`):

Cap on the number of recent filings returned per company.

## `maxHits` (type: `integer`):

Cap on the number of results returned by full-text search.

## `monitor` (type: `boolean`):

Company mode: compare against the previous run and flag filings not seen before (isNew). Run on a schedule for new-filing alerts.

## `snapshotGroup` (type: `string`):

Namespace for monitoring state, so separate watchlists track independently.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "forms": [],
  "maxFilingsPerCompany": 100,
  "maxHits": 100,
  "monitor": false,
  "snapshotGroup": "default"
}
```

# 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 = {
    "tickers": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gratifying_graph/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 = { "tickers": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("gratifying_graph/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 '{
  "tickers": [
    "AAPL"
  ]
}' |
apify call gratifying_graph/edgar-filing-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Filing Monitor - Search + New-Filing Alerts",
        "description": "Search and monitor SEC filings via EDGAR's official free APIs. Track a company's filings by ticker or CIK with new-since-last-run alerts, or run full-text search across all filings. Returns filing metadata and the canonical SEC document URL. Official data, no API key.",
        "version": "1.0",
        "x-build-id": "czOxRsQx3kD7f1qky"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gratifying_graph~edgar-filing-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gratifying_graph-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/gratifying_graph~edgar-filing-monitor/runs": {
            "post": {
                "operationId": "runs-sync-gratifying_graph-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/gratifying_graph~edgar-filing-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-gratifying_graph-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": {
                    "tickers": {
                        "title": "Tickers",
                        "type": "array",
                        "description": "Stock tickers to pull filings for (e.g. AAPL, MSFT). Resolved to CIK automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIKs",
                        "type": "array",
                        "description": "SEC Central Index Keys, if you prefer them over tickers (e.g. 320193).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Full-text search",
                        "type": "string",
                        "description": "Search phrase across all EDGAR filings. Use instead of (or alongside) tickers/CIKs."
                    },
                    "forms": {
                        "title": "Form types",
                        "type": "array",
                        "description": "Filter to these form types (e.g. 10-K, 10-Q, 8-K, S-1). Empty = all forms.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceDate": {
                        "title": "Only filings on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Company mode: skip filings before this date."
                    },
                    "maxFilingsPerCompany": {
                        "title": "Max filings per company",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on the number of recent filings returned per company.",
                        "default": 100
                    },
                    "maxHits": {
                        "title": "Max full-text hits",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on the number of results returned by full-text search.",
                        "default": 100
                    },
                    "monitor": {
                        "title": "Alert on new filings",
                        "type": "boolean",
                        "description": "Company mode: compare against the previous run and flag filings not seen before (isNew). Run on a schedule for new-filing alerts.",
                        "default": false
                    },
                    "snapshotGroup": {
                        "title": "Monitor group name",
                        "type": "string",
                        "description": "Namespace for monitoring state, so separate watchlists track independently.",
                        "default": "default"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
