Split-Adjusting Your Dividend History

Split-adjusting dividend history is the one repair almost no data feed performs for you. Price series arrive already adjusted for splits. Dividend records arrive as paid, at the per share cash a company actually distributed that quarter. Join the two conventions in a single calculation and a 4-for-1 split appears to quadruple a stock's trailing yield overnight, on a day when the cash reaching shareholders did not change at all.

This page is about the dividend stream and the series computed from it: yield, payout per share, projected income. The price side of the same problem lives in split-adjusted price history.

Why does a split break a dividend yield series?

A split divides each existing share into more shares and divides the price per share by the same factor. One share becomes four in a 4-for-1, and each of the four carries a quarter of the old per share dividend. Total cash to the holder is unchanged, which is the mechanism set out in whether a stock split changes your dividend.

The two series you join answer different questions. An adjusted price series answers: what would one share have cost, counted in today's share units? An as-paid dividend series answers: what did the company pay per share, in that quarter's share units? Each is internally correct. Dividing one by the other is not.

What a split does to the dividend stream

Apple's dividend records carry the as-paid amount and a restated amount side by side, which makes the gap visible in a single panel. The window below straddles Apple's 2020 split. Each row is keyed on an ex-dividend date, the first session on which a buyer no longer collects the upcoming payment.

SELECT
    toString(ex_dividend_date)                                                AS ex_date,
    formatDateTime(ex_dividend_date, '%b %e, %Y')                             AS ex_date_label,
    if(ex_dividend_date < '2020-08-31', 'before the split', 'after the split') AS split_side,
    round(any(toFloat64(cash_amount)), 4)                                     AS paid_per_share,
    round(any(toFloat64(split_adjusted_cash_amount)), 4)                      AS adjusted_per_share
FROM global_markets.stocks_dividends
WHERE ticker = 'AAPL'
  AND ex_dividend_date >= '2020-02-01'
  AND ex_dividend_date <  '2021-06-01'
GROUP BY ex_dividend_date
ORDER BY ex_dividend_date

Across those 6 quarters the as-paid column takes a step down and the restated column does not. The last payment before the split, ex-dividend Aug 7, 2020, was $0.82 per share as paid, and $0.205 once restated onto the current share count. The first payment after it, ex-dividend Nov 6, 2020, was $0.205. Read the as-paid column alone and the payout looks cut by three quarters. Read the restated column and it runs flat across the split, which is what happened to the cash.

Why does my dividend yield chart spike at a split?

Trailing dividend yield sums the last twelve months of payments and divides by the current price. For a full year after a split, that twelve month window still holds payments measured in the old share units while the price is already in the new ones. The panel computes both versions month by month, from the first month end after the split until the window has rolled clear of it.

WITH
    monthly_price AS
    (
        SELECT
            toStartOfMonth(date)           AS month_start,
            argMax(toFloat64(close), date) AS month_end_close
        FROM global_markets.stocks_daily_aggs
        WHERE ticker = 'AAPL'
          AND date >= '2020-09-01'
          AND date <  '2021-12-01'
        GROUP BY month_start
    ),
    payments AS
    (
        SELECT
            ex_dividend_date                           AS ex_date,
            any(toFloat64(cash_amount))                AS as_paid,
            any(toFloat64(split_adjusted_cash_amount)) AS restated
        FROM global_markets.stocks_dividends
        WHERE ticker = 'AAPL'
          AND ex_dividend_date >= '2019-10-01'
          AND ex_dividend_date <  '2021-12-01'
        GROUP BY ex_dividend_date
    )
SELECT
    toString(p.month_start)                                  AS month,
    round(100 * sum(d.as_paid)  / any(p.month_end_close), 2) AS as_paid_yield_pct,
    round(100 * sum(d.restated) / any(p.month_end_close), 2) AS adjusted_yield_pct
FROM monthly_price AS p
CROSS JOIN payments AS d
WHERE d.ex_date >= addMonths(p.month_start, -11)
  AND d.ex_date <  addMonths(p.month_start, 1)
GROUP BY p.month_start
HAVING count() = 4
ORDER BY p.month_start

At 2020-09-01 the as-paid sum puts the trailing yield at 2.75% against a post-split price. The split-aware sum puts it at 0.69%. One is four times the other, and only the smaller figure corresponds to cash a holder could have collected. The gap narrows as pre-split payments age out of the window. By 2021-11-01 the trailing year holds only post-split payments, and both methods print 0.52%. A yield screen run on the uncorrected series during that year would have ranked the name near the top of its peer group on a figure that never existed. The same arithmetic inflates a payout ratio and any income projection built from one. Trailing versus forward dividend yield takes the two yield definitions apart in more detail.

How to split-adjust a dividend history

Two repairs work. Pick one and apply it to the entire series.

1. Keep the adjusted prices, and divide every dividend paid before a split by the cumulative split factor: the product of every split ratio from that payment date to the present.
2. Request raw, unadjusted prices and leave the dividends exactly as paid. Each quarter is then measured in the share units of its own day.

What never works is mixing them. Adjusted prices with as-paid dividends is the default pairing most feeds hand you, and it overstates every historical yield sitting behind the latest split. Raw prices with restated dividends errs the other way and understates them.

The cumulative factor is where hand-rolled repairs go wrong, since a company that has split repeatedly needs the whole chain and not just the last link.

WITH apple_splits AS
(
    SELECT
        execution_date,
        any(toFloat64(split_to) / toFloat64(split_from)) AS multiplier,
        any(toUInt32(split_to))                          AS shares_to,
        any(toUInt32(split_from))                        AS shares_from
    FROM global_markets.stocks_splits
    WHERE ticker = 'AAPL'
      AND execution_date < '2021-01-01'
    GROUP BY execution_date
)
SELECT
    toString(s.execution_date)                    AS split_date,
    formatDateTime(s.execution_date, '%b %e, %Y') AS split_date_label,
    concat(toString(any(s.shares_to)), '-for-', toString(any(s.shares_from))) AS split_ratio,
    round(exp(sum(log(f.multiplier))), 2)         AS cumulative_factor
FROM apple_splits AS s
CROSS JOIN apple_splits AS f
WHERE f.execution_date >= s.execution_date
GROUP BY s.execution_date
ORDER BY s.execution_date

The record holds 3 Apple splits through the end of 2020. A dividend paid before the oldest of them, Feb 28, 2005, divides by 56 to reach current share units. The 4-for-1 on Aug 31, 2020 accounts for a factor of 4 on its own. Correct an older payment with that most recent split alone and the amount is still wrong by the entire rest of the chain.

SELECT
    toString(date)                                     AS date,
    round(close, 2)                                    AS close_stored,
    if(prev_close > 0, round(close / prev_close, 3), 0) AS prior_session_ratio
FROM
(
    SELECT
        date,
        toFloat64(close)                                  AS close,
        lagInFrame(toFloat64(close)) OVER (ORDER BY date) AS prev_close
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'AAPL'
      AND date >= '2020-08-17'
      AND date <  '2020-09-05'
)
ORDER BY date

Which dividend payers does this affect?

Any name with a split behind it, which covers most long-lived payers. The panel counts, for six widely held dividend stocks, how many recorded payments differ between the as-paid and restated columns. Figures cover each name's full recorded dividend history as of October 2026.

SELECT
    ticker,
    count()                               AS dividend_records,
    countIf(as_paid > restated + 0.00005) AS records_restated,
    round(max(as_paid / restated), 1)     AS largest_cumulative_factor
FROM
(
    SELECT
        ticker,
        ex_dividend_date,
        any(toFloat64(cash_amount))                AS as_paid,
        any(toFloat64(split_adjusted_cash_amount)) AS restated
    FROM global_markets.stocks_dividends
    WHERE ticker IN ('AAPL', 'MSFT', 'KO', 'NVDA', 'CSCO', 'JNJ')
      AND cash_amount > 0
      AND split_adjusted_cash_amount > 0
    GROUP BY ticker, ex_dividend_date
)
GROUP BY ticker
ORDER BY records_restated DESC, ticker

NVDA leads this group with 46 of its 56 recorded payments restated, and the widest gap between its two columns is a factor of 40. A name with no splits in its history shows zero restated records, and for that name the two columns are interchangeable. The practical consequence is that a yield history you assembled from one feed is wrong by a different factor for every ticker, at every date behind a split.

Store raw values, adjust on read

The storage rule follows from the arithmetic. Keep the as-paid amounts and the corporate action records as your stored truth, then rebuild the adjusted view each time you read. A split announced next quarter changes the correct adjusted value of every dividend before it. When the adjustment is a view, that is a free recompute. When the adjustment was baked into storage, a new split quietly falsifies last year's numbers, and nothing in the stored file marks which rows changed meaning.

Store the amount as paid and the ex-dividend date alongside the split records, and the adjusted series is one join away. A regeneration check belongs in the same place: recompute the adjusted history from scratch and compare it against what you published last quarter. Any row that moved without a split behind it is a vendor restatement worth reading. That check and its cousins are collected in market data quality checks, and the per share accounting it feeds sits in how annual dividend per share is calculated.

FAQ

Does a stock split change the dividend you receive?

No. A split multiplies your share count and divides the per share payment by the same factor, leaving total cash unchanged. Only the per share figure in a data file moves, and that is the figure a yield calculation reads.

How do I split-adjust a dividend paid before several splits?

Divide it by the cumulative factor, the product of every split ratio between that payment date and today. Two 2-for-1 splits and a later 4-for-1 give a divisor of sixteen for any payment made before all three.

Is it better to adjust the dividends or to use raw prices?

Either is internally consistent. Adjusted prices with adjusted dividends give one continuous per share history, which suits charts and backtests. Raw prices with as-paid dividends match what a holder saw at the time, which suits audit work. The error is combining one of each.

Why did my dividend yield chart spike on a split date?

A trailing yield divides twelve months of as-paid dividends by a current price. After a 4-for-1 split the price is quartered while the older payments in the window are not, so the ratio reads about four times too high until the window rolls past the split.

Should I store raw or adjusted dividend values?

Store the as-paid amounts next to the split records and compute adjusted series on read. A future split rewrites every adjusted number before it, so a stored adjusted value goes stale the day the next corporate action lands.

Every panel above ships with the SQL that produced it. To run the same as-paid against restated comparison on a ticker you follow, ask for it in plain English on the Strasmore terminal.