diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 05c3b08917b0d9..c1c391eb14889a 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -488,17 +488,17 @@ Blocks until a client (existing or connected later) has sent
 
 An exception will be thrown if there is no active inspector.
 
-## Node.js-specific protocol events
+## Integration with DevTools
 
-Node.js extends the Chrome DevTools protocol with Node.js-specific protocol events. DevTools
-frontends connected to a running Node.js instance can capture these events and display them
-accordingly to facilitate debugging.
-The following methods broadcast a Node.js-specific protocol event to all connected frontends.
+The `node:inspector` module provides an API for integrating with devtools that support Chrome DevTools Protocol.
+DevTools frontends connected to a running Node.js instance can capture protocol events emitted from the instance
+and display them accordingly to facilitate debugging.
+The following methods broadcast a protocol event to all connected frontends.
 The `params` passed to the methods can be optional, depending on the protocol.
 
 ```js
-// The `NodeNetwork.requestWillBeSent` event will be fired.
-inspector.NodeNetwork.requestWillBeSent({
+// The `Network.requestWillBeSent` event will be fired.
+inspector.Network.requestWillBeSent({
   requestId: 'request-id-1',
   timestamp: Date.now() / 1000,
   wallTime: Date.now(),
@@ -509,7 +509,7 @@ inspector.NodeNetwork.requestWillBeSent({
 });
 ```
 
-### `inspector.NodeNetwork.requestWillBeSent([params])`
+### `inspector.Network.requestWillBeSent([params])`
 
 <!-- YAML
 added:
@@ -522,10 +522,10 @@ added:
 
 This feature is only available with the `--experimental-network-inspection` flag enabled.
 
-Broadcasts the `NodeNetwork.requestWillBeSent` event to connected frontends. This event indicates that
+Broadcasts the `Network.requestWillBeSent` event to connected frontends. This event indicates that
 the application is about to send an HTTP request.
 
-### `inspector.NodeNetwork.responseReceived([params])`
+### `inspector.Network.responseReceived([params])`
 
 <!-- YAML
 added:
@@ -538,10 +538,10 @@ added:
 
 This feature is only available with the `--experimental-network-inspection` flag enabled.
 
-Broadcasts the `NodeNetwork.responseReceived` event to connected frontends. This event indicates that
+Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that
 HTTP response is available.
 
-### `inspector.NodeNetwork.loadingFinished([params])`
+### `inspector.Network.loadingFinished([params])`
 
 <!-- YAML
 added:
@@ -554,7 +554,7 @@ added:
 
 This feature is only available with the `--experimental-network-inspection` flag enabled.
 
-Broadcasts the `NodeNetwork.loadingFinished` event to connected frontends. This event indicates that
+Broadcasts the `Network.loadingFinished` event to connected frontends. This event indicates that
 HTTP request has finished loading.
 
 ## Support of breakpoints
diff --git a/lib/inspector.js b/lib/inspector.js
index 9e6448f36930b6..b38bb1af974819 100644
--- a/lib/inspector.js
+++ b/lib/inspector.js
@@ -197,10 +197,10 @@ function broadcastToFrontend(eventName, params) {
   emitProtocolEvent(eventName, JSONStringify(params ?? {}));
 }
 
-const NodeNetwork = {
-  requestWillBeSent: (params) => broadcastToFrontend('NodeNetwork.requestWillBeSent', params),
-  responseReceived: (params) => broadcastToFrontend('NodeNetwork.responseReceived', params),
-  loadingFinished: (params) => broadcastToFrontend('NodeNetwork.loadingFinished', params),
+const Network = {
+  requestWillBeSent: (params) => broadcastToFrontend('Network.requestWillBeSent', params),
+  responseReceived: (params) => broadcastToFrontend('Network.responseReceived', params),
+  loadingFinished: (params) => broadcastToFrontend('Network.loadingFinished', params),
 };
 
 module.exports = {
@@ -210,5 +210,5 @@ module.exports = {
   waitForDebugger: inspectorWaitForDebugger,
   console,
   Session,
-  NodeNetwork,
+  Network,
 };
diff --git a/lib/internal/inspector_network_tracking.js b/lib/internal/inspector_network_tracking.js
index 4f164d2c41df56..4865537e37b7d5 100644
--- a/lib/internal/inspector_network_tracking.js
+++ b/lib/internal/inspector_network_tracking.js
@@ -5,7 +5,7 @@ const {
 } = primordials;
 
 let dc;
-let NodeNetwork;
+let Network;
 
 let requestId = 0;
 const getNextRequestId = () => `node-network-event-${++requestId}`;
@@ -15,7 +15,7 @@ function onClientRequestStart({ request }) {
   const wallTime = DateNow();
   const timestamp = wallTime / 1000;
   request._inspectorRequestId = getNextRequestId();
-  NodeNetwork.requestWillBeSent({
+  Network.requestWillBeSent({
     requestId: request._inspectorRequestId,
     timestamp,
     wallTime,
@@ -31,11 +31,11 @@ function onClientResponseFinish({ request }) {
     return;
   }
   const timestamp = DateNow() / 1000;
-  NodeNetwork.responseReceived({
+  Network.responseReceived({
     requestId: request._inspectorRequestId,
     timestamp,
   });
-  NodeNetwork.loadingFinished({
+  Network.loadingFinished({
     requestId: request._inspectorRequestId,
     timestamp,
   });
@@ -45,8 +45,8 @@ function enable() {
   if (!dc) {
     dc = require('diagnostics_channel');
   }
-  if (!NodeNetwork) {
-    NodeNetwork = require('inspector').NodeNetwork;
+  if (!Network) {
+    Network = require('inspector').Network;
   }
   dc.subscribe('http.client.request.start', onClientRequestStart);
   dc.subscribe('http.client.response.finish', onClientResponseFinish);
diff --git a/src/inspector/network_inspector.cc b/src/inspector/network_inspector.cc
index 93fe5b85b05720..a03a66d461e527 100644
--- a/src/inspector/network_inspector.cc
+++ b/src/inspector/network_inspector.cc
@@ -6,20 +6,17 @@ namespace inspector {
 NetworkInspector::NetworkInspector(Environment* env)
     : enabled_(false), env_(env) {
   network_agent_ = std::make_unique<protocol::NetworkAgent>(this);
-  node_network_agent_ = std::make_unique<protocol::NodeNetworkAgent>(this);
 }
 NetworkInspector::~NetworkInspector() {
   network_agent_.reset();
-  node_network_agent_.reset();
 }
 
 void NetworkInspector::Wire(protocol::UberDispatcher* dispatcher) {
   network_agent_->Wire(dispatcher);
-  node_network_agent_->Wire(dispatcher);
 }
 
 bool NetworkInspector::canEmit(const std::string& domain) {
-  return domain == "Network" || domain == "NodeNetwork";
+  return domain == "Network";
 }
 
 void NetworkInspector::emitNotification(
@@ -28,8 +25,6 @@ void NetworkInspector::emitNotification(
     std::unique_ptr<protocol::DictionaryValue> params) {
   if (domain == "Network") {
     network_agent_->emitNotification(method, std::move(params));
-  } else if (domain == "NodeNetwork") {
-    node_network_agent_->emitNotification(method, std::move(params));
   } else {
     UNREACHABLE("Unknown domain");
   }
diff --git a/src/inspector/network_inspector.h b/src/inspector/network_inspector.h
index cd39bb73126dc5..1a30997bad98f1 100644
--- a/src/inspector/network_inspector.h
+++ b/src/inspector/network_inspector.h
@@ -3,10 +3,6 @@
 
 #include "env.h"
 #include "network_agent.h"
-#include "node_network_agent.h"
-#include "v8.h"
-
-#include <unordered_map>
 
 namespace node {
 class Environment;
@@ -34,7 +30,6 @@ class NetworkInspector {
   bool enabled_;
   Environment* env_;
   std::unique_ptr<protocol::NetworkAgent> network_agent_;
-  std::unique_ptr<protocol::NodeNetworkAgent> node_network_agent_;
 };
 
 }  // namespace inspector
diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi
index 99e7176846b15d..d559004be80944 100644
--- a/src/inspector/node_inspector.gypi
+++ b/src/inspector/node_inspector.gypi
@@ -27,8 +27,6 @@
       'src/inspector/network_inspector.h',
       'src/inspector/network_agent.cc',
       'src/inspector/network_agent.h',
-      'src/inspector/node_network_agent.cc',
-      'src/inspector/node_network_agent.h',
       'src/inspector/worker_inspector.cc',
       'src/inspector/worker_inspector.h',
     ],
@@ -44,8 +42,6 @@
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.h',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.cpp',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h',
-      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeNetwork.cpp',
-      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeNetwork.h',
     ],
     'node_protocol_files': [
       '<(protocol_tool_path)/lib/Allocator_h.template',
diff --git a/src/inspector/node_network_agent.cc b/src/inspector/node_network_agent.cc
deleted file mode 100644
index bf5716d9f87182..00000000000000
--- a/src/inspector/node_network_agent.cc
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "node_network_agent.h"
-#include "network_agent.h"
-#include "network_inspector.h"
-
-namespace node {
-namespace inspector {
-namespace protocol {
-
-NodeNetworkAgent::NodeNetworkAgent(NetworkInspector* inspector)
-    : inspector_(inspector) {
-  event_notifier_map_["requestWillBeSent"] =
-      &NodeNetworkAgent::requestWillBeSent;
-  event_notifier_map_["responseReceived"] = &NodeNetworkAgent::responseReceived;
-  event_notifier_map_["loadingFinished"] = &NodeNetworkAgent::loadingFinished;
-}
-
-void NodeNetworkAgent::emitNotification(
-    const String& event, std::unique_ptr<protocol::DictionaryValue> params) {
-  if (!inspector_->IsEnabled()) return;
-  auto it = event_notifier_map_.find(event);
-  if (it != event_notifier_map_.end()) {
-    (this->*(it->second))(std::move(params));
-  }
-}
-
-void NodeNetworkAgent::Wire(UberDispatcher* dispatcher) {
-  frontend_ = std::make_unique<NodeNetwork::Frontend>(dispatcher->channel());
-  NodeNetwork::Dispatcher::wire(dispatcher, this);
-}
-
-DispatchResponse NodeNetworkAgent::enable() {
-  inspector_->Enable();
-  return DispatchResponse::OK();
-}
-
-DispatchResponse NodeNetworkAgent::disable() {
-  inspector_->Disable();
-  return DispatchResponse::OK();
-}
-
-void NodeNetworkAgent::requestWillBeSent(
-    std::unique_ptr<protocol::DictionaryValue> params) {
-  String request_id;
-  params->getString("requestId", &request_id);
-  double timestamp;
-  params->getDouble("timestamp", &timestamp);
-  double wall_time;
-  params->getDouble("wallTime", &wall_time);
-  auto request = params->getObject("request");
-  String url;
-  request->getString("url", &url);
-  String method;
-  request->getString("method", &method);
-
-  frontend_->requestWillBeSent(
-      request_id, Request(url, method), timestamp, wall_time);
-
-  inspector_->emitNotification(
-      "Network", "requestWillBeSent", std::move(params));
-}
-
-void NodeNetworkAgent::responseReceived(
-    std::unique_ptr<protocol::DictionaryValue> params) {
-  String request_id;
-  params->getString("requestId", &request_id);
-  double timestamp;
-  params->getDouble("timestamp", &timestamp);
-
-  frontend_->responseReceived(request_id, timestamp);
-
-  inspector_->emitNotification(
-      "Network", "responseReceived", std::move(params));
-}
-
-void NodeNetworkAgent::loadingFinished(
-    std::unique_ptr<protocol::DictionaryValue> params) {
-  String request_id;
-  params->getString("requestId", &request_id);
-  double timestamp;
-  params->getDouble("timestamp", &timestamp);
-
-  frontend_->loadingFinished(request_id, timestamp);
-
-  inspector_->emitNotification("Network", "loadingFinished", std::move(params));
-}
-
-}  // namespace protocol
-}  // namespace inspector
-}  // namespace node
diff --git a/src/inspector/node_network_agent.h b/src/inspector/node_network_agent.h
deleted file mode 100644
index 6503ff8fef8b50..00000000000000
--- a/src/inspector/node_network_agent.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef SRC_INSPECTOR_NODE_NETWORK_AGENT_H_
-#define SRC_INSPECTOR_NODE_NETWORK_AGENT_H_
-
-#include "node/inspector/protocol/NodeNetwork.h"
-
-#include <unordered_map>
-
-namespace node {
-
-namespace inspector {
-class NetworkInspector;
-
-namespace protocol {
-
-class NodeNetworkAgent : public NodeNetwork::Backend {
- public:
-  explicit NodeNetworkAgent(NetworkInspector* inspector);
-
-  void emitNotification(const String& event,
-                        std::unique_ptr<protocol::DictionaryValue> params);
-
-  void Wire(UberDispatcher* dispatcher);
-
-  DispatchResponse enable() override;
-
-  DispatchResponse disable() override;
-
-  void requestWillBeSent(std::unique_ptr<protocol::DictionaryValue> params);
-
-  void responseReceived(std::unique_ptr<protocol::DictionaryValue> params);
-
-  void loadingFinished(std::unique_ptr<protocol::DictionaryValue> params);
-
- private:
-  NetworkInspector* inspector_;
-  std::shared_ptr<NodeNetwork::Frontend> frontend_;
-  using EventNotifier =
-      void (NodeNetworkAgent::*)(std::unique_ptr<protocol::DictionaryValue>);
-  std::unordered_map<String, EventNotifier> event_notifier_map_;
-};
-
-}  // namespace protocol
-}  // namespace inspector
-}  // namespace node
-
-#endif  // SRC_INSPECTOR_NODE_NETWORK_AGENT_H_
diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
index ef2ab2a24d6e20..ab7b6a5414c846 100644
--- a/src/inspector/node_protocol.pdl
+++ b/src/inspector/node_protocol.pdl
@@ -98,42 +98,6 @@ experimental domain NodeWorker
       SessionID sessionId
       string message
 
-experimental domain NodeNetwork
-  depends on Network
-
-  # Disables network tracking, prevents network events from being sent to the client.
-  command disable
-
-  # Enables network tracking, network events will now be delivered to the client.
-  command enable
-
-  # Fired when page is about to send HTTP request.
-  event requestWillBeSent
-    parameters
-      # Request identifier.
-      Network.RequestId requestId
-      # Request data.
-      Network.Request request
-      # Timestamp.
-      Network.MonotonicTime timestamp
-      # Timestamp.
-      Network.TimeSinceEpoch wallTime
-
-  # Fired when HTTP response is available.
-  event responseReceived
-    parameters
-      # Request identifier.
-      Network.RequestId requestId
-      # Timestamp.
-      Network.MonotonicTime timestamp
-
-  event loadingFinished
-    parameters
-      # Request identifier.
-      Network.RequestId requestId
-      # Timestamp.
-      Network.MonotonicTime timestamp
-
 # Partial support for Network domain of ChromeDevTools Protocol.
 # https://chromedevtools.github.io/devtools-protocol/tot/Network
 experimental domain Network
diff --git a/test/parallel/test-inspector-emit-protocol-event.js b/test/parallel/test-inspector-emit-protocol-event.js
index 1e0d3770797dd6..1a4e622c78881b 100644
--- a/test/parallel/test-inspector-emit-protocol-event.js
+++ b/test/parallel/test-inspector-emit-protocol-event.js
@@ -8,7 +8,7 @@ const inspector = require('node:inspector/promises');
 const assert = require('node:assert');
 
 const EXPECTED_EVENTS = {
-  NodeNetwork: [
+  Network: [
     {
       name: 'requestWillBeSent',
       params: {
@@ -64,7 +64,7 @@ const runAsyncTest = async () => {
   session.connect();
 
   // Check that all events emit the expected parameters.
-  await session.post('NodeNetwork.enable');
+  await session.post('Network.enable');
   for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) {
     for (const event of events) {
       session.on(`${domain}.${event.name}`, common.mustCall(({ params }) => {
@@ -75,9 +75,9 @@ const runAsyncTest = async () => {
   }
 
   // Check tht no events are emitted after disabling the domain.
-  await session.post('NodeNetwork.disable');
-  session.on('NodeNetwork.requestWillBeSent', common.mustNotCall());
-  inspector.NodeNetwork.requestWillBeSent({});
+  await session.post('Network.disable');
+  session.on('Network.requestWillBeSent', common.mustNotCall());
+  inspector.Network.requestWillBeSent({});
 };
 
 runAsyncTest().then(common.mustCall()).catch((e) => {
diff --git a/test/parallel/test-inspector-network-domain.js b/test/parallel/test-inspector-network-domain.js
index 94d79797c9f03d..1dc0d4f65a216e 100644
--- a/test/parallel/test-inspector-network-domain.js
+++ b/test/parallel/test-inspector-network-domain.js
@@ -48,29 +48,6 @@ const terminate = () => {
 };
 
 const testHttpGet = () => new Promise((resolve, reject) => {
-  let nodeNetworkEventFinished = false;
-  let networkEventFinished = false;
-
-  session.on('NodeNetwork.requestWillBeSent', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(params.request.url, 'http://127.0.0.1/hello-world');
-    assert.strictEqual(params.request.method, 'GET');
-    assert.strictEqual(typeof params.timestamp, 'number');
-    assert.strictEqual(typeof params.wallTime, 'number');
-  }));
-  session.on('NodeNetwork.responseReceived', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(typeof params.timestamp, 'number');
-  }));
-  session.on('NodeNetwork.loadingFinished', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(typeof params.timestamp, 'number');
-    nodeNetworkEventFinished = true;
-    if (networkEventFinished) {
-      resolve();
-    }
-  }));
-
   session.on('Network.requestWillBeSent', common.mustCall(({ params }) => {
     assert.ok(params.requestId.startsWith('node-network-event-'));
     assert.strictEqual(params.request.url, 'http://127.0.0.1/hello-world');
@@ -85,10 +62,7 @@ const testHttpGet = () => new Promise((resolve, reject) => {
   session.on('Network.loadingFinished', common.mustCall(({ params }) => {
     assert.ok(params.requestId.startsWith('node-network-event-'));
     assert.strictEqual(typeof params.timestamp, 'number');
-    networkEventFinished = true;
-    if (nodeNetworkEventFinished) {
-      resolve();
-    }
+    resolve();
   }));
 
   http.get({
@@ -99,29 +73,6 @@ const testHttpGet = () => new Promise((resolve, reject) => {
 });
 
 const testHttpsGet = () => new Promise((resolve, reject) => {
-  let nodeNetworkEventFinished = false;
-  let networkEventFinished = false;
-
-  session.on('NodeNetwork.requestWillBeSent', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(params.request.url, 'https://127.0.0.1/hello-world');
-    assert.strictEqual(params.request.method, 'GET');
-    assert.strictEqual(typeof params.timestamp, 'number');
-    assert.strictEqual(typeof params.wallTime, 'number');
-  }));
-  session.on('NodeNetwork.responseReceived', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(typeof params.timestamp, 'number');
-  }));
-  session.on('NodeNetwork.loadingFinished', common.mustCall(({ params }) => {
-    assert.ok(params.requestId.startsWith('node-network-event-'));
-    assert.strictEqual(typeof params.timestamp, 'number');
-    nodeNetworkEventFinished = true;
-    if (networkEventFinished) {
-      resolve();
-    }
-  }));
-
   session.on('Network.requestWillBeSent', common.mustCall(({ params }) => {
     assert.ok(params.requestId.startsWith('node-network-event-'));
     assert.strictEqual(params.request.url, 'https://127.0.0.1/hello-world');
@@ -136,10 +87,7 @@ const testHttpsGet = () => new Promise((resolve, reject) => {
   session.on('Network.loadingFinished', common.mustCall(({ params }) => {
     assert.ok(params.requestId.startsWith('node-network-event-'));
     assert.strictEqual(typeof params.timestamp, 'number');
-    networkEventFinished = true;
-    if (nodeNetworkEventFinished) {
-      resolve();
-    }
+    resolve();
   }));
 
   https.get({
@@ -160,12 +108,6 @@ const testNetworkInspection = async () => {
 httpServer.listen(0, () => {
   httpsServer.listen(0, async () => {
     try {
-      await session.post('NodeNetwork.enable');
-      await testNetworkInspection();
-      await session.post('NodeNetwork.disable');
-
-      // ChromeDevTools sends a 'Network.enable' command to enable network inspection.
-      // This test ensures that the 'Network.enable' command correctly enables network inspection.
       await session.post('Network.enable');
       await testNetworkInspection();
       await session.post('Network.disable');