Epic Games shipped v42.30 on October 1, 2026, kicking off the Fortnitemares 2026 event inside Chapter 7, Season 4: Override. If you’ve ever refreshed the Epic Games Launcher at 7 a.m. wondering whether today is a patch day, or you’ve lost three straight lobbies to squads that play like they practice eight hours a day, you’ve run into the two questions Fortnite never answers directly: has the game actually updated, and why do matches suddenly feel harder. This tutorial builds a small, self-hosted tool that answers both. By the end you’ll have a Python script that polls Fortnite’s public API for new content drops, stores a history of every patch it detects, pushes a Discord alert the moment something changes, and tracks your own match performance to flag when matchmaking pressure shifts. None of it touches Epic’s private systems or violates the game’s terms of service, it only reads data Epic already publishes.

You don’t need a background in game development to follow along. The project leans on three plain building blocks, a REST API call, a local database, and a webhook, the same stack you’d use to monitor a product restock or a GitHub release. What makes it worth building for Fortnite specifically is the volume of searches around “fortnite update today” and the complete absence of an official way to answer that question programmatically. Twelve steps later, you’ll have a script that answers it for you, logs every answer, and tells you when your own results start drifting.

What’s New in Fortnite’s October 2026 Update (v42.30 and Fortnitemares)

Chapter 7, Season 4 launched on August 20, 2026, under the name Override, on build v42.00, and it’s scheduled to run through October 31, 2026. The October 1 update, v42.30, opened Fortnitemares 2026 with the tagline “The Game Is Cursed.” Epic reworked part of the island for the Halloween window, replacing the Battlewoods point of interest with Nightmare Neighborhood, a horror-themed area built around a Freddy Krueger boss encounter. Fortnite’s own news feed confirms the season name directly: querying the game’s public news endpoint on October 1 returned the headline “Fortnite: Override Is Here!” alongside a fresh content hash, which is the exact signal this tutorial’s tracker watches for.

That hash matters because Epic doesn’t publish a simple “current patch number” field anywhere in its public API surface. Trackers and fan sites infer update activity from signals like the news hash, map changes, or item shop rotation, which is exactly the approach this project takes. If you want the stock version of that information before building anything, Epic’s own Fortnite status page and the Fortnite-API project’s status mirror both track uptime, though neither one tells you what changed inside a patch.

Chapter 7 itself arrived as a bigger structural reset than most prior chapters, folding in crossover content and a faster seasonal cadence than Chapter 6 ran. Override continues that pattern: rather than a single slow narrative arc, Season 4 has been built around rotating “override” mechanics that temporarily reskin parts of the map with references to other games, which is also why a horror-themed takeover like Fortnitemares 2026 can slot in mid-season without feeling like a detour. For a tracker script, none of that lore matters directly, but it explains why the news hash changes so often during a single season, each themed rotation is its own content push, and each one is a legitimate “yes, Fortnite updated today” event even when there’s no new numbered patch attached.

Why “Is Fortnite Updated Today” Is Hard to Answer

Searches for “fortnite update today” spike every single day Fortnite is live, because Epic ships hotfixes far more often than it ships numbered seasons. A hotfix might only touch a weapon’s damage value, while a numbered patch like v42.30 rewrites a chunk of the map. Fortnite’s launcher tells you a download is available, but it won’t tell you what changed, and third-party patch-note sites lag the actual release by hours while they write up notes manually.

Matchmaking adds a second layer of confusion. Epic’s own documentation describes a skill-based system that groups players by ability rather than pure rank. In Epic’s words, “the new matchmaking system accounts for various skill levels across different platforms and control inputs, and groups players of similar skill levels together,” a description that’s held up across multiple Fortnite matchmaking updates since it was introduced. Epic has also said the stated goal is fairness: the company’s blog framed the project around creating “fairer matches for all of our players, which includes special considerations for each platform.” A later rollout note added that “you will be more likely to match with players of similar skill, and as you get better, so should your opponents,” and Epic cautioned at the time that it would “slowly roll this out to all regions across Battle Royale core modes” while monitoring results.

What Epic has never shipped is a public dashboard showing your actual matchmaking rating. Ranked Fortnite shows you a visible rank and a progress bar, but that’s a separate system from the hidden MMR used in unranked Battle Royale. Epic’s help center still describes the underlying mechanic the same way it did when the system first rolled out in patch v10.40: matchmaking “matches players of similar skill rather than the current rank the players are placed in.” As of this writing, no 2026 patch notes or developer post confirm a new SBMM transparency tool, a settings toggle, or an official MMR viewer, so any number a third-party tool shows you, including the one you’re about to build, is an estimate, not Epic’s real value.

That gap is the whole reason to build your own tracker. You can’t see Epic’s number, but you can watch your own results over time and correlate shifts against patch dates, which is often a better practical signal anyway: did your win rate drop the same week a balance patch landed, or the same week you climbed a rank tier.

Hotfixes, Major Patches, and Live Events: Three Different Kinds of “Update”

Part of why “is Fortnite updated today” has no single answer is that Epic ships at least three different categories of change, and they don’t share a version numbering scheme a casual player can follow. A hotfix is a small, often server-side adjustment, a weapon damage tweak or a bug fix, that can land without a client download at all. A major patch, like v42.00 or v42.30, bundles map changes, new items, and larger systems work, and does require a download through the launcher. A live event sits on top of either one, a scheduled, time-boxed moment (the kind Fortnite built its early reputation on) that can reuse an existing patch’s assets rather than shipping new code.

The tracker in this tutorial treats all three the same way, as a changed content hash, because from a player’s perspective they all answer the same question: did something change since I last played. If you want to distinguish between them later, the MOTD title and body text returned by the news endpoint usually telegraph which category you’re looking at, a hotfix rarely gets its own MOTD banner, while a major patch or live event almost always does.

Prerequisites: Tools, Versions, and Accounts You Need

This build is deliberately lightweight. Everything runs on a laptop, a Raspberry Pi, or a free-tier cloud VM, and the full dependency list fits in one pip command. Here’s what to install and register before Step 1.

Tool / AccountMinimum VersionPurposeCost
Python3.11 or newer (3.12 recommended)Runs the polling script, SQLite storage, and scoring logicFree
requests library2.31 or newerHTTP calls to the Fortnite-APIFree
Fortnite-API keyN/AAuthenticates stats lookups at dash.fortnite-api.comFree tier
Discord server + webhookN/ADelivers patch and SBMM alertsFree
SQLite 3Bundled with PythonStores patch history and match snapshotsFree
Flask3.0 or newer (optional)Serves the lightweight status dashboardFree
cron (Linux/macOS) or Task Scheduler (Windows)N/AAutomates the polling intervalFree

You’ll also want your Epic Games display name handy, since the stats endpoint looks players up by username. If your profile’s public match data is hidden, the stats half of this project still runs, it just returns zeroed fields until you flip stat sharing on in Fortnite’s privacy settings.

If you’ve never touched a Python virtual environment before, it’s worth the two extra commands. A venv keeps this project’s dependencies, requests, Flask, and python-dotenv, separate from whatever else is installed system-wide, so upgrading one project never breaks another. Python’s built-in sqlite3 module needs no separate install at all, it ships with every standard Python distribution from 3.11 onward, which is one less dependency to manage.

Step 1 and Step 2: Setting Up Your Project and Environment

Step 1: Create the project folder and virtual environment. Keep this isolated from other Python projects so dependency versions don’t collide later.

mkdir fortnite-update-tracker
cd fortnite-update-tracker
python3 -m venv venv
source venv/bin/activate   # on Windows: venv\Scripts\activate
pip install requests flask python-dotenv

Step 2: Register for a free Fortnite-API key. Go to dash.fortnite-api.com, sign in, and generate a key under the API Keys section. Store it in a local .env file rather than hardcoding it, since you’ll eventually want to run this on a shared server without leaking the key in your source control history.

# .env
FORTNITE_API_KEY=your_key_here
DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/your_webhook_here
EPIC_USERNAME=your_display_name

Add .env to a .gitignore file immediately if you plan to push this to GitHub. API keys committed to public repos get scraped and revoked within hours.

Step 3 and Step 4: Connecting to the Fortnite-API and Reading Build Content

Step 3: Confirm the API is reachable. Fortnite-API’s /v2/news endpoint needs no authentication and returns a content hash every time Epic changes the in-game news feed, map, or mode of the day. That hash is your proxy for “something changed today.”

import requests

def fetch_news():
    url = "https://fortnite-api.com/v2/news"
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    payload = response.json()
    br_news = payload["data"].get("br", {})
    return {
        "hash": br_news.get("hash"),
        "date": br_news.get("date"),
        "title": br_news.get("motds", [{}])[0].get("title", "No title"),
        "body": br_news.get("motds", [{}])[0].get("body", ""),
    }

if __name__ == "__main__":
    print(fetch_news())

Step 4: Reference table for the endpoints this project uses. You won’t need every endpoint Fortnite-API exposes, just the three below plus the key dashboard. Run the Step 3 script now, before moving on, and confirm you get back a title string that matches whatever Epic currently has live, if it prints “No title,” double check the response structure hasn’t changed and adjust the dictionary keys accordingly.

EndpointRequires API KeyReturnsUsed For
/v2/newsNoContent hash, date, current MOTD title and bodyDetecting a new patch or content drop
/v2/stats/br/v2?name=USERNAMEYesWins, matches, K/D, top placements by modeEstimating SBMM pressure
/v2/cosmetics/brNoCurrent item shop and cosmetic catalogOptional: confirming a shop-only update
dash.fortnite-api.comAccount loginAPI key generation and usage limitsOne-time setup

Step 5 and Step 6: Storing Version History and Detecting New Patches

Step 5: Create a SQLite schema. You need two tables: one logging every news hash you’ve seen, and one logging match stat snapshots for the SBMM score later.

import sqlite3

def init_db(path="tracker.db"):
    conn = sqlite3.connect(path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS patch_log (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            hash TEXT UNIQUE,
            detected_at TEXT,
            title TEXT,
            body TEXT
        )
    """)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS stat_snapshots (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            captured_at TEXT,
            wins INTEGER,
            matches INTEGER,
            kd REAL,
            top1_rate REAL
        )
    """)
    conn.commit()
    return conn

Step 6: Compare the new hash against the last stored one. This is the detection logic, the core of the whole project. If the hash is new, you log it and return True so the alert step fires.

from datetime import datetime, timezone

def check_for_update(conn, news):
    cur = conn.cursor()
    cur.execute("SELECT hash FROM patch_log ORDER BY id DESC LIMIT 1")
    row = cur.fetchone()
    last_hash = row[0] if row else None

    if news["hash"] == last_hash:
        return False

    cur.execute(
        "INSERT OR IGNORE INTO patch_log (hash, detected_at, title, body) VALUES (?, ?, ?, ?)",
        (news["hash"], datetime.now(timezone.utc).isoformat(), news["title"], news["body"]),
    )
    conn.commit()
    return True

Run this on a fresh database and the first check always returns True, since there’s no prior hash to compare against. That’s expected, it just means you’re seeding the baseline.

Step 7 and Step 8: Sending Discord Alerts When an Update Drops

Step 7: Create a Discord webhook. In your Discord server, open a channel’s settings, go to Integrations, and create a webhook. Copy the URL into your .env file. Discord’s own developer documentation on webhooks covers the full payload schema if you want to add embeds or role pings later.

Step 8: Fire the alert. Keep the payload simple at first, a plain content string is easier to debug than an embed when something goes wrong.

import os
import requests

def send_discord_alert(title, body, webhook_url=None):
    url = webhook_url or os.environ["DISCORD_WEBHOOK_URL"]
    message = f"Fortnite update detected: {title}\n{body[:300]}"
    response = requests.post(url, json={"content": message}, timeout=10)
    if response.status_code not in (200, 204):
        raise RuntimeError(f"Discord webhook failed: {response.status_code} {response.text}")

Test this function by itself before wiring it into the full loop. A webhook that silently fails because of a typo’d URL is the single most common failure point in this entire project, and it’s much easier to catch in isolation.

Step 9 and Step 10: Pulling Match Stats and Scoring Your SBMM Pressure

Step 9: Pull your own stats from the authenticated endpoint. This requires the API key header, not a query parameter, which trips people up the first time.

def fetch_stats(username, api_key):
    url = "https://fortnite-api.com/v2/stats/br/v2"
    headers = {"Authorization": api_key}
    params = {"name": username}
    response = requests.get(url, headers=headers, params=params, timeout=10)
    response.raise_for_status()
    stats = response.json()["data"]["stats"]["all"]["overall"]
    return {
        "wins": stats.get("wins", 0),
        "matches": stats.get("matches", 0),
        "kd": stats.get("kd", 0.0),
        "top1_rate": stats.get("winRate", 0.0),
    }

Step 10: Build a pressure score. This is a heuristic you control, not an official Epic value, and the tutorial should be honest about that distinction. The idea: compare the current snapshot against the prior one, and flag a meaningful swing in win rate or K/D as a possible matchmaking shift, especially if it lines up with a patch_log entry from the same week.

def compute_pressure_score(conn, current):
    cur = conn.cursor()
    cur.execute("SELECT kd, top1_rate FROM stat_snapshots ORDER BY id DESC LIMIT 1")
    row = cur.fetchone()

    cur.execute(
        "INSERT INTO stat_snapshots (captured_at, wins, matches, kd, top1_rate) VALUES (?, ?, ?, ?, ?)",
        (datetime.now(timezone.utc).isoformat(), current["wins"], current["matches"], current["kd"], current["top1_rate"]),
    )
    conn.commit()

    if row is None:
        return {"score": 0.0, "note": "Baseline snapshot, no comparison yet"}

    prev_kd, prev_top1 = row
    kd_delta = current["kd"] - prev_kd
    top1_delta = current["top1_rate"] - prev_top1
    score = round((kd_delta * 0.6) + (top1_delta * 100 * 0.4), 2)

    if score <= -0.5:
        note = "Lobbies look noticeably tougher than your last snapshot"
    elif score >= 0.5:
        note = "Lobbies look easier than your last snapshot"
    else:
        note = "No significant shift detected"

    return {"score": score, "note": note}

This score is only meaningful relative to your own history. Don’t compare it against anyone else’s, and don’t treat a single negative reading as proof of a secret SBMM change, you want at least three or four consecutive snapshots before drawing conclusions.

How the Pressure Score Works Under the Hood

The weighting in compute_pressure_score isn’t arbitrary, it’s just simple enough to explain and tune. K/D delta carries 60 percent of the score because kill efficiency reacts faster to lobby difficulty than win rate does, a single tough squad can tank your win in one match without touching your eliminations, but a full session of harder lobbies drags your average kills down consistently. Win rate delta carries the remaining 40 percent, scaled by 100 since win rate is stored as a decimal, so it moves the score in comparable units to the K/D term.

Treat the 0.5 threshold as a starting point, not a law. Players who grind high volumes of matches per week will see noisier day-to-day swings and may want to widen the threshold to 0.8 or 1.0 to cut down on false alerts. Players who only log a handful of matches per session should probably average two or three snapshots together before trusting any single reading, since a two-match sample barely qualifies as a trend. The honest framing here matters: this score tells you when your own results shifted, it does not and cannot tell you what Epic’s matchmaking system actually did on its end, because that data has never been made public.

Step 11 and Step 12: Automating the Tracker and Building a Status Dashboard

Step 11: Wire everything into one runnable script and schedule it. Checking every 15 to 30 minutes is plenty, Fortnite doesn’t push multiple content changes per hour outside of a live event launch window.

# crontab -e
*/20 * * * * /path/to/fortnite-update-tracker/venv/bin/python /path/to/fortnite-update-tracker/tracker.py >> /path/to/fortnite-update-tracker/tracker.log 2>&1

On Windows, create a Basic Task in Task Scheduler that runs python.exe with tracker.py as the argument, set to repeat every 20 minutes, and point the “Start in” field at your project folder so relative paths resolve correctly.

Step 12: Add a lightweight dashboard. You don’t need a full web app, a single Flask route that reads the last few rows from SQLite and renders them as plain text or JSON is enough to check status from your phone.

from flask import Flask, jsonify
import sqlite3

app = Flask(__name__)

@app.route("/status")
def status():
    conn = sqlite3.connect("tracker.db")
    cur = conn.cursor()
    cur.execute("SELECT hash, detected_at, title FROM patch_log ORDER BY id DESC LIMIT 5")
    patches = cur.fetchall()
    cur.execute("SELECT captured_at, kd, top1_rate FROM stat_snapshots ORDER BY id DESC LIMIT 5")
    snapshots = cur.fetchall()
    return jsonify({"recent_patches": patches, "recent_snapshots": snapshots})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5050)

The Complete Working Project

Here’s the full tracker.py that ties every step above into a single runnable file. Save it in the project root alongside your .env file, and the init_db, fetch_news, check_for_update, send_discord_alert, fetch_stats, and compute_pressure_score functions from the steps above.

import os
from dotenv import load_dotenv

load_dotenv()

def main():
    conn = init_db()
    news = fetch_news()
    updated = check_for_update(conn, news)

    if updated:
        send_discord_alert(news["title"], news["body"])
        print(f"New update detected: {news['title']}")
    else:
        print("No new Fortnite content detected this run")

    username = os.environ.get("EPIC_USERNAME")
    api_key = os.environ.get("FORTNITE_API_KEY")
    if username and api_key:
        try:
            stats = fetch_stats(username, api_key)
            pressure = compute_pressure_score(conn, stats)
            print(f"SBMM pressure score: {pressure['score']} ({pressure['note']})")
            if abs(pressure["score"]) >= 0.5:
                send_discord_alert("SBMM pressure shift", pressure["note"])
        except Exception as exc:
            print(f"Stats check skipped: {exc}")

    conn.close()

if __name__ == "__main__":
    main()

That’s a complete, runnable project in under 150 lines across all the functions combined. Nothing here requires elevated permissions, third-party credentials beyond your own free API key, or anything that risks your Epic account standing, since every call targets Fortnite-API’s public mirror rather than Epic’s internal services directly.

Sample Output: What the Tracker Reports

Running tracker.py on a day with no content change looks like this.

$ python tracker.py
No new Fortnite content detected this run
SBMM pressure score: 0.12 (No significant shift detected)

Running it the moment a patch like v42.30 lands produces a different result, plus a matching message in your Discord channel.

$ python tracker.py
New update detected: Fortnite: Override Is Here!
SBMM pressure score: -0.68 (Lobbies look noticeably tougher than your last snapshot)

That second example is a realistic pattern worth watching for, a content drop followed by a tougher-lobby reading often means a wave of returning or highly engaged players logged in for new content, not that Epic silently changed its matchmaking formula.

Common Pitfalls When Building a Fortnite Update Tracker

  • Hardcoding the API key in source control. Always load it from an environment variable or .env file, and add that file to .gitignore before your first commit.
  • Treating the news hash as a version number. It changes with shop rotations and minor MOTD tweaks too, not just major patches, so pair it with the title and body text to judge significance.
  • Polling too aggressively. Checking every minute wastes requests and adds no real benefit, since Epic doesn’t push changes faster than every few hours even during events.
  • Reading too much into one SBMM snapshot. A single rough session can swing the score without any matchmaking change at all, use a rolling average of several sessions instead.
  • Forgetting stat privacy settings. If your Epic account has match stats set to private, /v2/stats/br/v2 returns empty or zeroed fields, and the pressure score becomes meaningless until you enable sharing.
  • Letting the SQLite file grow unbounded. Patch logs are small, but stat snapshots taken every 20 minutes add up fast, prune rows older than 90 days if you plan to run this for a full season.
  • Assuming the webhook always succeeds. Discord webhooks occasionally return 429 rate-limit responses during high-traffic periods, wrap the call in a retry with backoff for production use.
  • Writing an invalid cron expression. A misplaced asterisk can silently schedule the job for the wrong minute or not at all, paste your schedule string into crontab.guru before saving to confirm it reads the way you expect.
  • Comparing stats across different playlists without noticing. The /v2/stats/br/v2 response groups results by input type and mode, pulling from “all” overall versus a solo-only or squads-only bucket will produce very different pressure scores for the same account.

Troubleshooting Guide

SymptomLikely CauseFix
Script exits with “invalid or missing api key”Key missing from headers or expiredRegenerate the key at dash.fortnite-api.com and confirm it’s passed via the Authorization header, not a query string
/v2/stats/br/v2 returns empty statsPrivate match history on your Epic accountEnable public match stats in Fortnite’s in-game privacy settings, then retry
Discord message never arrivesWebhook URL expired or channel deletedGenerate a new webhook in Discord’s Integrations settings and update your .env
“the api is currently booting up” errorFortnite-API’s backend is cold-starting after low trafficWait 20 to 60 seconds and retry, this is normal on the free tier
Cron job never runsWrong Python path or missing environment variables in cron’s limited shellUse the absolute path to your venv’s python binary and load .env explicitly inside the script
SQLite “database is locked” errorDashboard and tracker script writing simultaneouslyOpen connections with a short timeout and close them promptly after each run
Same patch triggers duplicate alertsUNIQUE constraint not enforced correctlyConfirm the hash column has a UNIQUE index and that INSERT OR IGNORE is used, not plain INSERT
Pressure score stays at exactly 0.0Only one stat snapshot exists so farExpected behavior, wait for a second scheduled run to get a real comparison
Flask dashboard shows a blank responsetracker.db path differs between the script and the Flask appUse an absolute path to the database file in both files
Pressure score swings wildly between runsComparing stats across different game modes or input typesConfirm you’re reading the same “all” overall bucket every time, not mixing solo and squad data
Discord returns HTTP 429Too many webhook calls sent in a short windowAdd exponential backoff and cut the polling interval if alerts are firing more than expected

Advanced Tips to Extend Your Tracker

Once the base project runs reliably, a few extensions make it genuinely useful over a full season rather than just a weekend project.

Add a second Discord channel dedicated to shop-only changes by checking /v2/cosmetics/br separately from the news endpoint, since item shop rotations happen daily and you may not want those mixed with major content alerts. Splitting the channels also makes it easier to mute the noisy one during exam season without losing the patch alerts you actually care about.

Track multiple friends’ usernames in a loop and compare pressure scores across your squad, which surfaces whether a rough session was personal or affected the whole group, a far stronger signal than any single account’s data. If three squadmates all show a negative pressure score the same evening, that’s a much more convincing case for “the lobbies got harder” than one person’s result alone.

If you’re comfortable with GitHub Actions, you can run the whole script on a schedule without hosting anything yourself. GitHub’s own documentation on scheduled workflows covers the cron syntax GitHub Actions expects, which matches standard crontab format, so the same schedule string from Step 11 works there too. Store your API key and webhook URL as encrypted repository secrets rather than plain workflow variables, and the whole project runs for free on GitHub’s hosted runners.

Finally, log the season’s patch cadence over time in a spreadsheet exported from your SQLite file. By the end of Chapter 7, Season 4 you’ll have real data on how often Epic ships hotfixes versus numbered patches, instead of relying on gut feel, and you can carry that same database schema forward into whatever season follows Override without changing a line of code.

How This Compares to Third-Party Fortnite Status Sites

Plenty of fan-run sites already show Fortnite’s server status and recent patch notes, and they’re a fine first stop if you just want a quick answer without writing any code. What they can’t do is tie that information to your own account’s performance, because they’re built for a general audience, not for your specific stat history. A public status page will tell a million visitors the same thing, up or down, patched or not. The tracker in this tutorial only serves one purpose that matters to one player: did Fortnite change today, and did my lobbies change along with it.

There’s also a latency gap worth knowing about. General-purpose trackers often batch-update their patch note write-ups by hand, which can lag an actual release by an hour or more while someone writes a summary. A script polling the raw API directly sees the content hash change within whatever interval you set it to, typically 15 to 20 minutes here, with zero manual effort on the other end. The tradeoff is that you get a raw signal instead of a curated summary, which is exactly why this tutorial pairs the hash check with the actual MOTD title and body text rather than leaving you to guess what changed.

Fortnite Update Cadence and Season Data

MilestoneDateBuild / Detail
Chapter 7, Season 4 “Override” launchAugust 20, 2026v42.00
Fortnitemares 2026 event launchOctober 1, 2026v42.30, “The Game Is Cursed”
Nightmare Neighborhood POI addedOctober 1, 2026Replaced the Battlewoods point of interest
Scheduled Season 4 endOctober 31, 2026Subject to change via Epic’s own patch notes
Hotfix cadenceOngoingSmaller balance and bug-fix patches land between numbered updates, per Epic’s public patch note history

Keep in mind that scheduled end dates for Fortnite seasons shift fairly often, Epic has pushed season boundaries back in the past to extend events or finish a battle pass grind. Treat the October 31 date as a planning estimate, not a guarantee, and let your own tracker’s patch_log table be the source of truth once the season actually wraps.

This is also where a running patch_log genuinely beats memory. Most players can tell you roughly when a season started, almost nobody can tell you the exact date of the fourth hotfix after launch. Once you’ve run this tracker for even a few weeks, querying your own SQLite file answers that instantly, and if Epic ends up extending Season 4 past October 31, your database will show the real gap between the last detected content change and the next one, which is a more reliable signal than any single announcement.

If you’re also tracking the competitive side of the game, our breakdown of Fortnite Ranked versus FNCS scoring covers how the visible rank system this tutorial references actually works, and our guide to Zero Build versus Battle Royale ranked lobbies breaks down how lobby size affects matchmaking pressure. For the season timeline itself, see our piece on how to verify Fortnite leak dates before trusting a rumored release window, and if you’d rather watch the countdown than build a patch tracker, we also covered building a season countdown widget. Apex Legends players chasing the same kind of self-hosted insight can adapt the stats half of this project using our Apex Legends rank tracker tutorial, which follows a similar polling pattern against a different public API.

Frequently Asked Questions

Is there a Fortnite update today?
Check the Epic Games Launcher for a pending download, or run the tracker from this tutorial, it polls Fortnite’s public news feed and tells you the moment the content hash changes. As of October 1, 2026, the most recent major update is v42.30, which launched Fortnitemares 2026.

What chapter and season is Fortnite currently on?
Fortnite is in Chapter 7, Season 4, titled Override, which began August 20, 2026, and is scheduled to run through October 31, 2026.

Does Fortnite actually have skill-based matchmaking?
Yes, in Battle Royale’s core modes. Epic’s own help documentation describes a system that groups players by skill level rather than by visible rank, a mechanic the company has maintained and referenced since patch v10.40.

Can I see my exact Fortnite SBMM rating?
No. Epic has not released a public tool, dashboard, or settings panel that exposes your hidden matchmaking rating. The pressure score built in this tutorial is a personal estimate based on your own stat history, not Epic’s real internal value.

Do I need a paid Fortnite-API plan to run this project?
No. The free tier available at dash.fortnite-api.com covers both the news endpoint and the stats endpoint used in this tutorial.

How often does Fortnite release major updates?
Numbered season launches happen roughly every two to three months, while smaller hotfixes and content drops land far more frequently in between, based on Epic’s public patch note history.

Will running this tracker risk my Epic Games account?
No. The project only reads public data through Fortnite-API’s read-only endpoints and your own account’s visible stats, it never logs into Fortnite, automates gameplay, or touches Epic’s servers directly, so it doesn’t conflict with Fortnite’s terms of service.

Can this run on a Raspberry Pi or a free cloud server?
Yes. The script’s resource footprint is tiny, a Raspberry Pi, a free-tier cloud VM, or a scheduled GitHub Actions workflow can all run it comfortably around the clock.

What’s the difference between ranked Fortnite and the hidden SBMM system?
Ranked Fortnite shows you a visible tier and progress bar tied to your performance in ranked playlists specifically. The hidden SBMM system runs separately in unranked Battle Royale modes and has no visible number attached, which is exactly the gap this tutorial’s pressure score is built to estimate.