Alphanume
Reference DataPro

Historical Market Cap

See what a company was worth on any past trading day, and how many shares it had outstanding at the time, as the numbers stood that day rather than as they read after everything that happened since. Each covered US equity carries one row per trading date with market cap and shares outstanding.

GET /v1/historical-market-capNew observation each trading day
  • Size the universe as of the trade date.

    Filter on market_cap for the date the strategy actually traded, so a small cap that has ten-bagged since is still a small cap in the test.

  • Watch the share count move.

    shares_outstanding across consecutive date values turns issuance and buybacks into a dated series instead of a quarterly footnote.

  • Normalize any other signal by size.

    Join on date and ticker to divide a flow, a filing amount, or a move by the market cap that was current when it happened.

Ask your agent
Prompt · MCP or REST

My screen buys small companies. Re-run it using each company's size on the day it would have been bought instead of its size today, and tell me how much of the return that removes.

Your agent pulls the market cap in force on each of your trade dates and re-applies your size cut against that number rather than against the current one.

What this dataset is

Two numbers, dated the day they were true.

Market capitalization is share price times shares outstanding: what the whole company was worth at that moment. This dataset stores that number for each equity on each trading date, next to the share count it was computed from.

Storing it matters because both inputs move. Prices move every session, and share counts move whenever a company issues, repurchases, or converts stock. A market cap built from today's share count and an old price is a number nobody could have seen on that day, and a backtest that selects on it has quietly used information from the future.

Each row includes:

  • One trading date.
  • One equity ticker.
  • Market capitalization as of that date.
  • Shares outstanding as of that date.
  • A stored observation, not a figure recomputed from today's share count.

Market cap moves for two different reasons: the price changed, or the share count changed. Reading only the cap hides the second one, which is exactly the one a dilution or buyback study is looking for.

What you can do with it

A size filter is only honest if it is dated.

Any rule with a size threshold in it is a point-in-time question. A cut like 'only trade above two billion dollars' selects one universe when the cap is measured on the trade date and a very different one when it is measured today, because the winners grew into the threshold and the failures shrank or delisted out of the data. Applying current caps backward is one of the quietest ways to make a backtest look better than the strategy was.

Shares outstanding carries its own signal. A rising count is dilution in progress; a falling one is a buyback actually executing rather than being announced. Because the count is dated here, both become a series you can difference, align to filings or offerings, and study around.

  • Apply size cuts using market_cap on each rebalance date instead of one screen run today.
  • Difference shares_outstanding across dates to date issuance and buyback activity.
  • Divide event-driven amounts, such as a filing's dollar size, by the market cap current on the event date.
  • Build size deciles per date, so a size factor is ranked against the market as it stood.
  • Check where a ticker's history begins before backfilling a long study.
Where the data comes from

Recorded per trading day, then left alone.

Each observation is written for its own trading date and carries the shares outstanding known at that time. That is what makes the series point-in-time: rows are dated on the day they describe rather than restated later, so a query for a past window returns the same values on every rerun.

Results come back ordered by date descending, then ticker descending, and large pulls page with a cursor. A full history for one ticker is a loop over next_cursor, sending its two parts back as cursor_date and cursor_ticker on each call; sending one without the other returns a 400. A companion lookup, GET /v1/historical-market-cap/tickers, lists every ticker the dataset covers along with the earliest date available for each, which is the cheapest way to check coverage before starting that loop.

Fields that matter

Two values, and the cursor that pages them.

The headline fields below are a subset. Every field, with exact types and semantics, is documented in the API reference.

FieldTypeWhat it tells you
datestringObservation date in YYYY-MM-DD, the day both numbers were true
tickerstringEquity ticker symbol; also the filter for a single-name history
market_capfloatMarket capitalization on that date
shares_outstandingfloatShares outstanding on that date, the count the cap was computed from
countintegerRows returned in this page of the response
has_morebooleanWhether more rows are waiting behind a cursor
next_cursorobjectThe date and ticker to resume from on the next call
cursor_dateparamHalf of the pagination cursor; must match next_cursor from the previous response
cursor_tickerparamThe other half; sending only one of the two returns a 400
date_gteparamLower bound on date; date_lte, date_gt, and date_lt work the same way
Query it in one call

One call for a ticker, or one call for a date.

One key works across the REST API, the hosted MCP server, and this dashboard. Every response is JSON with a { count, data } envelope.

Python
import requests

url = "https://api.alphanume.com/v1/historical-market-cap"
params = {
    "ticker": "AAPL",
    "date": "2026-02-06",
    "api_key": "alp_abc123"
}

r = requests.get(url, params=params)
print(r.json())
cURL
curl "https://api.alphanume.com/v1/historical-market-cap?ticker=AAPL&date=2026-02-06&api_key=alp_abc123"
Example response
{
  "count": 1,
  "has_more": false,
  "next_cursor": null,
  "data": [
    {
      "date": "2026-02-06",
      "ticker": "AAPL",
      "market_cap": 4109599296360,
      "shares_outstanding": 14776353000
    }
  ]
}
Honest limitations

What this data does not claim.

  • Rows are stored observations, not restated figures. If a source later revised a share count, the row still reflects what was known on its own date.
  • shares_outstanding is a company-level count, not free float. Insider and restricted holdings sit inside the number, so it is not a measure of tradeable supply.
  • There is no price column. Cap divided by share count implies a price, but the dataset is not meant to be used as a price source.
  • Coverage begins at a different date for each ticker, so a long backtest will find some names simply absent at the front of the window rather than present at size zero.
  • Size-factor studies require sufficient historical coverage. The limited public dashboard preview is for evaluating the data, not running a full size-factor study.
Common questions

Asked by researchers, answered plainly.

How do I get the full market cap history for one ticker?

Send the ticker with no date filter and page through the cursor. Each response carries next_cursor; pass its two parts back as cursor_date and cursor_ticker on the following call, and stop when has_more is false. Rows arrive newest first.

What is the difference between market cap and float?

Market cap uses shares outstanding, every share the company has issued. Float counts only the shares available to trade, leaving out insider and restricted holdings. This dataset reports the outstanding count, so for a company with heavy insider ownership it will read higher than a float-based figure.

Can I use this to detect dilution?

You can date it. A step up in shares_outstanding is new stock arriving, and the size of the step against the prior count is the dilution percentage. It tells you shares were issued, not why, so pair it with filing data when the cause matters.

Why does my backtest change when I switch to point-in-time market cap?

Usually because the old universe was selected with current sizes. Companies that grew were treated as large the whole way through and screened out of a small-cap rule they would have passed at the time, while companies that failed were missing from the screen entirely. Dating the size cut puts both back in.

Start querying

Available with Pro. Enterprise for teams.

New REST API and MCP access requires Pro or Enterprise. Public dashboard previews are separate from a subscription. Pro includes the available historical record, current updates, REST, MCP, dashboard exports, and every standard dataset as it launches. Explore the dashboard preview before subscribing; its existing limits still apply.