# SEC Company Financials (XBRL): EDGAR Fundamentals (`fedfacts/sec-financials`) Actor

Revenue, net income, EPS, assets, debt and cash flow for any US public company, per year or quarter, from the SEC's official XBRL API. Source-linked.

- **URL**: https://apify.com/fedfacts/sec-financials.md
- **Developed by:** [FedFacts](https://apify.com/fedfacts) (community)
- **Categories:** Developer tools
- **Features:** Limited permissions
- **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 Company Financials (XBRL): EDGAR fundamentals as clean rows

Get income-statement, balance-sheet and cash-flow numbers for US public companies straight from the SEC's official XBRL APIs (data.sec.gov). Enter tickers or CIKs and get **one tidy row per company per fiscal year or quarter**, with revenue, net income, EPS, assets, liabilities, equity, cash, operating cash flow, shares and more. Every row links back to the SEC filing it came from.

Two more modes for power users:

- **Raw facts:** every XBRL fact a company reported (any concept, any unit), with form, filing date and accession number.
- **Frame (screen):** one concept for **all** filers in one calendar period, such as "Net income for every company, CY2024" (about 6,000 rows).

No API key needed. No scraping: it uses only the SEC's public JSON APIs.

### What you get (normalized mode)

One row per company and period. Annual rows come from 10-K (and 20-F/40-F for US GAAP filers); quarterly rows come from 10-Q.

| Field | Meaning |
|---|---|
| `recordType` | `company-period` |
| `cik`, `ticker`, `entityName` | Company identifiers (CIK is 10 digits, zero-padded) |
| `periodType` | `annual` or `quarterly` |
| `fiscalYear`, `fiscalPeriod` | Company's fiscal year and period (`FY`, `Q1`-`Q3`) |
| `periodStart`, `periodEnd` | Period the income-statement values cover |
| `cashFlowPeriodStart` | Start of the window for cash-flow values. In 10-Qs companies report cash flow **year-to-date**, so for Q2/Q3 this is the fiscal-year start |
| `form`, `accessionNumber`, `filedDate` | The filing the row is based on (the first filing that reported this period) |
| `reportedAsComparativeOnly` | `true` when the period only appears as a prior-year comparison in a later filing (common for the oldest years) |
| `revenue`, `costOfRevenue`, `grossProfit`, `researchAndDevelopment`, `operatingIncome`, `pretaxIncome`, `incomeTax`, `netIncome` | Income statement, USD |
| `epsBasic`, `epsDiluted` | USD per share |
| `weightedAvgSharesBasic`, `weightedAvgSharesDiluted` | Shares |
| `totalAssets`, `currentAssets`, `cashAndEquivalents`, `totalLiabilities`, `currentLiabilities`, `longTermDebt`, `stockholdersEquity`, `sharesOutstanding` | Balance sheet at `periodEnd` |
| `operatingCashFlow`, `investingCashFlow`, `financingCashFlow`, `capitalExpenditures`, `dividendsPaid` | Cash-flow statement, USD |
| `freeCashFlow` | Derived: `operatingCashFlow - capitalExpenditures` |
| `sharesOutstandingCoverPage`, `sharesOutstandingCoverPageDate` | Shares outstanding from the filing's cover page (all classes summed) and the date it was measured |
| `conceptsUsed` | Which XBRL tag filled each metric (for example `revenue: RevenueFromContractWithCustomerExcludingAssessedTax`) |
| `valuesFromOtherFilings` | Metrics that came from a different filing than `accessionNumber` (restatements or values missing in the original filing) |
| `extraConcepts` | Values of any extra XBRL concepts you asked for |
| `currency` | `USD` |
| `sourceUrls.companyFacts`, `sourceUrls.filingIndex` | SEC API URL used, and the EDGAR filing index page |

A metric is `null` when the company didn't report it under any of the tags we map for that period (banks, for example, don't report gross profit).

#### Example row (abridged)

```json
{
  "recordType": "company-period", "cik": "0000320193", "ticker": "AAPL", "entityName": "Apple Inc.",
  "periodType": "annual", "fiscalYear": 2025, "fiscalPeriod": "FY",
  "periodStart": "2024-09-29", "periodEnd": "2025-09-27",
  "form": "10-K", "accessionNumber": "0000320193-25-000079", "filedDate": "2025-10-31",
  "revenue": 416161000000, "netIncome": 112010000000, "epsDiluted": 7.46,
  "totalAssets": 359241000000, "operatingCashFlow": 111482000000,
  "conceptsUsed": { "revenue": "RevenueFromContractWithCustomerExcludingAssessedTax", "...": "..." },
  "sourceUrls": { "companyFacts": "https://data.sec.gov/api/xbrl/companyfacts/CIK0000320193.json", "filingIndex": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm" }
}
```

### Raw mode rows

`recordType: raw-fact`, `cik`, `ticker`, `entityName`, `taxonomy` (us-gaap, ifrs-full, dei, srt...), `concept`, `label`, `unit`, `value`, `periodStart` (null for point-in-time values), `periodEnd`, `durationDays`, `filingFiscalYear`, `filingFiscalPeriod` (of the filing, not the fact), `form`, `filedDate`, `accessionNumber`, `frame` (SEC's calendar frame, when assigned), `sourceUrl`, `filingIndexUrl`.

### Frame mode rows

`recordType: frame-row`, `cik`, `entityName`, `location`, `taxonomy`, `concept`, `label`, `unit`, `calendarPeriod`, `value`, `periodStart`, `periodEnd`, `accessionNumber`, `sourceUrl`, `filingIndexUrl`.

### Input

| Field | Default | Notes |
|---|---|---|
| `companies` | `["AAPL","MSFT"]` | Tickers (`BRK.B` works) or CIKs. Duplicates are skipped. Ignored in frame mode |
| `mode` | `normalized` | `normalized`, `raw` or `frame` |
| `forms` | `["10-K","10-Q"]` | Also `20-F`, `40-F`, `10-KT`, `10-QT` |
| `includeAmendments` | `true` | Include 10-K/A and 10-Q/A |
| `dateFrom`, `dateTo` | `2021-01-01`, empty | Filter by period end date (YYYY-MM-DD). Clear `dateFrom` for full history (XBRL starts ~2009) |
| `metrics` | all | Subset of the normalized metrics listed above |
| `concepts` | none | Extra XBRL tags (`InventoryNet`, `dei:EntityPublicFloat`). Raw mode: returns only these |
| `valueMode` | `asReported` | `asReported` = value from the original filing; `latest` = most recent (restated) value |
| `frameConcept`, `frameTaxonomy`, `frameUnit`, `framePeriod` | `Revenues`, `us-gaap`, `USD`, `CY2024` | Frame mode. Period formats: `CY2024`, `CY2024Q1`, `CY2024Q4I` (instant, for balance-sheet items) |
| `maxItems`, `maxItemsPerCompany` | 0 (no limit) | Hard caps on output rows |
| `requestsPerSecond` | 5 | Capped at 8, below the SEC's 10/s limit |

#### Examples

- Last 5 years of annual + quarterly fundamentals: `{"companies": ["AAPL","MSFT","NVDA"]}`
- Annual only, full history: `{"companies": ["KO"], "forms": ["10-K"], "dateFrom": ""}`
- Just revenue and net income, restated values: `{"companies": ["AMZN"], "metrics": ["revenue","netIncome"], "valueMode": "latest"}`
- One concept, raw: `{"companies": ["MSFT"], "mode": "raw", "concepts": ["Revenues"]}`
- Screen all companies: `{"mode": "frame", "frameConcept": "NetIncomeLoss", "framePeriod": "CY2024"}`

### Errors and warnings

Bad inputs don't fail the run. Unknown tickers, companies with no XBRL data (for example funds or trusts), and IFRS-only filers in normalized mode are listed in the `RUN_SUMMARY` record in the run's key-value store and in the log. **You are not charged for them**, since no rows are produced. Invalid settings (bad date format, unknown metric name) fail the run immediately before any data is fetched.

### Limits (read before relying on it)

- **US GAAP only in normalized mode.** IFRS filers (many 20-F companies such as TSM) return nothing there; use raw mode with `ifrs-full:` concepts.
- **No Q4 rows.** Companies file a 10-K, not a 10-Q, for the fourth quarter. Q4 = annual minus Q1-Q3 is not derived for you.
- **Quarterly cash flow is year-to-date** as filed; see `cashFlowPeriodStart`.
- **Tag mapping is a best effort.** Companies choose different XBRL tags. We check several common tags per metric in order and tell you which one was used (`conceptsUsed`). Industry-specific lines (bank net interest income, insurance premiums) may need `concepts`.
- **Only what the SEC publishes as XBRL "company facts":** no segment/dimension breakdowns, no text, no non-XBRL filings before ~2009.
- **Raw pulls can be big.** A large bank's full history is ~48,000 rows. Use `dateFrom`, `concepts` or `maxItems` to control cost.
- Not investment advice. Data is as filed with the SEC; verify important numbers against the filing (linked in every row).

### Data source and terms

- Data comes only from the SEC's official public APIs: `data.sec.gov/api/xbrl/companyfacts`, `data.sec.gov/api/xbrl/frames`, and `www.sec.gov/files/company_tickers.json` for ticker lookup. EDGAR data is public information from a US government agency.
- The Actor follows the SEC's [Fair Access policy](https://www.sec.gov/os/accessing-edgar-data): it declares a User-Agent (`FedFacts <contact email>`), throttles to 5 requests/second by default (the SEC limit is 10), and retries with exponential backoff on 429/403/5xx responses.
- No personal data. Output is company-level financial data only; this Actor does not collect insider (Form 3/4/5) or Form D person names.
- Not affiliated with or endorsed by the SEC.

### Pricing

Pay per event, no subscription:
| Event | Price | When charged |
|---|---|---|
| `company-period-record` | **$0.002** per row ($2 per 1,000) | Each normalized company-period row |
| `raw-fact-row` | **$0.0005** per row ($0.50 per 1,000) | Each raw fact row or frame row |
No start fee. Nothing is charged for inputs that return no data. The Actor respects your run's maximum-charge limit and stops cleanly when it's reached.

Typical costs: the default run (AAPL + MSFT, since 2021, annual + quarterly) = 44 rows = **$0.09**. Ten companies, 5 years of annual data = ~50 rows = **$0.10**. One frame screen (~6,000 companies) = **~$3.00**.

# Actor input Schema

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

Stock tickers (AAPL, BRK.B) or SEC CIK numbers (320193). Ignored in frame mode.

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

normalized = one row per company and fiscal period with standard metrics. raw = every reported XBRL fact. frame = one concept across all companies for a calendar period.

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

10-K gives annual records, 10-Q gives quarterly records (Q1-Q3; Q4 is not filed as a 10-Q).

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

Also use amended filings (10-K/A, 10-Q/A).

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

Only periods ending on or after this date. Clear it for full history (back to ~2009).

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

Only periods ending on or before this date. Empty = up to latest.

## `metrics` (type: `array`):

Subset of standard metrics to fill. Empty = all: revenue, costOfRevenue, grossProfit, researchAndDevelopment, operatingIncome, pretaxIncome, incomeTax, netIncome, epsBasic, epsDiluted, weightedAvgSharesBasic, weightedAvgSharesDiluted, totalAssets, currentAssets, cashAndEquivalents, totalLiabilities, currentLiabilities, longTermDebt, stockholdersEquity, sharesOutstanding, operatingCashFlow, investingCashFlow, financingCashFlow, capitalExpenditures, dividendsPaid.

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

XBRL tags such as InventoryNet or dei:EntityPublicFloat (us-gaap is assumed if no prefix). Raw mode: only these concepts are returned. Normalized mode: added under extraConcepts.

## `valueMode` (type: `string`):

asReported = value from the first filing that reported the period; latest = most recent value, including restatements.

## `frameConcept` (type: `string`):

XBRL tag for frame mode, e.g. Revenues, NetIncomeLoss, Assets.

## `frameTaxonomy` (type: `string`):

XBRL taxonomy of the frame concept.

## `frameUnit` (type: `string`):

USD, USD-per-shares, shares, pure ...

## `framePeriod` (type: `string`):

CY2024 (annual), CY2024Q1 (quarter), CY2024Q4I (instant, for balance-sheet items).

## `maxItems` (type: `integer`):

Stop after this many dataset items. 0 = no limit.

## `maxItemsPerCompany` (type: `integer`):

0 = no limit.

## `requestsPerSecond` (type: `integer`):

Kept below SEC's 10 req/s fair-access limit.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "mode": "normalized",
  "forms": [
    "10-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "dateFrom": "2021-01-01",
  "valueMode": "asReported",
  "frameConcept": "Revenues",
  "frameTaxonomy": "us-gaap",
  "frameUnit": "USD",
  "framePeriod": "CY2024",
  "maxItems": 0,
  "maxItemsPerCompany": 0,
  "requestsPerSecond": 5
}
```

# Actor output Schema

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

Dataset rows (one per record), as JSON/CSV/Excel via the dataset API.

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

Filters used, rows returned/dropped and why the run stopped.

# 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"
    ],
    "dateFrom": "2021-01-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fedfacts/sec-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",
    ],
    "dateFrom": "2021-01-01",
}

# Run the Actor and wait for it to finish
run = client.actor("fedfacts/sec-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"
  ],
  "dateFrom": "2021-01-01"
}' |
apify call fedfacts/sec-financials --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fedfacts/sec-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/mJx7wWAMz6iMhTo9c/builds/IaOcmAGOejSTgeVPf/openapi.json
