# US Company Financials Lookup (`thesjostrandproject/us-company-financials-lookup`) Actor

Look up annual and quarterly financial figures for US public companies by ticker or CIK number, such as revenue, net income and total assets, through the US regulator's public data API. One clean, typed record per figure and period, company level only. No login, no scraping. Pay per record.

- **URL**: https://apify.com/thesjostrandproject/us-company-financials-lookup.md
- **Developed by:** [The Sjöstrand Project](https://apify.com/thesjostrandproject) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 company financials records

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 Company Financials Lookup

### What this Actor returns

Give it the tickers or CIK numbers of US public companies and the figures you want, such as revenue, net income or total assets, and get one clean, typed record per figure and period. The records are made for a spreadsheet: one row each, the same 17 fields every time, and a value the source does not have is `null`, never a missing key.

- `cik`, `company_title`, `ticker`, `exchange`, `sic_code`, `fiscal_year_end`: which company it is
- `concept`, `unit`, `value`: which figure, in what unit, and what it was
- `period_end`, `fiscal_year`, `fiscal_period`: the period it covers
- `accession_number`, `form_type`, `filing_date`, `report_date`, `primary_document_url`: the filing that first reported it

The Actor reads the US regulator's public data API and nothing else. It does not scrape any website, and there is no login. It returns company-level figures only: no insider forms, no names of officers or directors, and no filings by individual investors.

### Who it helps

- **Analysts and investors** who want annual and quarterly figures for a handful of companies in a table, without reading each filing.
- **Developers and small teams** who want tidy financial data for a dashboard or a model, through the Apify API, without writing their own client for the source.

### Quick start

1. Open the Input tab and leave the defaults as they are. They look up revenue, net income and total assets for one large company over the years 2022 and 2023, so a first run returns up to 10 records (the default Maximum records).
2. Press Start. The default run costs about $0.03: 10 records at $0.003 each, plus Apify's tiny start event (see What it costs). Try it on one record first by setting Maximum records to 1; it costs a fraction of a cent.
3. Open the Output tab, check the records, then enter your own companies, metrics and years.

### Input

| Field | What it does | Default |
|---|---|---|
| Companies | Tickers like `AAPL` or CIK numbers like `320193`, separated by commas. Up to 25. | `AAPL` |
| Metrics | `revenue`, `gross_profit`, `operating_income`, `net_income`, `eps_diluted`, `assets`, `liabilities`, `equity`, `cash`, `operating_cash_flow`, or a us-gaap concept name like `ProfitLoss`. Separate several with commas. | `revenue, net_income, assets` |
| From year | Only periods that end in this year or later. | `2022` |
| To year | Only periods that end in this year or earlier. | `2023` |
| Maximum records | How many records to return at most, from 1 to 1000. | 10 |

Results come company by company in the order you gave them, newest period first, and within a period in the order of your metrics.

### Output

One record per company, concept, unit and period. The record below is what the default input returned on 12 October 2026, unchanged, except that the link in `primary_document_url` is described in words.

```json
{
  "cik": "0000320193",
  "company_title": "Apple Inc.",
  "ticker": "AAPL",
  "exchange": "Nasdaq",
  "sic_code": "3571",
  "fiscal_year_end": "0926",
  "accession_number": "0000320193-24-000006",
  "form_type": "10-Q",
  "filing_date": "2024-02-02",
  "report_date": "2023-12-30",
  "primary_document_url": "(the filing's main document on the source's website)",
  "concept": "RevenueFromContractWithCustomerExcludingAssessedTax",
  "unit": "USD",
  "value": 119575000000,
  "period_end": "2023-12-30",
  "fiscal_year": 2024,
  "fiscal_period": "Q1"
}
```

In the real record, `primary_document_url` is the full link to the filing.

### What it costs

You pay for one event, **Company financials record**, at $0.003 per record returned. Apify also adds its standard run-start event, $0.00005 per start for an Actor run with up to 1 GB of memory; it is the platform's own event, not ours. The default run of 10 records costs about $0.03. Records the Actor leaves out (see below) are never charged.

For example, three companies with three metrics over three years come to roughly 3 x 3 x 12 = 108 records if every figure exists, which costs about $0.32. If your Apify plan includes monthly credit, a small run draws on that credit.

If the source cannot be reached or keeps answering with errors, the run stops with a clear status message, and only the records already returned are charged.

### Limits and honest notes

- **Company level only.** The Actor never reads insider forms (Forms 3, 4, 5 and 144), filings by individual investors or any names of officers or directors. A record that held an email address or a phone number in its text would be left out.
- **Full years and single quarters.** You get each fiscal year (`FY`) and each of the first three quarters (`Q1`, `Q2`, `Q3`). Year-to-date totals are not included, and companies do not report the fourth quarter on its own: subtract the three quarters from the year if you need it.
- **First reported values.** When a later filing repeats a period, as a prior-year comparison or a restatement, the record keeps the value first reported, and `fiscal_year` and `fiscal_period` are those of that first filing. A later restatement is not shown. A balance at a date (such as total assets) is taken only from the filing whose own reporting period ends on that date, so a later report's copy of an earlier balance never becomes a second record.
- **Report types.** Only figures from annual and quarterly reports (forms 10-K and 10-Q, and their amendments) are returned. Figures from any other kind of filing are left out, and so are those of foreign filers' reports.
- **Concept names differ between companies.** One company tags its revenue `Revenues`, another `RevenueFromContractWithCustomerExcludingAssessedTax`. A metric name looks for the usual ones, and `concept` tells you which was used. Figures in other accounting standards, such as those of foreign filers using IFRS, are not read.
- **Filing details.** `report_date` and `primary_document_url` come from the company's most recent filings; for an older filing they are `null`.
- **Pace.** The source allows 10 requests a second. The Actor sends at most one request a second to each of its two addresses, always says who it is in the request, and waits as long as the source asks when it is busy. A company takes two requests, so 25 companies take about a minute.
- **Freshness** follows the source. The SEC says its XBRL APIs are updated "with a typical processing delay of under a minute", and that delays "may be longer during peak filing times".

### Questions

**Why did my run return fewer records than I asked for?**
Either fewer figures matched, or some were left out because they lacked a value, a period or a company name, or were not a company-level figure. You were not charged for those. The final status message counts them and says why.

**What does the run say when something is wrong?**
It says what it found and what to try. A message about a ticker means the symbol is not on the source's list: check the spelling, or give the CIK number. A message about a CIK number means the source has no such company. A message about metrics or years names the field to fix and shows the right shape. "Could not be reached" or "kept answering" means the source is busy; wait a few minutes and run again.

**What does "company:no_matching_facts" mean in the status message?**
The company was found, but it has no figures for your metrics and years. Try another metric, a wider range of years, or a us-gaap concept name.

**How do I find a company's CIK number?**
It is the number the regulator gives each filer. If you know the ticker, you do not need it: enter the ticker.

**Why are there several records for one metric and period?**
A company may report the same metric under more than one concept name, or in more than one unit. Each gets its own record; use `concept` and `unit` to pick the one you want.

**Can I run it on a schedule?**
Yes, with the Apify scheduler or the API. Each run is independent and charged per record returned.

### Data source and AI note

Data source: the public company data API of the US Securities and Exchange Commission (company submissions and XBRL company facts). The Commission states that information on its website is public and may be copied or further distributed by users without its permission, and asks for citation of the Commission as the source; that is the licence these records are reused under. `filing_date` is the date the filing was submitted, taken from the source's `filed` field; it is not a last-updated date, and the records have no source_updated_at field.

This tool is not affiliated with, endorsed by or sponsored by the US Securities and Exchange Commission.

This tool was built with the help of AI coding assistants.

### Help

Questions, a record that looks wrong, or an idea for a field: please open an issue on the Issues tab. Thank you for the report; every one is read.

# Actor input Schema

## `companies` (type: `string`):

Tickers like AAPL or MSFT, or CIK numbers like 320193, separated by commas. Up to 25 companies. A ticker with a dot, like BRK.B, works too.

## `metrics` (type: `string`):

What to look up, separated by commas: revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash, operating_cash_flow. A company may report one metric under several concept names; each gives its own records. You can also give a us-gaap concept name like ProfitLoss.

## `fromYear` (type: `integer`):

Only periods that end in this year or later. Use 1994 for no lower bound.

## `toYear` (type: `integer`):

Only periods that end in this year or earlier. Use 2100 for no upper bound.

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

How many records to return at most. You pay only for records returned.

## Actor input object example

```json
{
  "companies": "AAPL",
  "metrics": "revenue, net_income, assets",
  "fromYear": 2022,
  "toYear": 2023,
  "maxItems": 10
}
```

# Actor output Schema

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

The financial figures of this run, one record per company, concept and period, with the 17 fields described in the dataset schema (company, ticker, filing, concept, unit, value, period, fiscal year and period).

# 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",
    "metrics": "revenue, net_income, assets",
    "fromYear": 2022,
    "toYear": 2023,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("thesjostrandproject/us-company-financials-lookup").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",
    "metrics": "revenue, net_income, assets",
    "fromYear": 2022,
    "toYear": 2023,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("thesjostrandproject/us-company-financials-lookup").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",
  "metrics": "revenue, net_income, assets",
  "fromYear": 2022,
  "toYear": 2023,
  "maxItems": 10
}' |
apify call thesjostrandproject/us-company-financials-lookup --silent --output-dataset

```

## MCP server setup

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

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/jBlVpC4zNvSG9gUNk/builds/DX5XLsGBAujw7A38x/openapi.json
