# SEC Company Financials: Clean Fundamentals from EDGAR (`plainfold/sec-company-financials`) Actor

Clean annual and quarterly financials from official SEC EDGAR filings: revenue, net income, EPS, cash flow, assets, liabilities, cash, margins, YoY growth and TTM, plus company info and latest filings. Tickers, CIKs or names. No API key. $0.005/company, $0.0005/run.

- **URL**: https://apify.com/plainfold/sec-company-financials.md
- **Developed by:** [Plainfold](https://apify.com/plainfold) (community)
- **Categories:** AI, 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 company financials

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: Clean Fundamentals from EDGAR

### At a glance (for AI agents)

- **What it does:** For each ticker, CIK or company name you give it, returns **clean key financials from the company's official SEC filings** (EDGAR XBRL data): revenue, gross profit, operating income, net income, basic and diluted EPS, operating cash flow, capex, free cash flow, total assets, total liabilities, equity, cash, current assets/liabilities, long-term debt and shares, for the **latest fiscal years and quarters**, with **YoY and QoQ growth, margins and trailing twelve months (TTM)**. It also returns company info (CIK, tickers, exchange, industry SIC, state of incorporation, fiscal year end, business address) and the **latest filings with links** (10-K, 10-Q, 8-K, 20-F, 6-K...).
- **When to use it:** answering "how is company X doing?", comparing companies, checking growth and profitability before a sales call, investment research, enriching a list of public companies, or getting citable numbers (every period links to its source filing).
- **When not to use it:** stock prices or market data, private companies that don't file with the SEC, analyst estimates, or full line-by-line statements (this returns the key items, not every XBRL tag). No person data: insider (Form 3/4/5) and ownership filings are hidden by default, and individual filers are refused.
- **Cost:** pay-per-event: **$0.005 per company** returned with financial data, plus **$0.0005 per run** (Actor start, at the default 512 MB memory). Not-found companies, companies with no financial data on EDGAR and errors are free. 100 companies in one run cost at most about $0.50. Apify platform usage is included.
- **Speed:** about 0.5 to 2 seconds per company (two SEC API calls each; the Actor respects SEC's 10 requests/second limit).
- **Auth:** none. Uses SEC's official free APIs (data.sec.gov). AI agents can run it through the Apify API or Apify's MCP server.
- **Input:** just `companies`: tickers (`AAPL`), CIKs (`320193`) or names (`Figma`). Everything else is optional.

**Example input:**

```json
{
  "companies": ["AAPL", "Figma", "ASML"],
  "annualPeriods": 3,
  "quarterlyPeriods": 4
}
```

**Example output** (shortened, real data from a test run):

```json
{
  "input": "Figma",
  "found": true,
  "status": "ok",
  "matchedBy": "name",
  "cik": 1579878,
  "name": "Figma, Inc.",
  "tickers": ["FIG"],
  "exchanges": ["NYSE"],
  "sicDescription": "Services-Prepackaged Software",
  "fiscalYearEnd": "12-31",
  "stateOfIncorporation": "DE",
  "accountingStandard": "US GAAP",
  "currency": "USD",
  "latestAnnual": {
    "fiscalYear": 2025, "fiscalPeriod": "FY", "periodStart": "2025-01-01", "periodEnd": "2025-12-31",
    "revenue": 1055788000, "grossProfit": 870261000, "operatingIncome": -1290457000, "netIncome": -1250463000,
    "epsDiluted": -3.71, "operatingCashFlow": 250681000, "freeCashFlow": 246237000,
    "totalAssets": 2348207000, "totalLiabilities": 837566000, "cashAndEquivalents": 403469000,
    "grossMarginPct": 82.4, "netMarginPct": -118.4, "revenueGrowthYoYPct": 41,
    "form": "10-K", "filed": "2026-02-18",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/1579878/000162828026009228/0001628280-26-009228-index.htm"
  },
  "latestQuarter": { "fiscalYear": 2026, "fiscalPeriod": "Q2", "periodEnd": "2026-06-30", "revenue": 370083000, "revenueGrowthYoYPct": 48.2, "revenueGrowthQoQPct": 11 },
  "ttm": { "periodEnd": "2026-06-30", "revenue": 1281471000, "netIncome": -1578125000, "freeCashFlow": 232314000 },
  "annual": ["... one object per fiscal year, newest first ..."],
  "quarterly": ["... one object per quarter, newest first ..."],
  "filings": [{ "form": "10-Q", "filingDate": "2026-08-05", "reportDate": "2026-06-30", "documentUrl": "https://www.sec.gov/Archives/edgar/data/1579878/...", "indexUrl": "..." }],
  "summary": "Figma, Inc. (FIG): FY2025 revenue $1.06B (+41% YoY), net income $-1.25B; latest quarter Q2 FY2026 (to 2026-06-30) revenue $370.1M (+48.2% YoY)."
}
```

### What you get per period

Every object in `annual` and `quarterly` (and `latestAnnual` / `latestQuarter`) has:

| Field | Meaning |
|---|---|
| `fiscalYear`, `fiscalPeriod`, `periodStart`, `periodEnd` | The company's own fiscal labels (Apple's FY2025 ends 2025-09-27) |
| `revenue`, `grossProfit`, `operatingIncome`, `netIncome` | Income statement (net income attributable to the company) |
| `epsBasic`, `epsDiluted`, `dilutedSharesWeighted` | Per share |
| `operatingCashFlow`, `capitalExpenditures`, `freeCashFlow` | Cash flow (FCF = operating cash flow - capex) |
| `totalAssets`, `totalLiabilities`, `stockholdersEquity`, `cashAndEquivalents`, `currentAssets`, `currentLiabilities`, `longTermDebt`, `sharesOutstanding` | Balance sheet at period end |
| `grossMarginPct`, `operatingMarginPct`, `netMarginPct` | Margins, in percent |
| `revenueGrowthYoYPct`, `netIncomeGrowthYoYPct`, `epsDilutedGrowthYoYPct` (+ `operatingIncomeGrowthYoYPct` annual, `revenueGrowthQoQPct` quarterly) | Growth in percent vs the same period a year earlier (or the previous quarter). Losses use the absolute prior value, so a loss shrinking from -100 to -50 is +50% |
| `form`, `filed`, `accessionNumber`, `filingUrl` | The filing that first reported the period |
| `derived` | Fields computed rather than read directly (see below) |
| `xbrlTags` | The XBRL tag used for each field, for auditing |

Amounts are in **full currency units** (not thousands) in the company's **reporting currency** (`currency`: USD, EUR, TWD...). Missing items are `null`; the Actor never guesses.

### How the numbers are built

- **Source:** SEC's XBRL "company facts" API, the structured data companies file with every 10-K, 10-Q, 20-F and 40-F.
- **Tag mapping:** each line item has a list of equivalent tags (for example revenue: `Revenues`, `RevenueFromContractWithCustomerExcludingAssessedTax`, `SalesRevenueNet`...; IFRS: `Revenue`). The tag that covers the most recent period wins, and older periods are filled from the others, because companies switch tags over the years.
- **Restatements:** if a later filing restates a period, the latest figure is used.
- **Derived values:** companies often don't report Q4 separately (only the full year), and 10-Qs report cash flow year-to-date. The Actor derives those quarters by subtraction (Q4 = full year - nine months) and lists them in `derived`. EPS is never derived. If `totalLiabilities` isn't tagged, it's computed as total liabilities and equity minus equity.
- **TTM:** sum of the 4 latest consecutive quarters.
- **Foreign filers** (20-F/40-F, e.g. ASML, TSMC, Klarna): annual data in their reporting currency, under US GAAP or IFRS. Their interim 6-K reports carry no XBRL data, so `quarterly` is usually empty.
- **Recent IPOs:** quarterly data appears after the first 10-Q; annual data after the first 10-K. `notes` explains gaps.

### Status values

| status | meaning | charged |
|---|---|---|
| `ok` | Company found and financial data returned | yes |
| `no_financial_data` | Company found (info and filings returned) but no XBRL financials on EDGAR (funds, shells, brand-new registrants) | no |
| `not_found` | No SEC registrant matches; check `alternatives` | no |
| `not_a_company` | The CIK belongs to an individual filer | no |
| `error` | SEC unreachable; try again | no |

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array of strings | (required) | Tickers, CIKs or names. `name:Ford` / `ticker:FORD` force one reading |
| `annualPeriods` | integer | `5` | Fiscal years to return (0-20) |
| `quarterlyPeriods` | integer | `8` | Quarters to return (0-40) |
| `includeFilings` | boolean | `true` | Add the latest filings list |
| `maxFilings` | integer | `15` | Filings per company (0-100) |
| `filingForms` | array | (all but insider/ownership and 424B2/424B3/424B7/FWP) | Only these forms, e.g. `["10-K", "10-Q", "8-K"]` |

### Matching companies

Tickers and CIKs are exact. Names are matched against SEC's list of companies with tickers: exact name first (ignoring Inc./Corp./punctuation), then names starting with your text, then names containing all your words; other candidates are returned in `alternatives`. Companies without a ticker (private companies with SEC filings) need their CIK, which you can find on [EDGAR company search](https://www.sec.gov/edgar/searchedgar/companysearch).

### Pricing

Pay-per-event:

- **$0.005 per company** returned with financial data (`status: "ok"`)
- **$0.0005 per run** (Actor start, at the default 512 MB memory; one start event per GB of memory)
- No charge for `not_found`, `no_financial_data`, `not_a_company` or `error` results

Set a maximum cost per run and the Actor stops cleanly when the budget is reached.

### Use from code or an AI agent

Apify API, JavaScript/Python clients, or Apify's MCP server (`https://mcp.apify.com/?actors=plainfold/sec-company-financials`). Synchronous call:

`POST https://api.apify.com/v2/acts/plainfold~sec-company-financials/run-sync-get-dataset-items` with body `{"companies": ["MSFT"], "quarterlyPeriods": 4}`.

### FAQ

**Is this a scraper?** No. It calls SEC's official public APIs (data.sec.gov), which are free and need no key, with a declared User-Agent and under SEC's rate limit.

**How fresh is the data?** SEC updates the APIs within minutes of a filing being accepted. A company's numbers change when it files its next 10-Q/10-K.

**Why does a number differ from the press release?** Press releases often show adjusted (non-GAAP) figures; this Actor returns the GAAP/IFRS figures from the filing itself.

**Why is a field null?** The company didn't tag that item (for example, banks don't report gross profit, and many companies don't tag total liabilities). See `xbrlTags` for what was used.

### Support

Spotted a wrong mapping for a company? Open an issue on the Actor's Issues tab with the ticker.

More data tools from Plainfold, all usable by AI agents over MCP: [plainfold.github.io/tools](https://plainfold.github.io/tools/).

# Actor input Schema

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

Companies to look up, one per entry. Accepts a stock ticker ("AAPL", "BRK.B"), an SEC CIK ("320193" or "0000320193") or a company name ("Figma", "Ford Motor"). ALL-CAPS short entries are read as tickers first; write "name:Ford" or "ticker:FORD" to force one. Works for US companies and foreign companies that file with the SEC (20-F/40-F filers such as ASML or TSMC). One result (and one charge, only if financial data is returned) per entry. Up to 500 per run.

## `annualPeriods` (type: `integer`):

Number of most recent fiscal years to return in `annual` (from 10-K, 20-F or 40-F filings), newest first. 0 = none. Default: 5.

## `quarterlyPeriods` (type: `integer`):

Number of most recent fiscal quarters to return in `quarterly`, newest first. Q4 and quarterly cash flow are derived from year-to-date figures when the filing doesn't state them (flagged in `derived`). Foreign 20-F/40-F filers usually have no quarterly XBRL data. 0 = none. Default: 8.

## `includeFilings` (type: `boolean`):

Add the company's latest SEC filings (form, filing date, period, description, 8-K item numbers, document and index links) in `filings`. Insider and ownership forms (3, 4, 5, 144, 13D/G, 13F) and high-volume offering paperwork (424B2, 424B3, 424B7, FWP) are left out unless you list them in `filingForms`. Default: true.

## `maxFilings` (type: `integer`):

Maximum number of filings listed per company, newest first. Default: 15.

## `filingForms` (type: `array`):

Optional: list only these form types in `filings`, e.g. \["10-K", "10-Q", "8-K"] or \["20-F", "6-K"]. Empty = all forms except insider/ownership forms and 424B2/424B3/424B7/FWP.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "Figma",
    "ASML"
  ],
  "annualPeriods": 5,
  "quarterlyPeriods": 8,
  "includeFilings": true,
  "maxFilings": 15
}
```

# Actor output Schema

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

One item per company (Overview view; full items include annual, quarterly and filings arrays).

## `fullResults` (type: `string`):

All fields for every company.

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

Counts of companies with financials, without data and not found.

# 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",
        "Figma",
        "ASML"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("plainfold/sec-company-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",
        "Figma",
        "ASML",
    ] }

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

```

## MCP server setup

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