When Mutual Funds Trade: NAV Pricing at 4 pm

Mutual funds no dey trade at all during market hours. Every buy and sell order for traditional mutual fund, no matter when you place am, executes once per day, at the fund’s net asset value (NAV) wey dem calculate after the 4:00 pm ET close. Place order for 9:31 am or 3:59 pm, you go get the same price, and dem go determine am hours later. This page explain how the process dey work: the deadline, one worked example, the measured physical event wey dem use calculate every NAV, plus the exceptions.

How this once-a-day cycle dey work

Mutual fund order na instruction to the fund company, no be exchange order: “buy $500 of this fund.” By 4:00 pm ET, the fund go value every holding with the closing price, subtract liabilities, then divide am by the shares outstanding. Na this calculation be NAV, and every order wey enter before the cutoff go execute at that NAV. Orders wey enter after the cutoff go wait for tomorrow’s NAV. Three things follow: mutual fund no get intraday prices (nothing dey between NAVs), no limit or stop orders (no price stream dey trigger them), and no spreads. Everybody transact at NAV, buyer and seller alike.

The deadline no be broker etiquette; federal law set am. SEC Rule 22c-1, wey dem call the “forward pricing” rule, require every order to execute at the next NAV wey the fund calculate after the order enter. If person use yesterday’s order take collect today’s price wey everybody don already know (“late trading”), na clear illegal matter. Enforcement make this issue serious for 2003 (more below). One thing to note: 4:00 pm ET na the fund’s deadline. Brokers and retirement-plan recordkeepers need time to pass orders across, so their cutoffs dey earlier. Same-day cutoffs between 1:00 and 3:00 pm ET common for 401(k) platforms. Your real deadline na the cutoff wey your platform publish, no be the closing bell.

Worked example: $1,000 wey you place for 11 am

Make we talk say you submit $1,000 buy order for 11:04 am. Nothing execute for 11:04, so the order enter queue, and the price wey e go fill for never dey available. For 4:00 pm, the fund administrator value every holding with the official closing price. Suppose portfolio value na $50,762,500, while accrued fees and payables na $500,000. Fund get 2,000,000 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 round to the nearest cent)
• Your order: $1,000 ÷ $25.13 = 39.793 shares (fund shares dey carry three decimal places)

The numbers na hypothetical; but the sequence correct exactly. You commit the dollars for morning, price come show for evening, then the system post the three-decimal share count that night or next morning. Forward pricing mean say nobody know the execution price when dem place the order, and na by design. Nobody fit trade against price wey dem never calculate.

The 4 pm close na real, physical event

NAV only get meaning based on the closing prices wey dem use build am. Those prices come from the closing auction, wey be the biggest liquidity event for every trading day. You fit see am for the tape:

WITH
    (
        SELECT toFloat64(maxIf(size, has(conditions, 8)))
        FROM global_markets.stocks_trades
        WHERE ticker = 'SPY'
          AND sip_timestamp >= toDateTime('2026-07-10 16:00:00', 'America/New_York')
          AND sip_timestamp <  toDateTime('2026-07-10 16:10:00', 'America/New_York')
    ) AS closing_print
SELECT
    round(100.0 * (sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') + closing_print) / (sum(toFloat64(volume)) + closing_print), 1) AS final_half_hour_pct,
    round(100.0 * (sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') + closing_print) / (sum(toFloat64(volume)) + closing_print), 1) AS final_minute_pct,
    round((sum(toFloat64(volume)) + closing_print) / 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'

For that session, 24.6% of all SPY trading for the day happen during the final half hour. 5.1% happen during the last minute plus the closing auction print itself. Both figures add that print back from the trade tape. The print get its own sale condition because the one-minute bars for this tape leave am out. A meaningful part of this concentration na mutual-fund machinery: index funds dey execute the day’s net flows at the exact prices wey dem go use strike their NAVs.

If you zoom in well, the “closing price” wey NAV depend on na one physical trade. The listing exchange dey batch every end-of-day order into one cross. The tape marks am 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 print as one trade of 5.47 million shares at 16:00:00 ET exactly, for $315.32, the official close. That trade dey compare with median continuous trade of 5 shares, and e carry 16% of Apple’s consolidated volume. When fund mark an AAPL position at 4 pm, na this number e use mark am.

No be one lucky day, na every session, and e dey heaviest for month-end

One snapshot no dey prove much. Use the same yardstick across the fifteen latest complete sessions:

SELECT
    formatDateTime(b.session_date, '%Y-%m-%d') AS date,
    round(100.0 * (b.half_hour_bars + p.closing_print) / (b.session_bars + p.closing_print), 1) AS final_half_hour_pct,
    round(100.0 * (b.minute_bars + p.closing_print) / (b.session_bars + p.closing_print), 1)    AS final_minute_pct
FROM (
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
        sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') AS half_hour_bars,
        sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') AS minute_bars,
        sum(toFloat64(volume)) AS session_bars
    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
) AS b
INNER JOIN (
    SELECT
        toDate(toTimeZone(sip_timestamp, 'America/New_York')) AS session_date,
        toFloat64(maxIf(size, has(conditions, 8))) AS closing_print
    FROM global_markets.stocks_trades
    WHERE ticker = 'SPY'
      AND sip_timestamp >= toDateTime('2026-06-18 09:30:00', 'America/New_York')
      AND sip_timestamp < toDateTime('2026-07-10 16:10:00', 'America/New_York')
      AND toHour(sip_timestamp, 'America/New_York') IN (13, 16)
      AND toMinute(sip_timestamp, 'America/New_York') < 10
    GROUP BY session_date
    HAVING countIf(has(conditions, 8)) > 0
) AS p ON p.session_date = b.session_date
ORDER BY b.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
        b.session_date AS session_date,
        100.0 * (b.half_hour_bars + p.closing_print) / (b.session_bars + p.closing_print) AS final_half_hour_pct
    FROM (
        SELECT
            toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
            sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') AS half_hour_bars,
            sum(toFloat64(volume)) AS session_bars
        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
    ) AS b
    INNER JOIN (
        SELECT
            toDate(toTimeZone(sip_timestamp, 'America/New_York')) AS session_date,
            toFloat64(maxIf(size, has(conditions, 8))) AS closing_print
        FROM global_markets.stocks_trades
        WHERE ticker = 'SPY'
          AND sip_timestamp >= toDateTime('2026-06-18 09:30:00', 'America/New_York')
          AND sip_timestamp < toDateTime('2026-07-10 16:10:00', 'America/New_York')
          AND toHour(sip_timestamp, 'America/New_York') IN (13, 16)
          AND toMinute(sip_timestamp, 'America/New_York') < 10
        GROUP BY session_date
        HAVING countIf(has(conditions, 8)) > 0
    ) AS p ON p.session_date = b.session_date
)

Across all 15 sessions from 2026-06-18 reach 2026-07-10, the final half hour no ever carry less than 17.7% of SPY daily volume, and e average 24.8%. Na stretch wey take under 8% of the 390-minute session clock. The heaviest reading, 33.3%, show for 2026-06-30: the last trading day for June and for the quarter.

Calendar dey show for the tape. Month-end na when fund flows dey gather, payroll contributions enter investments, index funds rebalance, managers adjust tracking, and na for the close those orders dey execute. Divide 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
            b.session_date AS session_date,
            100.0 * (b.half_hour_bars + p.closing_print) / (b.session_bars + p.closing_print) AS final_half_hour_pct,
            100.0 * (b.minute_bars + p.closing_print) / (b.session_bars + p.closing_print) AS final_minute_pct
        FROM (
            SELECT
                toDate(toTimeZone(window_start, 'America/New_York')) AS session_date,
                sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') >= '15:30') AS half_hour_bars,
                sumIf(toFloat64(volume), formatDateTime(toTimeZone(window_start, 'America/New_York'), '%H:%i') = '15:59') AS minute_bars,
                sum(toFloat64(volume)) AS session_bars
            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
        ) AS b
        INNER JOIN (
            SELECT
                toDate(toTimeZone(sip_timestamp, 'America/New_York')) AS session_date,
                toFloat64(maxIf(size, has(conditions, 8))) AS closing_print
            FROM global_markets.stocks_trades
            WHERE ticker = 'SPY'
              AND sip_timestamp >= toDateTime('2026-01-01 00:00:00', 'America/New_York')
              AND sip_timestamp < toDateTime('2026-07-01 00:00:00', 'America/New_York')
              AND toHour(sip_timestamp, 'America/New_York') IN (13, 16)
              AND toMinute(sip_timestamp, 'America/New_York') < 10
            GROUP BY session_date
            HAVING countIf(has(conditions, 8)) > 0
        ) AS p ON p.session_date = b.session_date
    )
)

Across H1 2026's 6 month-end sessions, SPY final half hour average 28.1% of the day volume, compared with 20.1% across the other 117 sessions. Na 8-point gap, while the final minute and the closing print alone stand at 9.1% versus 5.4%. The fund machinery wey this page describe dey clear even from far away.

Mutual funds vs ETFs: na di same portfolio, but dem dey run on opposite clocks

Na dis comparison investors really need: an S&P 500 mutual fund and an S&P 500 ETF hold di same stocks. But ETF dey trade throughout di whole session for exchange, with live prices, limit orders, spreads, intraday mistakes and everything join. Fund dey execute only once at NAV, without any of those things. None of dem better for every situation. ETF give you control over timing and price, but you go pay di spread and you fit panic by 9:31 am. Fund give you di fair closing value for di day, but you get zero intraday control. One subtle advantage for fund be say 2010-style air pocket no fit fill your order, because na only di 4 pm NAV your order fit meet.

You fit measure di “no spreads” feature by looking at wetin no dey there. ETF or stock buyer dey pay di bid-ask spread: buy for ask, sell for bid; di gap na di toll. Fund buyer no ever touch am. Dis toll for di July 10 session, based on di 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, di toll almost be theory: 2-cent median spread, about $0.27 for every $10,000 round trip. Coca-Cola dey around $1.2. As you move down di liquidity curve, di spread dey grow. Nathan's Famous, wey be thin small cap, get 19-cent median spread, roughly $18.83 for every $10,000 round trip. Fund structure get its own tolls, including expense ratios, and sometimes loads and redemption fees. But spread genuinely no be one of dem.

Settlement: when shares and cash go really show

Execution and settlement no dey run on the same clock. NAV dey get calculated and published for early evening. Funds dey report am to the wires around 6:00 pm ET. Your share count dey post that night or the next morning. The trade settles—meaning cash actually moves—one business day later, T+1. Na the same cycle US stocks and ETFs move enter for May 2024. If you buy Tuesday morning, price go don known Tuesday evening and cash go comot Wednesday. If you sell before Tuesday cutoff, settled cash go show Wednesday. The main difference from ETF no be settlement date. ETF seller know the sale price by 10:15 am, but fund seller go learn the price after market close. Fund returns dey measure NAV-to-NAV by construction. Na the clearest real-world example of close-to-close convention for how returns dey measured.

Things wey you need know as exceptions

Money market funds. The once-a-day rule no too strict for here. Government money market funds dey transact at stable $1.00 NAV, and dem commonly allow same-day cash access. Some institutional funds dey strike NAV several times each day during set intraday windows. If your “mutual fund” na money market sweep, the 4 pm process mostly no apply.

Bond funds dey use earlier closing price. The US Treasury cash market recommend 3:00 pm ET as closing time, one hour before equities stop trading. Bond fund still dey strike NAV once after 4:00 pm, but the bond prices inside the fund don already set at that earlier close.

International funds and fair value. International-stock funds calculate NAV from markets wey close hours earlier. Tokyo session, for example, dey end at 2:00 am ET. Many funds apply fair-value adjustments, wey move stale foreign closing prices closer to where those stocks likely for trade based on everything wey happen since their home market close. This na direct result of the 2003 reforms: rapid traders dey exploit stale prices.

Retirement plans. Trade for 401(k) or IRA fund dey follow the same forward-pricing rule and the same 4 pm NAV. Intraday execution no dey happen. The difference na the extra intermediary. Recordkeepers dey batch and relay orders. Their cutoffs dey come earlier, and late trade go roll over to the next NAV.

Short-term redemption fees. Some funds dey charge redemption fee, commonly 0.25% to 2%, on shares wey investors sell inside stated periods such as 30, 60, or 90 days. Brokers fit add their own fees for no-transaction-fee funds. Once-a-day pricing make quick NAV-to-NAV flipping mechanically possible. These fees dey make the strategy unattractive.

The 2003 scandal, as e happen

The strict 4:00 pm rule no be theory. For September 2003, New York attorney general announce $40 million settlement with hedge fund Canary Capital Partners over two practices: late trading, wey mean say person place or confirm fund orders after 4:00 pm using the NAV wey dem don calculate for that day, and e dey illegal under Rule 22c-1; plus market timing, wey be quick buying and selling wey some fund companies quietly allow for favored clients, even as their own prospectuses warn against am. The investigations wey follow reach the biggest fund complexes for the industry, and settlements run into billions. The lasting fixes na the ones wey dey this page: hard intermediary-level cutoffs, fair-value pricing, and short-term redemption fees.

Mutual fund trading FAQ

Which time mutual fund trades dey execute?

Orders wey dem receive before fund’s 4:00 pm ET cutoff go execute for that day’s NAV, wey dem calculate after market close. Orders after the cutoff go use the next trading day’s NAV. No intraday execution dey happen for any price.

Why my mutual fund order take reach the next day?

E likely miss the cutoff — either fund’s 4 pm ET deadline or the earlier internal deadline wey your broker or recordkeeper set. Then e execute for the following session’s NAV, as e suppose be.

I fit set limit price for mutual fund order?

No. Since no intraday price stream dey, limit price no get anything to reference. All orders execute at NAV. If you want fund-like exposure wey fit use limit orders, na ETF dey do that work.

How long mutual fund trade dey take to settle?

Most stock and bond funds settle T+1. Cash move one business day after trade date, for the same cycle as ETFs and stocks. Dem know the execution price that evening, when dem publish NAV. Many money market funds settle same day.

Mutual funds dey trade for weekends or holidays?

No. Dem only strike NAV on days wey the underlying markets dey trade (the market calendar). Weekend orders go queue for Monday’s NAV.

Every panel wey dey above na stored, versioned query. You fit expand the SQL behind any number, or measure the close’s gravity yourself for Strasmore terminal.