Published Sep 16, 2025 ⦁ Updated Nov 10, 2026 ⦁ 6 min read

Chrome DevTools Extensions: 10 Best Picks for Developers

A Chrome DevTools extension adds its own tab or sidebar pane inside Chrome Developer Tools (F12). The ones most developers should install are the official debugger for their framework: React Developer Tools, Redux DevTools, Vue.js devtools or Angular DevTools. Add axe DevTools for accessibility and Requestly for rewriting requests. Skip anything Chrome already does itself, such as Lighthouse and Web Vitals.

5,000,000
users of React Developer Tools, the most installed framework DevTools extension
Aug 31, 2026
all remaining Manifest V2 extensions removed from the Chrome Web Store
1.5 / 5
rating of JSON Formatter (2.1K ratings) despite 2M users, a reason to check reviews before you install
0
permissions a basic DevTools panel extension needs (tested below)

This guide covers Chrome extensions that help you write and debug code. It does not repeat the tour of the Chrome web development tools that ship with the browser (Elements, Console, Network, Performance); that has its own guide: Chrome's built-in DevTools.

The list at a glance

All figures below were read from each extension's Chrome Web Store page on November 10, 2026. "Users" is the store's rounded install count. "Source" means the code is public on GitHub.

Extension What it adds Adds a DevTools panel? Users Rating Version (updated) Cost and source
React Developer Tools Components, Profiler, Suspense tabs Yes 5,000,000 3.5 (1.6K) 8.0.0 (Sep 11, 2026) Free, MIT, facebook/react
Redux DevTools Action log, state diff, time travel Yes 1,000,000 4.3 (740) 3.2.12 (Oct 19, 2026) Free, MIT, reduxjs/redux-devtools
Vue.js devtools Components, Pinia, router, timeline Yes 1,000,000 2.1 (2.2K) 7.7.7 (Jun 23, 2025) Free, MIT, vuejs/devtools
Angular DevTools Component tree, profiler, injector and router trees Yes 300,000 3.0 (193) 1.22.1 (Oct 28, 2026) Free, MIT, angular/angular
Apollo Client Devtools GraphQL cache, queries, mutations, Explorer Yes 200,000 2.5 (269) 4.26.5 (Oct 20, 2026) Free, MIT, apollo-client-devtools
axe DevTools Accessibility scan with fix guidance Yes 400,000 3.2 (131) 4.140.0 (Oct 28, 2026) Free; Pro is paid; closed source (engine is open)
Wappalyzer Detects frameworks, CMS, analytics on any site No (toolbar) 3,000,000 4.0 (2K) 6.12.8 (Oct 26, 2026) Free extension; paid plans; closed source
Requestly Redirect, modify headers, mock API responses No (own UI) 300,000 4.7 (1.8K) 26.9.29 (Sep 30, 2026) Free plan; paid plans; AGPL-3.0, requestly/requestly
JSON Formatter Readable, collapsible JSON in the browser No 2,000,000 1.5 (2.1K) 0.10.2 (May 16, 2026) Free, BSD-3, callumlocke/json-formatter
Refined GitHub Many small improvements to github.com No 100,000 4.8 (272) 26.11.6 (Nov 6, 2026) Free, MIT, refined-github

Two things stand out. Low ratings on framework debuggers usually reflect bug reports from people whose app the tool didn't detect, not malware, so read the recent reviews rather than the average. And a store version that is far ahead of, or far behind, the public repo is worth a second look (more on that under JSON Formatter and Vue).

Framework DevTools extensions

These add a tab inside Chrome DevTools (F12, or Cmd+Option+I on a Mac), which is what most people mean by a "Chrome DevTools extension". They only light up on pages that run the framework, and most of them work best on development builds.

1. React Developer Tools

What it is: the official React debugger, now published by the React Foundation. It adds Components and Profiler tabs, and since version 8.0.0 the Suspense tab is on by default.

What changed in 8.0.0 (released September 8, 2026, per the React DevTools changelog):

  • The Suspense tab is on by default, so you can see what made a component suspend.
  • The Timeline profiler tab was removed. To profile React, use Chrome's own Performance panel, which includes React tracks.
  • When you inspect a DOM node in the Elements panel, a new pane shows the matching React component.
  • A hotkey starts and stops profiling, and the Profiler's commit view has component search.

Permissions (from the Chrome manifest in the repo): scripting, storage, tabs, host access to <all_urls>, and an optional clipboardWrite. That is broad, and it has to be: the extension must inject a hook into every page before React loads.

Who it suits: anyone writing React, Next.js or Remix code. If you are looking for the best Chrome extensions for React developers, this is the one that matters; add Redux DevTools if you use Redux or Zustand.

Limitation: it only helps with React; for app-wide performance you still need Chrome's Performance panel. For a full walkthrough, see our React DevTools guide.

2. Redux DevTools

What it is: a log of every action your store dispatches, with the state before and after, a diff, and time travel. Redux Toolkit's configureStore connects to it with no code. Zustand and other libraries connect through their own middleware.

Permissions (manifest): notifications, contextMenus, storage, and host access to http://*/*, https://*/* and file:///*. The notifications permission shows the "Display notifications" warning (permissions list).

Limitation: it serializes every action and state, so a store holding large data can make it slow. Setup, sanitizers and production advice are in our separate guide: Redux DevTools best practices.

3. Vue.js devtools

What it is: the official Vue extension. It shows the component tree with editable state, Pinia stores, the router and a timeline of events.

Version notes: the Vue DevTools docs say version 7 and later support Vue 3 only. For Vue 2, install the v6 extension. The Chrome Web Store build is 7.7.7, last updated June 23, 2025. Development continues on GitHub, where v9.0.0-rc.3 was published as a pre-release on November 6, 2026, so a store update may be coming.

Who it suits: Vue 3 and Nuxt developers. If your project uses Vite, the docs recommend the Vue DevTools Vite plugin (npm add -D vite-plugin-vue-devtools), which runs inside your app and needs no extension.

Limitation: if both the v6 and v7 extensions are installed, disable the one you don't need; the docs tell you to remove other versions before installing. More detail in our Vue DevTools guide.

4. Angular DevTools

What it is: the Angular team's extension. Its tabs are Components (explore and edit component and directive state), Profiler (see which components change detection checked and how long each took), Injector Tree and Router Tree (angular.dev).

Permissions (manifest): storage, debugger and <all_urls>. The debugger permission is one of the strongest an extension can ask for; Chrome warns that it can "Access the page debugger backend" and "Read and change all your data on all websites". That makes sense for an official Angular tool. Treat the same permission on an unknown extension as a red flag.

Limitation: it only works on development builds. On a production build you see "We detected an application built with production configuration. Angular DevTools only supports development builds." The fix is to serve with ng serve (optimizations are off by default) or set "optimization": false for the build you want to debug. It also does not run on Chrome's new tab page, so open your app first.

5. Apollo Client Devtools

What it is: for apps using Apollo Client. It has four parts, per its store listing: a built-in Explorer that runs queries through your app's own network setup, a watcher for active queries and their variables, a mutation log, and a cache inspector.

Permissions (manifest): only storage, plus content scripts on <all_urls>, which still gives it access to every page.

Limitation: it only sees Apollo Client. If your app uses urql, Relay or plain fetch, use the Network panel or GraphQL Network Inspector (90,000 users, 4.2 stars, MIT, source), which shows each GraphQL operation separately, including batched queries, and works with Apollo, Relay or any other client.

Other framework debuggers

Extension Users Rating Last updated Notes
Ember Inspector 30,000 4.7 (342) Apr 24, 2026 Official, MIT, emberjs/ember-inspector
Preact Developer Tools 7,000 4.5 (16) Sep 28, 2026 Official, MIT, preactjs/preact-devtools
Svelte DevTools 10,000 3.1 (29) May 29, 2024 Repo sveltejs/svelte-devtools last pushed January 2025; check it supports your Svelte version

General developer tools for Chrome

These Chrome extensions (developer tools for any site, whatever it is built with) either add a DevTools panel or live in the toolbar.

6. axe DevTools

What it is: Deque's accessibility checker. It adds an axe DevTools panel; click scan and it lists WCAG issues such as missing labels, low contrast and invalid ARIA, with the element and how to fix it.

Price: the extension is free for automated, page-by-page testing. Intelligent guided tests, AI-assisted checks, user-flow analysis and CI integration are in the paid Pro and Bundle plans (Deque pricing). A trial needs no card.

Who it suits: front-end developers who want accessibility bugs caught before QA. Deque Systems has identified itself as a trader on the store listing.

Limitation: the extension itself is closed source. Its engine, axe-core, is open source (MPL-2.0) and is the same engine Lighthouse uses: Lighthouse 13.6.0 lists axe-core 4.14.0 in its package.json. Lighthouse's accessibility audit is a lighter first pass; the axe panel gives more detail per issue.

7. Wappalyzer

What it is: click the toolbar icon on any site to see its framework, CMS, CDN, analytics and payment provider. The store listing says it detects more than a thousand technologies and can export results to CSV.

Price: the extension is free. A free account adds 50 technology lookups a month; company and contact data are paid "Plus" features (Wappalyzer pricing).

Who it suits: checking what a client's or competitor's site runs, or which React or Next.js version a page ships, without reading its source.

Limitation: the code is no longer public (the old wappalyzer/wappalyzer GitHub repo returns 404 as of November 2026), so you cannot read what it does with the pages it sees. It is a good candidate for restricted site access: set it to run only when you click it (see the safety section).

8. Requestly

What it is: rules that change HTTP traffic in the browser. Redirect a production script to your local build, add or remove headers, delay requests, or return a mock API response before the backend exists. It also handles GraphQL mocking.

License and price: the repo is AGPL-3.0 outside its ee/ folder, and its LICENSE is copyright BrowserStack Inc. (LICENSE). The extension has a free plan; team plans are listed on Requestly's pricing page.

Who it suits: front-end developers who need to test against production data or fake an API.

Limitation: for a one-off change you may not need it. Chrome DevTools' own Local Overrides (Sources panel) can override a response body or response headers, with no extension at all. ModHeader was the other well-known header tool; see the section on extensions that disappeared.

9. JSON Formatter

What it is: turns a raw JSON response opened in a tab into a syntax-highlighted, collapsible tree, with a toggle back to raw. It also exposes the parsed data as json in the console.

Why it is here with a warning: it has 2,000,000 users but a 1.5 rating from 2.1K ratings. The public repo's commit history shows a "givefreely" component being added and then removed in January 2026 (commits "avoid initialising GF on irrelevant pages" and "remove givefreely"), and the repo's manifest says version 0.9.4 while the store ships 0.10.2 (May 16, 2026). The store listing says "No tracking, no advertising", but you cannot confirm the published build from the public code, and the repo has issues turned off.

Who it suits: people who open JSON in tabs every day and accept that trade-off.

Alternatives: paste a response into DevHunt's free JSON formatter, which runs in your browser, or use the Network panel's Preview tab, which already renders JSON as a tree. The popular open-source JSON Viewer by tulios is gone from the store (next section).

10. Refined GitHub

What it is: dozens of small improvements to github.com: linkified issue references in code, visible whitespace, one-click merge conflict fixers, CI status next to the repo name, and the first tag a merged PR shipped in. Each feature can be turned off in its options.

Permissions (manifest): host access only to github.com and api.github.com, with access to other sites optional. This is the model to look for: an extension that asks for exactly the sites it works on.

Limitation: GitHub changes its interface often, and individual features break until the next release. The extension ships often (26.11.6 on November 6, 2026).

More developer tools Chrome extensions, briefly

Extension Users Rating Last updated What to know
Web Developer 1,000,000 4.3 (2.8K) Jun 29, 2024 The classic Chrome web tools extension: a GPL-3.0 toolbar of page tools. MV3, but asks for cookies, history, browsingData, tabs and all sites (manifest)
ColorZilla 4,000,000 4.7 (3.9K) May 22, 2024 The DevTools color picker already has an eyedropper
WhatFont 3,000,000 3.8 (2.1K) Oct 12, 2026 Hover over text to identify its font
Postman Interceptor 700,000 2.7 (948) Aug 24, 2025 Sends browser requests, with their cookies, to the Postman app
Tampermonkey 12,000,000 4.8 (73.1K) Oct 4, 2026 User scripts. MV3 user-script managers rely on the userScripts API, which needs a per-extension toggle (see the Manifest V3 section)

You can browse more browser extension tools on DevHunt.

Pick by job

Best for React, Next.js and Remix apps: React Developer Tools
Official. Components, Profiler and Suspense tabs; 8.0.0 adds a React pane to the Elements panel.
Best for Redux, Redux Toolkit or Zustand state: Redux DevTools
Action log, diffs and time travel; Redux Toolkit connects with zero code.
Best for accessibility bugs: axe DevTools
Free automated scan per page with fix guidance; same engine as Lighthouse, more detail.
Best for mocking APIs and rewriting requests: Requestly
Redirects, header changes and mock responses as reusable rules. Use Local Overrides for one-offs.
Best for performance, Web Vitals, cookies, device sizes: Nothing (built in)
Chrome's Performance, Lighthouse, Application panels and device mode cover these.
Job Install Or use Chrome's built-in tool
Inspect React components and props React Developer Tools None
Inspect Vue 3 or Nuxt state Vue.js devtools (v7) or the Vite plugin None
Inspect Vue 2 state Vue.js devtools v6 None
Debug Angular change detection Angular DevTools Performance panel integration (Chromium)
Replay or diff Redux actions Redux DevTools None
Inspect an Apollo GraphQL cache Apollo Client Devtools Network panel for raw requests
Read batched GraphQL requests GraphQL Network Inspector Network panel, one request at a time
Accessibility audit axe DevTools Lighthouse accessibility audit
See what a site is built with Wappalyzer Sources panel (read the bundles yourself)
Mock an API or change headers Requestly Local Overrides in the Sources panel
Read JSON in a tab JSON Formatter (see the warning) Network panel Preview tab
Measure LCP, CLS, INP Nothing Performance panel live metrics
Run a Lighthouse report Nothing Lighthouse panel, or npm install -g lighthouse for CI
Edit cookies Nothing Application > Storage > Cookies
Pick a color, check contrast Nothing Styles pane color picker
Test screen sizes Nothing Device mode (Cmd+Shift+M / Ctrl+Shift+M)
Let an AI coding agent drive Chrome Nothing Chrome DevTools MCP server; see our MCP server directory

Extensions you no longer need

Extension Use this built-in feature instead
Web Vitals Live LCP, CLS and INP in the DevTools Performance panel. Google ended support for the extension with Chrome 132 in January 2025 and archived its repo (Chrome blog, repo)
Lighthouse The Lighthouse panel in DevTools, or the lighthouse npm package for CI
ColorZilla and other eyedroppers The color picker in the Styles pane has an eyedropper and contrast ratio
EditThisCookie and cookie editors Application > Storage > Cookies lets you view, edit and delete cookies
Window resizers Device mode (Ctrl+Shift+M / Cmd+Shift+M)

About Lighthouse: the Lighthouse README describes the extension as the way to run Lighthouse before it was built into DevTools, with similar features. The extension still has 1,000,000 users, but there is no reason to install it on a current Chrome. For CI, the CLI is at 13.6.0 (October 27, 2026) and needs Node 22 or later.

A tour of what Chrome already includes is in our Chrome DevTools overview.

Manifest V3: what changed for developer extensions

Manifest V3 is the current extension format. Google phased out Manifest V2 over two years, according to its official timeline:

  1. June 2024Warning banners on chrome://extensions for Manifest V2 extensions. MV2 extensions lose the Featured badge.
  2. October 2024Chrome stable starts disabling installed MV2 extensions; users can still turn them back on for a while.
  3. March 2025MV2 extensions disabled by default for everyone, with an option to re-enable.
  4. July 24, 2025Chrome 138: MV2 disabled everywhere, no re-enable. Chrome 139 removes the enterprise policy that kept them alive.
  5. August 31, 2026All remaining MV2 extensions removed from the Chrome Web Store. Old installs on Chrome 138 or earlier can't update or be reinstalled.

If an old developer tool vanished from your toolbar, that is the likely reason. Every extension in the top 10 runs on Manifest V3.

Developer extensions that were removed or broke

Only cases with a primary source are listed here.

  • JSON Viewer (tulios). The project's README still links to a store listing, but that listing now opens an empty page, and the extension's manifest in the repo still says "manifest_version": 2. That matches the August 31, 2026 removal of MV2 items.
  • Web Vitals. Not an MV3 casualty: Google retired it on purpose and moved its features into the Performance panel. Its repo is archived.
  • ModHeader. The "Install" link on modheader.com points to a Chrome Web Store listing that no longer loads (checked November 10, 2026). The source is closed, so the reason is not public. Several other listings now use the ModHeader name; check the publisher before installing one. Requestly or DevTools' header overrides do the same job.
  • EditThisCookie. The original listing no longer loads either, and store search shows copies such as "EditThisCookie V3" and "EditThisCookie (fork)" from other publishers. You don't need any of them: Chrome's Application panel edits cookies.
  • User-script managers such as Tampermonkey still exist under MV3, and extensions that use the userScripts API need extra consent. On Chrome 138 and later, each such extension needs its Allow User Scripts toggle turned on in chrome://extensions; before 138 it was the global Developer mode switch (Chrome docs). If your user scripts stopped running, check that toggle first.

Security: treat extensions like dependencies

A developer extension often has permission to "Read and change all your data on all websites", which includes your admin dashboards, cloud consoles and localhost. Extensions also update silently. Chrome's own guide for extension authors puts it plainly: if a developer account is compromised, "an attacker could push malicious code directly to all users" (Stay secure). So check an extension the way you would check an npm package.

How to judge whether an extension is safe

  1. Read the permission warning. Chrome shows it when you click Add to Chrome. The permissions list documents each warning. The ones that deserve a second thought:
Permission Warning Chrome shows Fine when
<all_urls> or *://*/* host access Read and change all your data on all websites The tool must work on any page (framework debuggers)
debugger Access the page debugger backend, plus read and change all your data Official framework tools such as Angular DevTools
tabs Read your browsing history It needs tab URLs (React DevTools)
history, cookies, browsingData History and cookie access Page tools that clear caches or cookies (Web Developer)
declarativeNetRequest Block content on any page Request rewriting tools
management Manage your apps, extensions, and themes Rarely, for a developer tool
storage, contextMenus, alarms, activeTab None Almost always
  1. Check the publisher. The listing's Developer section shows the name, and whether they identified as a trader (Google, Deque, Apollo and Requestly's company do; several solo maintainers don't). The Established Publisher badge means Google verified the publisher's identity and track record; the Featured badge is editorial and MV2 extensions lost it in 2024 (Chrome Web Store discovery docs). Neither badge can be bought.

  2. Check the last update. An extension untouched for two years (Svelte DevTools, Web Developer, ColorZilla, as of November 2026) may still work, but it won't get fixes if Chrome changes an API.

  3. Check the source. Prefer open-source extensions for anything that reads page content or network traffic, then compare the repo's manifest.json version with the store's version. A big gap, like JSON Formatter's, means you can't tell from the repo what you are running.

  4. Watch for new permissions. When an update adds a permission with a warning, Chrome disables the extension until you accept it (permission warnings). Treat that prompt as a review moment, not a click-through.

  5. Read the newest reviews, not the average. A sudden run of one-star reviews after an ownership change or an update is the clearest early warning.

Limit what installed extensions can see

  • Install only what you use, from the official publisher, and remove the rest.
  • In chrome://extensions, open Details and change site access from On all sites to On click or On specific sites (Chrome Web Store help). Good candidates: Wappalyzer, WhatFont, Web Developer. For framework debuggers, add your local dev URL (for example http://localhost:3000) under specific sites.
  • Use a separate Chrome profile for extension-heavy development, and keep your everyday profile (email, banking, production admin) lean.
  • Extensions are off in Incognito unless you turn on Allow in Incognito. Leave it off for anything you don't need there.

Build your own DevTools extension

A Chrome developer tools extension is a normal extension with a devtools_page key in manifest.json (Extend DevTools). Chrome loads that page each time a DevTools window opens, and only pages inside DevTools can use the chrome.devtools.* APIs: inspectedWindow (run code in the page), network (read its requests), panels (add tabs and sidebars), recorder and performance.

The example below adds a Page Inspector tab that reads page stats and lists finished requests, plus a Selected node pane in the Elements panel. It needs no permissions, so Chrome shows no install warning. Make a folder with these five files.

manifest.json

{
  "manifest_version": 3,
  "name": "Page Inspector Panel",
  "version": "1.0.0",
  "description": "Adds a DevTools panel that shows page stats and finished network requests.",
  "devtools_page": "devtools.html"
}

devtools.html (never visible; it only loads the script)

<!doctype html>
<html>
  <head><meta charset="utf-8"></head>
  <body>
    <script src="devtools.js"></script>
  </body>
</html>

devtools.js

// Runs once per DevTools window. It has access to chrome.devtools.*
chrome.devtools.panels.create('Page Inspector', '', 'panel.html', (panel) => {
  panel.onShown.addListener(() => console.log('Page Inspector panel shown'));
});

// A sidebar pane in the Elements panel that follows the selected node ($0).
chrome.devtools.panels.elements.createSidebarPane('Selected node', (pane) => {
  const update = () =>
    pane.setExpression(
      '$0 && { tag: $0.tagName, id: $0.id, classes: [...$0.classList], children: $0.children.length }'
    );
  update();
  chrome.devtools.panels.elements.onSelectionChanged.addListener(update);
});

panel.html

<!doctype html>
<html>
  <head>
    <meta charset="utf-8">
    <style>
      body { font: 12px system-ui, sans-serif; margin: 8px; }
      pre { background: #f3f3f3; padding: 8px; overflow: auto; }
      table { border-collapse: collapse; width: 100%; }
      td { border-bottom: 1px solid #ddd; padding: 2px 4px; }
    </style>
  </head>
  <body>
    <button id="stats">Read page stats</button>
    <button id="clear">Clear requests</button>
    <pre id="out">Click "Read page stats".</pre>
    <table><tbody id="requests"></tbody></table>
    <script src="panel.js"></script>
  </body>
</html>

panel.js

const out = document.getElementById('out');
const rows = document.getElementById('requests');

// Runs in the inspected page; the result must be JSON-serializable.
const STATS = `({
  title: document.title,
  url: location.href,
  domNodes: document.getElementsByTagName('*').length,
  scripts: document.scripts.length,
  iframes: document.querySelectorAll("iframe").length
})`;

document.getElementById('stats').addEventListener('click', () => {
  chrome.devtools.inspectedWindow.eval(STATS, (result, exceptionInfo) => {
    out.textContent = exceptionInfo
      ? 'Error: ' + JSON.stringify(exceptionInfo)
      : JSON.stringify(result, null, 2);
  });
});

document.getElementById('clear').addEventListener('click', () => {
  rows.textContent = '';
});

// Every request the inspected page finishes while DevTools is open (HAR format).
chrome.devtools.network.onRequestFinished.addListener((request) => {
  const tr = document.createElement('tr');
  for (const text of [
    request.response.status,
    request.request.method,
    Math.round(request.time) + ' ms',
    request.request.url,
  ]) {
    const td = document.createElement('td');
    td.textContent = String(text);
    tr.appendChild(td);
  }
  rows.prepend(tr);
});

// Clear the table when the inspected page navigates.
chrome.devtools.network.onNavigated.addListener(() => {
  rows.textContent = '';
});

Load and test it

  1. Open chrome://extensions, turn on Developer mode, click Load unpacked and pick the folder.
  2. Open any normal web page (not the new tab page), press F12 and find Page Inspector among the panel tabs (it may sit behind the » overflow menu).
  3. Click Read page stats, then reload the page or trigger a request to fill the table.
  4. After you edit a file, click the reload icon on the extension's card and close and reopen DevTools.

What this produced when run. These files were loaded unpacked into Playwright's Chromium (Chrome 153) with DevTools auto-opened, then driven over the Chrome DevTools Protocol on November 11, 2026. DevTools listed the new tab next to the built-in ones (internal id chrome-extension://<id>PageInspector), and on example.com the panel showed:

{
  "title": "Example Domain",
  "url": "https://example.com/",
  "domNodes": 22,
  "scripts": 1,
  "iframes": 0
}
200	GET	140 ms	https://example.com/?from=panel

The same run also produced two errors worth knowing:

  • Evaluating code that throws gives {"isException":true,"value":"ReferenceError: nope is not defined ..."} in exceptionInfo, and result is undefined. Always check exceptionInfo first.
  • A DevTools window open on an about:blank tab returned {"code":"E_FAILED","description":"Operation failed: %s","details":["Permission denied"],"isError":true}. inspectedWindow.eval fails on pages the extension isn't allowed to access, so check for this error and show a friendly message.

Notes on the APIs

  • chrome.* or browser.*? The docs now show browser.devtools.*. Chrome turned off the browser namespace for extensions with a devtools_page until Chrome 152, and DevTools methods only return Promises from Chrome 151 and 152 (Extend DevTools, panels reference). The callback style with chrome.* used above works on older and newer versions alike.
  • eval versus content scripts. Google recommends scripting.executeScript() when you don't need the page's own JavaScript objects. That needs the scripting permission and host access, which brings back the install warning. inspectedWindow.eval needs neither, because it only runs while the user has DevTools open on that page.
  • Lifetime. Each Chrome extension DevTools page gets one instance per DevTools window, and it lives as long as that window is open. Keep per-tab state there, not in globals you expect to survive.
  • The selected element. Code passed to inspectedWindow.eval or setExpression can use Console Utilities such as $0 (the selected node) and inspect().
  • Talking to the page. Scripts injected into the page can't call runtime.sendMessage to reach the panel. Relay through a content script with window.postMessage, as the docs show.
  • Theme. chrome.devtools.panels.themeName is "default" or "dark"; it returned "dark" in the test run, so style your panel for both.

For a real-world reference, React DevTools and Ember Inspector are both open source DevTools extensions listed in Google's docs as examples. If you publish one, you can list it among other browser extension tools on DevHunt.

How this guide was checked

Store numbers (users, rating, version, update date, developer) were read from each extension's Chrome Web Store page on November 10, 2026. Permissions come from each project's manifest.json on GitHub on the same date; closed-source extensions (axe DevTools, Wappalyzer) don't publish theirs, so none are listed. Version history comes from the projects' changelogs and GitHub releases, and the MV2 timeline, permission warnings and DevTools API details from developer.chrome.com. The DevTools panel code was run as described above.

FAQ

What is a Chrome DevTools extension?

An extension that adds its own tab or sidebar pane inside Chrome DevTools, using the devtools_page manifest key and the chrome.devtools APIs. React Developer Tools, Redux DevTools and Angular DevTools are the best-known examples. Other developer tools Chrome extensions, like Wappalyzer, live in the toolbar instead.

What are the best Chrome extensions for React developers?

React Developer Tools first; it is official, free and at version 8.0.0 as of November 2026. Add Redux DevTools if you use Redux or Zustand, and axe DevTools for accessibility. For profiling, React DevTools 8 removed its Timeline tab and points you to Chrome's Performance panel, which has React tracks.

Are Chrome developer extensions safe?

Most well-known ones are, but many can read every page you visit. Check the permission warning, the publisher, the last update and whether the source is public, restrict site access to "On click" or specific sites, and use a separate profile for development.

How do I add a DevTools extension to Chrome?

Open its Chrome Web Store page, click Add to Chrome and accept the permission prompt. Then open DevTools with F12 (or Cmd+Option+I on a Mac) on a page that uses the framework; the new tab appears next to Elements and Console, sometimes behind the » menu.

Why doesn't my framework's DevTools tab show up?

Usually the extension found no app on the page. Check you're on your app and not the new tab page, reload with DevTools open, and use a development build: Angular DevTools, for example, refuses production builds with an explicit error. If two versions are installed (Vue devtools v6 and v7), disable one.

Which Chrome debugging extensions did Manifest V3 kill?

Every Manifest V2 extension left the Chrome Web Store on August 31, 2026. Among developer tools, JSON Viewer by tulios is one whose public manifest is still MV2 and whose listing is gone. The Web Vitals extension was retired separately by Google, and its features moved into DevTools.

Do Chrome extensions work in Edge and Brave?

Yes. Edge, Brave, Arc, Opera and other Chromium browsers install extensions from the Chrome Web Store. Firefox needs its own versions, which most framework DevTools also publish.

Why don't my extensions appear in Incognito?

Extensions are disabled in Incognito by default. Open the extension's Details page in chrome://extensions and turn on Allow in Incognito.

Can I build my own Chrome DevTools extension?

Yes. Add "devtools_page": "devtools.html" to a Manifest V3 manifest.json, call chrome.devtools.panels.create() from that page, and load the folder with Load unpacked. The five-file example above needs no permissions and was tested in Chrome 153.