"Is the market open?" sounds like a one-line function. Opening time, closing time, weekday check, done.

Then you add a second exchange in another country and it falls apart. Clocks change on different dates. Holidays follow different calendars. Some days close at lunchtime. One exchange splits Friday in two. One holds a session on a Sunday.

We keep a small dataset of exchange hours and holidays, read from each exchange's own pages, and a market clock on top of it. These are the problems we hit building it, with real dates from the file (as of 15 October 2026) and code you can lift.

Rule 1: store local wall time plus an IANA zone, never a UTC offset

Every exchange publishes its hours in local time, so store them that way:

The LSE and JSE gaps are deliberate. Our script keeps an hour only if the exchange's own page states it in words we can match, and for those two it didn't (the JSE's pages blocked our script or didn't state hours). We do hold LSE holidays and half days. An honest "unknown" beats a guessed open.

If you store "NYSE opens at 14:30 UTC", you're right for about seven months a year and wrong for the rest.

Rule 2: the DST gap weeks are where bugs live

The US and UK don't change clocks on the same day. In 2026, the UK falls back on Sunday 25 October and the US on Sunday 1 November. For one week the gap between London and New York is four hours, not five.

Here's the NYSE 09:30 open converted with Python's zoneinfo (run on 16 October 2026):

Look at the columns, not the rows. Between 23 and 26 October only London moves. Between 26 October and 2 November, London stays put and everyone else's NYSE open moves an hour later, because India, Pakistan, Nigeria and South Africa don't observe daylight saving. A trader in Lagos sees the US open at 14:30 in October and 15:30 in November without their own clock changing at all.

The fix is to do every conversion from the exchange's zone at the specific date, never by adding a fixed offset.

Rule 3: JavaScript can format into a zone, but not out of one

Intl.DateTimeFormat will happily show a UTC instant in any IANA zone. What it won't do is the reverse: "09:30 in New York on 2 November, as UTC". You have to derive the offset yourself:

function zonedToUtc(dateStr, hhmm, tz) {
  const guess = new Date(`${dateStr}T${hhmm}:00Z`);
  const p = Object.fromEntries(
    new Intl.DateTimeFormat("en-US", {
      timeZone: tz, hourCycle: "h23",
      year: "numeric", month: "2-digit", day: "2-digit",
      hour: "2-digit", minute: "2-digit",
    }).formatToParts(guess).map(({ type, value }) => [type, value])
  );
  const wallAsUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute);
  return new Date(guess.getTime() - (wallAsUtc - guess.getTime()));
}

zonedToUtc("2026-10-26", "09:30", "America/New_York").toISOString();
// "2026-10-26T13:30:00.000Z"
zonedToUtc("2026-11-02", "09:30", "America/New_York").toISOString();
// "2026-11-02T14:30:00.000Z"

This one-pass version is fine for exchange opens, because none of them sit inside the 01:00–03:00 window where clocks jump. Don't reuse it for arbitrary times without a second pass. Once the Temporal API is available in your runtime, Temporal.ZonedDateTime replaces all of this.

Rule 4: a holiday belongs to a market, not a country

A US federal holiday doesn't close US stocks. On Monday 12 October 2026, Columbus Day, the US Office of Personnel Management listed a federal holiday and SIFMA recommended a full bond-market close, but the NYSE was open as normal. Veterans Day, 11 November 2026, is the same story.

Thanksgiving shows how far apart related markets can drift on one day. On Thursday 26 November 2026 the NYSE is closed, while CME Globex equity and interest-rate futures halt at 12:00 Chicago time. On Friday 27 November the NYSE closes at 13:00, CME's equity and rate futures at 12:15 Chicago time, and SIFMA's bond-market recommendation is a 14:00 close.

So key holidays by venue, and resist one shared is_holiday(country) helper.

Rule 5: half days and different calendars

Early closes are just a different close time on a known date, but they land at awkward moments across zones. On Thursday 24 December 2026:

• The LSE closes at 12:30 London time, which is 07:30 in New York, two hours before the NYSE opens.
• The NYSE closes at 13:00 New York time, which is 18:00 in London and 23:30 in Mumbai.

The LSE also has 12:30 half days on 31 December 2026 and on 24 and 31 December 2027. Then on Monday 28 December 2026 London and Lagos are both shut (Boxing Day, and its substitute in London) while New York trades.

Then there are calendars that aren't Gregorian at all. PSX and NGX holidays include Eid dates, which follow the moon. Our file lists Eid-ul-Fitr on 23 March 2026 at PSX and 20 and 23 March at NGX. Dates like these are announced close to the day and can shift, so treat any far-future Eid entry as provisional and re-read the exchange's notices.

Rule 6: weekday logic has exceptions both ways

Two from our file:

• PSX splits Friday. Monday to Thursday is one session; Friday has a morning session (09:17–12:00) and an afternoon one (14:32–16:30) around midday prayers. In our JSON, those are separate entries in sessions, so code can't assume sessions[0] covers every day. PSX's hours page also shows this table under an old Ramadan heading, and its 2026 Ramadan notice gave different hours. Our reading that it's the standard timetable is ours, not PSX's, so check its notices.
• NSE trades on a Sunday. Muhurat Trading for Diwali falls on Sunday 8 November 2026, and the exchange hadn't published the session time when we read its page. Two days later, Tuesday 10 November (Diwali-Balipratipada), is a full holiday. See NSE's 2026 holiday list and session times for the rest of the year.

Another wrinkle: NSE's 09:15 open is 23:45 the previous evening in New York (on 16 October 2026). A date stamped by a US server isn't the trading date in Mumbai.

Putting it together in Python

Here's a small status check against the market-hours.json structure (exchanges[], each with tz, sessions, holidays and early_closes):

import json
from datetime import datetime, time, timezone
from zoneinfo import ZoneInfo

data = json.load(open("market-hours.json"))
venues = {e["slug"]: e for e in data["exchanges"]}

def status(slug, when_utc):
    ex = venues[slug]
    if not ex["sessions"]:
        return "unknown (no verified hours)"
    local = when_utc.astimezone(ZoneInfo(ex["tz"]))
    day = local.date().isoformat()
    if any(h["date"] == day for h in ex["holidays"]):
        return "closed (holiday)"
    if local.weekday() >= 5:
        return "closed (weekend)"
    s = ex["sessions"][0]
    close = next((e["close"] for e in ex["early_closes"] if e["date"] == day), s["close"])
    is_open = time.fromisoformat(s["open"]) <= local.time() < time.fromisoformat(close)
    return "open" if is_open else "closed"

utc = lambda *a: datetime(*a, tzinfo=timezone.utc)
status("nyse", utc(2026, 12, 24, 17, 45))  # 'open'   (12:45 New York)
status("nyse", utc(2026, 12, 24, 18, 15))  # 'closed' (13:15, after the early close)
status("nse",  utc(2026, 11, 10, 5, 0))    # 'closed (holiday)'
status("lse",  utc(2026, 12, 28, 10, 0))   # 'unknown (no verified hours)'
status("ngx",  utc(2026, 12, 28, 10, 0))   # 'closed (holiday)'

It's deliberately incomplete: it ignores PSX's Friday split, NSE's Sunday session and weekends that aren't Saturday–Sunday (the Saudi Exchange trades Sunday to Thursday). Each needs its own field rather than another if.

What I'd tell my past self

1. Store local times with an IANA zone. Convert at the moment you need to, for that date.
2. Test the DST gap weeks explicitly (in 2026: 25 October to 1 November, and the March gap).
3. Treat holidays and early closes as per-venue data with a source and a date read, and let "unknown" be a real state.
4. Re-read the sources. Exchanges change hours, and moon-dated holidays move.

If you'd rather check a result than run code, there's a live market clock built on the same file, which works out open or closed in your browser from these hours.

Times and dates here come from each exchange's own pages as read on 15 October 2026. Check the exchange's notices before relying on them; this isn't trading advice.

Alexander Burnett is a co-founder of TradingLookup and a former day trader.