What is a stock index? Price-weighted vs cap-weighted, with US30 and US500

A stock index is a single number that summarizes the prices of a basket of shares, calculated by a published recipe: which stocks are in, how much each one counts, and a divisor that keeps the number continuous when the basket changes. The level on its own means little. Its changes tell you what the basket did.

Codes such as US30 and US500, which our indices API uses in place of licensed benchmark names, describe exactly this: a US basket of 30 companies, or of about 500. The bigger difference between them is not the size of the basket but the weighting method. Below, both methods run on the same five real stocks, with Python you can use to reproduce the numbers.

Three decisions define every index

• MembershipWhich stocks are in. Rules cover size, liquidity, sector and listing country, and a committee or a formula reviews them on a schedule.
• WeightingHow much each member counts: by share price, by market value, by free-float market value, equally, or with a cap on the largest names.
• DivisorA scaling number, adjusted for splits, spin-offs and membership changes, so the level does not jump when nothing in the market moved.

Levels also start from an arbitrary base, such as 100 or 1,000 on a chosen date. That is why US500 sits near 7,700 while US30 is above 51,000. The two levels are not comparable; only their percentage changes are.

Price-weighted index: one share of each

A price-weighted index adds up the price of one share of each member and divides by the divisor. It is the oldest method, because it can be computed with a pencil, and two major benchmarks still use it: the US 30 and the Japan 225.

The consequence is blunt. A $1 move in any member moves the index by the same amount, 1 ÷ divisor points, whether the company is worth $30 billion or $3 trillion. A stock with a high share price dominates simply because its shares are expensive, not because the company is large.

Market-cap-weighted index: every company at its value

A market-cap-weighted index counts each company in proportion to its market capitalization: shares outstanding times price. Most modern benchmarks use it, including the US 500, US 100, Germany 40 and UK 100, usually float-adjusted, so only shares available to the public count and a founder's locked-up stake does not inflate the weight. Some also cap any single member to limit concentration.

Same five stocks, two different indices

Here are both methods on five large US companies over one week, 18 to 25 September 2026. Closing prices come from the daily bars on the stocks endpoint; share counts are rounded to the nearest million.

import os
import sys

import requests

BASE_URL = "https://api.tickerlayer.com"
HEADERS = {"x-api-key": os.environ["TICKERLAYER_API_KEY"]}
START, END = "2026-09-18", "2026-09-25"

# Shares outstanding in millions, rounded (company share counts, late September 2026).
SHARES_M = {"US:KO": 4303, "US:JPM": 2658, "US:PG": 2324, "US:DIS": 1752, "US:GS": 291}


def first_and_last_close(symbol):
    url = f"{BASE_URL}/stocks/agg/{symbol}/1/day/{START}/{END}"
    resp = requests.get(url, headers=HEADERS, params={"sort": "asc"}, timeout=10)
    if resp.status_code != 200:
        sys.exit(f"{symbol}: HTTP {resp.status_code} {resp.text[:120]}")
    bars = resp.json()["results"]
    if not bars:
        sys.exit(f"{symbol}: no bars between {START} and {END}")
    return bars[0]["c"], bars[-1]["c"]


closes = {s: first_and_last_close(s) for s in SHARES_M}
start_sum = sum(p0 for p0, _ in closes.values())
end_sum = sum(p1 for _, p1 in closes.values())
start_cap = sum(SHARES_M[s] * p0 for s, (p0, _) in closes.items())
end_cap = sum(SHARES_M[s] * p1 for s, (_, p1) in closes.items())

print(f"{'symbol':<8}{'close':>9}{'week':>9}{'price wt':>10}{'cap wt':>8}")
for s, (p0, p1) in closes.items():
    print(f"{s:<8}{p1:>9.2f}{p1 / p0 - 1:>+9.2%}{p1 / end_sum:>10.1%}{SHARES_M[s] * p1 / end_cap:>8.1%}")

divisor = len(closes)  # a new price-weighted index starts with divisor = number of stocks
print()
print(f"Price-weighted: {start_sum / divisor:.2f} -> {end_sum / divisor:.2f} ({end_sum / start_sum - 1:+.2%})")
print(f"Cap-weighted:   100.00 -> {100 * end_cap / start_cap:.2f} ({end_cap / start_cap - 1:+.2%})")

symbol      close     week  price wt  cap wt
US:KO       87.81   -0.50%      5.4%   18.1%
US:JPM     343.06   -1.89%     21.2%   43.7%
US:PG      146.23   -0.11%      9.0%   16.3%
US:DIS     106.15   +3.39%      6.6%    8.9%
US:GS      935.45   -0.70%     57.8%   13.0%

Price-weighted: 325.80 -> 323.74 (-0.63%)
Cap-weighted:   100.00 -> 99.26 (-0.74%)

US:GS is 57.8% of the price-weighted index because one share costs $935, and only 13.0% of the cap-weighted one. US:KO is the reverse: the second-largest company here by value, and the smallest weight once only the share price counts. The two indices ended the week 0.11 percentage points apart. In a week when the expensive stock moves hard, that gap gets much wider.

Divisors: why a stock split does not move the index

Suppose US:GS split three for one. Its price would drop from 935.45 to 311.82 overnight with nothing changed about the company, and the price-weighted level would fall from 323.74 to 199.01. To stop that, the divisor is recomputed at the split so the level stays where it was.

The level survives, the weights do not: after the split US:GS is 31.3% of the price-weighted index instead of 57.8%, though the business is exactly the same. In a cap-weighted index a split changes nothing, because shares triple while the price falls to a third and market value stays put. Membership changes and spin-offs get the same divisor treatment under both methods.

What US30, US500 and the other codes mean

The short answer to "what is US30" follows from the recipe: it is the generic code for the US 30 benchmark, 30 large US companies in a price-weighted index, where the priciest shares carry the most weight. US500 covers about 500 large US companies weighted by float-adjusted market value, and it is the usual stand-in for the US market as a whole. The table decodes the main codes by construction.

Why the recipe matters when you use index data

• Price return or total return. Most headline levels drop dividends; DE40 reinvests them. Next to a price index, the German benchmark gets a head start of roughly its dividend yield every year, and over a decade that compounds into a large gap.
• Concentration. In a cap-weighted index the largest companies drive most of the move. A 1% move in US:JPM shifts the five-stock index above by 0.44%; the same move in US:DIS shifts it by 0.09%.
• Corporate actions. In a price-weighted index, weights change on events that change nothing about the business, so a member can lose half its influence overnight.
• You cannot buy an index. You buy a fund or a derivative that tracks it. ETF vs index fund explains the choice, and the ETF API guide covers fund prices.
• Signals inherit the recipe. A trend rule on a price-weighted index partly trades its most expensive shares. The golden cross backtest runs on US500 for that reason.