Divisor adjustment explained: how the S&P 500 (and the STI) preserves continuity when components change
Most index methodology gets hand-waved ("we rebalance monthly"). The actual mechanic that prevents discontinuities when constituents change is divisor adjustment — and it's what separates a real index from a basket. The S&P 500 has used this since 1957. The STI applies the same standard. Worked examples with real CS2 skin data, why this matters for backtest integrity, and how to spot amateur indices that don't do it.
The problem: phantom jumps
A market-cap-weighted index values its components proportional to their market cap (price × supply, or price × shares outstanding for equities). The natural calculation is just to sum the weighted market caps. Divide by a starting reference and you have an index value.
The problem appears at rebalancing time. Imagine a 3-skin index:
Skin A: market cap = $100
Skin B: market cap = $200
Skin C: market cap = $300
Index value = ($100 + $200 + $300) = $600At the next rebalance, the index methodology adds a 4th skin (say it qualifies because it grew enough to enter):
Skin A: market cap = $100
Skin B: market cap = $200
Skin C: market cap = $300
Skin D: market cap = $400 (newly added)
Sum = $1000
Naive index value = $1000The index supposedly jumped from $600 to $1000 — a +67% gain — but no actual prices moved. The +67% is pure methodology artifact: it's the value of Skin D that entered, not market movement. Without correction, every rebalance event would produce these phantom moves. The historical chart would be meaningless.
The fix: divisor adjustment
Instead of dividing by 1 (or some fixed number), the index divides by a divisor that gets recomputed every time the constituents change. The formula:
At each rebalance:
new_divisor = new_total_market_cap / old_index_value
So that:
new_index_value = new_total_market_cap / new_divisor
= old_index_value
→ continuity preserved at the moment of rebalanceContinuing the worked example:
Before rebalance:
total_mcap = $600
divisor = 1
index = $600 / 1 = $600
At rebalance (add Skin D):
new_mcap = $1000
new_divisor = $1000 / $600 = 1.667
New index value at rebalance:
$1000 / 1.667 = $600 ← matches old value, no jump
Going forward, use divisor = 1.667 for all calculations.
If next month all 4 skins go up 10%:
new_mcap = $1000 × 1.10 = $1100
index = $1100 / 1.667 = $660 ← +10% gain (correct)This is divisor adjustment in action. The chart line at the rebalance moment shows no jump. The +10% gain in the following month accurately reflects market movement, not methodology.
A real STI event: April 2026 luxury cap
The most instructive recent divisor event in STI history is the April 2026 luxury cap implementation (commit a2f4f84). Background:
- STI 30 historically included AWP Dragon Lore FN, M4A4 Howl FT, and M4A1-S Hot Rod FN
- All three priced above $1,800 (the Steam Market technical cap above which items can't be listed on SCM)
- Combined, these three contributed ~52% of STI 30's market cap
- They distorted representativeness because their pricing was CSFloat/Buff163 (off-Steam), not the Steam-priced universe of the rest of STI 30
The methodology fix on April 25, 2026 added max_price_usd: 1800 to inclusion rules, removing those three skins. Without divisor adjustment, the STI 30 chart would have shown a phantom drop of ~40% overnight. With divisor adjustment, the value smoothly transitioned:
Pre-cap (April 24, 2026):
STI 30 components = 30 skins (incl. Dragon Lore, Howl, Hot Rod)
total_mcap = ~$3.2M (illustrative — not actual)
divisor = D_old
index value = ~178.9
At cap implementation (April 25, 2026):
components updated → 27 skins (3 luxury removed)
new_total_mcap = ~$1.8M (~40% less)
new_divisor = $1.8M / 178.9 = D_new (smaller than D_old)
new index value = $1.8M / D_new = 178.9 ← continuity preserved
Forward (April 26 onwards):
Subsequent moves reflect actual prices of the 27-skin basket
Today (2026-04-30): STI 30 ≈ +37.5% from base, computed via D_newWithout divisor adjustment, the chart would have a vertical discontinuity on April 25, 2026, showing −40% that no actual investor experienced. The STI methodology specifically handles this: divisor adjustment preserves backtest integrity across methodology changes.
Which index types need divisor adjustment?
| Index type | Weighting | Needs divisor? | Example |
|---|---|---|---|
| Market-cap-weighted | price × supply | Yes | S&P 500, STI family |
| Price-weighted | price only | Yes (for splits) | Dow Jones |
| Equal-weighted | 1/N each | No | The Icons (legacy reference) |
| Total return | market cap + dividends | Yes (for distributions) | S&P 500 TR |
The STI family (STI 30, 100, 500, 1000, Cases, Stickers, Agents) is all market-cap-weighted, so all of them use divisor adjustment at every rebalance. The Icons (legacy reference, equal-weighted) doesn't need divisor — its rebalancing logic is different.
Index vs basket: spotting the difference
A "basket" just sums holdings without divisor adjustment. It's useful for portfolio P&L tracking (you bought these specific skins; what are they worth today combined). It's useless for benchmarking because every rebalance creates artificial jumps.
Many amateur skin trackers post "top 30 skins" tables that look like indices but are actually baskets:
- Red flag #1: the chart has visible vertical jumps that don't correspond to actual market moves
- Red flag #2: no mention of "divisor" or "methodology adjustment" in the documentation
- Red flag #3: constituents change frequently but historical values aren't reproducible from the current basket
- Red flag #4: the backtest extends "back" to skin-by-skin selection available today, with no divisor adjustment for entries/ exits over the window
Skin Trackers publishes the divisor for each index in /api/indices. You can audit it. This level of transparency is unusual — most index providers (S&P, MSCI, FTSE) don't publish per-rebalance divisors publicly.
Why this matters for backtest integrity
When you see a 6-year backtest of a CS2 skin index, divisor adjustment is what makes the historical numbers honest. Without it:
- Rebalance events look like returns. Adding Skin D to the basket makes the index "rise" by Skin D's market cap, which is a methodology event, not a market event.
- Methodology changes distort history. The April 2026 luxury cap event would show as a −40% "loss" in any non-divisor- adjusted backtest, even though no investor experienced that loss.
- Comparisons across indices become impossible. If two indices use different (or no) divisor methodology, comparing their charts is meaningless. Apples to apples requires consistent methodology.
- Reproducibility breaks. A reader auditing your backtest can't recompute it without knowing the divisor at every rebalance moment. Without published divisors, the backtest is unverifiable.
The S&P Dow Jones methodology guide (spglobal.com/spdji/en/methodology) treats divisor adjustment as foundational. Index providers who skip it aren't producing indices; they're producing baskets that pretend.
STI divisor history (open data)
Every STI rebalance triggers a divisor recomputation. Major divisor events for STI 30 in the recent past:
- April 2026 (commit a2f4f84): luxury cap implementation. Removed Howl FT, Dragon Lore FN, Hot Rod FN. Largest divisor change in STI 30's history.
- April 2026 (commit 2940ad0): blue-chip coverage fix. Added several ultra-rare items previously missing from the universe. Divisor recomputed.
- Quarterly rebalances: STI 30 reweights every quarter. Each event recomputes divisor.
- Monthly rebalances: STI 100, 500, 1000, Cases, Stickers, Agents reweight monthly. Each event recomputes divisor.
Divisor history at any point is reproducible from /api/indices. The implementation is at src/lib/indices.ts in the open-source repo.
Limitations
- Continuity ≠ accuracy. Divisor adjustment makes the chart look continuous, but the underlying methodology change is real and meaningful. The April 2026 luxury cap event removed three skins that contributed 52% of pre-cap market cap; future returns reflect a fundamentally different basket. Continuity at the moment of change is preserved; what comes after is a different index in spirit.
- Choice of split point matters. Divisor adjustment splices the chart at the moment of the change. The choice of moment (start of day, end of day, mid-day) creates small differences. Skin Trackers uses end-of-month closing values to align with monthly rebalance cadence.
- Doesn't fix universe drift. If the universe of eligible skins drifts over time (e.g., 2020 had 200 eligible skins meeting filters; 2026 has 500), divisor adjustment handles entries/exits but doesn't signal whether the universe itself has changed character. Read the methodology, not just the chart.
- Computational sensitivity. For highly-volatile components, the divisor adjustment can be sensitive to the exact moment of measurement. Small timing differences produce small but non-zero divisor differences. Industry practice: use end-of-period closing values consistently.
Frequently asked
What is divisor adjustment in plain English?
When a market-cap-weighted index changes its components — adds a stock, removes one, or rebalances weights — the sum of weighted prices changes for a reason that has nothing to do with actual market movement. To prevent this 'phantom' jump in the index value, you compute a new 'divisor' such that the index value at the moment of the change equals the value just before. From that moment forward, the new divisor is used. This way, the chart of the index reflects only real market movement, not artifacts of methodology changes. The S&P 500 has used divisor adjustment since 1957.
Why can't you just use the raw weighted sum?
Because adding or removing a constituent introduces value that isn't from market movement. Imagine an index with 3 skins worth $100, $200, $300 (sum = $600). At the next rebalance, you add a 4th skin worth $400 — sum is now $1000. The index value supposedly jumped from $600 to $1000 (+67%) but no actual prices changed. The 67% is pure methodology artifact. Without divisor adjustment, every rebalance produces these phantom moves. The chart becomes meaningless. Divisor adjustment compresses the new sum back to match the prior value.
What's the divisor adjustment formula?
When the constituents change, compute new_divisor = (new_market_cap_sum) / (old_index_value). The new index value at the moment of change equals new_market_cap_sum / new_divisor = old_index_value. From that moment forward, every index calculation uses new_divisor instead of the old one. This keeps the index continuous — the chart line at the moment of change has no break. The S&P 500 makes the divisor public; the STI does the same in /api/indices for full reproducibility.
Do all index types need divisor adjustment?
No, only market-cap-weighted ones. Equal-weighted indices (every constituent gets weight 1/N) don't need divisor — they just renormalize when components change. Price-weighted indices (Dow Jones style, where price determines weight) do need divisor when stock splits happen. Total return indices (which reinvest dividends) need divisor for cash distributions. The STI family (market-cap-weighted) uses divisor for every rebalance event — monthly for STI 100/500/1000/Cases, quarterly for STI 30. Equal-weighted reference indices like 'The Icons' don't need it.
How often does the STI divisor change?
Every rebalance event, plus any methodology change. STI 100, STI 500, STI 1000, STI Cases rebalance monthly — so divisor changes on the first of each month. STI 30 rebalances quarterly. STI Stickers and STI Agents rebalance monthly. Beyond regular rebalances, methodology changes (like the April 2026 luxury cap commit a2f4f84 that removed Howl/Dragon Lore/Hot Rod from STI 30) trigger ad-hoc divisor recomputation. Each divisor change is logged at /api/indices for transparency.
What's an example of divisor adjustment in action?
April 2026 luxury cap event for STI 30. Before the cap, STI 30 included AWP Dragon Lore FN, M4A4 Howl FT, and M4A1-S Hot Rod FN — three skins above $1,800 each, dominant in market cap, contributing 52% of STI 30's market cap. STI 30 value was at ~178.9 (post-blue-chip-cobertura fix). The cap of $1,800 removed those three skins. New market cap sum dropped sharply. Without divisor adjustment, STI 30 would have shown a phantom -40% drop overnight — which would have been false because no prices actually moved. With divisor adjustment, the new sum was divided by a new divisor calibrated to keep continuity, and the value smoothly transitioned. This is exactly why backtesting against discontinuous baskets gives misleading numbers; divisor adjustment is the fix.
What happens if you don't do divisor adjustment?
You get a 'basket' instead of an 'index'. A basket value just sums the holdings — useful for portfolio P&L tracking but useless for benchmarking because every rebalance creates artificial jumps. Many amateur skin trackers fall into this trap: they post 'top 30 skins' tables that look like indices but are actually baskets. The chart of such a basket has discontinuities at every rebalance. Compare to the STI, which uses divisor adjustment specifically so the chart line is honest. Backtest integrity requires divisor adjustment; without it, the historical numbers can't be trusted.
Where can I see the STI divisor history?
Public via /api/indices. Each index has a divisor field that updates each rebalance. You can reproduce the index value at any point in history by computing (sum_of_weighted_market_caps) / (divisor_at_that_time). Methodology code is open at src/lib/indices.ts in the GitHub repo. This level of transparency is unusual in the alternative-asset space — most index providers (S&P, MSCI, FTSE) don't publish per-rebalance divisors publicly. Skin Trackers does because the methodology IS the product.
Where to go from here
- See current STI divisors at /api/indices — public, machine-readable, per-index.
- Source code for divisor recomputation in
src/lib/indices.ts— open-source, auditable. - Full methodology including divisor handling at /en/methodology.
- For the related cluster spokes on STI metrics: Sharpe ratio, CAGR, Max drawdown, and correlation analysis.
Methodology note: divisor adjustment follows the S&P Dow Jones standard. Implementation in src/lib/indices.ts (open source); per-rebalance divisor history exposed in /api/indices. The STI does not claim official S&P licensing — "S&P-style" refers to methodology fidelity, not endorsement.