# SEC EDGAR Filings & Financials | by ticker | $0.5/1K (`plainapi/sec-edgar-filings-xbrl-financials`) Actor

Company filings and reported financial figures from the SEC's own public API. Ask by ticker, not CIK. Every filing row carries a direct link to the document. 10-K, 10-Q, 8-K, S-1, Form 4 and XBRL figures across every period.

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

## Pricing

from $0.50 / 1,000 rows

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 & Financials — ask by ticker

Company filings and reported financial figures, from the **SEC's own public API**.

```
Input:   { "companies": ["AAPL", "NVDA"], "forms": ["10-K", "10-Q"] }
Output:  one row per filing — form, date, period, and a direct link to the document
```

### Ask by ticker, not CIK

EDGAR identifies every company by a ten-digit CIK, and nobody remembers CIKs. This resolves
tickers against the SEC's own ticker list — 10,000+ companies — so `AAPL` just works. CIK numbers
are accepted too.

### Two modes

**Filings** — what a company has submitted, newest first.

```json
{ "companies": ["AAPL", "MSFT"], "mode": "filings", "forms": ["10-K", "10-Q", "8-K"], "since": "2024-01-01" }
```

Every row carries `documentUrl`, a direct link to the filing itself — so you can hand it straight
to a text extractor rather than working out where the document lives.

**Financials** — reported figures across every period a company has filed, from XBRL.

```json
{ "companies": ["NVDA"], "mode": "financials", "concepts": ["revenue", "netIncome", "eps"] }
```

Shorthands cover what people usually want:

`revenue` · `netIncome` · `assets` · `liabilities` · `equity` · `cash` · `eps` ·
`operatingIncome` · `researchAndDevelopment` · `sharesOutstanding`

A raw XBRL tag works too, if you know the one you want.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `companies` | array of strings | `["AAPL"]` | Tickers or CIK numbers |
| `mode` | string | `filings` | `filings` or `financials` |
| `forms` | array of strings | `["10-K","10-Q","8-K"]` | Filings mode. Empty means every form |
| `concepts` | array of strings | all shorthands | Financials mode. Shorthand names or XBRL tags |
| `since` | string | — | `YYYY-MM-DD`. Filings mode |
| `limit` | integer | `40` | Max rows per company. `0` for no limit |

### Output

**Filings rows** carry the company (name, tickers, industry, state of incorporation), the filing
(form, `filedAt`, `reportDate`, accession number, whether it has XBRL) and two links: the document
itself and its index page.

**Financials rows** carry the figure (`concept`, `tag`, `label`), its `value` and `unit`, and the
period it covers (`fiscalYear`, `fiscalPeriod`, `periodStart`, `periodEnd`, `filedAt`). Newest
first.

A `SUMMARY` record lists which CIK each company resolved to and how many rows it produced.

### Pricing

| | Price |
|---|---|
| Starting a run | **$0.00001** — one US cent per 1,000 runs |
| Each row returned | **$0.0005** — 50 US cents per 1,000 rows |

A company that never reported a figure produces no rows for it, and errors go to the log and
`SUMMARY` rather than the dataset — so what a company did not file costs nothing.

### Works well with

Pair it with a document text extractor: this finds **which filings exist and where each document
is**, that one reads them. `documentUrl` is on every filings row for exactly this.

### Typical uses

- **Fundamental screening.** Pull one figure across many companies and compare periods.
- **Filing alerts.** Run on a schedule with `since` and catch new submissions.
- **Research pipelines.** Get the document URLs, extract the text, feed a model.
- **Ownership and insider activity.** Form 4 filings are just another form type.

### Notes on data and compliance

- The SEC publishes these endpoints and asks that clients identify themselves with a contact. This
  Actor does, in its user agent.
- The SEC asks for no more than 10 requests a second; this stays far below that.
- Filings are public regulatory disclosures. Reading them is the purpose of the system.

### Limitations — stated up front

- **US registrants only.** EDGAR covers companies that file with the SEC.
- Only the filing metadata and links are returned, not the document text — use a text extractor for
  that, which keeps this fast and cheap when you only need the index.
- XBRL figures exist only from around 2009 and only for companies that tag them.
- A figure a company never reported returns nothing rather than a zero. That distinction matters,
  so it is preserved.
- `Revenues` is one of several revenue tags in US GAAP; a company using a different one will return
  nothing for the `revenue` shorthand. Pass the exact tag when this matters.

### Not affiliated

This is an independent tool. It is not affiliated with or endorsed by the U.S. Securities and
Exchange Commission. Data comes from the SEC's publicly documented EDGAR APIs.

# Actor input Schema

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

Tickers such as AAPL, MSFT, or CIK numbers. Tickers are resolved against the SEC's own ticker list.

## `mode` (type: `string`):

Filings lists what a company submitted, with a direct link to each document. Financials pulls reported figures across every period.

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

Filings mode only. e.g. 10-K, 10-Q, 8-K, S-1, DEF 14A, 4. Leave empty for every form.

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

Financials mode only. Use a shorthand — revenue, netIncome, assets, liabilities, equity, cash, eps, operatingIncome, researchAndDevelopment, sharesOutstanding — or a raw XBRL tag. Leave empty for all of the shorthands.

## `since` (type: `string`):

YYYY-MM-DD. Filings mode only.

## `limit` (type: `integer`):

0 means no limit.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "mode": "filings",
  "forms": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "concepts": [
    "revenue",
    "netIncome",
    "eps"
  ],
  "limit": 40
}
```

# Actor output Schema

## `rows` (type: `string`):

Filings or financial figures.

## `rowsCsv` (type: `string`):

The same rows as CSV.

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

Which CIK each company resolved to and how many rows it produced.

# 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",
        "NVDA"
    ],
    "forms": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "concepts": [
        "revenue",
        "netIncome",
        "eps"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("plainapi/sec-edgar-filings-xbrl-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",
        "NVDA",
    ],
    "forms": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "concepts": [
        "revenue",
        "netIncome",
        "eps",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("plainapi/sec-edgar-filings-xbrl-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",
    "NVDA"
  ],
  "forms": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "concepts": [
    "revenue",
    "netIncome",
    "eps"
  ]
}' |
apify call plainapi/sec-edgar-filings-xbrl-financials --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,plainapi/sec-edgar-filings-xbrl-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/ecSGyX56scOJTLLly/builds/Mdaa9kY5wzkTGG7iD/openapi.json