Auth0 is pulling Node 18 out from under your login code. Here's how to move it to Node 22
Auth0 is retiring the Node.js 18 runtime that custom login code runs on. If your tenant still uses it, you've got until 10 May 2027 to move to Node 22 and test it. Leave it, and Auth0 will eventually move that code for you, tested or not.
part 45 of 45 · Platform releases, explained from scratchthe ideaTest on Node 22 and switch yourself before Auth0 moves your code.
after reading, you can- Spot what in your tenant still runs on Node 18, and which dropdown or Action moves it
- Spot the Node 22 changes that break Actions, Rules and connection scripts before your users do
- Plan a switch you can back out of, and move Hooks first, since they stop after 30 April 2027 anyway
If your Auth0 tenant still runs custom code on Node.js 18, you've got a deadline. Auth0 deprecated that runtime on 10 November 2026 and gives tenants that still use it until 10 May 2027 to get onto Node 22. Make the switch yourself, after testing, so Auth0 doesn't make it for you later.
Auth0 is changing what your login code runs on. Pick the day yourself
Auth0 runs the sign-in for your apps. Many teams add their own code to that sign-in: something that puts a user's role into their token, checks a new sign-up, or looks up passwords in an old database while users are being moved across. That code runs on a version of Node.js, the engine that executes JavaScript, and Auth0 decides which version from your settings. Node.js 18 stopped getting security fixes from its own maintainers in April 2025, and now Auth0 is retiring it too. You have until 10 May 2027 to switch to Node 22 and check nothing broke. Code that's still on Node 18 after that will eventually be moved to a newer engine by Auth0, whether anyone has tested it there or not.
Think of a building that's replacing its old lift motor next spring. The lift keeps running either way. But if your floor had custom buttons wired for the old motor, you want an electrician to check them before the swap, while you still choose the day.
- Teams with Auth0 Actions on Node 18
- Tenants that still run Rules or Hooks
- Custom database or social connections
- Anyone using Marketplace Actions
- Terraform configs that still say node18
Why should anyone outside the identity team care?
Custom login code is usually a security control. It adds the roles your apps check, blocks sign-ins that shouldn't happen, or decides whether a password from the old user store is right. If that code breaks after a runtime change, logins can fail, or tokens can go out without the claims your apps rely on. The switch is when those failures show up, so pick the day yourself and have someone watching.
Auth0 hasn't published a date for the forced move. Its notice says the Node 18 option will "progressively become unavailable for selection", first for tenants that no longer use it, and that leftover code "will eventually be forced to run on a newer runtime". Removal comes some time after the grace perioddefinitionHow long Auth0 lets tenants still on Node 18 keep using it: until 10 May 2027. Don't treat the last day as the plan. ends. Plan as if the move could happen any day after that.
There's a second clock most notices skip. The Node.js project's own schedule ends support for Node 22 on 30 April 2027, ten days before Auth0's grace period runs out. Node 22 is still what Auth0 recommends, and its changelog, when we read it on 17 November 2026, listed nothing newer for extensibility. So expect another notice like this one. Write the code now so the next switch is a dull afternoon.
-
01 Code runs on Node 18
Any Action set to Node 18, plus Rules, Hooks and connection scripts if the tenant settings still say Node 18.
-
02 The option starts to vanish
Node 18 drops out of the runtime menus, first for tenants that no longer use it.
-
03 You switch and test
You deploy a new version of each Action on Node 22. Someone flips the tenant settings in a development tenant first and only touches production once logins there work.
-
04 Grace period ends
Once 10 May 2027 passes, Auth0 starts removing Node 18 for good. It hasn't published a date for the last step, so don't plan around one.
-
05 Leftovers get moved for you
Code still on Node 18 is eventually forced onto a newer runtime. Marketplace Actions whose authors never updated them may lose support.
For engineers: Actions and tenant settings move separately. Each Action version has its own runtime, so you upgrade it by deploying a new version on Node 22, and you can revert to the old version if logins break. The tenant settings work differently. One dropdown moves every Rule and Hook at once, and the other moves every custom database and custom social connection script. Auth0's guide says to change them in a development tenant first and only touch production once everything there passes.
What actually breaks when code moves to Node 22?
- Upstream security fixes have already stopped
- The option is disappearing from the menus
- use npm directive still available
- Code can write to the filesystem
- The runtime Auth0 recommends
- Node.js project support until 30 April 2027
- No use npm directive
- No filesystem writes
- Top-level Action code reused across runs
The changes that touch this switch
Deprecated on 10 November 2026. Tenants still using it have a grace period until 10 May 2027, then the end-of-life phase starts.
Legacy Extensibility covers Rules and Hooks. The other setting covers custom database and custom social connection scripts. Each change hits every script under it at once.
Auth0's Node 22 guide says the use npm directive is gone. If your code pulls packages that way, someone has to rewrite it before it moves.
Disabled on Node 22. Anything that writes a temp file, a cache file or a certificate to disk needs another approach.
On Node 22 the code at the top of an Action file runs once per instance, and Auth0 can reuse the result across many executions. Anything stored there can outlive the login that set it.
Rules, Hooks and connection scripts can only load the module versions on Auth0's Can I Require list for the runtime. The Node 22 list isn't the same as the Node 18 one.
Auth0 says a Marketplace integration may lose support if its author never ships a version for a newer runtime. Ask the vendor now, while there's time to find a replacement.
A module runs in the runtime of the Action that imports it, so a module that's fine from a Node 18 Action can fail from a Node 22 one.
The reused top-level code is the quiet one. People often set up a client or read a value at the top of an Action file. On Node 22 that code runs once per instance and Auth0 can reuse the result across many logins. A top-level variable that holds anything about one user could still be there when the next user signs in. Keep anything per-login inside the handler.
The use npm directive and filesystem writes are easier to spot. Search the code for both before you move anything, because each needs a rewrite on Node 22. Action Modules deserve their own test pass. Auth0 builds a module with its builder runtime but runs it in the runtime of the Action that imports it, so test each importing Action separately.
One admin on Auth0's community forum reported a trap in the legacy sandbox. After switching their tenant to Node 22, they found a Hook could no longer load google-auth-library, though googleapis, which bundles it, was still allowed. An Auth0 community responder called it a known gap in the Node 22 module list and suggested getting the auth client through googleapis. Check every require() in Rules, Hooks and connection scripts against the Node 22 list before you flip the setting.
| Code type | Where the runtime is set | How to move it | Date to watch |
|---|---|---|---|
| Actions | Each Action version | Deploy a new version on Node 22 | 10 May 2027 |
| Rules | Tenant: Legacy Extensibility | One setting moves every Rule | 10 May 2027, Rules stop 31 Jan 2028 |
| Hooks | Tenant: Legacy Extensibility | Same setting as Rules | Hooks stop 30 Apr 2027 |
| Custom database scripts | Tenant: Extensibility runtime | One setting moves every connection | 10 May 2027 |
| Custom social connections | Tenant: Extensibility runtime | Same setting; Marketplace scripts only via Management API | 10 May 2027 |
| Marketplace Actions | The integration's author | Install the author's newer version | May lose support |
Auth0 runtimes and the dates around this switch
- Jan 2025Node 22 available in Auth0
New Actions start defaulting to Node 22, and the tenant runtime setting gets split in two. That's why there are two dropdowns today.
- 19 Feb 2025Node 12 and 16 deprecated
Auth0 deprecates the two older runtimes and tells everyone to use Node 22.
- 30 Apr 2025Node.js 18 end of life
The Node.js project stops fixing Node 18.
- 10 Nov 2026Auth0 deprecates Node 18
Tenants still on Node 18 enter the grace period. The option starts disappearing from the menus from here on.
- 30 Apr 2027Hooks stop, Node 22 end of life
Auth0 removes Hooks. The Node.js project stops fixing Node 22 the same day.
- 10 May 2027Grace period ends
The end-of-life phase for Node 18 begins.
- 31 Jan 2028Rules stop
Auth0 removes Rules.
How do you switch without breaking logins?
Before: Node 18 in three places
Some Actions still pin Node 18, and both tenant settings point at it. The deploy pipeline keeps it that way.
After: Node 22 everywhere, tested first
Every deployed Action runs on Node 22, both settings say Node 22, and the pipeline config says node22 too, so a routine deploy doesn't bring Node 18 back.
The switch, from inventory to production
- 01List what runs on Node 18
Open each Action and write down its runtime, or pull it from the runtime field in your Terraform config. Check both tenant dropdowns too. For custom social connections, use the Management API query from Auth0's guide that filters on strategy oauth1 and oauth2.
- 02Read the code for Node 22 traps
Search for the use npm directive and for filesystem writes. Move per-login data out of top-level variables. Check every require() in Rules, Hooks and connection scripts against the Node 22 Can I Require list.
- 03Upgrade Actions one at a time
Create a new version of each Action with Node 22 as its runtime and deploy it. Watch the logs for a day. If logins break, revert to the previous version from the Action's version history.
- 04Flip the tenant settings in development
Do it in a development tenant first: Settings, Advanced, Extensibility, and set both runtimes to Node 22. Then have someone sign in through every connection and app you've got, custom database and social ones included. If anything breaks, you've found it before a customer did.
- 05Repeat in production in a quiet window
Make the same change with someone watching the tenant logs. Don't count on switching back for long: Auth0 says the Node 18 option disappears first for tenants that no longer use it.
- 06Change the deploy code too
Set runtime to node22 on Terraform auth0_action resources and sandbox_version to 22 on auth0_tenant. If the code still says Node 18, the next deploy can set it back.
- 07Treat Hooks as a migration
Hooks stop running after 30 April 2027 whatever runtime they use. A Hook that breaks on Node 22 can't be edited, because Hooks code has been read-only since November 2024, so move it to an Action now.
What should each person do now?
What to do now, by who you are
- Ask whoever runs Auth0 whether anything still uses Node 18, and get a switch date well before 10 May 2027.
- Ask which Marketplace integrations you rely on, and whether each has a Node 22 version yet.
- Make sure the Hooks migration has its own plan. Hooks stop after 30 April 2027, before the runtime deadline.
- Export the tenant into source control. Then you've got one list of every runtime setting and Action runtime instead of a Dashboard hunt.
- Switch a development tenant to Node 22 first and run test logins through every connection.
- Pick a production window and decide in advance what you'll do if a Rule or Hook fails.
- Update the Terraform config in the same change.
- Rip out use npm and any filesystem writes. Neither works on Node 22.
- Move per-login values out of top-level variables in Actions.
- Check every require() in the legacy sandbox against the Node 22 Can I Require list.
- Ship each Action upgrade as a new version, so you can roll back just that one if it breaks.
- Test each Action that imports an Action Module, because the module runs on the caller's runtime.
- Confirm nothing in the tenant or the deploy code still says Node 18.
- Record the change, the test logins and who approved it.
- Add 30 April 2027 to the risk register. That's when the Node.js project stops fixing Node 22 too.
How do you make the next runtime change routine?
Habits that make the next notice cheap
- 01Keep the tenant in source control
With Terraform, every runtime value sits in a file someone reviews. Finding every Node 18 reference becomes a text search instead of a Dashboard tour.
- 02Keep a test tenant that looks like production
Same connections, same Actions, a few test users per connection. Run the same sign-ins after every change and compare the tokens.
- 03No user data at the top of an Action
Anything about the person signing in lives inside the handler. Top-level code only sets up things that are safe to share, like a client object.
- 04Keep dependencies few and current
Stick to maintained packages, run npm audit, and take the latest version where you can, which is what Auth0's coding guidance asks for too. Every package you drop is one less thing to break on the next runtime.
- 05Get off Rules and Hooks
Hooks stop after 30 April 2027 and Rules on 31 January 2028. Once everything's an Action, each piece changes runtime on its own and can be rolled back on its own.
If the switch goes wrong
The usual failure is a burst of failed logins, or tokens missing a claim, right after a runtime change. Work through these phases in order, and fix the cause before you try again.
- 01Stop the damagefirst 15 minutes
- Was it an Action? Revert it to the previous version from its version history, and logins go back to how they were.
- If a tenant setting caused it, set it back to Node 18 if the option is still there.
- If Node 18 is gone, decide with the security team whether the failing Rule or Hook can be disabled safely. Disabling a check can let people in without it.
- Warn the support desk. Users will call about failed logins, and someone there should know why.
- 02Find the causefirst day
- Read the tenant logs for failed logins, then the Action's execution logs. Don't sit on it: Auth0 only keeps execution logs for 10 days.
- Look for the usual suspects: a module missing from the Node 22 list, use npm, a filesystem write, or shared top-level state.
- Test any Action Module under a Node 22 Action. The module runs on whatever runtime the caller uses, so it can break even though nobody touched it.
- 03Fix and retestthis week
- Fix the Action in the development tenant and rerun the full set of test logins.
- A broken Rule or Hook can't be patched, because nobody can edit their code. The fix is a replacement Action.
- 04Report and learnafter the fix
- If anyone got access they shouldn't have, treat it as a security incident and follow your usual reporting.
- Write down what broke and add a test login that would've caught it, so the next switch catches it for you.
What does this look like in a real tenant?
Three typical Auth0 tenants
- the setup
- A product team has four Actions, all created on Node 18. One of them builds an API client at the top of the file and also keeps the last user's organisation ID there to save a lookup.
- what happens
- The runtime change itself goes fine. Because Node 22 reuses top-level code across executions, the cached organisation ID can carry into the next login on the same instance, and a token could carry the wrong organisation.
- what to do
- Move the organisation lookup inside the handler, then upgrade each Action as a new version on Node 22 and compare tokens before and after.
- the setup
- A retailer is moving customers off an old user store with an Auth0 custom database connection. The login and get-user scripts run on the tenant's Extensibility runtime, still set to Node 18.
- what happens
- Changing that one dropdown moves every connection script at once. If the login script uses a package that isn't on the Node 22 list, every customer who hasn't been migrated yet can't sign in until someone fixes it.
- what to do
- Copy the connection into a development tenant, switch it to Node 22 and sign in as a few not-yet-migrated test users. Fix the script there first. The change to custom DB imports on 20 January 2027 is worth testing in the same pass.
- the setup
- An enterprise still has Hooks from an older admin extension. One of them loads google-auth-library to reach a Google API. Nobody can edit the Hook's code, because Hooks became read-only in November 2024.
- what happens
- The legacy runtime goes to Node 22 and the Hook can no longer load the package. Nobody can patch the Hook, so the feature stops until the setting goes back to Node 18, if that's still offered.
- what to do
- Find this in a development tenant first. Then replace the Hook with an Action now. Hooks stop after 30 April 2027 anyway, so the runtime switch only moves that work forward.
We run Auth0 runtime switches and Rules and Hooks migrations, and we compare tokens before and after each step so you can see that nothing changed for users. Our Auth0 page explains how we work. If you'd rather keep it in-house, you can hire Auth0 engineers to join your team, or start with an identity assessment that lists what your tenant still runs. The other Auth0 deadlines are in our posts on Rules and Hooks end of life and the custom DB import change.
What to take from this
- 01
Node 18 is on its way out of Auth0. Pick your own day before 10 May 2027 to move everything to Node 22.
- 02
Actions move one version at a time with a way back. Tenant settings move every Rule, Hook or connection script at once.
- 03
Before switching, hunt for use npm, filesystem writes, user data in top-level variables and modules missing from the Node 22 list. Each of those can bite on Node 22.
- 04
Hooks stop after 30 April 2027 and can't be edited. Replace them with Actions instead of only switching their runtime.
- 05
Node 22 loses Node.js project support on 30 April 2027 as well, so keep the tenant in code and expect the next notice.
01When does Auth0 stop supporting Node 18?
Auth0 deprecated it on 10 November 2026, and tenants still using it have until 10 May 2027. After that Auth0 starts the end-of-life phase and eventually removes Node 18 completely. Don't leave it for the last week.
02What happens if we do nothing?
Auth0 says code still on Node 18 will eventually be forced onto a newer runtime. It hasn't given a date for that. The risk is that the move happens on a day you didn't pick, with code nobody tested on Node 22.
03Which parts of Auth0 does this affect?
All five kinds of custom code: Actions, Rules, Hooks, custom database and custom social connection scripts. Actions get switched one at a time. Rules and Hooks follow the Legacy Extensibility setting, and custom database and social connection scripts follow the other dropdown, both under Settings, Advanced, Extensibility. Change either and every script under it moves at once.
04Do we still need to do anything for Hooks if they stop in April anyway?
Hooks stop running after 30 April 2027, ten days before the runtime grace period ends. Switching the legacy runtime still affects them while they run. The better use of the time is replacing each Hook with an Action.
05Can we switch back to Node 18 if something breaks?
For an Action, yes: revert to the previous version, which keeps its old runtime. For the tenant settings, only while Node 18 is still offered, and Auth0 says it disappears first for tenants that no longer use it. Test in a development tenant so you don't need to.
06How long will Node 22 last?
Node 22 is the runtime Auth0 recommends today. The Node.js project's schedule ends its support on 30 April 2027, so another Auth0 runtime change is likely. Keep the tenant in code so the next switch is quick.
07One of our Marketplace integrations still runs on Node 18. What should we do?
Ask the author for a version that targets a newer runtime. Auth0 says Marketplace Actions that depend on Node 18 and get no update may become unsupported. If it's a social connection, its script can only be changed through the Management API.
Three questions, about a minute
Pick an answer and we'll tell you if it's right, and why it is or isn't. The score stays in this browser.
-
Q1Your team flips the Legacy Extensibility setting to Node 22 in production and a Hook starts failing. What's the realistic fix?
show the answer
B. Set it back to Node 18 if offered, then replace the Hook with an Action Hooks code has been read-only since November 2024, so nobody can patch it. You can only switch back while Node 18 is still offered, and Hooks stop after 30 April 2027 anyway, so the lasting fix is an Action.
-
Q2Someone's post-login Action keeps the current user's region in a variable at the top of the file. Why does that bite on Node 22?
show the answer
C. That value can still be sitting there when the next person logs in On Node 22 module-level code runs once per instance of the Action and can be reused across many executions. A value about one user could still be there for the next, so per-login data belongs inside the handler.
-
Q3You've switched every Action and both tenant settings to Node 22 in the Dashboard. A week later Terraform runs. What should you have changed as well?
show the answer
A. The Terraform code too, so it says node22 for the Actions and 22 for the tenant Terraform sets resources to what the code says. If auth0_action still says node18 or auth0_tenant still says 18, the next deploy can put Node 18 back.