Key Takeaways
- Fastify v3 has been past end of life since June 30, 2023, and v4 followed on June 30, 2025.
- Only the v5 line still gets fixes from the Fastify team, and v6 has already entered alpha.
- Fastify v5 needs Node.js 20 or newer, and Node 20 hit EOL in April 2026 – so a framework upgrade drags a runtime upgrade with it.
- TuxCare’s Endless Lifecycle Support covers Fastify 3.29.5 and 4.29.1 with ongoing CVE patches while you plan the move.
Run an inventory across a large Node.js fleet and you will usually find services still running Fastify v3, which reached its end of LTS in June 2023. That is over three years with no framework security fixes for code that is sitting in production right now.
Fastify v4 is no longer supported either, since its LTS window closed on June 30, 2025. That leaves v5, released in September 2024, as the only line the core team still fixes. Moving to it also means moving to a Node.js release that is still supported, because Node 20 is now EOL and Node 22 has already dropped into maintenance.
Below you will find what Fastify EOL actually means, which risks are real versus theoretical for each line, what a v3 fleet looks like when that migration ticket keeps sliding to another quarter, and what your three realistic options are.
What Is Fastify?
Fastify is a Node.js web framework built for low per-request overhead, with a plugin architecture that keeps things encapsulated so one route’s decorators cannot leak into another’s. It validates and serializes through JSON Schema and logs through pino. When v5 shipped, the OpenJS Foundation put monthly downloads at 7.8 million, with 296 officially recognized plugins in the ecosystem. By July 2026, per npm-stat, that figure had climbed past 43 million monthly downloads.
Set against the frameworks you have probably already used, Express is the older and much bigger one, pulling roughly twelve times Fastify’s monthly npm downloads with barely any built-in validation, and it is the most common thing teams arrive from. Hapi asks for heavier configuration and ships more batteries included. Koa is a thin middleware core where nearly everything else is a separate decision you have to make. NestJS is not really a competitor, since it is an application framework that runs on top of either Express or a Fastify adapter.
If your service is a NestJS app running the Fastify adapter, Fastify is sitting in your dependency tree whether or not your team’s asset inventory calls it a Fastify app. Same story with the Node.js version underneath it, quietly gone end of life and pinned there by a framework somebody chose two teams and one reorg ago.
Pro Tip: run npm ls fastify –all in every service repo, not just the ones you think use it. Adapters, generators, and internal SDKs pull Fastify in as a transitive dependency, and those copies rarely have a clear owner. That is usually how a stray v3 install turns up.
Has Fastify Reached End of Life?
Fastify v1, v2, v3, and v4 have all passed their end-of-LTS dates. v5 is the only line getting active fixes from the core team, and its entry in the official schedule still reads TBD. That will not stay open forever, though. Fastify 6.0.0-alpha.1 landed in August 2026, and under the same policy v5 drops to security-only updates for six months once v6 ships.
The schedule is not arbitrary, even if it looks that way from the outside. Fastify’s LTS policy gives each major release a minimum of six months of active support, plus another six months of security-only updates once the next major arrives. That is the arithmetic that put v4’s end of LTS on June 30, 2025.
After that window closes, the policy does say maintainers will keep reviewing and releasing security fixes, but only when the community supplies them and only when they do not run into other constraints, such as the minimum supported Node.js version. That is conditional, community-powered support rather than a maintained release line. A serious bug in v4 today might get a community patch, might get a polite note to upgrade, or might just sit open as a GitHub issue.
Betting a production API on which of those three outcomes you get is where teams get burned. It is exactly why extended security support exists in the first place.
Fastify Version Lifecycle and Key EOL Dates
These dates come straight from Fastify’s published LTS schedule. The Node.js column reproduces the release lines listed there for each major, which is why it includes short-lived Current releases such as 9 and 11 alongside the LTS lines.
| Fastify version | Release date | End of LTS | Current status | Node.js lines listed |
| 1.0.0 | March 6, 2018 | September 1, 2019 | EOL | 6, 8, 9, 10, 11 |
| 2.0.0 | February 25, 2019 | January 31, 2021 | EOL | 6, 8, 10, 12, 14 |
| 3.0.0 | July 7, 2020 | June 30, 2023 | EOL | 10, 12, 14, 16, 18 |
| 4.0.0 | June 8, 2022 | June 30, 2025 | EOL | 14, 16, 18, 20, 22 |
| 5.0.0 | September 17, 2024 | Not announced | Active | 20, 22 |
One caveat on the v5 row. It records what was tested when v5 shipped, and Fastify’s CI on main now runs its unit tests against Node 24 and 26. Node 20 appears in that row too, but it went EOL on April 30, 2026, so treat it as a compatibility floor rather than a runtime you would deploy on.
Now look at the v3 row next to today’s date. Three years past the end of LTS, on a Node.js range (10 through 18) that is entirely EOL itself, and with v4 dead as well there is no halfway step left to land on. That is why “just upgrade” is a much bigger ask for a v3 fleet than it sounds for a v4 one.
Security Risks of Running EOL Fastify in Production
The risk is not that a specific CVE is sitting in your node_modules right now. It is the asymmetry that kicks in the day your version goes EOL and compounds every year after. Security research on Fastify keeps moving at full speed, and the fixes it produces are developed for the supported v5 line. For a v4 fleet that is already over a year of accumulated gap. For a v3 fleet, three.
Framework CVEs Stop Reaching Your Version
The content-type validation family is a clean illustration of what that costs in practice. In April 2025, CVE-2025-32442 documented a flaw where apps defining per-content-type validation could have that validation skipped entirely, just by sending a slightly altered Content-Type header. The advisory lists Fastify 5.0.0 through 5.3.1 and 4.29.0 as affected, with fixes in 5.3.2 and 4.29.1. v4 got a patched release because it was still inside its support window, and v3 was never listed as affected. A year later the same family produced CVE-2026-33806, a high-severity bypass of that very fix using nothing more exotic than a leading space in the header, patched only in 5.8.5.
The OpenJS Foundation’s Q1 2026 security update counts 18 ecosystem CVEs published through its CNA operations that quarter, three of them in the Fastify ecosystem. Two were in Fastify itself. CVE-2026-3419 was a malformed Content-Type validation issue affecting 5.7.2 through 5.8.0 and fixed in 5.8.1, which makes it a v5-only regression rather than a missing backport. CVE-2026-3635 is the one worth staring at: a trustProxy header-spoofing flaw whose advisory covers every Fastify release through 5.8.2, with the fix shipping only in 5.8.3. Every v3 and v4 install falls inside that affected range, and none of them received a patched release.
The third, CVE-2026-2880, was a high-severity authorization bypass in the optional @fastify/middie plugin, where path-scoped middleware could be skipped because the plugin normalized request paths differently from the router. The fix exists in middie 9.2.0, and the 9.x line is developed against Fastify v5. The 8.x line that v4 apps run stopped at 8.3.3 in September 2024 and never got it.
None of this is slowing down. OpenJS reports in its Q2 2026 update that its CNA published 3 CVEs in the second half of 2025 and 49 in the first half of 2026, with roughly ten more waiting on releases. Most of that jump is heavier triage and AI-assisted scanning rather than a sudden wave of new bugs, but the effect on an EOL line is the same either way. More disclosures – none of them landing in your version.
The Runtime Underneath Has Its Own Clock
Fastify v3 was verified against Node.js 10 through 18, every one of which is now EOL itself. Teams stay on old Fastify because upgrading is expensive, and the same budget pressure that keeps them there usually keeps them on an old Node line too. For a v3 service that is frequently two clocks that both ran out years ago, and the runtime is the one exposing the wider attack surface, from TLS and HTTP parsing to networking and everything else sitting below your application code.
This is the real reason teams get stuck, and it is rarely the framework’s fault. Nobody scopes “upgrade the web framework” as a runtime migration plus a base image change plus a native-module rebuild. Then somebody does, the estimate triples, and the ticket slides to next quarter.
Where Dependency Constraints Box You In
Fastify’s own tree is genuinely lean, and it is worth being honest about that. As of Fastify 5.12.0, installing v5 pulls in 15 direct runtime dependencies: avvio, find-my-way, fast-json-stringify, light-my-request, pino, secure-json-parse, semver, rfdc, toad-cache, process-warning, abstract-logging, and four @fastify/* packages. For a web framework, that is a genuinely small direct dependency set.
Reaching EOL does not freeze that tree on its own, and it is worth being precise about what does happen. Fastify declares semver ranges, and npm will move dependencies to newer versions that still satisfy them, so plenty of upstream security fixes arrive without anyone touching Fastify. The problem is narrower and more irritating than a frozen tree. When the only fixed release sits outside the range your Fastify line accepts, taking it means an override, a direct dependency change, or a framework upgrade that your version was never tested against.
So your scanner flags a transitive advisory, and the clean remediation path turns out to be “upgrade Fastify,” which is the exact thing you were trying to avoid. For a v3 app that usually means a Node.js upgrade plus schema and API changes, not a patch release. That gap is how a clean audit turns into a quarter of arguing with your security team about accepted risk versus false positives.
Your Options After Fastify End of Life
There are three options, and which one is right has less to do with engineering taste than with which version you are actually running and how much time your team has this quarter.
| If this describes you | Do this |
| Running v3 or v4 in a regulated environment, with no bandwidth for a runtime and framework migration this quarter | Extended support on your current version, then migrate on your own schedule |
| Already on a supported Node.js release, few deprecated APIs, plugins maintained | Upgrade to v5 now |
| Framework is a poor fit beyond the EOL problem | Replace it and budget properly |
TuxCare’s Endless Lifecycle Support
TuxCare’s Endless Lifecycle Support (ELS) covers EOL open-source runtimes, libraries, and frameworks. It delivers backported security patches for versions the upstream project no longer maintains, through standard package management, which keeps changes to your deployment pipeline to a minimum. For Fastify specifically, the covered versions are 3.29.5 and 4.29.1, the last releases in the v3 and v4 lines. Fixes arrive through npm and are tracked publicly in TuxCare’s CVE Tracker, so your security team can see exactly what is covered before signing off.
For a team stuck on an EOL Fastify line, whether that is a v4 fleet a year past LTS or a v3 fleet three years past it, that buys continued security fixes for the version already in production instead of a forced jump to v5 that drags a multi-version Node.js upgrade along with it. It also buys patch documentation you can hand to a SOC 2 or PCI DSS review, and a migration timeline you set yourself rather than one dictated by a disclosure calendar or an auditor’s finding.
The teams that end up here are not lazy. They are dealing with real constraints: platform compatibility limits, engineering bandwidth that is already spoken for, testing complexity across dozens of services, or regulatory rules that turn an unplanned framework upgrade into a change-control problem instead of a technical one. For a v3-era service, that is often closer to a full re-platform than a version bump.
TuxCare’s role here is to be a bridge, keeping the covered Fastify version patched while the migration happens on your own schedule rather than upstream’s.
Upgrade to Fastify v5
This is the right call when you can afford it, and for a v4 fleet the jump is smaller than most major version upgrades tend to be. Fastify’s own migration guide is genuinely short. For a v3 fleet, budget for something closer to a re-platform, with two majors’ worth of deprecated APIs to work through plus a runtime jump from whatever EOL Node line the service is on today to something currently supported.
Four things drive the estimate. The first is the runtime, since v5 requires Node.js 20 or newer and that part is non-negotiable. Because Node 20 is itself EOL as of April 2026, a fresh migration should land on a currently supported LTS release, which in late 2026 means Node 24 rather than stopping at 20.
The second is full JSON Schema. The jsonShorthand option is gone, and when you use the default validator, querystring, params, body, and response schemas all need complete schema objects, including the type property.
The third is removed APIs. Fastify v5 dropped the APIs that were deprecated across the v4 lifecycle, so the deprecation warnings you have been scrolling past in your logs are a good starting point for the task list. Coming from v3, that is two deprecation cycles to work through rather than one.
The fourth is plugin compatibility. Every @fastify/* and community plugin needs a v5-compatible release, and this is usually where the timeline actually slips. It slips hardest for older plugin sets that nobody has touched since 2022.
If your plugin set is entirely first-party and actively maintained and you are coming from v4, the work tends to stay contained. If you are coming from v3, or you have community plugins that went quiet years ago, scope the replacement work first. That is the part that can turn a contained upgrade into a substantially larger migration project.
Replace Fastify
Swapping frameworks to solve an EOL problem is almost always more expensive than upgrading, and that goes double from v3, where you are already looking at a large rewrite either way. Express 5, Hapi, and Hono are all reasonable frameworks, but moving to any of them can mean substantial rework across route registration, hooks and middleware, validation, plugins, and framework-specific application code. That is a rewrite wearing an upgrade’s clothing. Do it if Fastify is genuinely the wrong fit for you, not because the version happened to go EOL.
Secure Fastify Beyond EOL with TuxCare
Fastify v3 reached the end of LTS in June 2023, and v4 followed in June 2025. Neither date was the risk event by itself. The risk is the gap that runs from whichever date applies to your fleet until the day your last EOL service ships on something supported, and for a lot of teams that gap is measured in quarters at best and years at worst.
Close it one of two ways. Move to v5 now and eat the runtime upgrade that comes with it, or keep patching what you are already running, 3.29.5 and 4.29.1 included, while you migrate on a schedule you actually control. Both are defensible positions. Running EOL and hoping is not.
If you are in that second camp, TuxCare’s Endless Lifecycle Support keeps covered EOL frameworks and runtimes, including Fastify 3.29.5 and 4.29.1, patched and audit-ready for as long as the business needs them to be.
FAQs
Only Fastify v5. Versions 1 through 4 have all passed their end-of-LTS dates, v3 on June 30, 2023 and v4 on June 30, 2025. The v5 entry in the schedule still reads TBD, although v6 entered alpha in August 2026. Note that v5 requires Node.js 20 or newer, and since Node 20 is itself EOL, production deployments should be on a currently supported Node.js release.
Its LTS ended on June 30, 2025, which is the practical end of life for the line. After that date the Fastify team only reviews and releases security fixes that the community supplies, so v4 no longer behaves like a maintained line. Fastify v5 had already shipped nine months earlier, on September 17, 2024.
Fastify v3 is no longer maintained by the project, so running it without another source of security fixes carries risk that grows every quarter. Its officially tested compatibility range also tops out at Node.js 18, which is EOL, so the runtime underneath is usually part of the same problem.
Only if you are below Node 20. Apps already on 20 or newer will run v5, though Node 20 went EOL in April 2026, so a supported line is worth planning for anyway. Either way, schedule the container image change and native-module rebuild alongside the framework upgrade rather than after it. Coming from v3, expect a jump of several Node majors.
Yes. The @fastify/* plugins are versioned and released independently of the framework itself, each with its own advisories and compatibility ranges. A supported core version does not guarantee every plugin in your tree is still maintained, and some plugins used by older v3 and v4 apps are no longer active or compatible with current Fastify releases. @fastify/middie is the obvious example, where the fix for CVE-2026-2880 landed in the 9.x line built for v5 and never in the 8.x line.




