# SEC EDGAR Filings & XBRL Financials API (`sam_i_am_not/sec-edgar-scraper`) Actor

Official SEC EDGAR data as clean JSON for analysts and AI agents: every filing (10-K, 10-Q, 8-K, Form 4, S-1...) with document links, and XBRL financials (revenue, net income, EPS, assets...) as one value per period. By ticker or CIK, no API key.

- **URL**: https://apify.com/sam_i_am_not/sec-edgar-scraper.md
- **Developed by:** [Andrew Van De Poel](https://apify.com/sam_i_am_not) (community)
- **Categories:** AI, Developer tools, News
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 filings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 & XBRL Financials API

**Get any US public company's SEC filings and reported financials as clean JSON, CSV or Excel: every 10-K, 10-Q, 8-K, Form 4, S-1 and proxy filing with direct document links, plus XBRL numbers like revenue, net income, EPS, assets and cash as a clean time series.** Look companies up by ticker or CIK. No API key, no SEC rate-limit handling, no parsing of SEC's columnar JSON. A typical company takes about a second.

Built for analysts, quant and fintech developers, investor-relations and compliance teams, and AI agents that need filings or fundamentals on demand or on a schedule.

### What you get

| Data | What it contains |
|---|---|
| **Filings** | Form type, filing and report dates, acceptance time, accession number, 8-K item numbers, links to the main document and the filing index, XBRL flags. Newest first, back to 1994 |
| **Financials** | XBRL facts from 10-K and 10-Q reports (us-gaap, ifrs-full and dei taxonomies): concept, label, value, unit, period start and end, fiscal year and period, the filing it came from, and SEC's calendar frame (`CY2025`, `CY2025Q2`) |

Filters:

- **Form types:** e.g. `10-K`, `10-Q`, `8-K`, `4`, `S-1`, `DEF 14A`, `13F-HR`
- **Dates:** filings filed between two dates; facts whose period ends between them
- **Concepts:** any XBRL concept, or leave empty for the headline set (revenue, operating and net income, EPS, assets, liabilities, equity, cash, operating cash flow, shares outstanding)
- **Periods:** annual, quarterly, point in time (balance sheet), or other

By default, financials come back as **one value per period**: the latest figure SEC assigns to that calendar year or quarter, so restatements and prior-year comparatives don't show up as duplicates. Turn on **Every reported value** to get each figure as reported in every filing.

### How to use it

1. Add tickers (`AAPL`, `BRK.B`) or CIK numbers (`320193`), one per line.
2. Pick **Filings**, **Financials** or both, and optionally form types, dates and concepts.
3. Click **Start**. Download results from the Output tab as JSON, CSV, Excel or HTML, or fetch them through the API. The Output tab has separate views for filings and financials.

#### Input example

```json
{
    "companies": ["AAPL", "MSFT", "1067983"],
    "dataTypes": ["filings", "financials"],
    "formTypes": ["10-K", "10-Q", "8-K"],
    "maxFilingsPerCompany": 20,
    "concepts": ["RevenueFromContractWithCustomerExcludingAssessedTax", "NetIncomeLoss"],
    "factPeriods": ["annual", "quarterly"],
    "dateFrom": "2020-01-01"
}
```

### Output

Real output for Apple's latest 10-K and its fiscal 2025 revenue:

```json
[
    {
        "dataType": "filing",
        "cik": "0000320193",
        "ticker": "AAPL",
        "companyName": "Apple Inc.",
        "form": "10-K",
        "filingDate": "2025-10-31",
        "reportDate": "2025-09-27",
        "acceptanceDateTime": "2025-10-31T10:01:26.000Z",
        "accessionNumber": "0000320193-25-000079",
        "description": "10-K",
        "items": [],
        "primaryDocument": "aapl-20250927.htm",
        "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm",
        "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm",
        "fileNumber": "001-36743",
        "sizeBytes": 9392337,
        "isXBRL": true,
        "isInlineXBRL": true,
        "sourceUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm",
        "scrapedAt": "2026-10-25T15:13:50.471Z"
    },
    {
        "dataType": "fact",
        "cik": "0000320193",
        "ticker": "AAPL",
        "companyName": "Apple Inc.",
        "taxonomy": "us-gaap",
        "concept": "RevenueFromContractWithCustomerExcludingAssessedTax",
        "label": "Revenue from Contract with Customer, Excluding Assessed Tax",
        "unit": "USD",
        "value": 416161000000,
        "periodStart": "2024-09-29",
        "periodEnd": "2025-09-27",
        "periodType": "annual",
        "frame": "CY2025",
        "fiscalYear": 2025,
        "fiscalPeriod": "FY",
        "form": "10-K",
        "filed": "2025-10-31",
        "accessionNumber": "0000320193-25-000079",
        "sourceUrl": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0000320193",
        "scrapedAt": "2026-10-25T15:13:50.471Z"
    }
]
```

A run summary (companies succeeded and failed, the reasons, warnings and charged events) is saved as `OUTPUT` in the run's key-value store.

### Pricing

You pay per **filing** and per **financial fact** delivered.

| Apify plan | Per filing | Per financial fact | 1,000 filings | 1,000 facts |
|---|---|---|---|---|
| Free | $0.001 | $0.0003 | $1.00 | $0.30 |
| Starter (Bronze) | $0.0004 | $0.0001 | $0.40 | $0.10 |
| Scale and above | $0.0003 | $0.00008 | $0.30 | $0.08 |

- Every annual headline number Apple has reported in XBRL (fiscal 2007 onward) is 106 facts, about $0.01 on Starter.
- **No charge** for companies that fail or that have nothing matching your filters.
- **No start fee** beyond Apify's standard $0.00005 per run.
- Platform usage is included.
- Set **Max cost per run** in the run options, and the Actor stops cleanly when it gets there, delivering exactly what fits.

### Why use this instead of…

- **SEC's own API:** you get rows instead of columnar arrays, tickers instead of zero-padded CIKs, document links built for you, filings older than the last 1,000 fetched automatically, and duplicate facts removed. Rate limits and SEC's User-Agent rules are handled.
- **Paid fundamentals APIs:** the numbers come straight from the companies' own XBRL filings at SEC, with the accession number of the filing each value came from, for a fraction of the price.
- **Your own script:** a live test runs against SEC every day, so if SEC changes something, it's caught early.

### Use with AI agents (MCP)

This Actor works as a tool through the [Apify MCP server](https://mcp.apify.com), so Claude, ChatGPT, Cursor and other MCP clients can call it directly. Every input field has a plain-English description the agent can read. Typical agent calls:

```json
{ "companies": ["NVDA"], "formTypes": ["8-K"], "maxFilingsPerCompany": 5 }
```

```json
{ "companies": ["MSFT", "GOOGL"], "dataTypes": ["financials"], "concepts": ["NetIncomeLoss"], "factPeriods": ["annual"], "dateFrom": "2020-01-01" }
```

Rows are flat and small, and default filters keep results to what was asked, so they fit comfortably in an agent's context. The `documentUrl` of a filing can be handed to a browsing or document tool to read the filing itself.

You can also call it from code with the Apify API or the `apify-client` package for JavaScript and Python.

### FAQ

**Which concept holds revenue?** It depends on the company and year. Since 2018 most companies use `RevenueFromContractWithCustomerExcludingAssessedTax`; others, and older filings, use `Revenues`. Both are in the default set. Banks and insurers use their own concepts (e.g. `InterestAndDividendIncomeOperating`); use `*` once to see everything a company reports.

**What is the `frame` field?** SEC aligns each value to a calendar period: `CY2025` for a year, `CY2025Q2` for a quarter, `CY2025Q2I` for a point in time. Values that a later filing superseded have no frame and are only returned with **Every reported value** on.

**Why does a fiscal year show a different calendar frame?** SEC maps fiscal periods to the closest calendar period. Apple's fiscal year ending September 2025 is `CY2025`. Use `fiscalYear` and `fiscalPeriod` for the company's own labels, and `periodStart`/`periodEnd` for exact dates.

**Why does a ticker return only recent filings?** A ticker points to the entity that's listed today. After a reorganization into a new holding company, the old entity's history stays under its old CIK. For example, `XOM` now resolves to ExxonMobil Holdings Corp, whose first filing at SEC is from July 2026, while Exxon Mobil Corp's filings back to 1994 are under CIK `34088`. A company's EDGAR page lists its former names.

**Do foreign companies work?** Companies that file with SEC do, including those reporting in IFRS (`ifrs-full` taxonomy). Companies that only file on paper, and most funds and trusts, have no XBRL financials; their filings still work.

**Can I search the full text of filings?** Not yet. Open an issue if you need it.

**Is this allowed?** The data comes from SEC's official public API, which SEC provides for this purpose. The Actor follows SEC's fair-access rules (at most 8 requests per second and a declared User-Agent). You can put your own email in **Contact email** so SEC can reach you about your usage.

**Does the Actor send anything back to the developer?** At the end of each run it sends us a small usage record: how many of each billable event the run was charged, the prices it was charged at, your pricing tier, whether your plan is paid, and a one-way hash of your user ID. That's how we see which Actors are worth maintaining, because Apify doesn't share this with developers. Your input, your results and your account details are never sent.

**Something broke or looks wrong?** Open an issue on the Issues tab. Issues get a response within 48 hours.

# Changelog

This Actor's version history is a separate document: https://apify.com/sam_i_am_not/sec-edgar-scraper/changelog.md

# Actor input Schema

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

Stock tickers ("AAPL", "BRK.B") or SEC CIK numbers ("320193"), one per line. CIKs also work for companies without a ticker, such as private issuers, funds and insiders.

## `dataTypes` (type: `array`):

Filings: the company's EDGAR filings with links to the documents, billed per filing. Financials: XBRL numbers from 10-K/10-Q reports, billed per fact.

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

Only return filings of these forms, e.g. 10-K, 10-Q, 8-K, 4, S-1, DEF 14A, 13F-HR. Amendments are separate forms ("10-K/A"). Leave empty for every form.

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

Newest first. 0 = no limit (large companies have several thousand filings, most of them Form 4 insider trades).

## `concepts` (type: `array`):

XBRL concept names, e.g. "NetIncomeLoss" or "us-gaap:Revenues". Leave empty for the headline set: revenue, operating and net income, EPS, assets, liabilities, equity, cash, operating cash flow and shares outstanding. Use "\*" for every concept the company reports (often 10,000+ facts per company).

## `factPeriods` (type: `array`):

Which kinds of period to return. Annual and quarterly are flows (revenue, income); point in time is balance-sheet values (assets, cash, shares). Leave empty for all.

## `allFactValues` (type: `boolean`):

Off: one value per period, the latest one SEC assigns to the calendar period (a clean time series). On: every value as reported in every filing, including prior-year comparatives and restatements (3-4x more rows).

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

YYYY-MM-DD. Filings filed on or after this date; facts whose period ends on or after it.

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

YYYY-MM-DD. Filings filed on or before this date; facts whose period ends on or before it.

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

SEC asks API clients to identify themselves. If you set an email, it's sent to sec.gov in the User-Agent header instead of this Actor's name. It isn't stored or sent anywhere else.

## Actor input object example

```json
{
  "companies": [
    "NVDA",
    "1067983"
  ],
  "dataTypes": [
    "filings",
    "financials"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxFilingsPerCompany": 10,
  "factPeriods": [
    "annual"
  ],
  "allFactValues": false,
  "dateFrom": "2020-01-01",
  "dateTo": "2025-12-31"
}
```

# Actor output Schema

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

One row per filing and one row per financial fact.

## `summary` (type: `string`):

Counts of succeeded and failed companies, failure reasons, warnings and charged events.

# 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",
        "TSLA"
    ],
    "dataTypes": [
        "filings",
        "financials"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "maxFilingsPerCompany": 10,
    "factPeriods": [
        "annual"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sam_i_am_not/sec-edgar-scraper").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",
        "TSLA",
    ],
    "dataTypes": [
        "filings",
        "financials",
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "maxFilingsPerCompany": 10,
    "factPeriods": ["annual"],
}

# Run the Actor and wait for it to finish
run = client.actor("sam_i_am_not/sec-edgar-scraper").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",
    "TSLA"
  ],
  "dataTypes": [
    "filings",
    "financials"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxFilingsPerCompany": 10,
  "factPeriods": [
    "annual"
  ]
}' |
apify call sam_i_am_not/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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

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/pDnmK9Sygu2zUQFug/builds/VaePcEwyXPvArM8EC/openapi.json