When Do Mutual Funds Trade? NAV Pricing at 4 pm

Mutual funds do not trade during market hours at all. Every buy and sell order for a traditional mutual fund, whenever you place it, executes exactly once per day, at the fund's net asset value (NAV) computed after the 4:00 pm ET close. Place an order at 9:31 am or at 3:59 pm and you get the same price, determined hours later. This page walks the machinery: the deadline, a worked example, the measured physical event every NAV is struck from, and the exceptions.

How the once-a-day cycle works

A mutual fund order is an instruction to the fund company, not an exchange order: "buy $500 of this fund." At 4:00 pm ET the fund values every holding at its closing price, subtracts liabilities, divides by shares outstanding, that is NAV, and every order received before the cutoff executes at it. Orders arriving after the cutoff wait for tomorrow's NAV. Three consequences follow: no intraday fund prices (nothing exists between NAVs), no limit or stop orders (there is no price stream to trigger against), and no spreads, everyone transacts at NAV, buyer and seller alike.

The deadline is not broker etiquette; it is federal law. SEC Rule 22c-1, the "forward pricing" rule, requires every order to execute at the next NAV computed after it arrives. Handing yesterday's order today's already-known price ("late trading") is squarely illegal, and enforcement got very real in 2003 (more below). One wrinkle: 4:00 pm ET is the fund's deadline. Brokers and retirement-plan recordkeepers need time to relay orders, and their cutoffs sit earlier, 1:00–3:00 pm ET same-day cutoffs are common on 401(k) platforms. Your real deadline is whichever cutoff your platform publishes, not the bell.

A worked example: $1,000 placed at 11 am

Say you submit a $1,000 buy at 11:04 am. Nothing executes at 11:04, the order queues, and the price it will fill at does not exist yet. At 4:00 pm the fund's administrator marks every holding at its official closing price. Suppose the portfolio marks at $50,762,500 against $500,000 of accrued fees and payables, with 2,000,000 fund shares outstanding:

• Net assets: $50,762,500 − $500,000 = $50,262,500
• NAV: $50,262,500 ÷ 2,000,000 shares = $25.13 per share (NAV is rounded to the cent)
• Your order: $1,000 ÷ $25.13 = 39.793 shares (fund shares carry three decimal places)

The numbers are hypothetical; the sequence is exact. Dollars committed in the morning, price discovered in the evening, a three-decimal share count posted that night or the next morning. Forward pricing means nobody knows the execution price at order time, by design: no one can trade against a price that has not been computed yet.

The 4 pm close is a real, physical event

NAV is only as meaningful as the closing prices it is built from, and those come from the closing auction, the largest liquidity event of every trading day. It is visible on the tape:

SELECT
    round(100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') / sum(toFloat64(volume)), 1) AS final_half_hour_pct,
    round(100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') / sum(toFloat64(volume)), 1) AS final_minute_pct,
    round(sum(toFloat64(volume)) / 1e6, 1) AS session_shares_m
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker = 'SPY'
  AND window_start >= '2026-07-10 13:30:00' AND window_start < '2026-07-10 20:00:00'

On that session, 22.5% of SPY's entire day traded in the final half hour, 2.4% in the last minute alone. A meaningful slice of that concentration IS the mutual-fund machinery: index funds executing the day's net flows at the very prices their NAVs will be struck from.

Zoom all the way in and the "closing price" a NAV hangs on is one physical trade, the listing exchange batches every end-of-day order into a single cross, flagged on the tape with its own condition code:

SELECT
    round(toFloat64(maxIf(size, has(conditions, 8))) / 1e6, 2) AS auction_shares_m,
    formatDateTime(toTimeZone(argMaxIf(sip_timestamp, (size, sip_timestamp), has(conditions, 8)), 'America/New_York'), '%H:%i:%S') AS auction_time_et,
    toUInt8(formatDateTime(toTimeZone(argMaxIf(sip_timestamp, (size, sip_timestamp), has(conditions, 8)), 'America/New_York'), '%H:%i:%S') = '16:00:00') AS printed_at_1600,
    round(argMaxIf(price, (size, sip_timestamp), has(conditions, 8)), 2) AS auction_price,
    round(quantileDeterministicIf(0.5)(toFloat64(size), toUInt64(sip_timestamp), NOT has(conditions, 8) AND NOT hasAny(conditions, [15, 16, 38]))) AS median_trade_shares,
    round(100 * toFloat64(maxIf(size, has(conditions, 8))) / toFloat64(sumIf(size, NOT hasAny(conditions, [15, 16, 38]))), 1) AS auction_pct_of_volume
FROM global_markets.stocks_trades
WHERE ticker = 'AAPL'
  AND sip_timestamp >= toDateTime('2026-07-10 04:00:00', 'America/New_York')
  AND sip_timestamp < toDateTime('2026-07-10 20:00:00', 'America/New_York')

Apple's entire closing auction printed as one trade of 5.47 million shares at 16:00:00 ET on the dot, $315.32, the official close, against a median continuous trade of 5 shares, and carried 16% of Apple's consolidated volume. When a fund marks an AAPL position at 4 pm, this is the number it gets marked at.

Not one lucky day, every session, and heaviest at month-end

One snapshot proves little. The same yardstick, across the fifteen most recent complete sessions:

SELECT
    formatDateTime(session_date, '%Y-%m-%d') AS date,
    final_half_hour_pct,
    final_minute_pct
FROM (
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
        round(100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') / sum(toFloat64(volume)), 1) AS final_half_hour_pct,
        round(100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') / sum(toFloat64(volume)), 1) AS final_minute_pct
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND window_start >= toDateTime('2026-06-18 09:30:00', 'America/New_York')
      AND window_start < toDateTime('2026-07-10 16:00:00', 'America/New_York')
      AND formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') BETWEEN '09:30' AND '15:59'
    GROUP BY session_date
)
ORDER BY session_date

SELECT
    round(min(final_half_hour_pct), 1) AS min_half_hour_pct,
    round(avg(final_half_hour_pct), 1) AS avg_half_hour_pct,
    round(max(final_half_hour_pct), 1) AS max_half_hour_pct,
    formatDateTime(argMax(session_date, (final_half_hour_pct, session_date)), '%Y-%m-%d') AS heaviest_session
FROM (
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
        100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') / sum(toFloat64(volume)) AS final_half_hour_pct
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND window_start >= toDateTime('2026-06-18 09:30:00', 'America/New_York')
      AND window_start < toDateTime('2026-07-10 16:00:00', 'America/New_York')
      AND formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') BETWEEN '09:30' AND '15:59'
    GROUP BY session_date
)

Across all 15 sessions from 2026-06-18 through 2026-07-10, the final half hour never carried less than 16.3% of SPY's daily volume and averaged 22.2%, for a stretch that occupies under 8% of the 390-minute session clock. The heaviest reading, 30.2%, printed on 2026-06-30: the last trading day of June, and of the quarter.

The calendar shows up in the tape. Month-end is when fund flows batch together, payroll contributions invest, index funds rebalance, managers true up tracking, and the close is where those orders execute. Split every H1 2026 session into two buckets:

SELECT
    countIf(is_month_end) AS month_end_sessions,
    countIf(NOT is_month_end) AS other_sessions,
    round(avgIf(final_half_hour_pct, is_month_end), 1) AS month_end_final_half_pct,
    round(avgIf(final_half_hour_pct, NOT is_month_end), 1) AS other_final_half_pct,
    round(avgIf(final_half_hour_pct, is_month_end) - avgIf(final_half_hour_pct, NOT is_month_end), 1) AS gap_pp,
    round(avgIf(final_minute_pct, is_month_end), 1) AS month_end_final_min_pct,
    round(avgIf(final_minute_pct, NOT is_month_end), 1) AS other_final_min_pct
FROM (
    SELECT
        session_date,
        final_half_hour_pct,
        final_minute_pct,
        session_date = max(session_date) OVER (PARTITION BY toStartOfMonth(session_date)) AS is_month_end
    FROM (
        SELECT
            toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
            100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') / sum(toFloat64(volume)) AS final_half_hour_pct,
            100.0 * sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') / sum(toFloat64(volume)) AS final_minute_pct
        FROM global_markets.delayed_stocks_minute_aggs
        WHERE ticker = 'SPY'
          AND toDate(toTimeZone(window_start, 'America/New_York')) >= '2026-01-01'
          AND toDate(toTimeZone(window_start, 'America/New_York')) < '2026-07-01'
          AND formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') BETWEEN '09:30' AND '15:59'
        GROUP BY session_date
    )
)

Across H1 2026's 6 month-end sessions, SPY's final half hour averaged 25.1% of the day's volume, versus 18.3% across the other 117 sessions, a 6.9-point gap, with the final minute alone at 5.2% versus 3.2%. The fund machinery this page describes is visible from orbit.

Mutual funds vs ETFs: the same portfolio, opposite clocks

The comparison everyone actually needs: an S&P 500 mutual fund and an S&P 500 ETF hold the same stocks, but the ETF trades all session on the exchange, live prices, limit orders, spreads, intraday mistakes and all, while the fund executes once at NAV with none of those. Neither is strictly better: the ETF gives control of timing and price at the cost of paying the spread and being able to panic at 9:31 am; the fund gives the day's fair closing value at the cost of zero intraday agency. One subtle fund edge: a 2010-style air pocket cannot fill your order, since your order only ever meets the 4 pm NAV.

The "no spreads" property is measurable, by its absence. An ETF or stock buyer pays the bid-ask spread: buy at the ask, sell at the bid, the gap is the toll. A fund buyer never touches it. That toll on the July 10 session, from the consolidated quote feed:

SELECT
    ticker,
    round(quantileDeterministic(0.5)(toFloat64(ask_price - bid_price), toUInt64(sip_timestamp)) * 100, 1) AS median_spread_cents,
    round(quantileDeterministic(0.5)(toFloat64(ask_price - bid_price) / (toFloat64(ask_price + bid_price) / 2), toUInt64(sip_timestamp)) * 10000, 2) AS round_trip_cost_per_10k_usd
FROM global_markets.cache_stocks_quotes
WHERE ticker IN ('SPY', 'KO', 'NATH')
  AND sip_timestamp >= toDateTime('2026-07-10 09:30:00', 'America/New_York')
  AND sip_timestamp < toDateTime('2026-07-10 16:00:00', 'America/New_York')
  AND bid_price > 0
  AND ask_price > bid_price
GROUP BY ticker
ORDER BY indexOf(['SPY', 'KO', 'NATH'], ticker)

For SPY the toll is nearly theoretical: a 2-cent median spread, about $0.27 per $10,000 round trip. Coca-Cola ran about $1.2. Walk down the liquidity curve and it grows: Nathan's Famous, a thin small cap, quoted a 19-cent median spread, roughly $18.83 per $10,000 round trip. The fund structure charges its own tolls (expense ratios, sometimes loads and redemption fees), but the spread genuinely is not one of them.

Settlement: when you actually see shares and cash

Execution and settlement run on different clocks. NAV is struck and published in the early evening, funds report it to the wires around 6:00 pm ET, your share count posts that night or the next morning, and the trade settles (cash actually moves) one business day later, T+1, the same cycle US stocks and ETFs moved to in May 2024. Buy Tuesday morning: price known Tuesday evening, cash gone Wednesday. Sell before Tuesday's cutoff: settled cash Wednesday. The real difference from an ETF is not the settlement date, an ETF seller knows the sale price at 10:15 am; the fund seller learns it after the close. Fund returns are NAV-to-NAV by construction, the cleanest real-world example of the close-to-close convention in how returns are measured.

The exceptions worth knowing

Money market funds. The once-a-day rule bends here. Government money market funds transact at a stable $1.00 NAV and commonly offer same-day cash access; some institutional funds strike NAV several times a day at set intraday windows. If your "mutual fund" is a money market sweep, the 4 pm mechanics mostly do not bind.

Bond funds mark off an earlier close. The US Treasury cash market's recommended close is 3:00 pm ET, an hour before equities stop trading. A bond fund still strikes its NAV once, after 4:00 pm, but the bond prices inside it were set at that earlier close.

International funds and fair value. International-stock funds compute NAV from markets that closed hours earlier, Tokyo's session ends at 2:00 am ET. Many apply fair-value adjustments, nudging stale foreign closes toward where those stocks would likely trade given everything since their home close. A direct descendant of the 2003 reforms: stale prices were exactly what rapid traders exploited.

Retirement plans. A 401(k) or IRA fund trade follows the same forward-pricing rule, same 4 pm NAV, no intraday execution. The difference is the extra intermediary: recordkeepers batch and relay orders, their cutoffs come earlier, and a late trade rolls to the next NAV.

Short-term redemption fees. Some funds charge a redemption fee, commonly 0.25% to 2%, on shares sold within a stated window such as 30, 60, or 90 days; brokers may add their own fees on no-transaction-fee funds. Once-a-day pricing makes rapid NAV-to-NAV flipping mechanically possible; these fees exist to make it unattractive.

The 2003 scandal, specifically

The legal rigidity around 4:00 pm is not abstract. In September 2003, New York's attorney general announced a $40 million settlement with hedge fund Canary Capital Partners over two practices: late trading, placing or confirming fund orders after 4:00 pm at that day's already-computed NAV, illegal under Rule 22c-1, and market timing, rapid in-and-out trading several fund companies had quietly permitted for favored clients while their own prospectuses discouraged it. The investigations that followed reached the industry's largest fund complexes; settlements ran into the billions. The durable fixes are the ones on this page: hard intermediary-level cutoffs, fair-value pricing, short-term redemption fees.

Mutual fund trading FAQ

What time do mutual fund trades execute?

Orders received before the fund's 4:00 pm ET cutoff execute at that day's NAV, computed after the close. Orders after the cutoff get the next trading day's NAV. There is no intraday execution at any price.

Why did my mutual fund order take until the next day?

It likely missed the cutoff, the fund's 4 pm ET deadline or your broker's or recordkeeper's earlier internal one. It then executed at the following session's NAV, as designed.

Can I set a limit price on a mutual fund order?

No. With no intraday price stream there is nothing for a limit to reference; all orders execute at NAV. If you want limit orders on a fund-like exposure, that is what ETFs are for.

How long does a mutual fund trade take to settle?

Most stock and bond funds settle T+1: cash moves one business day after the trade date, the same cycle as ETFs and stocks. The execution price is known the evening of the trade date, when NAV is published. Many money market funds settle same day.

Do mutual funds trade on weekends or holidays?

No, NAV is only struck on days the underlying markets trade (the market calendar). Weekend orders queue for Monday's NAV.

Every panel above is a stored, versioned query, expand the SQL behind any number, or measure the close's gravity yourself on the Strasmore terminal.