# SEC EDGAR Filings Data Scraper (Company Filings JSON) (`steadfetch/sec-edgar-monitor`) Actor

Track official SEC EDGAR filing metadata by issuer CIK or full-text query: accession number, form type, dates and the primary document URL. Public data, schema-validated results, pay per event.

- **URL**: https://apify.com/steadfetch/sec-edgar-monitor.md
- **Developed by:** [Steadfetch](https://apify.com/steadfetch) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 filing delivereds

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?

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

## steadfetch/sec-edgar-monitor

Track official SEC EDGAR filing metadata without scraping the HTML website. Search
by issuer CIK and/or EDGAR full-text query and get one clean, schema-validated
record per filing.

### What it does

- Reads the official, key-free SEC EDGAR JSON endpoints:
  - submissions: `https://data.sec.gov/submissions/CIK##########.json`
  - full-text search: `https://efts.sec.gov/LATEST/search-index`
  - filing index (only to resolve the primary document of a full-text hit)
- Returns filing metadata for an issuer (`cik`) or for a full-text query
  (`query`); when both are provided, the full-text search is restricted to that
  issuer.
- Filters by form type (`formTypes`) and filing date (`startDate`, `endDate`).
- Paginates EDGAR's full-text results and its additional submissions pages until
  `maxResults` is reached or the source is exhausted. Deduplicates by accession
  number and pushes only items that pass the dataset output schema.
- Implements the SEC access contract: a declared User-Agent with a contact e-mail
  and a hard limit of **10 requests per second** with backoff for transient
  errors (429/5xx).
- Contains no person-level data: only filing metadata and issuer organisations
  (CIK and company name). Officer, signatory and contact fields are never
  requested and are explicitly scrubbed (RGPD).

### Input

```json
{
  "cik": "0000320193",
  "formTypes": ["10-K", "10-Q", "8-K"],
  "startDate": "2026-01-01",
  "maxResults": 10
}
```

Provide `cik` or `query` (at least one). Full-text example:

```json
{
  "query": "supply agreement",
  "formTypes": ["8-K"],
  "startDate": "2026-10-01",
  "endDate": "2026-10-17",
  "maxResults": 50
}
```

### Minimum input

```json
{ "cik": "0000320193" }
```

Identify what to pull with `cik` (10-digit issuer key) or `query` (EDGAR full-text search). `formTypes` defaults to `["10-K", "10-Q", "8-K"]`; `startDate`/`endDate` narrow the filing window; `maxResults` defaults to 100.

### Output fields

- `accession_no` — SEC accession number of the filing.
- `cik`, `company_name` — 10-digit issuer key and registered (organisation) name.
- `form_type` — e.g. `10-K`, `10-Q`, `8-K`; `is_amendment` is true when the form ends in `/A`.
- `filing_date`, `report_date`, `acceptance_datetime` — dates as published by EDGAR; null when not provided.
- `primary_document_url` and `url` — official EDGAR archive URL of the primary document.
- `scrapedAt` — UTC run timestamp. Filing metadata only: no person-level fields.

### Example output

```json
{
  "accession_no": "0000320193-26-000020",
  "cik": "0000320193",
  "company_name": "Apple Inc.",
  "form_type": "10-Q",
  "filing_date": "2026-07-31",
  "report_date": "2026-06-27",
  "acceptance_datetime": "2026-07-31T14:01:02.000Z",
  "primary_document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/aapl-20260627.htm",
  "is_amendment": false,
  "url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/aapl-20260627.htm",
  "scrapedAt": "2026-10-19T12:00:00.000Z"
}
```

`url` is the common Steadfetch envelope and mirrors `primary_document_url`.
`acceptance_datetime` is `null` when EDGAR's full-text endpoint does not return
it; the Actor never invents timestamps.

### Pricing

- **5.00 USD per 1,000 filings** (`apify-default-dataset-item` = 0.005 USD per
  filing), plus the Apify-recommended `apify-actor-start` event (0.00005 USD per
  run, first 5 seconds of compute included).
- Measured **cost per 1,000**: below **0.10 USD** (HTTP/JSON only, no browser;
  compute plus SEC transfer are negligible). Margin is above 98%.
- Empty searches, 4xx/5xx responses and retries are not charged.

**Works on the Apify free plan** — about 999 filings for the $5 monthly credit ((5.00 USD − 0.0002 USD run-start at the default 4 GB memory) ÷ 0.005 USD per filing).

### FAQ

**Does it need an API key?** No. SEC EDGAR's published endpoints are anonymous;
the Actor still declares a User-Agent with a contact e-mail as the SEC requires.

**What is the request limit?** At most 10 requests per second per IP. The client
queue enforces it and backs off on 429/5xx.

**Does it collect personal data?** No. Only filing metadata and issuer
organisations. Contact/officer fields are excluded by design and scrubbed again
before pushing.

**What about amendments?** Forms ending in `/A` (for example `8-K/A`) are
returned when included in `formTypes` and flagged with `is_amendment: true`.

**How far back does issuer history go?** The submissions endpoint is paginated;
the Actor follows EDGAR's additional filing pages, newest to oldest, until
`maxResults` is satisfied. Filing dates can be bounded with `startDate` and
`endDate` to keep runs short and cheap.

**What does `primary_document_url` point to?** The filing's primary document. If
a full-text query matches an exhibit instead, the Actor resolves the primary
document from the official filing index; if that lookup fails it falls back to
the matched document instead of dropping the filing.

**How long is the declared contact mailbox monitored?** The Actor declares
`contact@steadfetch.com` in its User-Agent. That mailbox is the SEC's contact
channel for access questions and must stay monitored while the Actor is
published.

### Maintenance

Tested daily by the Steadfetch catalog QA workflow with fixture-based tests and a
minimal platform smoke run. If the source changes shape, the schema validation
fails the run instead of delivering bad data.

# Actor input Schema

## `cik` (type: `string`):

SEC Central Index Key of the issuer (1-10 digits, leading zeros optional). Example: 0000320193 for Apple Inc.

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

EDGAR full-text search query, matched against filing documents.

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

Only return these SEC form types.

## `startDate` (type: `string`):

Inclusive lower bound for the filing date (YYYY-MM-DD).

## `endDate` (type: `string`):

Inclusive upper bound for the filing date (YYYY-MM-DD).

## `maxResults` (type: `integer`):

Maximum number of filings delivered to the dataset.

## Actor input object example

```json
{
  "cik": "0000320193",
  "query": "supply agreement",
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxResults": 10
}
```

# Actor output Schema

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

Dataset items validated against the item schema in dataset_schema.json (fields).

# 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 = {
    "cik": "0000320193",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadfetch/sec-edgar-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 = {
    "cik": "0000320193",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("steadfetch/sec-edgar-monitor").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 '{
  "cik": "0000320193",
  "maxResults": 10
}' |
apify call steadfetch/sec-edgar-monitor --silent --output-dataset

```

## MCP server setup

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

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/nzXYGOe1KYpObCml8/builds/JDHtEVX0hsTCQpjEX/openapi.json