# US Company Filings & Financials: 10-K, 10-Q, 8-K, XBRL Facts (`tan-solutions/company-filings`) Actor

Get the filing history, profile and key financial facts (revenue, net income, assets, EPS, cash flow) of US public companies by ticker or CIK, from SEC EDGAR public data. Official endpoints, your own declared contact. Pay per company; failures are free. Not affiliated with the U.S. SEC.

- **URL**: https://apify.com/tan-solutions/company-filings.md
- **Developed by:** [Tan Solutions](https://apify.com/tan-solutions) (community)
- **Categories:** Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 company delivereds

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

## US Company Filings & Financials: 10-K, 10-Q, 8-K, XBRL Facts

Get the filing history, profile and key financial facts of US public companies by ticker or CIK. Give a list of tickers (AAPL, MSFT) or CIK numbers (320193) and get one clean row per company: the company profile,
its filing history (10-K, 10-Q, 8-K, S-1 and more, each with a direct link) and the latest key financial facts
(revenue, net income, EPS, assets, liabilities, equity, cash, operating cash flow, shares outstanding).

All data is public data from SEC EDGAR, read through the official public JSON endpoints only. Not affiliated with,
endorsed or approved by the U.S. Securities and Exchange Commission.

### Run it from the API or on a schedule

Get one row per company back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token from Console, **Settings**, **API & Integrations**):

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~company-filings/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies":["AAPL","MSFT"],"forms":["10-K","10-Q"],"companyName":"Your Company","contactEmail":"you@example.com"}'
```

Put your own company name and contact email in place of `Your Company` and `you@example.com`: the SEC requires them for automated access. Without them the run returns one free row that says what to add.

Check the same companies for new filings every weekday at 22:00 UTC with an Apify schedule (`GLcxOiTSuBPtnhkhU` is this Actor's ID):

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name": "company-filings-daily", "cronExpression": "0 22 * * 1-5", "timezone": "UTC", "isEnabled": true, "isExclusive": true,
       "actions": [{"type": "RUN_ACTOR", "actorId": "GLcxOiTSuBPtnhkhU",
         "runInput": {"body": "{\"companies\":[\"AAPL\",\"MSFT\"],\"forms\":[\"10-K\",\"10-Q\"],\"companyName\":\"Your Company\",\"contactEmail\":\"you@example.com\"}", "contentType": "application/json"}}]}'
```

In Apify Console the same is: **Schedules**, **Create new**, cron `0 22 * * 1-5`, add this Actor with your input.

### What it does

- Finds each ticker in the official ticker list, or takes the CIK number you give.
- Reads the company's profile and filing list and, if you want them, its XBRL financial facts.
- Keeps only the form types and filing dates you ask for, newest first, up to `maxFilingsPerCompany` per company.
- Picks the latest annual value of 11 key metrics plus shares outstanding, and any extra XBRL concepts you name.
- Sends every request with your company name and contact email, as the SEC asks, at a polite pace.
- If the SEC asks it to slow down, it waits once, tries once more and otherwise stops cleanly. Companies it could
  not fetch are listed and cost nothing.

### Who it is for

- Analysts and investors who want filings and key numbers for a watchlist in one table.
- Developers and AI agents that need clean, structured company data from an API call.
- Sales, compliance and research teams who check public companies by ticker.

### Quick start

1. Add your tickers or CIK numbers in **Companies**.
2. Add **your company or name** and **your contact email**. The SEC requires every automated tool to say who is
   behind it, so these two go into the request header sent to the SEC. They are never in your results, and the email
   is masked in the log. Without them the run makes no request to the SEC and returns one free row that tells you
   what to add.
3. Click **Start**. A few companies take a few seconds; 100 companies take about 4 minutes.

### Input

| Field | Required | What it is |
| --- | --- | --- |
| `companies` | yes | Tickers or CIK numbers, one per line. At most 1,000 per run. |
| `companyName` | yes (the SEC requires it) | Your company or your own name. Sent only to the SEC, in the request header. |
| `contactEmail` | yes (the SEC requires it) | An address where the SEC can reach you. Sent only to the SEC, never in the output. |
| `forms` | no | Form types to keep, e.g. `10-K`, `10-Q`, `8-K`. Empty = all company forms. |
| `includeAmendments` | no | Also keep the amendments (`10-K/A` for `10-K`). On by default. |
| `filedAfter`, `filedBefore` | no | Filing date window, YYYY-MM-DD. |
| `maxFilingsPerCompany` | no | Filings per company, newest first (default 20, 0 to 2,000). 0 = profile and facts only. |
| `includeFacts` | no | Add the key financial facts. On by default. |
| `extraConcepts` | no | More XBRL concepts, e.g. `us-gaap:ResearchAndDevelopmentExpense` (at most 30). |
| `includeInsiderFilings` | no | Also return Forms 3/4/5, 144 and 13D/13G, and accept CIKs of individual filers. Off by default. |
| `maxCompanies` | no | Cap on companies per run (default 100, at most 1,000). |
| `requestsPerSecond` | no | Pace, 0.5 to 5 (default 2). Lower it if you run several jobs at the same time. |

```json
{
  "companies": ["AAPL", "MSFT", "320193"],
  "companyName": "Your Company Ltd",
  "contactEmail": "you@example.com",
  "forms": ["10-K", "10-Q"],
  "filedAfter": "2025-01-01",
  "maxFilingsPerCompany": 20
}
```

Replace the name and email with your own: placeholder domains such as example.com are refused, so this example does not run as is.

### Output example

One row per company (the same company twice gives one row). This is a real row from a run on 13 November 2026,
shortened to one filing and three of the twelve facts:

```json
{
  "input": "AAPL",
  "status": "ok",
  "cik": "0000320193",
  "name": "Apple Inc.",
  "tickers": ["AAPL"],
  "exchanges": ["Nasdaq"],
  "entityType": "operating",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "category": "Large accelerated filer",
  "stateOfIncorporation": "CA",
  "fiscalYearEnd": "0926",
  "filingsMatched": 315,
  "filingsReturned": 20,
  "filings": [
    { "accessionNumber": "0000320193-26-000026", "form": "10-K", "filingDate": "2026-11-03", "reportDate": "2026-09-26",
      "primaryDocument": "aapl-20260926.htm", "isXBRL": true, "isInlineXBRL": true,
      "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000026/aapl-20260926.htm",
      "indexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000026/0000320193-26-000026-index.htm" }
  ],
  "factsAvailable": true,
  "keyFacts": [
    { "metric": "revenue", "concept": "us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax", "unit": "USD",
      "value": 478834000000, "fiscalYear": 2026, "fiscalPeriod": "FY", "form": "10-K", "periodEnd": "2026-09-26" },
    { "metric": "netIncome", "concept": "us-gaap:NetIncomeLoss", "unit": "USD",
      "value": 132175000000, "fiscalYear": 2026, "fiscalPeriod": "FY", "form": "10-K", "periodEnd": "2026-09-26" },
    { "metric": "epsDiluted", "unit": "USD/shares", "value": 8.98, "fiscalYear": 2026, "fiscalPeriod": "FY", "form": "10-K" }
  ],
  "source": "U.S. SEC EDGAR",
  "sourceUrl": "https://data.sec.gov/submissions/CIK0000320193.json",
  "error": null,
  "scrapedAt": "2026-11-13T09:40:19.578Z"
}
```

`status` is one of `ok`, `not_found`, `invalid_input`, `individual_filer`, `not_fetched`, `error`, `too_large`. Every
row that is not `ok` has an `error.code` and a plain message. A `SUMMARY` record in the key-value store lists the
counts, the companies not fetched and why the run stopped.

### Pricing

You pay per company delivered (the `company` event): one row with status `ok`, with its profile, filings and key
facts. Not found, skipped and failed companies are free, and so are invalid inputs and companies not fetched. If your
spending limit is reached, the run stops cleanly and tells you so.

| Apify plan | Price per 1,000 companies |
| --- | --- |
| Free | $0.80 |
| Bronze | $0.65 |
| Silver | $0.55 |
| Gold | $0.50 |

Apify's standard Actor start event is charged when a run starts, at the platform's default price.

### Limits

- At most 1,000 companies per run (default cap 100). There is no "all companies" mode.
- The SEC allows at most 10 requests per second per user. This Actor sends one request at a time, 2 per second by
  default and never more than 5, and needs about 2 requests per company. It never uses proxies or changes identity.
- Need every filer or every filing? The SEC publishes nightly bulk ZIP files of the same data (submissions.zip and
  companyfacts.zip, under the EDGAR API documentation on sec.gov). Use those for bulk work; this Actor is for lists of
  companies you choose.
- Facts are what each company tagged in XBRL. Companies tag differently and filings can be amended, so some metrics
  are missing for some companies (`keyFacts` then has fewer entries).
- Filing documents are linked, not downloaded.
- Individual filers (insiders, beneficial owners) are skipped unless you turn on `includeInsiderFilings`, and their
  addresses, phone numbers and tax IDs are never returned.

### FAQ

**Why do I have to give my name and email?** The SEC requires every automated tool to declare who is behind it in the
request header. Your details go only to the SEC in that header. They are not in the dataset and are masked in the log.

**What if a ticker is not found?** You get a free `not_found` row for it. Tickers change after mergers and renames; the
CIK number always works.

**What happens if the SEC slows me down?** The run pauses once for up to 10 minutes and tries again. If the SEC still
says no, the run ends cleanly, the rest are listed as `not_fetched` and you pay nothing for them. Run them again later,
or lower `requestsPerSecond`.

**Can I get only annual reports?** Yes: set `forms` to `10-K` (amendments are included unless you turn that off), or
`maxFilingsPerCompany` to 0 for profile and facts only.

**Can I get the full text of a filing?** Not in this version: each filing has a direct link to its main document.

### Related tools by Tan Solutions

- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): web pages to clean Markdown for LLMs, RAG pipelines and AI agents.
- [Document to Markdown](https://apify.com/tan-solutions/document-to-markdown): PDF, Word and PowerPoint files to Markdown for LLMs and RAG.
- [SEO Audit Tool](https://apify.com/tan-solutions/seo-audit): on-page SEO checker with PageSpeed for any list of pages.
- [Domain Intelligence](https://apify.com/tan-solutions/domain-intel): DNS, WHOIS/RDAP, SSL and tech stack for up to 1,000 domains.

### More from Tan Solutions

- [US company filings tool page](https://www.tansolutions.org/tools/company-filings/): details and examples for this Actor on our site.
- [Guide: 10-K and XBRL company facts by API, limits and fields](https://www.tansolutions.org/guides/company-facts-api-10-k-xbrl/)
- [All Tan Solutions data tools](https://www.tansolutions.org/tools/)

### Your responsibilities

You are responsible for lawful use of the data you get back and for following the SEC's fair-access policy in your own
downstream use. The Actor reads only official public endpoints, declares your contact, keeps to a polite pace and stops
when asked. Data is provided without warranty (XBRL values and calendar alignment are approximate, and filings can be
amended); liability is capped at the fees you paid in the last 12 months. Please cite the U.S. SEC (EDGAR) as the
source when you publish the data. Questions and issues are answered within 14 days through the Actor's Issues tab.

Not affiliated with, endorsed or approved by the U.S. Securities and Exchange Commission. SEC and EDGAR are marks of
the U.S. Securities and Exchange Commission.

Made by Tan Solutions.

# Actor input Schema

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

Tickers (AAPL, BRK.B) or SEC CIK numbers (320193). Duplicates are removed. Up to 1,000 per run.

## `companyName` (type: `string`):

The SEC fair-access policy asks automated tools to declare a company name and a contact email in the User-Agent header. This is yours; it is sent only to the SEC and never stored in the results.

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

An address where the SEC can reach you about your traffic. Sent only to the SEC in the User-Agent header; never stored in the results and masked in the log.

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

Only these forms, e.g. 10-K, 10-Q, 8-K, DEF 14A, 20-F. Empty = all forms. Insider forms (3, 4, 5, 144, 13D, 13G) need the insider option below.

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

When a form type is listed, also return its amendments.

## `filedAfter` (type: `string`):

Date YYYY-MM-DD. Older filing pages are read only when this window reaches back to them.

## `filedBefore` (type: `string`):

Date YYYY-MM-DD.

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

Newest first. 0 = profile and facts only.

## `includeFacts` (type: `boolean`):

Latest annual revenue, gross profit, operating income, net income, EPS, assets, liabilities, equity, cash, operating cash flow and shares outstanding, from the company's XBRL data.

## `extraConcepts` (type: `array`):

More facts as taxonomy:Concept, e.g. us-gaap:ResearchAndDevelopmentExpense. Up to 30.

## `includeInsiderFilings` (type: `boolean`):

Off by default: Forms 3/4/5, 144 and Schedules 13D/13G, and CIKs that belong to individual people. Personal addresses are never returned.

## `maxCompanies` (type: `integer`):

A safety cap for this run. Companies past it are listed in the run SUMMARY and not charged.

## `requestsPerSecond` (type: `number`):

The SEC allows 10 per second per user across all machines; Apify IPs are shared, so this Actor uses 2 by default and never more than 5.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "320193"
  ],
  "includeAmendments": true,
  "maxFilingsPerCompany": 20,
  "includeFacts": true,
  "includeInsiderFilings": false,
  "maxCompanies": 100,
  "requestsPerSecond": 2
}
```

# Actor output Schema

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

One item per company: name, tickers, filings returned and key facts.

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

// Run the Actor and wait for it to finish
const run = await client.actor("tan-solutions/company-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",
        "MSFT",
        "320193",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tan-solutions/company-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",
    "MSFT",
    "320193"
  ]
}' |
apify call tan-solutions/company-filings --silent --output-dataset

```

## MCP server setup

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