Strasmore Research
Learn Matt ConnorBy Matt Connor · data as of September 16, 2026 · refreshed weekly

Dividend Increases Expected This Month

Dividend increases expected this month: companies that raised in each of the last five years and announced in this month, split into declared and pending.

Which dividend increases are expected this month? The list below is built from five years of declaration dates: it keeps every quarterly payer that raised its dividend in each of the last five completed calendar years and declared that raise in the current calendar month in at least four of those five. It is a pattern-based expectation, not a forecast of the amount. A company that has announced its raise in the same month for four or five years running has a habit, and the panel reports that habit, who has already acted on it this month, and who has not yet.

Which dividend increases are expected this month?

The method takes two sentences. A raise is any regular quarterly dividend whose per-share amount is higher than the one before it, dated by the day the company declared it rather than by the ex-dividend date. A company makes the list when it recorded a raise in each of the last five completed calendar years, never cut the quarterly amount over that span, and declared its raise in this calendar month in at least four of those five years.

QueryCompanies expected to raise their dividend this month, declared names first
tickerstatususual_windowpast_declaration_daysyears_declared_in_monthlast_raise_pctlast_raise_declared
BRCdeclaredfirst week of SeptemberSep 1 to 54 of 52Sep 1, 2026
NNWWFdeclaredsecond week of SeptemberSep 4 to 125 of 52.4Sep 8, 2026
VICIdeclaredfirst week of SeptemberSep 4 to 84 of 52.2Sep 3, 2026
ACNexpected, not yet declaredlast week of SeptemberSep 22 to 285 of 510.1Sep 25, 2025
CHCOexpected, not yet declaredlast week of SeptemberSep 24 to 284 of 510.1Sep 24, 2025
MSFTexpected, not yet declaredthird week of SeptemberSep 14 to 205 of 59.6Sep 15, 2025
OGEexpected, not yet declaredlast week of SeptemberSep 23 to 295 of 50.9Sep 23, 2025
PMexpected, not yet declaredsecond week of SeptemberSep 12 to 195 of 58.9Sep 19, 2025
SBUXexpected, not yet declaredthird week of SeptemberSep 8 to 295 of 51.6Sep 8, 2025
STCexpected, not yet declaredfirst week of SeptemberSep 1 to 34 of 54.8Aug 31, 2026
SVAUFexpected, not yet declaredthird week of SeptemberSep 13 to 155 of 50.5Jun 16, 2026
TXNexpected, not yet declaredthird week of SeptemberSep 15 to 215 of 54.4Sep 18, 2025
VZexpected, not yet declaredfirst week of SeptemberSep 2 to 75 of 52.5Jan 30, 2026
The exact SQL behind every number
WITH changes AS
(
    SELECT
        ticker,
        ex_dividend_date,
        declaration_date,
        amount,
        prev_amount,
        (prev_amount > 0 AND amount > prev_amount
             AND declaration_date > toDate('2000-01-01'))            AS is_raise,
        (prev_amount > 0 AND amount < prev_amount)                   AS is_cut,
        round((amount / prev_amount - 1) * 100, 1)                   AS raise_pct
    FROM
    (
        SELECT
            ticker,
            ex_dividend_date,
            declaration_date,
            amount,
            lagInFrame(amount, 1) OVER (PARTITION BY ticker ORDER BY ex_dividend_date
                                        ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_amount
        FROM
        (
            SELECT
                ticker,
                ex_dividend_date,
                ifNull(max(declaration_date), toDate('1970-01-01')) AS declaration_date,
                ifNull(max(toFloat64(cash_amount)), 0)              AS amount
            FROM global_markets.stocks_dividends
            WHERE toString(frequency) = '4'
              AND ex_dividend_date >= toDate('2020-01-01')
              AND ticker NOT IN ('SPCX')
            GROUP BY ticker, ex_dividend_date
        )
    )
)
SELECT
    ticker,
    if(declared_this_month > 0, 'declared', 'expected, not yet declared')  AS status,
    concat(multiIf(median_day <= 7,  'first week of ',
                   median_day <= 14, 'second week of ',
                   median_day <= 21, 'third week of ',
                                     'last week of '),
           monthName(today()))                                             AS usual_window,
    concat(formatDateTime(today(), '%b'), ' ', toString(earliest_day),
           ' to ', toString(latest_day))                                   AS past_declaration_days,
    concat(toString(years_in_month), ' of 5')                              AS years_declared_in_month,
    last_raise_pct,
    concat(formatDateTime(last_declared, '%b'), ' ',
           toString(toDayOfMonth(last_declared)), ', ',
           toString(toYear(last_declared)))                                AS last_raise_declared
FROM
(
    SELECT
        ticker,
        uniqExactIf(toYear(declaration_date),
                    is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1))
                                                                                AS years_with_raise,
        uniqExactIf(toYear(declaration_date),
                    is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
                             AND toMonth(declaration_date) = toMonth(today()))  AS years_in_month,
        countIf(is_cut AND ex_dividend_date >= addYears(toStartOfYear(today()), -5))
                                                                                AS cuts,
        countIf(is_raise AND toStartOfMonth(declaration_date) = toStartOfMonth(today()))
                                                                                AS declared_this_month,
        quantileExactIf(0.5)(toDayOfMonth(declaration_date),
                    is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
                             AND toMonth(declaration_date) = toMonth(today()))  AS median_day,
        minIf(toDayOfMonth(declaration_date),
                    is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
                             AND toMonth(declaration_date) = toMonth(today()))  AS earliest_day,
        maxIf(toDayOfMonth(declaration_date),
                    is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
                             AND toMonth(declaration_date) = toMonth(today()))  AS latest_day,
        argMaxIf(raise_pct, declaration_date, is_raise)                         AS last_raise_pct,
        maxIf(declaration_date, is_raise)                                       AS last_declared
    FROM changes
    GROUP BY ticker
    HAVING years_with_raise = 5
       AND years_in_month >= 4
       AND cuts = 0
)
ORDER BY status ASC, ticker ASC
Run this yourself

The panel holds 13 names as of today, sorted by the status column, which is the one to read first. A row marked declared has already announced this month's raise: its last_raise_declared date falls inside the current month and its last_raise_pct is the size of that new raise. A row marked expected, not yet declared has a four- or five-year habit of declaring in this month and has not done so yet, so its last_raise_pct is last year's step. The usual_window column turns the median day of those past declarations into plain words, and past_declaration_days shows the earliest and latest day of the month the company has actually used, which is the practical range to watch. Every declared name also appears, with its old and new quarterly amounts, in this month's dividend increases and cuts.

Which of this month's expected raises have already been declared?

The split between declared and expected moves on every trading day of the month, so the second panel tracks it as a count and lines it up against the same count for each of the past five years. The historical rows answer the fair question about any pattern list: when these companies were expected in earlier years, how many delivered inside the month?

QueryDeclared vs. still expected: this month in each of the last six years
yeardeclared_in_monthnot_declared_in_monthmedian_raise_pct
20211034.2
20221218.2
20231304.8
20241304.2
20251304
20263102.2
The exact SQL behind every number
WITH changes AS
(
    SELECT
        ticker,
        ex_dividend_date,
        declaration_date,
        amount,
        prev_amount,
        (prev_amount > 0 AND amount > prev_amount
             AND declaration_date > toDate('2000-01-01'))            AS is_raise,
        (prev_amount > 0 AND amount < prev_amount)                   AS is_cut,
        round((amount / prev_amount - 1) * 100, 1)                   AS raise_pct
    FROM
    (
        SELECT
            ticker,
            ex_dividend_date,
            declaration_date,
            amount,
            lagInFrame(amount, 1) OVER (PARTITION BY ticker ORDER BY ex_dividend_date
                                        ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_amount
        FROM
        (
            SELECT
                ticker,
                ex_dividend_date,
                ifNull(max(declaration_date), toDate('1970-01-01')) AS declaration_date,
                ifNull(max(toFloat64(cash_amount)), 0)              AS amount
            FROM global_markets.stocks_dividends
            WHERE toString(frequency) = '4'
              AND ex_dividend_date >= toDate('2020-01-01')
              AND ticker NOT IN ('SPCX')
            GROUP BY ticker, ex_dividend_date
        )
    )
),
qualifiers AS
(
    SELECT ticker
    FROM changes
    GROUP BY ticker
    HAVING uniqExactIf(toYear(declaration_date),
                       is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)) = 5
       AND uniqExactIf(toYear(declaration_date),
                       is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
                                AND toMonth(declaration_date) = toMonth(today())) >= 4
       AND countIf(is_cut AND ex_dividend_date >= addYears(toStartOfYear(today()), -5)) = 0
)
SELECT
    spine.year                                                        AS year,
    ifNull(r.names_declared, 0)                                       AS declared_in_month,
    (SELECT count() FROM qualifiers) - ifNull(r.names_declared, 0)    AS not_declared_in_month,
    ifNull(r.median_raise_pct, 0)                                     AS median_raise_pct
FROM
(
    SELECT toUInt16(toYear(today()) - 5 + arrayJoin(range(6))) AS year
) AS spine
LEFT JOIN
(
    SELECT
        toUInt16(toYear(declaration_date))          AS year,
        uniqExact(ticker)                           AS names_declared,
        round(quantileExact(0.5)(raise_pct), 1)     AS median_raise_pct
    FROM changes
    WHERE is_raise
      AND toMonth(declaration_date) = toMonth(today())
      AND ticker IN (SELECT ticker FROM qualifiers)
    GROUP BY year
) AS r ON r.year = spine.year
ORDER BY year
Run this yourself

Reading the last row, 3 of the names have declared so far in 2026, and 10 are still expected but undeclared. In 2025, the most recent completed year, 13 of today's names declared in this month, with a median raise of 4%. Five years back, in 2021, the count was 10.

One caution on the historical rows: they are high by construction. The list admits only companies that declared in this month in at least four of the five years, so a past-year count can never fall far below the size of the list. The useful reading is the gap. A name counted under not_declared_in_month in a past year did raise that year, just in an adjacent month, which is the single miss the four-of-five rule allows. A declaration slipping a week or two across a month boundary is the most common way a reliable raiser drops out of a month-anchored list.

Why do dividend raises cluster in the same month each year?

A dividend raise is a board decision, and most boards review the payout once a year at a fixed point on the corporate calendar, commonly the meeting that follows the fiscal year-end or the one that approves the next budget. The new amount is then declared alongside that quarter's regular dividend. A company whose fiscal year closes in June reviews its payout after the June books are done, which puts the declaration in September. Stack every company's habit together and the declaration calendar is anything but flat.

QueryWhen dividend raises get declared: share by calendar month, starting from this month
labeldeclaration_countshare_pct
Sep923
Oct32310.5
Nov2498.1
Dec1966.3
Jan36111.7
Feb59019.1
Mar1314.2
Apr2959.6
May2608.4
Jun792.6
Jul2849.2
Aug2277.4
The exact SQL behind every number
WITH changes AS
(
    SELECT
        ticker,
        ex_dividend_date,
        declaration_date,
        amount,
        prev_amount,
        (prev_amount > 0 AND amount > prev_amount
             AND declaration_date > toDate('2000-01-01'))            AS is_raise,
        (prev_amount > 0 AND amount < prev_amount)                   AS is_cut
    FROM
    (
        SELECT
            ticker,
            ex_dividend_date,
            declaration_date,
            amount,
            lagInFrame(amount, 1) OVER (PARTITION BY ticker ORDER BY ex_dividend_date
                                        ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_amount
        FROM
        (
            SELECT
                ticker,
                ex_dividend_date,
                ifNull(max(declaration_date), toDate('1970-01-01')) AS declaration_date,
                ifNull(max(toFloat64(cash_amount)), 0)              AS amount
            FROM global_markets.stocks_dividends
            WHERE toString(frequency) = '4'
              AND ex_dividend_date >= toDate('2020-01-01')
              AND ticker NOT IN ('SPCX')
            GROUP BY ticker, ex_dividend_date
        )
    )
),
growers AS
(
    SELECT ticker
    FROM changes
    GROUP BY ticker
    HAVING uniqExactIf(toYear(declaration_date),
                       is_raise AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)) = 5
       AND countIf(is_cut AND ex_dividend_date >= addYears(toStartOfYear(today()), -5)) = 0
)
SELECT
    label,
    declaration_count,
    round(100 * declaration_count / sum(declaration_count) OVER (), 1) AS share_pct
FROM
(
    SELECT
        toMonth(declaration_date)                      AS month_num,
        any(formatDateTime(declaration_date, '%b'))    AS label,
        count()                                        AS declaration_count
    FROM changes
    WHERE is_raise
      AND (toYear(declaration_date) BETWEEN toYear(today()) - 5 AND toYear(today()) - 1)
      AND ticker IN (SELECT ticker FROM growers)
    GROUP BY month_num
)
ORDER BY (month_num - toMonth(today()) + 12) % 12
Run this yourself

This panel counts every raise declared over the last five completed years by companies with five straight years of raises and no cuts, grouped by calendar month and rotated so the current month comes first. Sep accounts for 92 of those declarations, 3% of the total; the month after, Oct, carries 10.5%. A perfectly even calendar would give each month about 8.3%, so the distance from that line is the size of the seasonal habit. The full-year shape, including which months are the busiest, is the subject of when companies announce dividend raises.

What does one company's declaration habit look like?

Microsoft (MSFT) is the textbook case, and its trace is pinned to 2019 through 2025 so the panel never changes. Each row is one raise: the year, the declaration day, the quarterly amounts before and after it, and the step in percent.

QueryMSFT dividend raise declarations, 2019 to 2025 (pinned)
yeardeclared_onday_of_monthquarterly_beforequarterly_afterraise_pct
2019Sep 1818$0.46$0.5110.9
2020Sep 1515$0.51$0.569.8
2021Sep 1414$0.56$0.6210.7
2022Sep 2020$0.62$0.689.7
2023Sep 1919$0.68$0.7510.3
2024Sep 1616$0.75$0.8310.7
2025Sep 1515$0.83$0.919.6
The exact SQL behind every number
SELECT
    toYear(declaration_date)                                     AS year,
    concat(formatDateTime(declaration_date, '%b'), ' ',
           toString(toDayOfMonth(declaration_date)))             AS declared_on,
    toDayOfMonth(declaration_date)                               AS day_of_month,
    concat('$', toString(toDecimal64(prev_amount, 2)))           AS quarterly_before,
    concat('$', toString(toDecimal64(amount, 2)))                AS quarterly_after,
    round((amount / prev_amount - 1) * 100, 1)                   AS raise_pct
FROM
(
    SELECT
        ex_dividend_date,
        declaration_date,
        amount,
        lagInFrame(amount, 1) OVER (ORDER BY ex_dividend_date
                                    ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_amount
    FROM
    (
        SELECT
            ex_dividend_date,
            ifNull(max(declaration_date), toDate('1970-01-01')) AS declaration_date,
            ifNull(max(toFloat64(cash_amount)), 0)              AS amount
        FROM global_markets.stocks_dividends
        WHERE ticker = 'MSFT'
          AND toString(frequency) = '4'
          AND ex_dividend_date BETWEEN toDate('2018-06-01') AND toDate('2026-03-31')
        GROUP BY ex_dividend_date
    )
)
WHERE prev_amount > 0
  AND amount > prev_amount
  AND declaration_date BETWEEN toDate('2019-01-01') AND toDate('2025-12-31')
ORDER BY declaration_date
Run this yourself

The first raise in the window was declared on Sep 18, 2019, a 10.9% step; the most recent, on Sep 15, 2025, was 9.6%. Read the day_of_month series against the raise_pct series. Timing and size are separate decisions, and the trace shows them moving independently: the declaration day sits in a narrow band while the percentage varies with each year's board decision. Verizon's dividend increase history walks the same kind of trace for a different name.

How is this different from an ex-dividend calendar?

An ex-dividend calendar lists dates that are already fixed: the company has declared the dividend, and the ex-date and pay date are on the record. Our upcoming ex-dividend dates page is that calendar. This list works one step earlier. It names companies whose declaration has not happened yet and says when, on past form, it has tended to arrive. Once a name declares, it moves into the declared group here and appears in the increases-and-cuts post with its new amount; a few weeks after that, the new dividend reaches the ex-dividend calendar. For the longest raise streaks regardless of month, see dividend growth champions.

What the list cannot tell you

  • The amount. The pattern says when a company has tended to declare and nothing about the size of the next step; the last_raise_pct column is history.
  • Whether the raise happens at all. A board can hold the dividend flat in any year. The list only knows what has been declared, so a company that skips a raise stays in the expected group until the month ends and then drops out of next year's list.
  • Names without a recorded declaration date. A raise is dated by its declaration, so a dividend record without one cannot be counted, which can exclude a company that does raise every year.
  • Names with a stock split in the window. The raise test compares consecutive per-share amounts as paid, so a split quarter registers as a drop and removes the company under the no-cut rule.

The list refreshes on the same weekly cadence as the other rolling dividend pages, so a declaration made today appears once the dividend record carries it, typically within a day or two.

FAQ

What does "expected, not yet declared" mean for a dividend?

It means the company has declared a dividend raise in this calendar month in at least four of the last five years, has raised in every one of those years, and has not announced this year's raise yet. It is a statement about past timing, with no promise that a raise is coming or how large it will be.

How do I know when a company will announce its dividend increase?

Look at its declaration dates from prior years. Most companies review the dividend once a year at the same board meeting, so the declaration tends to land in the same week of the same month. The usual_window and past_declaration_days columns above summarize that history for each name.

Does a company have to raise its dividend every year?

No. A dividend is declared by the board each quarter, and a company can hold it flat or cut it at any point. Long raise streaks are a track record, not an obligation, which is why this page keeps what has been declared separate from what is only expected.

Where can I see the dividend increases already declared this month?

The declared group at the top of the first panel lists them, and dividend increases and cuts shows each one with its old and new quarterly amounts.

Every panel here ships with the exact SQL beneath it. To check one company's declaration history, or to re-anchor the list to a different month, ask the question in plain English on the Strasmore terminal.

#dividend increases#dividend calendar#dividend growth#declaration date#dividend aristocrats