Published Sep 16, 2025 ⦁ Updated Nov 4, 2026 ⦁ 16 min read
Redux DevTools: Install, Set Up and Debug Your Store (Best Practices)

Redux DevTools: Install, Set Up and Debug Your Store (Best Practices)

Redux DevTools is a free browser extension that shows every action your Redux store dispatches, the state before and after, and a diff, and lets you jump back to any earlier state ("time travel"). Install the Redux DevTools Chrome extension (or the Firefox add-on, or the Microsoft Edge add-on). If you create your store with Redux Toolkit's configureStore, it connects automatically, with no code changes (Redux docs). Then open your browser's developer tools and click the Redux tab.

1,000,000+
Chrome Web Store users of the Redux DevTools extension
4.3 / 5
Chrome Web Store rating, from 740 ratings
39,371
average daily Firefox users (rated 4.7 / 5 from 137 ratings)
14.4k
GitHub stars on reduxjs/redux-devtools (MIT license)
2.7M
npm downloads of @redux-devtools/extension, Oct 4 to Nov 2, 2026
133M
npm downloads of @reduxjs/toolkit in the same 30 days (DevTools built in)

What Redux DevTools is (and which package you need)

"Redux DevTools" is used for a few different things, which is why searches for redux devtools, redux dev tool, redux developer tools and redux debugger all land in the same place. They all live in the reduxjs/redux-devtools monorepo:

Name What it is Who needs it
Redux DevTools extension The browser extension for Chrome, Edge and Firefox. This is what most people mean. Everyone debugging a web app
@reduxjs/toolkit (configureStore) Not a DevTools package, but it connects to the extension for you Redux Toolkit apps (no extra install)
@redux-devtools/extension Small npm helpers (composeWithDevTools, devToolsEnhancer) for wiring the extension into createStore Legacy Redux, TypeScript typings, Zustand
redux-devtools-extension The old name of the package above. Last release 2.13.9 (March 2021), marked on npm as "Package moved to @redux-devtools/extension" Nobody; migrate
@redux-devtools/cli A standalone server and UI (Electron app or web page) for remote debugging Safari, React Native, Node, Electron
@redux-devtools/remote A store enhancer that sends actions to that server Same as above
Monitor packages (@redux-devtools/inspector-monitor, log-monitor, chart-monitor, rtk-query-monitor) The views inside the extension, also usable on their own Custom setups

There is no single "Redux Toolkit extension". When people search for a redux toolkit extension or redux chrome extension, they mean the same Redux DevTools extension, which works with Redux Toolkit out of the box.

The Redux style guide lists using the Redux DevTools extension for debugging as a strongly recommended practice, because seeing the action history is one of the main reasons to use Redux at all.

Install the Redux DevTools extension

Browser Where to get it Notes
Chrome, Brave, Arc, Opera, Vivaldi Chrome Web Store Version 3.2.12, updated October 19, 2026
Microsoft Edge Edge Add-ons The Chrome Web Store version also installs in Edge
Firefox Mozilla Add-ons Version 3.2.12, MIT license
Electron Pass REDUX_DEVTOOLS to electron-devtools-installer Per the extension README
Safari, React Native, Node No extension Use the remote setup below

Add Redux DevTools to Chrome

  1. Open the Redux DevTools page on the Chrome Web Store and click Add to Chrome, then Add extension.
  2. Optional: click the puzzle icon in the toolbar and pin Redux DevTools, so its icon lights up on pages that have a store.
  3. If you open your app from the file system (file:///...), go to chrome://extensions, open Redux DevTools' Details, and turn on Allow access to file URLs. The troubleshooting guide calls this out because the extension otherwise never sees the page.
  4. Reload your app tab. The extension only attaches to pages loaded after it was installed.

Searching the Web Store for "redux extension" also finds it; to be sure you have the official one, use the link in the extension README. The same Chrome Redux DevTools steps work in Brave, Arc and other Chromium browsers. If your company blocks the Web Store, the GitHub releases page has an extension.zip you can load with Load unpacked in developer mode.

Redux DevTools for Edge and Firefox

For Redux DevTools in Edge, install from Edge Add-ons, or enable Allow extensions from other stores in edge://extensions and use the Chrome Web Store listing. For Redux DevTools in Firefox, install from Mozilla Add-ons. The Redux DevTools Edge listing and the Redux DevTools Firefox add-on are built from the same source as Chrome and share a version number, so features are the same in all three. One small difference: clicking a stack frame in the Trace tab to open Chrome's Sources panel only works in Chromium, which is why the extension also supports opening frames in your own editor (see Trace).

How to open Redux DevTools in Chrome

There are four ways to open it once it's installed:

  • DevTools panel: press F12 (Cmd+Option+I on a Mac) and click the Redux tab. If you don't see it, click the >> overflow arrow in the tab bar.
  • Toolbar popup: click the Redux DevTools icon. It's colored when the page has a store and gray when it doesn't.
  • Keyboard shortcut: Cmd+Shift+E (Ctrl+Shift+E on Windows and Linux) opens the popup when a store is on the page. It's the only shortcut set by default; add others under Keyboard shortcuts on chrome://extensions (extension FAQ).
  • Right-click menu: right-click the page and choose Redux DevTools to open it in a separate window, a side panel, or the remote monitor.

If the panel says "No store found", the extension is installed but your app isn't connected. The next sections cover that.

Set up with Redux Toolkit (the default)

Redux Toolkit is the officially recommended way to write Redux. Its configureStore has a devTools option that defaults to true, so this is all you need:

import { configureStore } from '@reduxjs/toolkit'
import todosReducer from './todosSlice'

export const store = configureStore({
  reducer: { todos: todosReducer },
})

That's the answer to the common question "is Redux Toolkit configureStore devTools enabled by default?": yes. The official configureStore docs say the devTools option "Defaults to true". A boolean turns the extension on or off; an object turns it on and is passed to composeWithDevTools() as options.

Pass an object instead of true to configure the extension (options reference):

export const store = configureStore({
  reducer: { todos: todosReducer },
  devTools: process.env.NODE_ENV !== 'production' && {
    name: 'Todo app',
    maxAge: 100,
    actionsDenylist: ['ui/mouseMoved'],
  },
})

When DevTools is enabled, configureStore also turns on action stack traces in development builds, so you can see which line of code dispatched each action. The docs explain that capturing traces adds overhead, so Redux Toolkit enables them in development mode only.

Three more things the docs spell out that save debugging time:

  • Don't add composeWithDevTools yourself. The enhancers option "should not include the Redux DevTools Extension composeWithDevTools, as this is already handled by configureStore." Adding it again gives you two instances or a broken store.
  • Your enhancers run before DevTools. "All enhancers will be included before the DevTools Extension enhancer", so enhancers: (getDefaultEnhancers) => getDefaultEnhancers().concat(myEnhancer) is the right way to add one.
  • Return getDefaultEnhancers(), not a bare array. If you return a plain array, applyMiddleware is dropped and your thunks stop working, which looks like a DevTools problem but isn't.

Redux Toolkit DevTools with TypeScript

Redux DevTools TypeScript support is built in, so no extra types are needed: the devTools option is typed as boolean | DevToolsOptions, so your editor autocompletes name, maxAge, trace, the sanitizers and so on. If you reach for the extension's globals directly (for example in a non-RTK store), type them through @redux-devtools/extension instead of (window as any), which is what the extension README suggests for TypeScript users.

Set up with plain Redux (createStore)

Older codebases using createStore must wire the extension in manually. The recommended way is the @redux-devtools/extension npm package. It replaced the old redux-devtools-extension package, which is deprecated.

npm install @redux-devtools/extension
import { createStore, applyMiddleware } from 'redux'
import { thunk } from 'redux-thunk'
import { composeWithDevTools } from '@redux-devtools/extension'
import rootReducer from './reducers'

const store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(thunk)),
)

To pass options, call it with an object first: composeWithDevTools({ name: 'My app', trace: true })(applyMiddleware(thunk)). If you have no middleware or other enhancers, use devToolsEnhancer() as the last argument to createStore.

Without the package, use the global the extension injects, falling back to Redux's compose when the extension isn't installed:

import { createStore, applyMiddleware, compose } from 'redux'
import { thunk } from 'redux-thunk'
import rootReducer from './reducers'

const composeEnhancers =
  (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || compose

const store = createStore(rootReducer, composeEnhancers(applyMiddleware(thunk)))

The simplest form, for a store with no middleware, is passing window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__() as the enhancer. Add the typeof window !== 'undefined' guard for server-rendered apps.

window.devToolsExtension, which still shows up in old tutorials, was replaced by these names years ago (extension README).

Migrating from redux-devtools-extension to @redux-devtools/extension

If your package.json still lists redux-devtools-extension, the switch is two lines:

npm uninstall redux-devtools-extension
npm install @redux-devtools/extension
- import { composeWithDevTools } from 'redux-devtools-extension'
+ import { composeWithDevTools } from '@redux-devtools/extension'

The exports have the same names: composeWithDevTools, devToolsEnhancer, plus the production variants covered below. Two things to know about @redux-devtools/extension 4.0.0 (March 2026): its release notes say it is now ESM-only, so an old CommonJS setup that require()s it may need 3.x, and its peer dependency accepts Redux 3.1 through 5.

The old package is still downloaded more than the new one, mostly through old dependency trees:

Monthly npm downloads of Redux DevTools-related packages
redux-devtools-extension (deprecated) 2.90M
@redux-devtools/extension 2.70M
reactotron-redux 451K
redux-devtools-expo-dev-plugin 299K
remote-redux-devtools (old) 150K
@redux-devtools/remote 85K
@redux-devtools/cli 71K

redux-devtools-extension is deprecated. Redux Toolkit users need none of these packages. Source: npm downloads API, Oct 4 to Nov 2, 2026

Zustand and other libraries (devtools middleware)

The extension isn't limited to Redux. It exposes a connection API that other state libraries use, and the actions show up exactly like Redux actions.

Zustand ships a devtools middleware in zustand/middleware. Per the Zustand devtools docs, you also install @redux-devtools/extension (for its types):

import { create } from 'zustand'
import { devtools } from 'zustand/middleware'

type BearStore = { bears: number; addBear: () => void }

export const useBearStore = create<BearStore>()(
  devtools(
    (set) => ({
      bears: 0,
      addBear: () => set((s) => ({ bears: s.bears + 1 }), undefined, 'bears/addBear'),
    }),
    { name: 'BearStore' },
  ),
)

The third argument to set is the action name. Leave it out and every update shows as anonymous, which makes the action list useless. Zustand's enabled option defaults to true in development and false in production, and name separates multiple stores in the instance dropdown. The middleware also accepts actionsDenylist.

Other libraries with Redux DevTools integrations include NgRx (@ngrx/store-devtools for Angular) and Jotai (through jotai-devtools); each library's docs cover the setup. If you're writing your own store, the extension's integrations docs show the connect() API. What you get depends on the integration: action log and state diff are universal, while time travel and the Dispatcher only work if the library handles the extension's jump and dispatch messages.

Using Redux DevTools to debug

This is the part most "how to use Redux DevTools" searches are after. Open the Redux tab and you'll see the action list on the left and a detail pane on the right. The dropdown at the top left switches between monitors (Inspector by default, plus Log Monitor, Chart and RTK Query views), and the instance dropdown picks which store to show if the page has several.

  • Inspector: the action list on the left. Click an action to see its payload (Action), the full state after it (State), and what changed (Diff). Diff is usually the fastest way to spot a reducer bug.
  • Time travel: use the slider at the bottom, or Jump on any action, to put the app back into that state. Skip removes an action from history and recomputes the state without it, which helps answer "what if this action never fired?"
  • Trace: shows the call stack that dispatched the selected action. Click a frame to open the source.
  • Dispatcher: dispatch a hand-written action, such as { "type": "todos/added", "payload": "test" }, to test a reducer without touching the UI.
  • Persist: keeps the action history across page reloads, useful for bugs that happen during startup.
  • Export/Import: save the action history to a JSON file and load it on another machine. Attach it to a bug report so a teammate can replay exactly what you saw.

How to use Redux DevTools in Chrome: a five-minute workflow

If you're asking how to use Redux dev tools in Chrome on a real bug, here is a routine that finds most Redux bugs quickly:

  1. Reproduce the bug with the Redux tab open. Each action appears in the list as it's dispatched, newest at the bottom.
  2. Filter the noise. Type part of an action type in the filter box at the top of the list, such as todos/, to see only that slice.
  3. Find the first wrong state. Click actions from the top and open Diff. You're looking for the first action whose diff is unexpected: a field that changed when it shouldn't, or didn't change when it should.
  4. Check the payload. Open Action for that entry. If the payload is wrong, the bug is in the code that dispatched it (go to Trace). If the payload is right but the diff is wrong, the bug is in the reducer.
  5. Confirm the fix with time travel. After editing the reducer, hot reload recomputes the history, so you can scrub the slider and check every step without clicking through the UI again.

The State tab has a Raw view that shows the whole state as JSON. Copy it into the JSON formatter if you want to search or fold a large tree, or paste two snapshots into the diff checker to compare states from different sessions.

Action and state diff

The Diff tab shows only what changed between the previous state and this one, as a tree of added, removed and changed values (changes read as old => new). Two practical tips:

  • An empty diff is a clue. If an action that should change state shows nothing in Diff, either the reducer didn't handle it (wrong action type, wrong slice) or it returned the same reference.
  • Changes everywhere are also a clue. If a small action shows half your state as changed, a reducer is probably rebuilding objects it didn't need to, which causes extra re-renders.

Redux DevTools time travel debugging

Time travel works because DevTools keeps the list of actions and can recompute state from any point. The slider replays history; Jump goes to one action; Skip toggles an action off and recomputes everything after it; and Reorder lets you drag actions to change their order. Commit makes the current state the new starting point and clears the list, and Revert goes back to the last committed state.

Time travel only works reliably when reducers are pure and state is serializable. The troubleshooting guide notes that if only @@INIT shows, or going back and forward doesn't update your UI, the most likely cause is a state mutation, followed by having more than one store (DevTools attached to one, the app reading from another).

Trace: find the line that dispatched an action

The Trace tab shows the stack trace recorded when the action was dispatched. Redux Toolkit turns trace on in development; for createStore, pass trace: true to composeWithDevTools. Per the trace docs:

  • traceLimit (default 10) caps the number of stack frames stored.
  • To open frames in your editor rather than the browser, enable it in the extension's Settings and set your project root path. It works with VS Code, the JetBrains IDEs, Sublime, Emacs, MacVim, TextMate and Atom.
  • If the stack is cut off (for example after a setTimeout), pass a function as trace that returns your own stack string.

Persist and share debug sessions

Click Persist at the bottom of the panel to keep the action history across page reloads, or add ?debug_session=<name> to the page URL to name a persisted session (FAQ). It's the tool for bugs that happen during app startup, where the history would otherwise vanish on reload.

Export downloads the history as JSON and Import loads it back, on any machine with the extension. Add an export to a bug ticket and the person fixing it can step through the exact session, which beats a screen recording. Strip secrets first (see sanitizers below), because the file contains every state.

Redux DevTools Log Monitor and other monitors

The monitors are separate packages in the same repo, bundled into the extension:

Monitor npm package Use it for
Inspector @redux-devtools/inspector-monitor (7.0.1) Default view: action list, Action / State / Diff / Trace / Test tabs
Log Monitor @redux-devtools/log-monitor (6.0.0) A scrolling log of every action with its state as a tree, easier for long sessions
Chart @redux-devtools/chart-monitor (6.0.0) The state drawn as a tree graph, handy for understanding a store's shape
RTK Query @redux-devtools/rtk-query-monitor (7.0.0) Queries, cache entries, tags and subscriptions for RTK Query

Versions are from npm as of November 2026. The Test tab in the Inspector generates a test template (Jest, Mocha, Tape or AVA) from the selected actions, which is a quick start for a regression test.

Options worth knowing

All options are documented in the arguments reference.

Option Default Use it to
name document.title Tell stores apart when a page has several
maxAge 50 Keep more (or fewer) actions in history; more costs memory
latency 500 (ms) Batch actions sent to the extension; 0 sends each one immediately
trace false (RTK: on in development) Record the stack trace for each action
traceLimit 10 Limit stack depth
actionsDenylist none Hide noisy actions by type (strings are treated as regex)
actionsAllowlist none Show only matching actions; overrides the denylist
predicate none (state, action) => boolean for custom filtering
actionSanitizer, stateSanitizer none Replace large or secret values before they reach the extension
serialize JSON.stringify Handle Map, Set, dates, Immutable.js structures
actionCreators none Make your action creators clickable in the Dispatcher
shouldHotReload true Set false to stop history being recomputed on hot reload or replaceReducer
shouldCatchErrors not set Show reducer exceptions in the monitor
shouldStartLocked false Block app actions until you click Unlock
features all on Turn off specific features, such as jump or dispatch

Filtering high-frequency actions like scroll, mouse move, or timer ticks with actionsDenylist keeps the action list readable and the extension fast.

The features keys are pause, lock, persist, export, import, jump, skip, reorder, dispatch and test. When you pass an object, only keys set to true are enabled.

Sanitizers for large state

Every action and state is serialized and sent to the extension, which runs in a separate process. The troubleshooting guide names serializing very large objects as the cause of excessive memory and CPU use, and the fix is sanitizing:

export const store = configureStore({
  reducer,
  devTools: {
    actionSanitizer: (action) =>
      action.type === 'files/downloaded' && action.payload
        ? { ...action, payload: '<<LONG_BLOB>>' }
        : action,
    stateSanitizer: (state) =>
      state.files?.data ? { ...state, files: { ...state.files, data: '<<LONG_BLOB>>' } } : state,
  },
})

Good candidates for sanitizing: file contents and base64 images, big normalized lists (replace with a count), RTK Query cache entries you don't care about, and anything secret. Sanitizers only change what DevTools displays; your app state is untouched.

For values JSON can't represent, set serialize: true, which handles dates, regex, undefined, errors, symbols, Map, Set and functions. It's slower than plain JSON.stringify, so only turn it on if you need it (and Redux Toolkit's serializability check will already warn you about most of these values in state).

Best practices

  1. Keep state serializable. DevTools serializes state to show and replay it. Class instances, functions, and Promises in state display badly and break time travel. Redux Toolkit's serializability check warns you about this in development.
  2. Name actions by domain and event. todos/added filters and reads better than ADD. createSlice does this for you.
  3. Sanitize big or sensitive data. Large blobs (file contents, huge lists) slow the extension. Tokens and personal data in state are visible to anyone with DevTools open. Use stateSanitizer and actionSanitizer:
devTools: {
  stateSanitizer: (state) =>
    state.auth ? { ...state, auth: { ...state.auth, token: '<redacted>' } } : state,
}
  1. Decide on production deliberately. Because devTools defaults to true, a Redux Toolkit app exposes its state history in production to any visitor who has the extension installed. Most apps should set devTools: process.env.NODE_ENV !== 'production', which is what the Redux docs' full example does. If you do keep it on in production for support, sanitize state and consider the features option to disable dispatch, jump, and import.
  2. Raise maxAge only when needed. Long sessions with a high maxAge use a lot of memory.
  3. Never dispatch React events. Synthetic events can't be serialized. Dispatch event.target.value, not the event (troubleshooting guide).
  4. Name every store. Micro-frontends, iframes, and Zustand plus Redux on one page all show up in the instance dropdown; a name saves guessing.
  5. Make DevTools part of how your team works. Ask for a DevTools export with bug reports, and review action names in code review. Before you hire, Redux Toolkit developer candidates can be given a quick practical test: find a reducer bug with the Diff and Trace tabs. It shows whether they actually understand the data flow.

Disabling Redux DevTools in production

There are two schools of thought. The Redux docs example disables it for production, while the extension's own FAQ says you usually don't have to, because a visitor needs the extension installed and only sees your own app's state. Pick based on what's in your state.

Setup Disable in production Keep, but log only
Redux Toolkit devTools: process.env.NODE_ENV !== 'production' devTools: { features: { pause: true, export: true }, stateSanitizer }
@redux-devtools/extension composeWithDevToolsDevelopmentOnly / devToolsEnhancerDevelopmentOnly composeWithDevToolsLogOnlyInProduction / devToolsEnhancerLogOnlyInProduction
Zustand Default (enabled is false in production) enabled: true plus a denylist

The "log only" helpers keep the action log available in production while limiting the extension to logging, which is usually enough for support. They rely on process.env.NODE_ENV being set to 'production' in your production build (the extension README shows the webpack DefinePlugin line for this).

Troubleshooting "No store found" and other problems

"Redux DevTools not working" usually comes down to one of these. Work down the table:

Symptom Likely cause Fix
"No store found" No enhancer connected Use configureStore (with devTools not false), or add composeWithDevTools / __REDUX_DEVTOOLS_EXTENSION_COMPOSE__ to createStore
"No store found" in production devTools disabled for production builds Expected; test with a development build
"No store found" in Next.js or another SSR app Store only created on the server, or created before the page hydrates Make sure the store is created in a client component; the typeof window guard handles SSR
Icon gray on a local file:// page File URL access is off Enable Allow access to file URLs for the extension
Panel empty after installing Page loaded before the extension Reload the tab; if that fails, reload the extension at chrome://extensions
Only @@INIT shows, or time travel doesn't update the UI State mutation, or two stores Fix the mutation (Redux Toolkit's Immer and immutability check help); make sure there's one store
State resets on @@INIT / REPLACE, actions replayed Hot reload recomputes history Set shouldHotReload: false
Breaks with other enhancers Enhancer order Let composeWithDevTools order them; batchedSubscribe-style enhancers go after DevTools
Browser slow, high memory Huge state or actions serialized Add stateSanitizer / actionSanitizer, lower maxAge, denylist noisy actions
Dates, Maps, Symbols missing Plain JSON serialization serialize: true
Zustand actions all "anonymous" No action name passed to set Pass a name as the third argument

Most of these come straight from the official troubleshooting guide. If none fit, try the extension on a known-good demo (the repo has Counter and TodoMVC examples): if it works there, the problem is your store setup, not the extension.

Redux DevTools in Safari and React Native

There's no Safari extension. For Safari, React Native, or any other environment, use @redux-devtools/remote with the @redux-devtools/cli server:

import { createStore } from 'redux'
import { devToolsEnhancer } from '@redux-devtools/remote'

const store = createStore(
  rootReducer,
  devToolsEnhancer({ realtime: true, hostname: 'localhost', port: 8000 }),
)

Run the CLI on the same port, then open its monitor (or click Remote in the browser extension) to see the store. Remote monitoring is on by default only when NODE_ENV is development.

Standalone app with @redux-devtools/cli

The CLI (version 6.0.0, released October 17, 2026) runs a local socket server plus the full DevTools UI:

npm install --save-dev @redux-devtools/cli @redux-devtools/remote
npx redux-devtools --hostname=localhost --port=8000 --open

--open launches the standalone Electron app; --open=browser opens it as a web page instead. Defaults are localhost, port 8000 and http; use --protocol=https with --key and --cert for a secure socket. The package is @redux-devtools/cli, not redux-devtools (that's the React component for embedding DevTools in your app). With Redux Toolkit, set devTools: false and add the remote enhancer through enhancers: (getDefaultEnhancers) => getDefaultEnhancers().concat(devToolsEnhancer({ realtime: true, port: 8000 })).

Redux DevTools React Native options

You have three realistic options in 2026:

  • Expo apps (and bare apps with Expo modules): redux-devtools-expo-dev-plugin runs the full Redux DevTools as an Expo dev plugin (Expo SDK 50 and above). With Redux Toolkit, set devTools: false and concat its devToolsEnhancer() in enhancers, keeping it last.
  • Remote DevTools: @redux-devtools/remote in the app plus @redux-devtools/cli on your machine, as above. On an Android device or emulator, run adb reverse tcp:8000 tcp:8000 so the app can reach localhost:8000.
  • Reactotron with reactotron-redux, a separate desktop app that shows Redux actions alongside network and logs.

React Native's own debugger focuses on components, not Redux state; for that side see our guide to React DevTools for React Native.

Redux DevTools vs redux-logger and other Redux debuggers

Tool How you see it Time travel Best for
Redux DevTools extension Browser panel Yes Day-to-day debugging of web apps
redux-logger (3.0.6, last released 2017) Browser console No Quick logging, or environments where you prefer console output
@redux-devtools/cli + remote Standalone app or web page Yes Safari, React Native, Node, Electron
Reactotron + reactotron-redux Desktop app Not its focus React Native teams wanting one tool for state, network and logs
React DevTools Browser panel No Component props, hooks and render performance (complements Redux DevTools)

redux-logger still gets about 4.1 million npm downloads a month (npm, Oct 4 to Nov 2, 2026), but DevTools shows the same information with diffs, search and time travel, so most teams don't need both. For component-level debugging, pair it with React DevTools; for everything else in the browser, see debugging with Chrome DevTools.

Release timeline

  1. Mar 2021redux-devtools-extension 2.13.9, its last release. The package is later marked as moved to @redux-devtools/extension.
  2. Redux 4.2.0createStore gets a visual @deprecated tag pointing to Redux Toolkit's configureStore; legacy_createStore is added.
  3. Mar 2026@redux-devtools/extension 4.0.0, now ESM-only.
  4. Oct 17, 2026Redux DevTools extension 3.2.12, plus @redux-devtools/cli 6.0.0 and @redux-devtools/remote 1.0.1 (releases).
  5. Nov 3, 2026Redux Toolkit 2.14.0 on npm; configureStore still enables DevTools by default.

For other debugging and state tools, see browser extensions on DevHunt and frameworks and libraries. For catching Redux errors that happen to real users, monitoring tools cover what DevTools can't.

FAQ

Is Redux DevTools free?

Yes. The extension and all @redux-devtools/* packages are open source under the MIT license, maintained in the reduxjs/redux-devtools repository.

How do I use Redux DevTools in Chrome?

Install the extension from the Chrome Web Store, reload your app, press F12 and open the Redux tab. Click any action to see its payload, the resulting state and a diff, and use the slider at the bottom to time travel. Redux Toolkit apps connect automatically; createStore apps need composeWithDevTools.

Why does Redux DevTools say "No store found"?

The page has no store connected. Check that you use configureStore (with devTools not set to false), or that you added composeWithDevTools or __REDUX_DEVTOOLS_EXTENSION_COMPOSE__ to createStore. Then reload the page with DevTools open. A production build with devTools disabled also shows this.

Is devTools enabled by default in Redux Toolkit configureStore?

Yes. The official docs say the devTools option defaults to true, and with it on, configureStore also records action stack traces in development. Set it to false, or to process.env.NODE_ENV !== 'production', to turn it off.

What happened to the redux-devtools-extension npm package?

It moved to @redux-devtools/extension. The API is the same (composeWithDevTools, devToolsEnhancer), so switching is an import change. Redux Toolkit users need neither package.

Is there a Redux DevTools extension for Edge and Firefox?

Yes. Edge has a listing on Edge Add-ons (and also accepts the Chrome Web Store version), and Firefox has one on Mozilla Add-ons. Both run the same 3.2.12 version as Chrome as of November 2026. Safari has no extension; use the remote setup with @redux-devtools/cli.

Does Redux DevTools work with Zustand or other state libraries?

Several libraries integrate with the same extension. Zustand has a devtools middleware in zustand/middleware that connects to it; pass an action name as the third argument to set so actions aren't labeled "anonymous". NgRx and Jotai have integrations too. The features available depend on the library's integration.

How do I use Redux DevTools with React Native?

There's no extension for React Native. Use redux-devtools-expo-dev-plugin in Expo apps, or @redux-devtools/remote in the app with @redux-devtools/cli running on your computer (run adb reverse tcp:8000 tcp:8000 for Android). Reactotron is an alternative.

Should I disable Redux DevTools in production?

Usually yes: set devTools: process.env.NODE_ENV !== 'production' in configureStore. Otherwise anyone with the extension can read your app's state and action history.

Why is Redux DevTools slow or using a lot of memory?

It serializes every action and state. Large state (file contents, big lists) is the usual cause. Add stateSanitizer and actionSanitizer to replace big values, lower maxAge, and use actionsDenylist for high-frequency actions.

What's the difference between Redux DevTools and redux-logger?

redux-logger prints actions and state to the browser console. Redux DevTools shows the same data in a dedicated panel with diffs, filtering, stack traces, export and time travel. Most apps only need DevTools.