Trailing vs Forward Dividend Yield Explained

Trailing dividend yield and forward dividend yield are two answers to the same question, and the whole difference sits in the numerator. Trailing yield, usually written TTM for trailing twelve months, adds up the dividends a company actually paid over the past year. Forward yield takes the most recently declared payment and multiplies it by the number of payments a year. Both divide by the same share price. Whenever a payout has moved inside the last twelve months, the two conventions print different numbers for the same stock at the same moment.

The arithmetic of the ratio belongs to how to calculate dividend yield. This page owns the choice above the line: which dividend figure a source put in the numerator, and why two screeners quote the same ticker at two different yields on one afternoon.

What is trailing twelve month dividend yield?

Trailing yield sums every cash dividend with an ex-dividend date inside the last 365 days, then divides that sum by the current price. The ex-dividend date is the day a stock begins trading without the upcoming payment attached, and it is the date most data providers use to place a dividend in time.

Nothing in a trailing figure is estimated. It is a record of cash that already moved, and the right measure of what an owner collected. The weakness is the mirror image of that strength: a trailing yield describes a payout that may no longer exist. A company that reset its quarterly dividend last month still carries three checks at the old rate inside its trailing window, and it will carry them for another nine months.

What is forward dividend yield?

Forward yield annualizes the newest declared payment: the latest check multiplied by the payment frequency, over the same price. A quarterly payer whose newest declaration is $0.50 a share carries a $2.00 forward rate. A monthly payer at $0.25 carries $3.00.

That is a projection built on one observation, and it assumes the next payments look like the last one. What it buys is currency. When a company raises, the new rate enters the forward figure with the first larger check, while the trailing figure needs four full quarters to absorb it.

Trailing vs forward dividend yield on eight household payers

The panel below runs both calculations over eight large payers against the same recent session price. The trailing column sums the last twelve months of recurring cash dividends. The forward column annualizes the most recent one, using the payment frequency filed with it.

WITH last_px AS (
    SELECT ticker,
           argMax(close, window_start) AS close_price
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('ABBV', 'CVX', 'JNJ', 'KO', 'MCD', 'MSFT', 'PEP', 'PG')
      AND window_start >= now() - INTERVAL 10 DAY
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY ticker
),
paid AS (
    SELECT ticker,
           sum(cash_amount) AS ttm_cash,
           count() AS checks_in_window,
           argMax(cash_amount, ex_dividend_date) AS latest_cash,
           argMax(frequency, ex_dividend_date) AS pay_frequency
    FROM global_markets.stocks_dividends
    WHERE ticker IN ('ABBV', 'CVX', 'JNJ', 'KO', 'MCD', 'MSFT', 'PEP', 'PG')
      AND distribution_type = 'recurring'
      AND cash_amount > 0
      AND ex_dividend_date > today() - INTERVAL 1 YEAR
      AND ex_dividend_date <= today()
    GROUP BY ticker
)
SELECT p.ticker AS ticker,
       round(toFloat64(d.ttm_cash) / toFloat64(p.close_price) * 100, 2) AS trailing_yield_pct,
       round(toFloat64(d.latest_cash) * d.pay_frequency / toFloat64(p.close_price) * 100, 2) AS forward_yield_pct,
       round((toFloat64(d.latest_cash) * d.pay_frequency - toFloat64(d.ttm_cash))
             / toFloat64(p.close_price) * 100, 2) AS forward_minus_trailing_pp,
       d.checks_in_window AS checks_in_window,
       round(toFloat64(p.close_price), 2) AS share_price
FROM last_px AS p
INNER JOIN paid AS d ON p.ticker = d.ticker
ORDER BY forward_minus_trailing_pp DESC

Rows are sorted by the distance between the conventions. At the top, PEP prints a forward yield of 4.24% against a trailing yield of 4.12%. At the bottom, MSFT prints 0.78% forward against 0.77% trailing. Same companies, same prices, two legitimate methods.

The checks column is the quieter source of divergence. A rolling 365 day window is not the same thing as four quarters. Ex-dates drift by a few days each year, and a window that catches a fifth check lifts the trailing figure while the declared rate has not moved at all.

What a dividend reset does to the two readings

3M reset its quarterly dividend in 2024, alongside the separation of its health care business. The 26 month ends below track both conventions from that point on, with the declared quarterly payment beside them.

WITH px AS (
    SELECT toStartOfMonth(toDate(toTimeZone(window_start, 'America/New_York'))) AS month_start,
           max(toDate(toTimeZone(window_start, 'America/New_York'))) AS last_day,
           argMax(close, window_start) AS close_price
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'MMM'
      AND toDate(toTimeZone(window_start, 'America/New_York')) >= toDate('2024-06-01')
      AND toDate(toTimeZone(window_start, 'America/New_York')) <= toDate('2026-07-31')
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY month_start
),
dv AS (
    SELECT ex_dividend_date, cash_amount
    FROM global_markets.stocks_dividends
    WHERE ticker = 'MMM'
      AND distribution_type = 'recurring'
      AND frequency = 4
      AND cash_amount > 0
      AND ex_dividend_date >= toDate('2023-05-01')
)
SELECT formatDateTime(px.month_start, '%Y-%m') AS month,
       formatDateTimeInJodaSyntax(px.month_start, 'MMM yyyy') AS month_label,
       round(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)), 2) AS declared_quarterly_usd,
       round(sumIf(toFloat64(dv.cash_amount), dv.ex_dividend_date > px.last_day - INTERVAL 1 YEAR)
             / toFloat64(any(px.close_price)) * 100, 2) AS trailing_yield_pct,
       round(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)) * 4
             / toFloat64(any(px.close_price)) * 100, 2) AS forward_yield_pct,
       round(abs(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)) * 4
                 - sumIf(toFloat64(dv.cash_amount), dv.ex_dividend_date > px.last_day - INTERVAL 1 YEAR))
             / toFloat64(any(px.close_price)) * 100, 2) AS gap_abs_pp
FROM px, dv
WHERE dv.ex_dividend_date <= px.last_day
GROUP BY px.month_start, px.last_day
ORDER BY px.month_start

In Jun 2024 the declared payment was $0.7 while three checks at the old rate still sat inside the trailing window. Trailing yield read 5.1%. Forward yield read 2.74%. The two conventions stood 2.36 points apart on one stock, on one day, with the identical price under both fractions. A screen sorted by trailing yield that month ranked 3M on cash it had already stopped paying at that rate. Neither number was wrong; they answer different questions.

The gap column then closes over four quarters as the old checks roll out of the window. By Jul 2026 the readings were 1.71% trailing and 1.77% forward, 0.06 points apart. Convergence is the resting state. The wedge opens only when the payout moves, which dividend increases and cuts covers across the market, and 3M's dividend record tracks payment by payment.

Monthly payers, twelve checks and sometimes thirteen

Realty Income raises its monthly payment in small steps several times a year, which keeps its forward rate slightly ahead of the year behind it. The checks column counts what the trailing window actually holds at each reading.

WITH px AS (
    SELECT toStartOfMonth(toDate(toTimeZone(window_start, 'America/New_York'))) AS month_start,
           max(toDate(toTimeZone(window_start, 'America/New_York'))) AS last_day,
           argMax(close, window_start) AS close_price
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'O'
      AND toDate(toTimeZone(window_start, 'America/New_York')) >= toDate('2024-08-01')
      AND toDate(toTimeZone(window_start, 'America/New_York')) <= toDate('2026-07-31')
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY month_start
),
dv AS (
    SELECT ex_dividend_date, cash_amount
    FROM global_markets.stocks_dividends
    WHERE ticker = 'O'
      AND distribution_type = 'recurring'
      AND frequency = 12
      AND cash_amount > 0
      AND ex_dividend_date >= toDate('2023-07-01')
)
SELECT formatDateTime(px.month_start, '%Y-%m') AS month,
       formatDateTimeInJodaSyntax(px.month_start, 'MMM yyyy') AS month_label,
       round(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)), 4) AS declared_monthly_usd,
       countIf(dv.ex_dividend_date > px.last_day - INTERVAL 1 YEAR) AS checks_in_window,
       round(sumIf(toFloat64(dv.cash_amount), dv.ex_dividend_date > px.last_day - INTERVAL 1 YEAR)
             / toFloat64(any(px.close_price)) * 100, 2) AS trailing_yield_pct,
       round(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)) * 12
             / toFloat64(any(px.close_price)) * 100, 2) AS forward_yield_pct,
       round(abs(toFloat64(argMax(dv.cash_amount, dv.ex_dividend_date)) * 12
                 - sumIf(toFloat64(dv.cash_amount), dv.ex_dividend_date > px.last_day - INTERVAL 1 YEAR))
             / toFloat64(any(px.close_price)) * 100, 2) AS gap_abs_pp
FROM px, dv
WHERE dv.ex_dividend_date <= px.last_day
GROUP BY px.month_start, px.last_day
ORDER BY px.month_start

In Aug 2024 the window held 11 payments, printing 4.57% trailing against 5.08% forward. In Jul 2026 it held 13 payments on a declared monthly rate of $0.271, printing 5.49% trailing against 5.09% forward, 0.4 points apart. A rolling year that catches a thirteenth check lifts the trailing figure by about a twelfth with no change in the dividend itself. Monthly dividend stocks covers the schedule, and Realty Income's payment record lists every check.

How far apart do the conventions run across the market?

One stock is an anecdote. The block below runs both calculations for every US listed payer above $1 billion in market value, grouped by how often each one pays.

WITH universe AS (
    SELECT ticker,
           argMax(price, date) AS last_price
    FROM global_markets.stocks_ratios
    WHERE date = (SELECT max(date) FROM global_markets.stocks_ratios)
      AND price >= 5
      AND market_cap >= 1000000000
    GROUP BY ticker
),
paid AS (
    SELECT ticker,
           sum(cash_amount) AS ttm_cash,
           argMax(cash_amount, ex_dividend_date) AS latest_cash,
           argMax(frequency, ex_dividend_date) AS pay_frequency
    FROM global_markets.stocks_dividends
    WHERE distribution_type = 'recurring'
      AND cash_amount > 0
      AND frequency IN (1, 2, 4, 12)
      AND ex_dividend_date > today() - INTERVAL 1 YEAR
      AND ex_dividend_date <= today()
    GROUP BY ticker
)
SELECT multiIf(d.pay_frequency = 12, 'monthly',
               d.pay_frequency = 4, 'quarterly',
               d.pay_frequency = 2, 'semi-annual',
               'annual') AS schedule,
       count() AS payers,
       round(quantileDeterministic(0.5)(toFloat64(d.ttm_cash) / toFloat64(u.last_price) * 100,
                                        cityHash64(u.ticker)), 2) AS median_trailing_pct,
       round(quantileDeterministic(0.5)(toFloat64(d.latest_cash) * d.pay_frequency / toFloat64(u.last_price) * 100,
                                        cityHash64(u.ticker)), 2) AS median_forward_pct,
       round(quantileDeterministic(0.5)(abs(toFloat64(d.latest_cash) * d.pay_frequency - toFloat64(d.ttm_cash))
                                        / toFloat64(u.last_price) * 100,
                                        cityHash64(u.ticker)), 3) AS median_gap_pp,
       round(quantileDeterministic(0.9)(abs(toFloat64(d.latest_cash) * d.pay_frequency - toFloat64(d.ttm_cash))
                                        / toFloat64(u.last_price) * 100,
                                        cityHash64(u.ticker)), 3) AS p90_gap_pp,
       round(100 * countIf(abs(toFloat64(d.latest_cash) * d.pay_frequency - toFloat64(d.ttm_cash))
                           / toFloat64(u.last_price) * 100 >= 0.5) / count(), 1) AS pct_gap_over_half_point
FROM universe AS u
INNER JOIN paid AS d ON u.ticker = d.ticker
GROUP BY schedule
ORDER BY payers DESC

The largest group is quarterly payers, 1128 names, with a median trailing yield of 1.93% against a median forward yield of 2.03%. At the median the two conventions land 0.03 points apart. The distribution has a tail: 8.7% of that group sit at least half a percentage point apart, and the ninetieth percentile gap is 0.357 points. Half a point on a 3% yield is a sixth of the number, which is the difference between a screen surfacing a name and skipping it. The monthly group, 21 names, carries a median gap of 0.484 points.

For the level rather than the method, what counts as a good dividend yield puts the market distribution in one place, and what dividend yield is starts from the ratio itself.

Why do two screeners quote different dividend yields?

• The convention. One provider annualizes the latest declaration, another sums the last twelve months. This is the disagreement the rest of this page is about.
• Where the window lands. A rolling 365 days can hold four checks or five for a quarterly payer, twelve or thirteen for a monthly one.
• Special dividends. A one time payment stays inside the trailing window for a year. Some providers keep it in the numerator, some strip it out, and a large special moves the trailing figure a long way.
• The price underneath. A yield computed on last night's close differs from one computed at 2pm.
• The company's own page. Investor relations sites almost always publish the declared annual rate, which is the forward numerator, often against a price that is not live. Fund sheets quote a 30 day SEC yield or a distribution yield, which are two more conventions again.

Trailing vs forward dividend yield FAQ

What is TTM dividend yield?

TTM stands for trailing twelve months. A TTM dividend yield adds up every dividend paid over the last year and divides by the current share price, which measures cash that has already been paid rather than a rate that is expected.

Which is better, trailing or forward dividend yield?

Neither is the correct one. Trailing measures what an owner collected over the past year, and forward states the current declared rate annualized. Anyone comparing income already received wants the trailing figure, and anyone pricing the rate a company pays today wants the forward figure.

Why does my broker show a different dividend yield than the company's investor page?

Investor relations pages usually publish the declared annual rate, which is the forward numerator, often against a price that is not live. A broker or screener may be summing the last twelve months instead. Both numbers can be arithmetically correct at the same moment.

Does a dividend cut show up in the trailing yield right away?

No. A reset enters the forward figure with the first smaller check, and enters the trailing figure one payment at a time over the following year. In the 3M window above, the two conventions stood 2.36 points apart in Jun 2024 and 0.06 points apart by Jul 2026.

Every figure above is a stored query over filed dividend records and real session prices. Open any panel to read the SQL, or run the same two calculations on a ticker you follow on the Strasmore terminal.