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

Financials and SEC EDGAR filings for US public companies, built for AI agents: one clean row per company and fiscal period (revenue, net income, EPS, assets, cash flow) with a source-filing link, plus filing lists and full-text search. Not affiliated with the SEC. By Harlo.

- **URL**: https://apify.com/brightish_ascent/company-financials-sec-filings.md
- **Developed by:** [Michael Rice](https://apify.com/brightish_ascent) (community)
- **Categories:** Business, Developer tools, Agents
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company-period financials 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?

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

## US Public Company Financials & SEC Filings API for AI Agents

Get **financial statements for US public companies** as **one clean JSON row per company and fiscal period**: revenue, gross profit, operating income, net income, EPS, assets, liabilities, equity, cash, debt, operating cash flow, capex and free cash flow. Every row links to the **source SEC filing**, so an AI agent (or an analyst) can cite it. The Actor also lists a company's **SEC filings** (10-K, 10-Q, 8-K with plain-English item labels, 20-F, proxy statements, registration statements …) and runs **full-text search across EDGAR filings**. Turn on **"Only new since last run"** and it becomes a scheduled monitor for new filings or new fiscal periods.

> **Not affiliated with, endorsed by, or operated by the U.S. Securities and Exchange Commission (SEC).** "SEC" and "EDGAR" are used only to describe the data source. Data comes from the SEC's documented public data APIs ([data.sec.gov](https://www.sec.gov/search-filings/edgar-application-programming-interfaces) submissions and XBRL company facts, plus the [company ticker file](https://www.sec.gov/files/company_tickers.json)) and, for search mode, the SEC's [EDGAR full-text search](https://www.sec.gov/edgar/search/) service. Data is returned **as filed**.
>
> **Not investment advice.** Figures are provided for information only, may contain filer errors or omissions, and should be verified against the linked filing before you rely on them.

### What this Actor does

- **Financials, de-duplicated.** Raw XBRL "company facts" repeat every number under every later filing (Apple's FY2025 10-K also carries FY2024 and FY2023 revenue). This Actor keeps each value **only from the filing that reports that period as its own**, so you get exactly one row per fiscal year or quarter, with `sourceFilingUrl`, `accessionNumber`, `form` and `filed` for citation. If an amendment (10-K/A, 10-Q/A) re-files a value, the amended value wins and `amendedBy` names it.
- **Annual or quarterly.** Annual rows come from 10-K, 20-F and 40-F. Quarterly rows come from 10-Q; fiscal Q4 and year-to-date-only cash flows are derived (for example FY minus 9 months) and listed in `derivedMetrics`, never silently mixed in.
- **Stable, flat schema for agents.** Every metric key is always present. A metric the company doesn't report is `null`, never a missing key, and `conceptsUsed` shows the exact XBRL concept behind each number (with fallbacks such as `Revenues` → `RevenueFromContractWithCustomerExcludingAssessedTax`). One reporting currency per company (USD, or e.g. TWD/EUR for foreign 20-F filers).
- **Filings list.** One row per filing with the primary document link, filing index link, filing and period dates, acceptance timestamp, and **8-K item codes with labels** (e.g. `2.02` → "Results of Operations and Financial Condition"). Filter by form type and date range.
- **Full-text search.** Search the text of SEC filings since 2001 for a phrase (`"going concern"`, `"material weakness"`, `"share repurchase"`), optionally limited to companies, forms and dates. One row per matching filing with a link to the matched document.
- **Monitor mode.** Opt-in `onlyNewSinceLastRun` returns only new filings, new fiscal periods or new search hits since the previous run with the same filters, so scheduled runs cost you only for genuinely new rows.
- **Company-level data only.** Insider and private-offering filings with personal data (**Forms 3, 4, 5, 144 and D**) are **permanently excluded**: they are never returned, can't be requested, and individual filers can't be looked up. Beneficial-ownership schedules (SC 13D/13G) and SEC correspondence are also not returned.
- **Polite by design.** A single shared rate limiter keeps the Actor at **at most 4 requests per second per run** (the SEC's fair-access limit is 10 requests per second per user, counted across all machines), with a declared User-Agent and contact, and backoff on HTTP 429/403/5xx. **Avoid running many copies in parallel**: batch companies into one run instead (up to 25). No login, no API key, no proxies.

### Who it's for

- **AI agents and LLM apps** answering "What were Microsoft's revenue and net income for the last 4 years?" or "List Tesla's 8-Ks since June" with citable numbers
- **Analysts, researchers and students** who want fundamentals in CSV, Excel or Google Sheets without parsing XBRL
- **Compliance, IR and competitive-intelligence teams** monitoring peers' new 10-Ks, 10-Qs and 8-Ks
- **Developers** who need a stable company-financials API on top of SEC EDGAR data

### Quick start

1. Click **Try for free** and run the prefilled input: Apple (`AAPL`), annual, last 4 fiscal years (4 rows).
2. Put your own tickers in `companies` (up to 25), choose `periodType` (`annual` or `quarterly`) and `periods`.
3. For a filing list, set `mode` to `filings` (optionally `forms: ["8-K"]` and `dateFrom`). For text search, set `mode` to `search` and `query`.
4. To monitor, turn on `onlyNewSinceLastRun` and add an Apify **Schedule** (daily works well).

An empty input `{}` works too. It behaves exactly like the prefill (AAPL, annual, 4 periods), never an unbounded crawl.

### Input

| Field | Type | Modes | Notes |
| --- | --- | --- | --- |
| `mode` | enum | all | `financials` (default), `filings`, `search` |
| `companies` | string\[] | all | Ticker (`AAPL`, `BRK.B`), CIK (`320193`) or exact company name (`Apple Inc.`). Up to 25. Empty in financials/filings = `AAPL` |
| `periodType` | enum | financials | `annual` (default) or `quarterly` |
| `periods` | int | financials | Most recent fiscal periods per company, 1–20 (default 4) |
| `forms` | enum\[] | filings, search | `10-K`, `10-Q`, `8-K`, `20-F`, `40-F`, `6-K`, `S-1`, `S-3`, `S-4`, `S-8`, `F-1`, `F-3`, `F-4`, `424B`, `DEF 14A`, `DEFA14A`, `PRE 14A`, `11-K`, `ARS`, `SD`, `10-12B`, `8-A12B`, `NT 10-K`, `NT 10-Q`, `25-NSE`, `10-KT`, `10-QT`. Each includes its `/A` amendment. Empty = all of them |
| `query` | string | search | Required in search mode. Words, or an exact phrase in double quotes |
| `dateFrom` / `dateTo` | YYYY-MM-DD | filings, search | Filing date range |
| `maxItems` | int | all | Max rows per run, 1–1000 (default 20). In financials mode the cap applies across all companies (companies × periods), so raise it when you ask for many companies. Companies cut by the cap are never dropped silently (see below) |
| `onlyNewSinceLastRun` | bool | all | Monitor mode (default false) |
| `lookbackHours` | int | all | Delta safety window for late-indexed filings, 0–720 (default 48) |

**How `maxItems` works with several companies.** Rows are returned company by company, and the default `maxItems` of 20 covers 5 companies × 4 periods. For more, set `maxItems` to at least companies × periods (for example `6 × 4 = 24`) or split the call. If the cap cuts the result, the Actor never drops a company silently. It logs a warning naming the skipped or partial companies, sets the run status message, and writes `truncationNote` (for example `"truncated: 1 company skipped, raise maxItems … Skipped: CVX."`), `skippedCompanies`, `partialCompanies` and a per-company entry in `notes` to the `OUTPUT` run summary. If the run's maximum cost per run stops it first, the same fields are filled but the note says `max total charge per run reached, not maxItems`, and each entry's `reason` is `maxTotalCharge` instead of `maxItems`.

### Input examples

Annual financials for three companies:

```json
{ "companies": ["MSFT", "GOOGL", "AMZN"], "periodType": "annual", "periods": 5 }
```

Last 8 quarters for one company:

```json
{ "companies": ["NVDA"], "periodType": "quarterly", "periods": 8 }
```

Recent 8-Ks for two companies:

```json
{ "mode": "filings", "companies": ["TSLA", "MSFT"], "forms": ["8-K"], "dateFrom": "2026-06-01", "maxItems": 20 }
```

Full-text search:

```json
{ "mode": "search", "query": "\"material weakness\"", "forms": ["10-K", "10-Q"], "dateFrom": "2026-01-01", "maxItems": 20 }
```

### Output example

Financials row (`rowType: "financials"`; abbreviated `conceptsUsed`):

```json
{
  "rowType": "financials",
  "ticker": "AAPL",
  "tickerNote": null,
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "periodType": "annual",
  "fiscalYear": 2025,
  "fiscalPeriod": "FY",
  "periodStart": "2024-09-29",
  "periodEnd": "2025-09-27",
  "form": "10-K",
  "filed": "2025-10-31",
  "accessionNumber": "0000320193-25-000079",
  "sourceFilingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm",
  "amendedBy": null,
  "currency": "USD",
  "taxonomy": "us-gaap",
  "revenue": 416161000000,
  "costOfRevenue": 220960000000,
  "grossProfit": 195201000000,
  "operatingIncome": 133050000000,
  "netIncome": 112010000000,
  "epsBasic": 7.49,
  "epsDiluted": 7.46,
  "weightedAverageDilutedShares": 15004697000,
  "totalAssets": 359241000000,
  "totalLiabilities": 285508000000,
  "stockholdersEquity": 73733000000,
  "cashAndEquivalents": 35934000000,
  "longTermDebt": 78328000000,
  "operatingCashFlow": 111482000000,
  "capitalExpenditures": 12715000000,
  "sharesOutstanding": 14776353000,
  "sharesOutstandingDate": "2025-10-17",
  "freeCashFlow": 98767000000,
  "derivedMetrics": ["freeCashFlow"],
  "conceptsUsed": { "revenue": "us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax", "netIncome": "us-gaap:NetIncomeLoss", "freeCashFlow": "derived:operatingCashFlow-capitalExpenditures" },
  "filingAcceptedAt": "2025-10-31T14:01:26Z",
  "dataSource": "SEC EDGAR XBRL company facts (data.sec.gov)"
}
```

Filing row (`rowType: "filing"`; search hits use the same fields with `rowType: "searchHit"` and `matchedDocumentType`):

```json
{
  "rowType": "filing",
  "ticker": "AAPL",
  "tickerNote": null,
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "form": "8-K",
  "formFamily": "8-K",
  "filingDate": "2026-07-30",
  "reportDate": "2026-07-30",
  "acceptedAt": "2026-07-31T00:30:28Z",
  "accessionNumber": "0000320193-26-000018",
  "description": "8-K",
  "itemCodes": ["2.02", "9.01"],
  "itemLabels": ["Results of Operations and Financial Condition", "Financial Statements and Exhibits"],
  "isXBRL": true,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
  "sicDescription": "Electronic Computers",
  "matchedDocumentType": null,
  "dataSource": "SEC EDGAR submissions (data.sec.gov)"
}
```

Every row also has `tickerNote` (usually `null`). It explains a missing or re-pointed ticker, for example when you pass a predecessor's CIK that is no longer in the SEC ticker file.

The run summary is saved as `OUTPUT` in the run's key-value store: row and charge counts, resolved and unresolved companies, how many person-form filings were filtered out, `truncated`, `incomplete` (plus `truncationNote`, `skippedCompanies` and `partialCompanies` when `maxItems` or the maximum cost per run cut companies), SEC request statistics and, in monitor mode, watermark details. `truncated` means more rows exist beyond `maxItems`; `incomplete` is true whenever this run returned fewer rows than were available (maxItems or the maximum cost per run). Check `truncationNote` for details.

### Only new since last run (monitor mode)

Set `onlyNewSinceLastRun: true` and schedule the Actor. The first run is a **baseline**: it returns the newest rows (up to `maxItems`) and remembers everything that exists now. Each later run with the same companies and filters returns only rows that appeared since: new filings (filings mode), new fiscal periods (financials mode) or new matching filings (search mode; if you set no `dateFrom`, the search window is chosen automatically). A run with nothing new is a successful run that costs only the start fee. State lives in the key-value store `company-financials-sec-filings-state` in your own Apify account, one record per filter set. Delete the record to start over. In financials mode a fiscal period counts as delivered once: a later amendment (10-K/A, 10-Q/A) for a period you already received is not re-delivered. Run without monitor mode to get the amended values. If your max-charge limit cuts a monitor run, the oldest new rows are returned first and the rest arrive on the next run.

### Use with AI agents / MCP

This Actor is built to be an agent tool: small inputs, an enum for every choice, a fixed flat output schema, and a source link on every row.

**Apify MCP server.** Add it as a tool on the hosted server (`https://mcp.apify.com`):

```text
https://mcp.apify.com?tools=brightish_ascent/company-financials-sec-filings
```

MCP client config (Claude Desktop, Cursor, VS Code and other MCP clients). You sign in to Apify with OAuth on first connect:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=brightish_ascent/company-financials-sec-filings"
    }
  }
}
```

- The tool is named `brightish_ascent--company-financials-sec-filings`. Its arguments are the input fields above.
- A call returns the run status and a `datasetId`. The agent reads rows with `get-dataset-items` (`limit`, `offset`, `fields`).
- With the default tool set, an agent can also run it via `call-actor` with `actor: "brightish_ascent/company-financials-sec-filings"`.
- Local stdio server: `npx @apify/actors-mcp-server --tools brightish_ascent/company-financials-sec-filings`, with `APIFY_TOKEN` set.

**Agent frameworks.** LangChain: `ApifyActorsTool("brightish_ascent/company-financials-sec-filings")` from `langchain-apify`. CrewAI: `ApifyActorsTool(actor_name="brightish_ascent/company-financials-sec-filings")` from `crewai_tools`. OpenAI Agents SDK: `MCPServerStreamableHttp` with the MCP URL above and an `Authorization: Bearer <APIFY_TOKEN>` header. These tools return every row inline, so keep `maxItems` and `periods` small.

**Example agent prompts:**

> What were Microsoft's revenue, net income and free cash flow for the last 4 fiscal years? Use the company financials tool with `companies: ["MSFT"]`, `periodType: "annual"`, `periods: 4`, and cite `sourceFilingUrl` for each year.

> Compare Coca-Cola and PepsiCo gross margin over the last 8 quarters. Use `companies: ["KO", "PEP"]`, `periodType: "quarterly"`, `periods: 8`, and compute grossProfit / revenue.

> Did Tesla file any 8-Ks about material agreements since June? Use `mode: "filings"`, `companies: ["TSLA"]`, `forms: ["8-K"]`, `dateFrom: "2026-06-01"`, `maxItems: 10`, and read `itemLabels`.

**Cost per call.** $0.00005 per run, plus $0.002 per financials row (company-period) or $0.001 per filing / search row:

| Call | Rows | Cost |
| --- | ---: | ---: |
| 1 company × 4 annual periods (the prefill) | 4 | ≈ $0.008 |
| 3 companies × 4 annual periods | 12 | ≈ $0.024 |
| 1 company × 8 quarters | 8 | ≈ $0.016 |
| 20 filings or search hits (default `maxItems`) | 20 | ≈ $0.020 |

Unresolved tickers, rejected inputs and runs with nothing new cost only the start fee. With `call-actor`, you can also cap spend with `maxTotalChargeUsd`.

**Tips for agents:**

- Prefer tickers. If a ticker is ambiguous or new, pass the CIK.
- Keep `periods` at 4–8. In financials mode set `maxItems` to at least companies × periods (the default 20 covers 5 companies × 4 periods). If companies were cut, `OUTPUT.truncationNote` and the run status message name them.
- Make one call with several companies (up to 25) instead of many parallel calls. Each run is limited to 4 requests per second, and the SEC's 10 requests per second limit applies to all runs together.
- `null` means "not reported under the concepts we map", not zero. Check `conceptsUsed` and `derivedMetrics` before comparing companies.
- Quarterly EPS is not derived for fiscal Q4 (EPS isn't additive), so Q4 `epsBasic`, `epsDiluted` and `weightedAverageDilutedShares` are usually `null`.
- Always cite `sourceFilingUrl` (financials) or `filingUrl` (filings). Not investment advice.

### Pricing

**Pay per event (PAY_PER_EVENT)** only, no "+ usage" fees:

| Event | Price (USD) | When |
| --- | ---: | --- |
| Actor start (`apify-actor-start`) | **$0.00005** | Per run, per GB of memory (1 event at the default 256 MB) |
| Company-period row (`company-period-row`) | **$0.002** | Per financials row returned (one company × one fiscal period) |
| Filing row (`filing-row`) | **$0.001** | Per filing or full-text search row returned |

You're charged only for rows actually returned. Filtered rows, excluded forms, unresolved companies and already-seen rows (monitor mode) are never charged.

### FAQ

**Is this the official SEC API?** No. It's an independent client for the SEC's documented data APIs (data.sec.gov) and its public EDGAR full-text search service. It isn't made by, affiliated with, or endorsed by the SEC.

**Is this investment advice?** No. The data is returned as filed by companies, for information only. Verify against the linked filing.

**Why does my company show `null` for some metrics?** Companies tag their statements differently. We map each metric to a short list of standard XBRL concepts and return `null` rather than guess. Banks, insurers and some foreign filers often have no `costOfRevenue`/`grossProfit`; companies with several share classes may have no `sharesOutstanding`.

**Why are some quarterly values marked as derived?** 10-Qs report cash flows year-to-date only, and the fourth quarter appears only in the annual report. The Actor derives those quarters by subtraction (for example FY minus 9 months) and lists them in `derivedMetrics`; `conceptsUsed` shows the exact calculation.

**Can I get insider trades (Form 4), Form 144 or Form D?** No. Those filings contain personal data about individuals and are permanently excluded. You also can't look up an individual filer's CIK. Beneficial-ownership schedules (SC 13D/13G) and SEC correspondence aren't returned either.

**Does it return people's names?** It returns company filings only and isn't a people-search tool. Filing titles and exhibit descriptions are company disclosures and can name officers or directors (for example an employment agreement exhibit), as published by the company.

**Does it download filings or exhibits?** No. It returns metadata and links (`sourceFilingUrl`, `filingUrl`, `filingIndexUrl`). Open the link to read the document.

**Which companies are covered?** Any SEC registrant with a ticker in the SEC's company ticker file, or any company CIK. Financials need XBRL data, which US filers have provided since about 2009–2011. Foreign 20-F/40-F filers are covered when they file XBRL (often IFRS, in their own currency).

**What happens with a bad ticker?** The run still succeeds. The ticker is listed in `OUTPUT.unresolvedCompanies` with a hint, and you pay only the start fee.

**How fast is it?** About 2 requests per company (financials) at no more than 4 requests per second per run, so a 1-company call usually finishes in a few seconds. Don't run many copies in parallel: the SEC's limit of 10 requests per second applies to all runs together.

### Limitations (honest list)

- Numbers are as filed. Filer tagging errors, restatements in later years, and unusual concepts are not corrected. Values come from the filing that reports each period as its own (or its amendment), not from later comparatives.
- Only non-dimensional (consolidated, whole-company) XBRL facts are used. Segment data and per-class share counts aren't included.
- A ticker can briefly point to a new holding company that has no XBRL history yet (e.g. after a reorganization). The run then says so in `OUTPUT.notes`; pass the predecessor's CIK to get its history (for example ExxonMobil: CIK `34088`).
- Fiscal Q4 EPS (`epsBasic`, `epsDiluted`) and `weightedAverageDilutedShares` are left `null` in quarterly mode unless the company tags the 3-month figure itself. They aren't additive, so subtracting 9-month EPS from full-year EPS would be wrong.
- Full-text search uses the JSON service behind sec.gov's EDGAR Full-Text Search page. The SEC doesn't document it as an API, so it may change without notice.
- Full-text search covers filings since 2001, returns at most the first 1,000 matching documents per run, and is ranked by relevance (use `dateFrom`/`dateTo` to focus on recent filings).
- In financials mode, rows are filled company by company up to `maxItems`; companies past the cap are reported in `OUTPUT.truncationNote` and the status message, not returned.
- In filings mode, `maxItems` keeps the newest filings across all requested companies; only a company with no filing returned is reported in `truncationNote`. In a monitor baseline run, rows past `maxItems` are remembered as known and are not delivered later.
- Price data, ratios, analyst estimates and earnings-call transcripts aren't included.

### License

MIT (Actor code). SEC EDGAR data is public information; see the SEC's [website policies](https://www.sec.gov/privacy) and [fair-access guidance](https://www.sec.gov/os/accessing-edgar-data).

# Actor input Schema

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

What to return. financials = income statement, balance sheet and cash-flow highlights, one row per company and fiscal period (annual or quarterly) from XBRL data, with prior-year duplicates removed. filings = list of a company's SEC filings (10-K, 10-Q, 8-K, ...) with links, newest first. search = full-text search across SEC filings for a phrase (optionally limited to companies, forms and dates).

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

US-listed companies by stock ticker (AAPL, MSFT, BRK.B), SEC CIK number (320193) or exact registered company name (Apple Inc.). Up to 25. Required for financials and filings mode (if empty there, AAPL is used); optional filter in search mode. Company-level data only: individual filers (insiders) are rejected.

## `periodType` (type: `string`):

Financials mode only. annual = fiscal-year rows from 10-K, 20-F or 40-F. quarterly = fiscal-quarter rows from 10-Q; fiscal Q4 and year-to-date-only cash flows are derived (full year minus 9 months) and listed in derivedMetrics. Fiscal Q4 EPS (epsBasic, epsDiluted) and weightedAverageDilutedShares are left null unless the company reports the 3-month figure itself, because they are not additive.

## `periods` (type: `integer`):

Financials mode only. Number of most recent fiscal periods to return per company, 1-20 (default 4). Each returned row is one charged company-period row.

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

Filings and search mode. Limit to these SEC form types; each also matches its amendment (10-K includes 10-K/A; 424B includes 424B1-424B8). Empty = all supported company forms. Forms 3, 4, 5, 144 and D (insider and private-offering filings with personal data) are permanently excluded and cannot be requested.

## `query` (type: `string`):

Search mode only (required there). Words or an exact phrase in double quotes to find in filing text, e.g. "share repurchase", "going concern", "material weakness", tariffs. Returns one row per matching filing with a link to the matched document.

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

Filings and search mode. Earliest filing date, YYYY-MM-DD, e.g. 2026-01-01. Empty = no lower bound (filings: newest first; search: all years since 2001).

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

Filings and search mode. Latest filing date, YYYY-MM-DD. Empty = today.

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

Max rows per run, 1-1000 (default 20). In financials mode the cap applies across ALL companies: a run needs companies x periods rows (e.g. 6 x 4 = 24), so raise maxItems or split the call. Cut companies are never dropped silently: OUTPUT truncationNote and the run status name them. You pay per returned row.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled monitoring. If true, returns only rows that appeared since an earlier run with the same companies and filters (new filings, new fiscal periods, new search hits), so you are not charged twice. The first run is a baseline that returns the newest rows. State lives in the key-value store company-financials-sec-filings-state in your account; delete it to reset. Default false.

## `lookbackHours` (type: `integer`):

Only with onlyNewSinceLastRun. Re-checks this many hours before the last watermark for late-indexed filings, de-duplicated against rows already returned (never re-charged). 0-720, default 48.

## Actor input object example

```json
{
  "mode": "financials",
  "companies": [
    "AAPL"
  ],
  "periodType": "annual",
  "periods": 4,
  "maxItems": 20,
  "onlyNewSinceLastRun": false,
  "lookbackHours": 48
}
```

# Actor output Schema

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

Default dataset. financials rows: ticker, cik, companyName, periodType, fiscalYear, fiscalPeriod, periodStart, periodEnd, form, filed, accessionNumber, sourceFilingUrl, currency, revenue, costOfRevenue, grossProfit, operatingIncome, netIncome, epsBasic, epsDiluted, weightedAverageDilutedShares, totalAssets, totalLiabilities, stockholdersEquity, cashAndEquivalents, longTermDebt, operatingCashFlow, capitalExpenditures, freeCashFlow, sharesOutstanding, derivedMetrics, conceptsUsed. filing/searchHit rows: ticker, cik, companyName, form, formFamily, filingDate, reportDate, acceptedAt, accessionNumber, description, itemCodes, itemLabels, filingUrl, filingIndexUrl, matchedDocumentType.

## `runSummary` (type: `string`):

Counts, charged rows, resolved/unresolved companies, excluded person-form count, truncated (more rows exist beyond maxItems), incomplete (this run returned fewer rows than were available because of maxItems or the maximum cost per run; in filings mode it is usually true because maxItems keeps only the newest filings), truncationNote / skippedCompanies / partialCompanies when companies were cut, SEC request stats and delta-mode watermark info.

# 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"
    ],
    "periods": 4,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("brightish_ascent/company-financials-sec-filings").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"],
    "periods": 4,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("brightish_ascent/company-financials-sec-filings").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"
  ],
  "periods": 4,
  "maxItems": 20
}' |
apify call brightish_ascent/company-financials-sec-filings --silent --output-dataset

```

## MCP server setup

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

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/HBgbexTOCJIjWGEgc/builds/Dn3KXsrbICyobL4wd/openapi.json