# SEC EDGAR Filings & Financials API - 10-K, 10-Q, 8-K, XBRL (`olsols4/sec-edgar-filings-financials`) Actor

Get SEC EDGAR filings (10-K, 10-Q, 8-K, Form 4, S-1, 13F...) by ticker or CIK with direct document links, plus clean XBRL financials: standardised revenue, net income, EPS, assets and cash flow as annual or quarterly time series. Official SEC APIs, new-filings-only monitoring.

- **URL**: https://apify.com/olsols4/sec-edgar-filings-financials.md
- **Developed by:** [Olly](https://apify.com/olsols4) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## SEC EDGAR Filings & Financials API - 10-K, 10-Q, 8-K, XBRL

**Get SEC filings and clean financial statements for any US-listed company in one run.** Type tickers, pick forms (10-K, 10-Q, 8-K, Form 4, S-1, 13F...) and get every filing with direct document links, plus standardised XBRL financials (revenue, net income, EPS, assets, cash flow) as tidy annual or quarterly time series.

✅ Tickers, CIKs or company names   ✅ Every form type, history back to 1994   ✅ Direct links to the main document and the filing index   ✅ 8-K item codes (2.02 results, 5.02 executive changes...)   ✅ **Key financials**: 16 standard metrics mapped across XBRL tag changes, one value per period   ✅ Cross-company XBRL frames (e.g. revenue of every filer for CY2024)   ✅ New-filings-only monitoring   ✅ Official SEC APIs, no proxy: $1 per 1,000 filings

### What can you use it for?

- **Filing alerts**: get new 8-Ks, Form 4 insider trades or 10-Qs for a watchlist every hour, straight into Slack, Sheets or a webhook
- **Financial analysis and screening**: 10+ years of revenue, margins, EPS, debt and cash flow for any company, ready for a spreadsheet or model
- **AI / RAG pipelines**: document URLs for 10-Ks and 10-Qs to feed into LLMs for summarisation or Q\&A
- **Investment research**: compare peers, or pull one metric for every filer with XBRL frames
- **Compliance and due diligence**: company profile (SIC, state of incorporation, EIN, former names) plus full filing history
- **Deal sourcing**: monitor S-1, Form D or 8-K filings for an industry

### How to use it

1. Add **Companies**: tickers (`AAPL`), CIKs (`320193`) or exact names (`Apple Inc.`).
2. Optional: choose **Form types** and a **Filed from / to** date range.
3. Optional: set **Financial data** to *Key financials* and choose annual or quarterly periods.
4. For alerts, turn on **Only new filings since last run** and schedule the Actor.
5. Click **Start**, then export JSON, CSV or Excel, or use the API.

#### Input example: filings + 5 years of key financials

```json
{
  "companies": ["AAPL", "MSFT", "NVDA"],
  "formTypes": ["10-K", "10-Q", "8-K"],
  "filedFrom": "2025-01-01",
  "maxFilingsPerCompany": 50,
  "financials": "key",
  "financialsPeriod": "annual",
  "financialsFromYear": 2021
}
```

#### Input example: hourly insider-trade monitor

```json
{
  "companies": ["TSLA", "META", "AMZN"],
  "formTypes": ["4"],
  "maxFilingsPerCompany": 20,
  "includeCompanyProfile": false,
  "onlyNewFilings": true
}
```

#### Input example: revenue of every company for 2024

```json
{ "frames": ["us-gaap/Revenues/USD/CY2024"], "maxFrameRows": 500 }
```

### Output

Each row has a `type`: `filing`, `fact`, `company` or `frameFact`. The **Filings** and **Financials** tabs show each as a table.

Filing row:

```json
{
  "type": "filing",
  "cik": 320193,
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "form": "8-K/A",
  "filingDate": "2026-09-01",
  "reportDate": "2026-04-17",
  "accessionNumber": "0001140361-26-035325",
  "items": ["5.02"],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/ef20081427_8ka.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/0001140361-26-035325-index.htm",
  "isXBRL": true,
  "sizeBytes": 241262
}
```

Financial fact row (key financials, annual):

```json
{
  "type": "fact",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "metric": "Revenue",
  "concept": "RevenueFromContractWithCustomerExcludingAssessedTax",
  "unit": "USD",
  "value": 416161000000,
  "periodStart": "2024-09-29",
  "periodEnd": "2025-09-27",
  "fiscalYear": 2025,
  "fiscalPeriod": "FY",
  "form": "10-K",
  "filedDate": "2025-10-31"
}
```

**Key financials** metrics: Revenue, CostOfRevenue, GrossProfit, ResearchAndDevelopment, OperatingIncome, NetIncome, EpsBasic, EpsDiluted, TotalAssets, TotalLiabilities, StockholdersEquity, CashAndEquivalents, LongTermDebt, OperatingCashFlow, CapitalExpenditure, SharesOutstanding. Add any other XBRL tag with **Extra XBRL concepts**.

### How much does it cost?

| Event | Price |
|---|---|
| Filing | **$0.001** ($1 per 1,000) |
| Financial fact (one metric for one period) | **$0.0002** ($0.20 per 1,000) |
| Company profile | **$0.001** |

No start fee, no proxy costs, and nothing for companies or forms with no matches.

**Examples**

- 3 companies, 50 filings each, plus profiles = 153 rows = **$0.15**
- 16 key metrics × 10 fiscal years for one company ≈ 160 facts = **$0.03** (+ $0.001 profile)
- Same for the 100 largest companies ≈ **$3.30**
- Hourly Form 4 monitor on 20 tickers, ~30 new filings a day = **$0.03 a day**
- Revenue of every filer for CY2024 (~2,500 companies) = **$0.50**

### Use it via API

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("olsols4/sec-edgar-filings-financials").call(run_input={
    "companies": ["AAPL", "NVDA"], "formTypes": ["10-K"], "financials": "key"})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "fact":
        print(row["ticker"], row["metric"], row["periodEnd"], row["value"])
```

Connect to Google Sheets, Slack, Make, Zapier, n8n or a webhook through Apify integrations, and use **Schedules** for alerts.

### FAQ

**Where does the data come from?** The SEC's official EDGAR APIs (data.sec.gov submissions, company facts and frames). The Actor identifies itself to the SEC and stays under its 10 requests/second fair-access limit.

**Which companies are covered?** Every SEC filer: US-listed companies, foreign private issuers (20-F, 40-F), funds, and individuals filing Form 4 or 13D. Companies without a ticker work by CIK.

**Why is there no fiscal Q4 in quarterly financials?** Companies report Q4 only inside the annual 10-K. Subtract Q1-Q3 from the annual value to get Q4.

**Why does one metric come from different XBRL tags over the years?** Companies switch tags (e.g. `Revenues` to `RevenueFromContractWithCustomerExcludingAssessedTax` after ASC 606). Key financials merges them into one series; the `concept` field shows which tag each value came from.

**Do I get the full text of filings?** You get direct links to every document. Fetch them with any HTTP client (send a User-Agent with your contact email, as the SEC requires).

**How does monitoring work?** With *Only new filings since last run* on, the first run returns everything matching and stores it as a baseline; later runs with the same companies and forms return only filings not seen before.

### Support

Need another field, form parser or metric? Open an issue on the **Issues** tab. Issues are answered within a few days.

# Actor input Schema

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

Tickers (AAPL), CIK numbers (320193) or exact company names (Apple Inc.). Any company or person that files with the SEC, including those without a ticker (use the CIK).

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

Only keep these forms, e.g. 10-K, 10-Q, 8-K, 4, S-1, DEF 14A, 13F-HR, 20-F. Leave empty for every form.

## `includeAmendments` (type: `boolean`):

Also keep amended versions of the chosen forms (10-K/A for 10-K).

## `filedFrom` (type: `string`):

Only filings made on or after this date (YYYY-MM-DD).

## `filedTo` (type: `string`):

Only filings made on or before this date (YYYY-MM-DD).

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

Newest first. Set 0 to skip filings and only get financials. History goes back to 1994; older pages are loaded only when needed.

## `onlyNewFilings` (type: `boolean`):

For monitoring: remembers filings already returned for the same companies and form types, and saves only new ones next time. The first run returns everything (that is the baseline). Schedule it hourly or daily.

## `includeCompanyProfile` (type: `boolean`):

One row per company: industry (SIC), exchanges, fiscal year end, state of incorporation, address, website, former names.

## `financials` (type: `string`):

Adds financial facts from the SEC's XBRL company facts. 'Key financials' maps 16 standard metrics across tag changes so you get one clean series per metric.

## `customConcepts` (type: `array`):

Optional. Extra XBRL tags to include, e.g. InventoryNet, us-gaap:AccountsReceivableNetCurrent, dei:EntityPublicFloat.

## `financialsPeriod` (type: `string`):

Which reporting periods to keep for financial facts. Balance-sheet values are point-in-time and follow the filing's period.

## `financialsFromYear` (type: `integer`):

Only financial values for periods ending in or after this year.

## `dedupeFacts` (type: `boolean`):

The same number is repeated in later filings (prior-year comparisons). Keep only the latest-filed value for each metric and period. Turn off to get every reported instance.

## `frames` (type: `array`):

Optional. One value per company for a concept and calendar period, across all filers: taxonomy/concept/unit/period, e.g. us-gaap/Revenues/USD/CY2024, us-gaap/Assets/USD/CY2024Q4I (I = instant). Each company is one row.

## `maxFrameRows` (type: `integer`):

Keep only the N largest values per frame (e.g. top 500 by revenue). 0 = all companies.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "includeAmendments": true,
  "maxFilingsPerCompany": 100,
  "onlyNewFilings": false,
  "includeCompanyProfile": true,
  "financials": "none",
  "financialsPeriod": "annual",
  "dedupeFacts": true,
  "maxFrameRows": 0
}
```

# Actor output Schema

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

Filings with document links in a table view.

## `financials` (type: `string`):

Financial facts in a table view.

## `allItems` (type: `string`):

Every row, including company profiles.

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

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

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

```

## MCP server setup

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

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/8KW0dudyAEJkoYx9c/builds/rjABuSJnUetJcOYv8/openapi.json