MSFT Dividend 2026: Dates, Raise, Per Share

The MSFT dividend 2026 schedule holds four quarterly payments, with ex-dividend dates in February, May, August and November and cash paid roughly three weeks after each one. Microsoft resets the rate once a year through a mid-September declaration whose first payment lands in December, which splits the 2026 record into three payments at the rate declared in September 2025 and a fourth at the rate set in September 2026. Every date and figure below is read live from the dividend record and the page refreshes as new entries arrive; the evergreen Microsoft dividend page covers the long history, while this one is the dated record for 2026.

MSFT dividend 2026: ex-dividend, record and pay dates

Four dates define each payment. The declaration date is the day the board announces the dividend. The ex-dividend date is the first day the stock trades without the right to that payment, meaning a buyer has to own the shares before it to collect. The record date is the day the company takes its list of shareholders, and since the May 2024 move to one-day (T+1) settlement it falls on the same day as the ex-date. The pay date is when the cash reaches accounts. A fuller walk-through lives in our ex-dividend date explainer.

SELECT
    toString(ex_day)                                                            AS ex_date,
    concat(formatDateTime(ex_day, '%b'), ' ', toString(toDayOfMonth(ex_day)))   AS ex_label,
    toString(record_day)                                                        AS record_date,
    toString(pay_day)                                                           AS pay_date,
    concat(formatDateTime(pay_day, '%b'), ' ', toString(toDayOfMonth(pay_day))) AS pay_label,
    toString(declared_day)                                                      AS declared_on,
    round(toFloat64(dividend), 2)                                               AS dividend_per_share
FROM
(
    SELECT
        ex_dividend_date                                AS ex_day,
        toDateOrNull(toString(any(record_date)))        AS record_day,
        toDateOrNull(toString(any(pay_date)))           AS pay_day,
        toDateOrNull(toString(any(declaration_date)))   AS declared_day,
        any(cash_amount)                                AS dividend
    FROM global_markets.stocks_dividends
    WHERE ticker = 'MSFT'
      AND ex_dividend_date >= toDate('2026-01-01')
      AND ex_dividend_date <  toDate('2027-01-01')
    GROUP BY ex_dividend_date
)
ORDER BY ex_day

The record lists 4 ex-dividend dates in 2026. The first three, Feb 19, May 21 and Aug 20, each carried $0.91 per share, the quarterly rate declared in September 2025, and the cash went out on Mar 12, Jun 11 and Sep 10. The fourth ex-date of the year falls in mid-November and is the first to carry the rate set in the September 2026 declaration. It enters this table only once that declaration is recorded, and the row count above is the quickest check on whether it has.

What is the Microsoft dividend per share for 2026?

There are two correct answers, and they differ. Microsoft's fiscal year runs from July 1 to June 30, which means "fiscal 2026" covers July 2025 through June 2026 and overlaps only half of calendar 2026. A per-share total for "2026" depends on which twelve months you mean. The panel below computes both, keyed to the ex-dividend date, the date that decides who receives each payment.

SELECT
    tupleElement(slice, 1) AS basis,
    tupleElement(slice, 2) AS payments,
    tupleElement(slice, 3) AS dividends_per_share,
    tupleElement(slice, 4) AS ex_dates_counted
FROM
(
    SELECT arrayJoin([
        ('Calendar 2026',
         countIf(in_calendar_2026),
         round(sumIf(dividend, in_calendar_2026), 2),
         'ex-dates Jan 1 to Dec 31, 2026'),
        ('Fiscal 2026',
         countIf(in_fiscal_2026),
         round(sumIf(dividend, in_fiscal_2026), 2),
         'ex-dates Jul 1, 2025 to Jun 30, 2026')
    ]) AS slice
    FROM
    (
        SELECT
            ex_dividend_date,
            toFloat64(any(cash_amount))                                                              AS dividend,
            ex_dividend_date >= toDate('2026-01-01') AND ex_dividend_date < toDate('2027-01-01')     AS in_calendar_2026,
            ex_dividend_date >= toDate('2025-07-01') AND ex_dividend_date < toDate('2026-07-01')     AS in_fiscal_2026
        FROM global_markets.stocks_dividends
        WHERE ticker = 'MSFT'
          AND ex_dividend_date >= toDate('2025-07-01')
          AND ex_dividend_date <  toDate('2027-01-01')
        GROUP BY ex_dividend_date
    )
)
ORDER BY basis

On the calendar basis, the 4 ex-dates recorded so far in 2026 add up to $3.71 per share. On the fiscal basis, the four ex-dates from July 2025 through June 2026 add up to $3.56 per share, and that figure is final, since Microsoft's fiscal 2026 closed on June 30. The two totals differ for a mechanical reason: the fiscal year reaches back to the August 2025 ex-date, which paid the older rate, while the calendar year swaps that payment out for the November 2026 one at the newest rate.

When a search asks for "Microsoft dividend per share 2026", it almost always means the calendar year: the cash a holder collected on shares owned through 2026, which is also how brokerage tax statements roll it up. For Microsoft the pay date always falls in the same calendar year as its ex-date, and the two ways of counting agree. The fiscal-year figure is the one Microsoft itself reports in its annual filing, where dividends are tallied by declaration date within the fiscal year. Keep the two apart when comparing sources; a tracker quoting one and a filing quoting the other are both right. The calendar total is complete once the panel counts four payments, and a count of three means the November ex-date is still to be recorded. The mechanics of summing a year's payments are in how annual dividend per share is calculated.

When did Microsoft raise its dividend, and by how much?

Microsoft's dividend increases follow a fixed rhythm. The board declares the new rate in mid-September, the first ex-date at that rate falls in mid-November, and the first payment arrives in December. The panel below reads that pattern straight from the record: for each year since 2020 it takes the November ex-date, compares its rate with the prior November's, and lists the declaration, ex and pay dates that came with it.

SELECT
    cur.year                                                                    AS year,
    round(toFloat64(prev.new_rate), 2)                                          AS prior_quarterly_rate,
    round(toFloat64(cur.new_rate), 2)                                           AS new_quarterly_rate,
    round((toFloat64(cur.new_rate) / toFloat64(prev.new_rate) - 1) * 100, 1)    AS raise_pct,
    concat(formatDateTime(cur.declared_day, '%b'), ' ',
           toString(toDayOfMonth(cur.declared_day)), ', ',
           toString(toYear(cur.declared_day)))                                  AS declared_on,
    concat(formatDateTime(cur.first_ex_day, '%b'), ' ',
           toString(toDayOfMonth(cur.first_ex_day)), ', ',
           toString(toYear(cur.first_ex_day)))                                  AS first_ex_date_at_new_rate,
    concat(formatDateTime(cur.first_pay_day, '%b'), ' ',
           toString(toDayOfMonth(cur.first_pay_day)), ', ',
           toString(toYear(cur.first_pay_day)))                                 AS first_pay_date_at_new_rate
FROM
(
    SELECT
        toYear(ex_dividend_date)                        AS year,
        max(cash_amount)                                AS new_rate,
        toDateOrNull(toString(any(declaration_date)))   AS declared_day,
        min(ex_dividend_date)                           AS first_ex_day,
        toDateOrNull(toString(any(pay_date)))           AS first_pay_day
    FROM global_markets.stocks_dividends
    WHERE ticker = 'MSFT'
      AND toMonth(ex_dividend_date) >= 10
      AND ex_dividend_date >= toDate('2019-10-01')
      AND ex_dividend_date <  toDate('2027-01-01')
    GROUP BY year
) AS cur
INNER JOIN
(
    SELECT
        toUInt16(toYear(ex_dividend_date) + 1)          AS next_year,
        max(cash_amount)                                AS new_rate
    FROM global_markets.stocks_dividends
    WHERE ticker = 'MSFT'
      AND toMonth(ex_dividend_date) >= 10
      AND ex_dividend_date >= toDate('2019-10-01')
      AND ex_dividend_date <  toDate('2027-01-01')
    GROUP BY next_year
) AS prev ON cur.year = prev.next_year
ORDER BY year

The oldest row, 2020, lifted the quarterly rate from $0.51 to $0.56, a 9.8% increase. The newest, 2026, moved it from $0.91 to $0.98, or 7.7%, declared on Sep 14, 2026 with a first ex-date of Nov 19, 2026 and a first payment on Dec 10, 2026. The years in between follow the same shape: one raise per year, each of a similar percentage size.

Read the year on that newest row. A 2026 row means the September 2026 declaration is in the record, and the figures above are the new rate for the payment due in December 2026. A 2025 row means the September 2026 declaration has not yet been recorded here. In that case the quarterly rate in force is $0.98, this page carries no estimate of the next one, and the row fills in on the first refresh after the declaration lands. The wider pattern of when boards announce increases, and how far ahead of the ex-date they do it, is covered in when companies announce dividend raises.

What is the MSFT dividend yield in 2026?

Dividend yield is the annual dividend divided by the share price, expressed as a percentage. Two versions are common. The indicated yield takes the latest quarterly rate, multiplies it by four and divides by the price; it is the figure most quote pages show. The trailing yield adds up the actual payments over the past twelve months instead. On a stock that raises once a year, the two sit close together for most of the year and separate for a quarter after each raise.

The trace below plots the indicated yield on every Microsoft ex-dividend date since the start of 2024, using the closing price on that day.

SELECT
    toString(d.ex_day)                                                          AS ex_date,
    concat(formatDateTime(d.ex_day, '%b'), ' ',
           toString(toDayOfMonth(d.ex_day)), ', ',
           toString(toYear(d.ex_day)))                                          AS ex_label,
    round(toFloat64(d.dividend), 2)                                             AS quarterly_dividend,
    round(toFloat64(d.dividend) * 4, 2)                                         AS indicated_annual_dividend,
    concat('$', toString(round(toFloat64(p.close), 2)))                         AS close_on_ex_date,
    round(toFloat64(d.dividend) * 4 / toFloat64(p.close) * 100, 2)              AS indicated_yield_pct
FROM
(
    SELECT
        ex_dividend_date    AS ex_day,
        any(cash_amount)    AS dividend
    FROM global_markets.stocks_dividends
    WHERE ticker = 'MSFT'
      AND ex_dividend_date >= toDate('2024-01-01')
      AND ex_dividend_date <= today()
    GROUP BY ex_dividend_date
) AS d
INNER JOIN
(
    SELECT
        toDate(date)        AS day,
        any(close)          AS close
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'MSFT'
      AND date >= toDate('2024-01-01')
      AND date <= today()
    GROUP BY day
) AS p ON p.day = d.ex_day
ORDER BY d.ex_day

On Feb 14, 2024, Microsoft closed at $409.49 with a quarterly dividend of $0.75, an indicated yield of 0.73%. On the most recent ex-date in the trace, Aug 20, 2026, the quarterly dividend stood at $0.91, the close at $481.15 and the indicated yield at 0.76%. The dividend line steps up once a year in November; the yield line moves with the share price in between. A rising dividend can sit alongside a flat or falling yield whenever the price climbs faster than the payout.

Yield at the latest close and payout ratio

The current figures use the most recent stored closing price. The payout ratio is the share of earnings paid out as dividends: trailing twelve-month dividends per share divided by earnings per share. Both numbers come from stored fields only, and this page carries no forecast of future earnings or of the next dividend rate.

SELECT
    toString(p.day)                                                             AS price_date,
    concat(formatDateTime(p.day, '%b'), ' ',
           toString(toDayOfMonth(p.day)), ', ',
           toString(toYear(p.day)))                                             AS price_date_label,
    round(p.close, 2)                                                           AS close_price,
    round(d.trailing_dividends, 2)                                              AS trailing_12m_dividends,
    round(d.trailing_dividends / p.close * 100, 2)                              AS trailing_yield_pct,
    round(r.eps, 2)                                                             AS earnings_per_share,
    round(d.trailing_dividends / r.eps * 100, 1)                                AS payout_ratio_pct
FROM
(
    SELECT
        max(toDate(date))                   AS day,
        argMax(toFloat64(close), date)      AS close
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'MSFT'
      AND date >= today() - 30
) AS p
CROSS JOIN
(
    SELECT sum(toFloat64(dividend)) AS trailing_dividends
    FROM
    (
        SELECT
            ex_dividend_date,
            any(cash_amount) AS dividend
        FROM global_markets.stocks_dividends
        WHERE ticker = 'MSFT'
          AND ex_dividend_date >  today() - 365
          AND ex_dividend_date <= today()
        GROUP BY ex_dividend_date
    )
) AS d
CROSS JOIN
(
    SELECT argMax(toFloat64(earnings_per_share), date) AS eps
    FROM global_markets.stocks_ratios
    WHERE ticker = 'MSFT'
      AND date >= today() - 120
) AS r

As of Sep 18, 2026, Microsoft closed at $493.78. The four dividends with ex-dates in the trailing twelve months total $3.64 per share, a trailing yield of 0.74%. Set against stored earnings per share of $18.01, the payout ratio comes to 20.2%, meaning Microsoft distributes roughly that share of each dollar of earnings and retains the rest. For the next ex-date across the market, the rolling upcoming ex-dividend dates list is refreshed from the same record.

FAQ

When is the next MSFT ex-dividend date?

Microsoft's ex-dividend dates fall in mid-February, mid-May, mid-August and mid-November. The next one after August 2026 is the November 2026 ex-date, which appears in the 2026 record table above once the September 2026 declaration is recorded, along with its record and pay dates.

How much is Microsoft's quarterly dividend in 2026?

The February, May and August 2026 payments were $0.91 per share each, the rate declared in September 2025. The November 2026 payment carries the rate set in the September 2026 declaration; the raise-history panel lists it under 2026 once recorded and shows the 2025 declaration until then.

Does Microsoft pay dividends monthly?

No. Microsoft pays quarterly, four times a year, with ex-dates in February, May, August and November and payment about three weeks after each ex-date. It has raised the rate once a year, in September, in every year shown in the raise-history panel.

What is Microsoft's dividend payout ratio?

As of Sep 18, 2026, trailing twelve-month dividends of $3.64 per share against stored earnings per share of $18.01 give a payout ratio of 20.2%.

Why is Microsoft's fiscal 2026 dividend total different from the calendar 2026 total?

Microsoft's fiscal year runs from July to June, and the company raises its dividend every September. Fiscal 2026 (July 2025 through June 2026) includes the August 2025 payment at the older rate, while calendar 2026 replaces it with the November 2026 payment at the newest rate. Same four-payments-a-year rhythm, different twelve-month window.

Every panel above carries the exact SQL beneath it. To pull the same dated record for another dividend payer, or to check a single ex-date, ask the question in plain English on the Strasmore terminal.