# SEC EDGAR Filings Fetcher (`inn_corp/sec-edgar-filings`) Actor

Fetch SEC EDGAR company filings by ticker or CIK. Returns filing metadata and optional document text. Official SEC data, no personal data.

- **URL**: https://apify.com/inn\_corp/sec-edgar-filings.md
- **Developed by:** [Inn Corp](https://apify.com/inn_corp) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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/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 EDGAR Filings Fetcher

Fetch official SEC EDGAR company filings by ticker or CIK. Clean, structured
records with working links, and optional plain-text extraction of the filing
itself. Built for analysts, researchers, and AI agents that need real filing
data instead of guesses.

### What it does

- Give it tickers (`AAPL`, `MSFT`) or CIK numbers (`0000320193`), mixed freely.
- Filter by form type (`10-K`, `10-Q`, `8-K`, `S-1`, `DEF 14A`, ...) and date range.
- Get back one record per filing: company details, form, dates, accession
  number, direct links to the document and the filing index, XBRL flags.
- Optionally include the primary document's plain text (inline-XBRL
  bookkeeping stripped), capped at a length you choose.

### What it deliberately does not do

- **No insider or ownership forms.** Forms whose subject is a named individual
  (3, 4, 5, 144, MA-I) are excluded in code and cannot be requested. Records
  describe the filings of whatever public company or filer you query.
- **No guessing.** Every field comes from the SEC's own responses. Missing
  data is `null`, never invented.

### Data source and compliance

All data comes from the U.S. Securities and Exchange Commission's official
EDGAR endpoints, which are public domain. The SEC permits scripted access
with a declared User-Agent and a rate under 10 requests/second; this Actor
declares its User-Agent (with the contact email you provide) and stays well
under that limit with built-in throttling and retries.

### Output example

```json
{
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "form": "8-K",
  "filingDate": "2026-07-30",
  "reportDate": "2026-07-30",
  "items": "2.02,9.01",
  "accessionNumber": "0000320193-26-000018",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
  "isInlineXBRL": true
}
```

### Typical uses

- Monitor 8-K current reports for a watchlist of companies.
- Pull the latest 10-K/10-Q text for summarization or analysis pipelines.
- Feed an AI assistant real filing text so its answers cite the source.
- Build datasets of filing metadata across many companies.

### Input

| Field | Meaning |
| --- | --- |
| `identifiers` | Tickers or CIKs, mixed. Required. |
| `formTypes` | Forms to include. Empty = all company forms. |
| `dateFrom` / `dateTo` | Filing-date window, `YYYY-MM-DD`. |
| `maxFilingsPerCompany` | Newest first, default 25. |
| `includeDocumentText` | Also fetch and extract the primary document text. |
| `maxTextChars` | Truncation cap for extracted text. |
| `contactEmail` | Used only inside the SEC User-Agent header and sent only to sec.gov. Never written to the output dataset or the logs. (Like any Actor input, the Apify platform keeps it in your run's input record.) |

### Recipe: monitor 8-K earnings announcements on a schedule

You do not need a separate monitoring tool for earnings alerts. This Actor plus
Apify's built-in Schedules does it:

1. Create a Task for this Actor with your watchlist, for example:
   `identifiers: ["AAPL", "MSFT", "TSLA"]`, `formTypes: ["8-K"]`,
   `maxFilingsPerCompany: 5`, and `dateFrom` set to a recent date.
2. Attach an Apify Schedule to the Task (for example hourly on weekdays).
3. In the results, earnings announcements are the 8-K records whose `items` field
   contains `2.02` (Results of Operations and Financial Condition). The `items`
   value comes straight from the SEC, for example `"2.02,9.01"`.
4. Pair the schedule with an Apify integration (webhook, Slack, email).
   Integrations fire on each run with the full matching set, so the new
   filings are the accession numbers you have not seen before.

Honest latency note: the SEC's submissions feed updates in near real time
(typically well under a minute), so your effective delay is simply your
schedule interval. This is scheduled polling, not a real-time push stream.

### Fair pricing

Pay per filing record returned once pay-per-event pricing is enabled; records
with extracted document text cost slightly more because they fetch the full
document. No subscription.

# Actor input Schema

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

Company tickers (AAPL, MSFT) or CIK numbers (0000320193). Mix freely.

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

Filing forms to include, for example 10-K, 10-Q, 8-K, S-1. Leave empty for all company forms. Forms that name individuals (3, 4, 5, 144) are always excluded.

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

YYYY-MM-DD. Leave empty for no lower bound.

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

YYYY-MM-DD. Leave empty for no upper bound.

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

Newest first.

## `includeDocumentText` (type: `boolean`):

Download the primary document and return plain text. Slower and costs more events.

## `maxTextChars` (type: `integer`):

Truncate extracted text to this length.

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

The SEC requires a contact email in the User-Agent header. It is sent only to sec.gov and never written to the output or logs.

## Actor input object example

```json
{
  "identifiers": [
    "AAPL",
    "MSFT",
    "0000320193"
  ],
  "formTypes": [
    "10-K"
  ],
  "dateFrom": "2024-01-01",
  "dateTo": "2026-12-31",
  "maxFilingsPerCompany": 25,
  "includeDocumentText": false,
  "maxTextChars": 200000,
  "contactEmail": "you@example.com"
}
```

# Actor output Schema

## `filings` (type: `string`):

No description

# 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 = {
    "identifiers": [
        "AAPL"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inn_corp/sec-edgar-filings").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 = {
    "identifiers": ["AAPL"],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("inn_corp/sec-edgar-filings").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 '{
  "identifiers": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ]
}' |
apify call inn_corp/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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

```

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/YwVG8btZsyZkuu8lr/builds/jm6K5eadhYhSqOCc2/openapi.json