Upcoming Ex-Dividend Dates: Stocks This Week

Upcoming ex-dividend dates decide who gets paid: own the stock before its ex-dividend date and the next payment is yours; buy on or after it and the seller keeps the cash. This page is a live calendar of the dates ahead, the names going ex each day this week, the biggest companies going ex over the next two weeks, computed from declared dividend records and refreshed weekly. It also measures what the share price actually does on the ex-morning, and whether the "dividend capture" trade survives contact with the data.

Ex-dividend dates this week

Every declared cash dividend going ex in the next seven days, by day, split by how often the payer pays:

SELECT toString(ex_dividend_date) AS ex_date,
       formatDateTime(ex_dividend_date, '%b %e') AS ex_date_label,
       count() AS names_going_ex,
       countIf(frequency = 12) AS monthly_payers,
       countIf(frequency = 4) AS quarterly_payers
FROM global_markets.stocks_dividends
WHERE ex_dividend_date > today()
  AND ex_dividend_date <= today() + 7
  AND cash_amount > 0
GROUP BY ex_dividend_date
ORDER BY ex_dividend_date

The near-term calendar carries 5 ex-dividend days, starting Aug 26 with 69 names, 28 monthly payers, 16 quarterly ones. That split matters when you scan a calendar: the monthly names (income funds, mortgage trusts, some REITs) reappear every four weeks and bunch around mid-month; the quarterly names, most operating companies, turn up once a season. To collect any of these payments the position must be owned at the close of the trading day before the listed date. The timing machinery is in our ex-dividend date guide, and record date vs ex-dividend date explains why the ex-date is the one that matters for buyers.

Big names going ex-dividend in the next two weeks

The largest companies ($10B market cap and up) going ex inside fourteen days, payment, pay date, and the annual yield that payment implies at the current price:

WITH latest AS (
    SELECT ticker, argMax(market_cap, date) AS mcap, argMax(price, date) AS px
    FROM global_markets.stocks_ratios
    WHERE date >= today() - 10
    GROUP BY ticker
)
SELECT d.ticker AS ticker,
       toString(d.ex_dividend_date) AS ex_date,
       formatDateTime(d.ex_dividend_date, '%b %e') AS ex_date_label,
       round(max(d.cash_amount), 4) AS per_share_usd,
       toString(any(d.pay_date)) AS pay_date,
       formatDateTime(any(d.pay_date), '%b %e') AS pay_date_label,
       round(any(l.mcap) / 1e9, 0) AS mcap_bn,
       round(100 * max(d.cash_amount) * max(d.frequency) / any(l.px), 2) AS indicated_yield_pct
FROM global_markets.stocks_dividends d
JOIN latest l ON d.ticker = l.ticker
WHERE d.ex_dividend_date > today()
  AND d.ex_dividend_date <= today() + 14
  AND d.cash_amount > 0
  AND d.distribution_type = 'recurring'
  AND d.frequency > 0
  AND l.mcap >= 10000000000
  AND d.ticker NOT IN ('SPCX')
GROUP BY d.ticker, d.ex_dividend_date
ORDER BY any(l.mcap) DESC
LIMIT 12

The biggest name on the list is GOOGL, going ex on Sep 4 with a $0.22 per-share payment landing Sep 14, an indicated annual yield of 0.25% at its recent price. Read the yield column carefully: it annualizes the declared payment at its stated frequency, snapshot arithmetic, not a promise. A big per-share number and a big yield are different things, as what is dividend yield shows. One symbol is filtered out of the ranked tables (the filter is visible in the panel's SQL): its ticker was reused by a second issuer, so records under it span two companies, and we drop it rather than print a row we cannot attribute.

Which kinds of companies are paying now

The dividend feed carries no sector label, so the shape of a two-week window has to come from what the records do hold: company size, payment cadence and the yield each declared payment implies at the current price. Every recurring payer with a market-cap record going ex inside fourteen days, grouped by size band:

WITH latest AS (
    SELECT ticker, argMax(market_cap, date) AS mcap, argMax(price, date) AS px
    FROM global_markets.stocks_ratios
    WHERE date >= today() - 10
    GROUP BY ticker
),
names AS (
    SELECT d.ticker AS ticker,
           multiIf(any(l.mcap) >= 1e11, '1 Mega cap ($100B+)',
                   any(l.mcap) >= 1e10, '2 Large cap ($10-100B)',
                   any(l.mcap) >= 2e9,  '3 Mid cap ($2-10B)',
                                        '4 Small cap (under $2B)') AS size_band,
           max(d.cash_amount) AS amt,
           max(d.frequency) AS freq,
           any(l.px) AS px
    FROM global_markets.stocks_dividends d
    JOIN latest l ON d.ticker = l.ticker
    WHERE d.ex_dividend_date > today()
      AND d.ex_dividend_date <= today() + 14
      AND d.cash_amount > 0
      AND d.distribution_type = 'recurring'
      AND d.frequency > 0
      AND l.px > 0
      AND l.mcap > 0
    GROUP BY d.ticker
)
SELECT size_band,
       count() AS names_going_ex,
       round(quantileDeterministic(0.5)(100 * amt * freq / px, cityHash64(ticker)), 2) AS median_indicated_yield_pct,
       countIf(freq = 12) AS monthly_payers,
       countIf(freq = 4) AS quarterly_payers
FROM names
GROUP BY size_band
ORDER BY size_band

The window carries 21 mega caps ($100B and up) and 91 large caps ($10B to $100B), alongside 89 mid caps and 84 smaller names. Median indicated yield runs 1.83% in the mega-cap band, 1.4% across the large caps, 2.04% at mid cap and 2.89% among the small caps. Size and yield are separate axes: a calendar sorted by yield surfaces a different set of names than one sorted by company size, which is why a screen built on yield alone quietly walks you down the size ladder. Cadence splits the same way as the day-by-day table above. The quarterly habit rules the top of the market, with 21 of the mega caps paying quarterly and 0 paying monthly, while the monthly crowd sits further down the cap table: 9 of the small-cap names in this window pay every month. Paying twelve times a year is a structural choice rather than a size effect, and monthly dividend stocks covers which structures do it and how their yields actually compare with the quarterly standard.

What you actually have to do to get paid

Nothing, in almost every case. No form, no broker call, no registration: hold the shares at the close of the trading day before the ex-date and the cash lands in your account on the pay date, usually a few weeks later. Buying on that last day still counts, US trades settle the next business day (T+1), and the ex-date is set around that. The one optional step is a DRIP (dividend reinvestment plan), a broker setting that turns the cash into fractional shares of the same stock.

Tax treatment is where the ex-date bites. In a US taxable account a dividend is qualified, taxed at the lower long-term capital-gains rates, only if you hold the shares more than 60 days within the 121-day window beginning 60 days before the ex-dividend date. Buy the day before an ex-date, take the payment, sell a week later, and that test fails: the payment is taxed as ordinary income. REIT and many fund distributions are ordinary income regardless, and account type changes the picture (an IRA sidesteps it). Not tax advice, but a short-hold "capture" is worth less after tax than it looks.

What the price actually does on the ex-morning

The standard line is that a stock opens on its ex-date "adjusted down by the dividend." The exchange does mark the reference price down before the open, but the opening print is that markdown plus everything else that happened overnight. Three household payers at their most recent ex-dates:

WITH last_ex AS (
    SELECT ticker,
           max(ex_dividend_date) AS ex_d,
           argMax(cash_amount, ex_dividend_date) AS div_amt
    FROM global_markets.stocks_dividends
    WHERE ticker IN ('KO', 'VZ', 'XOM')
      AND cash_amount > 0
      AND distribution_type = 'recurring'
      AND ex_dividend_date < today()
      AND ex_dividend_date >= today() - 120
    GROUP BY ticker
),
daily AS (
    SELECT ticker,
           toDate(toTimeZone(window_start, 'America/New_York')) AS d,
           argMaxIf(toFloat64(close), window_start, (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS close_px,
           argMinIf(toFloat64(open), window_start, (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS open_px,
           countIf((toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS bars
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('KO', 'VZ', 'XOM')
      AND window_start >= toDateTime(today() - 130)
    GROUP BY ticker, d
    HAVING bars > 200
),
seq AS (
    SELECT ticker, d, open_px, close_px,
           lagInFrame(close_px, 1) OVER (PARTITION BY ticker ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS pre_close
    FROM daily
)
SELECT s.ticker AS ticker,
       toString(e.ex_d) AS last_ex_date,
       formatDateTime(e.ex_d, '%b %e') AS last_ex_label,
       round(e.div_amt, 4) AS dividend_usd,
       round(s.pre_close, 2) AS close_before_ex_usd,
       round(s.open_px, 2) AS ex_morning_open_usd,
       round(100 * (s.open_px - s.pre_close) / s.pre_close, 2) AS open_gap_pct,
       round(100 * e.div_amt / s.pre_close, 2) AS dividend_pct_of_price
FROM seq s
JOIN last_ex e ON e.ticker = s.ticker AND e.ex_d = s.d
WHERE s.pre_close > 0
ORDER BY ticker

Take Coca-Cola's most recent ex-date, Jun 15: a $0.53 payment, worth 0.64% of the $82.6 close the evening before, against a first ex-morning print of $81.08, a gap of -1.84%. Verizon's payment was worth 1.68% of its $42.22 prior close; it opened -1.46%. Exxon's was worth 0.64%; it opened 0.01%. Three payers, three different-sized gaps, none exactly the payment. The markdown is a bookkeeping adjustment to the reference price; the open is a price, and prices move overnight for reasons unrelated to the dividend. The payment is known in advance; the ex-morning price is not.

Does the dividend-capture trade work?

"Dividend capture" is the idea of buying just before the ex-date, collecting the payment, and selling once the price recovers. That contains a testable claim. The test: 68 ex-dividend events across fifty mega-cap payers over the past six months, each tracked from the close before its ex-date through the ex-morning open, the ex-day close, and one, five and ten sessions on.

WITH rth AS (
    SELECT ticker,
           toDate(toTimeZone(window_start, 'America/New_York')) AS d,
           argMaxIf(toFloat64(close), window_start, (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS close_px,
           argMinIf(toFloat64(open), window_start, (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS open_px,
           countIf((toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) AS bars
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('AAPL', 'MSFT', 'JNJ', 'KO', 'PG', 'XOM', 'CVX', 'JPM', 'HD', 'MCD',
                     'PEP', 'ABBV', 'MRK', 'PFE', 'VZ', 'T', 'CSCO', 'IBM', 'WMT', 'CAT',
                     'BAC', 'WFC', 'C', 'GS', 'MS', 'UNH', 'LLY', 'AMGN', 'BMY', 'GILD',
                     'TXN', 'QCOM', 'AVGO', 'ADP', 'LMT', 'RTX', 'HON', 'GE', 'MMM', 'UPS',
                     'LOW', 'TGT', 'COST', 'SBUX', 'NKE', 'DIS', 'CMCSA', 'DUK', 'SO', 'NEE')
      AND window_start >= toDateTime(today() - 190)
    GROUP BY ticker, d
    HAVING bars > 200
),
seq AS (
    SELECT ticker, d, open_px,
           lagInFrame(close_px, 1) OVER w AS pre_close,
           close_px AS ex_close,
           leadInFrame(close_px, 1) OVER w AS c1,
           leadInFrame(close_px, 5) OVER w AS c5,
           leadInFrame(close_px, 10) OVER w AS c10
    FROM rth
    WINDOW w AS (PARTITION BY ticker ORDER BY d ROWS BETWEEN 1 PRECEDING AND 10 FOLLOWING)
),
ev AS (
    SELECT s.ticker AS ticker, s.d AS ex_d, s.pre_close AS pre_close, s.open_px AS ex_open,
           s.ex_close AS ex_close, s.c1 AS c1, s.c5 AS c5, s.c10 AS c10,
           max(dv.cash_amount) AS div_amt
    FROM seq s
    JOIN global_markets.stocks_dividends dv ON dv.ticker = s.ticker AND dv.ex_dividend_date = s.d
    WHERE dv.cash_amount > 0
      AND dv.distribution_type = 'recurring'
      AND s.d >= today() - 160
      AND s.pre_close > 0 AND s.c1 > 0 AND s.c5 > 0 AND s.c10 > 0
    GROUP BY s.ticker, s.d, s.pre_close, s.open_px, s.ex_close, s.c1, s.c5, s.c10
),
paths AS (
    SELECT ticker, ex_d, pre_close, div_amt,
           arrayJoin([('1 ex-day open', ex_open),
                      ('2 ex-day close', ex_close),
                      ('3 one session later', c1),
                      ('4 five sessions later', c5),
                      ('5 ten sessions later', c10)]) AS chk
    FROM ev
)
SELECT chk.1 AS checkpoint,
       count() AS events,
       round(avg(100 * div_amt / pre_close), 2) AS avg_dividend_pct,
       round(avg(100 * (chk.2 - pre_close) / pre_close), 2) AS avg_move_pct,
       round(quantileDeterministic(0.5)(100 * (chk.2 - pre_close) / pre_close, cityHash64(ticker, ex_d)), 2) AS median_move_pct,
       round(100 * countIf(chk.2 >= pre_close) / count(), 1) AS pct_back_above_pre_ex
FROM paths
GROUP BY checkpoint
ORDER BY checkpoint

The average payment here was worth 0.67% of the pre-ex share price. On the ex-morning open the average stock moved -0.42% from its pre-ex close (median -0.43%), and only 27.9% of events opened at or above the prior close: the markdown is real and immediate. What follows is the part the pitch skips. By the ex-day close the average event stood -0.63% from the starting price; one session later, -0.86%; five later, -0.33%; ten later, 1.53%, with 55.9% back at or above where they started.

Waiting for the price to "come back" means holding through ten sessions of ordinary volatility, moves that dwarf a 0.67% payment in both directions, while the short hold forfeits qualified-dividend tax treatment. The dividend is a transfer from the share price to your account, not free money on the tape, and the price path afterwards belongs to the market.

Funds and ETFs: why they are missing from the forward calendar

Income investors often hold funds rather than single stocks, and the forward calendar above is thin on them for a structural reason: most exchange-traded funds do not declare an ex-date far in advance the way a company board does, their distributions enter the record tape at, or barely before, the ex-date. What they do have is a metronomic cadence, enough to plan around. Thirteen widely held income funds, with their last ex-date, their typical gap between ex-dates, and the date that cadence implies next:

WITH hist AS (
    SELECT ticker, ex_dividend_date, cash_amount, frequency,
           dateDiff('day', lagInFrame(ex_dividend_date) OVER (PARTITION BY ticker ORDER BY ex_dividend_date), ex_dividend_date) AS gap_days
    FROM global_markets.stocks_dividends
    WHERE ticker IN ('SCHD', 'VYM', 'VIG', 'DVY', 'SPYD', 'JEPI', 'JEPQ', 'QYLD', 'SPHD', 'NOBL', 'DGRO', 'HDV', 'SPY')
      AND cash_amount > 0
      AND ex_dividend_date >= today() - 800
)
SELECT ticker,
       any(frequency) AS payments_per_year,
       toString(max(ex_dividend_date)) AS last_ex_date,
       formatDateTime(max(ex_dividend_date), '%b %e') AS last_ex_label,
       round(argMax(cash_amount, ex_dividend_date), 4) AS last_per_share_usd,
       round(quantileDeterministicIf(0.5)(gap_days, cityHash64(ticker, ex_dividend_date), gap_days BETWEEN 5 AND 200)) AS typical_gap_days,
       toString(max(ex_dividend_date) + toIntervalDay(round(quantileDeterministicIf(0.5)(gap_days, cityHash64(ticker, ex_dividend_date), gap_days BETWEEN 5 AND 200)))) AS implied_next_ex,
       formatDateTime(max(ex_dividend_date) + toIntervalDay(round(quantileDeterministicIf(0.5)(gap_days, cityHash64(ticker, ex_dividend_date), gap_days BETWEEN 5 AND 200))), '%b %e') AS implied_next_label
FROM hist
GROUP BY ticker
HAVING countIf(gap_days BETWEEN 5 AND 200) > 0
ORDER BY implied_next_ex, ticker

The soonest of the group is JEPI, last ex on Aug 3 at $0.3666 per share on a 30-day rhythm, putting its next ex-date near Sep 2. The furthest out, HDV, runs a 90-day cadence pointing at Nov 17. The payments_per_year column splits the families: twelve-a-year names go ex every four weeks or so; four-a-year funds once a quarter, in the quarter-end months. Treat the implied date as an estimate, only the sponsor's notice is final.

Is this a heavy month or a light one?

Ex-dividend dates are not spread evenly across the year, three years of records, averaged by calendar month:

SELECT multiIf(toMonth(ex_dividend_date) = 1, '01 Jan', toMonth(ex_dividend_date) = 2, '02 Feb', toMonth(ex_dividend_date) = 3, '03 Mar',
               toMonth(ex_dividend_date) = 4, '04 Apr', toMonth(ex_dividend_date) = 5, '05 May', toMonth(ex_dividend_date) = 6, '06 Jun',
               toMonth(ex_dividend_date) = 7, '07 Jul', toMonth(ex_dividend_date) = 8, '08 Aug', toMonth(ex_dividend_date) = 9, '09 Sep',
               toMonth(ex_dividend_date) = 10, '10 Oct', toMonth(ex_dividend_date) = 11, '11 Nov', '12 Dec') AS month,
       round(count() / 3.0) AS ex_dates_per_year,
       round(countIf(frequency = 4) / 3.0) AS quarterly_payers,
       round(countIf(frequency = 12) / 3.0) AS monthly_payers
FROM global_markets.stocks_dividends
WHERE ex_dividend_date >= toStartOfMonth(today()) - INTERVAL 36 MONTH
  AND ex_dividend_date < toStartOfMonth(today())
  AND cash_amount > 0
GROUP BY month
ORDER BY month

The quarter-end months carry the load: March averages 5605 ex-dates, June 5792, September 4973 and December 6380, each holding more than two thousand quarterly payers (2640 in June alone). The first month of each quarter runs light, January averages 2043 and July 3194, half a quarter-end month or less. The floor under the quiet months is the monthly crowd: 1661 of July's average are monthly payers, ignoring the quarterly calendar entirely. A short list this week is a feature of the calendar, not a verdict on the market.

Why calendars disagree, and how to read this one

Compare this page to a broker's calendar and you will find small differences. Every calendar is built from company declarations, and sources differ in how fast they ingest announcements, whether they show amended dates, and whether they count funds, trusts and foreign listings as well as operating companies (the day counts above include them all; only the ranked tables apply a market-cap floor). When two calendars disagree, the company's declaration press release is the tiebreaker. The depth receipt, computed live:

SELECT countIf(ex_dividend_date > today()) AS future_ex_dates_declared,
       countIf(ex_dividend_date > today() AND ex_dividend_date <= today() + 7) AS in_the_next_7_days,
       countIf(ex_dividend_date > today() AND ticker IN ('SCHD', 'VYM', 'VIG', 'DVY', 'SPYD', 'JEPI', 'JEPQ', 'QYLD', 'SPHD', 'NOBL', 'DGRO', 'HDV', 'SPY')) AS fund_records_declared_ahead,
       toString(max(ex_dividend_date)) AS furthest_declared_date,
       formatDateTime(max(ex_dividend_date), '%b %e, %Y') AS furthest_declared_label
FROM global_markets.stocks_dividends
WHERE ex_dividend_date > today() - 1
  AND cash_amount > 0

4344 future ex-dividend dates are on file right now, 769 of them inside a week, with declarations reaching out to Nov 12, 2027. Across the thirteen funds above, forward-declared ex-dates number 0, the structural gap that makes cadence, not declarations, the way to anticipate a fund's next ex-date. Boards declare one meeting at a time, so the far calendar fills in as announcements land: treat the near dates as reliable and the far ones as provisional.

Ex-dividend calendar FAQ

How do I find upcoming ex-dividend dates?

Companies declare each dividend with its ex-dividend, record and pay dates, and those declarations flow into market data feeds. This page computes the calendar straight from those records, 4344 future dates on file, and rebuilds weekly.

If I buy a stock on its ex-dividend date, do I get the dividend?

No. The ex-dividend date is the first day the stock trades without the payment attached. To receive it you must own the stock at the close of the trading day before the ex-date; buy on the ex-date and the seller keeps the payment.

Do I need to do anything to receive a dividend?

No. Hold the shares through the close before the ex-date and the cash is credited to your brokerage account on the pay date automatically, no form, no claim, no call. The only optional step is a DRIP, the broker setting that reinvests the payment into more shares.

Does buying a stock right before the ex-dividend date to capture the payment work?

The data argues against it. Across 68 mega-cap ex-dividend events in the past six months, the average stock's open moved -0.42% from its pre-ex close against an average payment worth 0.67% of the price, and ten sessions later only 55.9% were back at or above where they started. The short hold also fails the qualified-dividend holding-period test.

Are dividends taxed differently depending on when I buy?

Yes, in a US taxable account. A dividend is qualified, taxed at long-term capital-gains rates, only if you hold the shares more than 60 days within the 121-day window starting 60 days before the ex-dividend date. A buy-just-before, sell-just-after trade misses that window and the payment is taxed as ordinary income. REIT and many fund distributions are ordinary income regardless. A mechanic, not tax advice.

Dividend profiles by ticker

Every large-cap payer on this calendar has its own measured dividend profile, the current yield computed from the latest close, the full payment history as recorded on the tape, the growth streak, and how its ex-dividend mornings have actually traded:

AAPL, ABBV, ABT, ACN, ADP, AMGN, AVGO, AXP, BAC, BLK, BMY, C, CAT, CL, CMCSA, COP, COST, CRM, CSCO, CVX, DE, DHR, DUK, GE, GILD, GIS, GOOGL, GS, HD, HON, IBM, JNJ, JPM, KMB, KO, LIN, LLY, LMT, LOW, MA, MCD, MDLZ, MDT, META, MMM, MO, MRK, MS, MSFT, NEE, NKE, O, ORCL, PEP, PFE, PG, PM, QCOM, RTX, SBUX, SO, SPGI, T, TGT, TMO, TXN, UNH, UNP, USB, V, VZ, WFC, WMT, XOM.

Every table above is a stored, versioned query over declared dividend records and real minute bars, expand the SQL under any panel, or screen the calendar yourself on the Strasmore terminal.