# How to Selectively Enable or Disable Tool Categories in Chrome DevTools MCP

> Learn to selectively enable or disable tool categories in Chrome DevTools MCP using CLI flags or programmatic options. Control emulation, network, and more for efficient debugging.

- Repository: [ChromeDevTools/chrome-devtools-mcp](https://github.com/chromedevtools/chrome-devtools-mcp)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Use the `--no-category-<name>` CLI flags (e.g., `--no-category-emulation`, `--no-category-network`) when starting the server, or pass equivalent options programmatically via `parseArguments()` to filter which tool sets are registered.**

Chrome DevTools MCP (Model Context Protocol) organizes its automation capabilities into distinct tool categories such as **emulation**, **network**, **performance**, and **extensions**. When running the `ChromeDevTools/chrome-devtools-mcp` server, you can selectively enable or disable these categories to control which tools are exposed to AI clients, reducing overhead and limiting scope to only the capabilities you need.

## Understanding Tool Categories in MCP

The MCP server categorizes tools to allow granular control over the Chrome DevTools Protocol (CDP) surface area exposed to LLMs.

### Where Categories Are Defined

Tool categories are enumerated in [`src/tools/categories.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/tools/categories.ts). The `ToolCategory` enum defines the available classifications:

```typescript
// src/tools/categories.ts
export enum ToolCategory {
  EMULATION = 'emulation',
  NETWORK = 'network',
  PERFORMANCE = 'performance',
  EXTENSIONS = 'extensions',
}

```

Each tool definition in the codebase (e.g., [`src/tools/emulation.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/tools/emulation.ts), [`src/tools/network.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/tools/network.ts)) annotates its `ToolDefinition` with a `category` property drawn from this enum.

### CLI Flag Definitions

The command-line interface declares boolean flags for each category in [`src/cli.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/cli.ts). By default, **emulation**, **network**, and **performance** are enabled (`true`), while **extensions** is disabled (`false`):

```typescript
// src/cli.ts (simplified)
.option('categoryEmulation', {
  type: 'boolean',
  default: true,
  description: 'Enable tools in the emulation category'
})
.option('categoryNetwork', {
  type: 'boolean',
  default: true,
  description: 'Enable tools in the network category'
})
// ... similar for performance and extensions

```

The `yargs` library automatically generates negated forms (`--no-<flag>`), allowing you to disable categories via `--no-category-emulation`, `--no-category-network`, etc.

## How to Disable Specific Tool Categories

You can selectively disable tool categories when launching the MCP server from the command line or programmatically.

### Disabling Emulation Tools

To disable all device emulation, viewport manipulation, and user agent spoofing tools:

```bash
npx chrome-devtools-mcp@latest --no-category-emulation

```

This sets `categoryEmulation` to `false`, causing the server to skip registration of any tool where `category === ToolCategory.EMULATION`.

### Disabling Network Tools

To disable network interception, throttling, and request blocking capabilities:

```bash
npx chrome-devtools-mcp@latest --no-category-network

```

### Disabling Performance Tools

To disable performance monitoring, tracing, and profiling tools:

```bash
npx chrome-devtools-mcp@latest --no-category-performance

```

### Handling Extensions (Disabled by Default)

The **extensions** category is unique in that it defaults to `false`. To enable extension management tools (loading, unloading, and querying Chrome extensions):

```bash
npx chrome-devtools-mcp@latest --category-extensions

```

To explicitly keep it disabled (redundant but explicit):

```bash
npx chrome-devtools-mcp@latest --no-category-extensions

```

## Programmatic Configuration

When embedding the MCP server as a library, you can pass category flags directly to the argument parser.

### Using parseArguments()

Import `parseArguments` from [`src/cli.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/cli.ts) and provide an array of CLI-style flags:

```typescript
import { parseArguments } from './src/cli.js';
import { runServer } from './src/main.js';

// Disable emulation and network, enable extensions
const args = parseArguments('1.0.0', [
  '--no-category-emulation',
  '--no-category-network',
  '--category-extensions',
]);

// Start the server with filtered categories
await runServer(args);

```

The `args` object returned by `parseArguments()` contains boolean properties (`categoryEmulation`, `categoryNetwork`, etc.) that `runServer` uses to filter tool registration.

## How Category Filtering Works Under the Hood

The selective enable/disable mechanism is implemented in [`src/main.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/main.ts) within the `registerTool()` function.

### The Registration Guard

When the server initializes, it iterates over all tool definitions. For each tool, `registerTool()` checks the corresponding category flag:

```typescript
// src/main.ts (conceptual flow)
function registerTool(tool: ToolDefinition, args: Arguments) {
  // Check if the tool's category is enabled
  if (tool.category === ToolCategory.EMULATION && !args.categoryEmulation) {
    return; // Skip registration
  }
  if (tool.category === ToolCategory.NETWORK && !args.categoryNetwork) {
    return;
  }
  // ... similar checks for performance and extensions
  
  // If we reach here, register the tool with the MCP server
  server.tool(tool.name, tool.description, tool.schema, tool.handler);
}

```

If a category flag is `false`, the function returns early and the tool is never exposed to the MCP client. This reduces the tool surface area visible to AI models and eliminates unnecessary CDP overhead for disabled categories.

## Summary

- **Tool categories** (emulation, network, performance, extensions) are defined in [`src/tools/categories.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/tools/categories.ts) via the `ToolCategory` enum.
- **CLI flags** (`--category-emulation`, `--category-network`, etc.) control activation, with negated forms (`--no-category-*`) available to disable categories.
- **Default behavior**: Emulation, network, and performance are enabled by default; extensions are disabled by default.
- **Registration filtering** occurs in [`src/main.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/main.ts) where `registerTool()` skips tools whose category flag is `false`, preventing them from appearing in the MCP protocol.

## Frequently Asked Questions

### What are the default category settings in Chrome DevTools MCP?

By default, the **emulation**, **network**, and **performance** categories are enabled (`true`), while the **extensions** category is disabled (`false`). This default configuration is hardcoded in [`src/cli.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/cli.ts) and can be overridden using the respective CLI flags.

### Can I enable extensions while disabling other categories?

Yes. Since extensions default to `false`, you must explicitly enable them with `--category-extensions` while disabling other categories with their `--no-category-*` counterparts. For example: `npx chrome-devtools-mcp@latest --category-extensions --no-category-emulation --no-category-network`.

### How does MCP handle tools when their category is disabled?

When a category is disabled, the `registerTool()` function in [`src/main.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/main.ts) performs an early return before registering those tools with the MCP server. Consequently, disabled tools never appear in the tool list sent to AI clients and cannot be invoked, effectively removing that CDP surface area from the session.

### Is it possible to toggle categories after the server starts?

No. Category selection is determined at server startup during the argument parsing phase in [`src/cli.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/cli.ts) and the subsequent tool registration loop in [`src/main.ts`](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/src/main.ts). There is no runtime API to dynamically enable or disable categories after initialization; you must restart the server with different flags to change the active tool set.