diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md
index 40d3372b5cf..036292f358c 100644
--- a/doc/api/diagnostics_channel.md
+++ b/doc/api/diagnostics_channel.md
@@ -165,12 +165,17 @@ const channel = diagnostics_channel.channel('my-channel');
 added:
  - v18.7.0
  - v16.17.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/65383
+    description: Returns a `Disposable` which removes the handler.
 -->
 
 * `name` {string|symbol} The channel name
 * `onMessage` {Function} The handler to receive channel messages
   * `message` {any} The message data
   * `name` {string|symbol} The name of the channel
+* Returns: {Disposable} A Disposable that removes the message handler.
 
 Register a message handler to subscribe to this channel. This message handler
 will be run synchronously whenever a message is published to the channel. Any
@@ -192,6 +197,32 @@ diagnostics_channel.subscribe('my-channel', (message, name) => {
 });
 ```
 
+The returned Disposable removes the message handler, which allows the
+subscription to be scoped with the [`using`][] syntax. Disposing it more than
+once has no further effect.
+
+```mjs
+import diagnostics_channel from 'node:diagnostics_channel';
+
+{
+  using subscription = diagnostics_channel.subscribe('my-channel', (message, name) => {
+    // Received data
+  });
+}
+// The handler is removed on scope exit
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+
+{
+  using subscription = diagnostics_channel.subscribe('my-channel', (message, name) => {
+    // Received data
+  });
+}
+// The handler is removed on scope exit
+```
+
 #### `diagnostics_channel.unsubscribe(name, onMessage)`
 
 <!-- YAML
@@ -425,6 +456,9 @@ added:
  - v15.1.0
  - v14.17.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/65383
+    description: Returns a `Disposable` which removes the handler.
   - version:
     - v24.8.0
     - v22.20.0
@@ -440,6 +474,7 @@ changes:
 * `onMessage` {Function} The handler to receive channel messages
   * `message` {any} The message data
   * `name` {string|symbol} The name of the channel
+* Returns: {Disposable} A Disposable that removes the message handler.
 
 Register a message handler to subscribe to this channel. This message handler
 will be run synchronously whenever a message is published to the channel. Any
@@ -465,6 +500,39 @@ channel.subscribe((message, name) => {
 });
 ```
 
+The returned Disposable removes the message handler, which allows the
+subscription to be scoped with the [`using`][] syntax instead of pairing the
+call with [`channel.unsubscribe(onMessage)`][]. Disposing it more than once has
+no further effect.
+
+```mjs
+import diagnostics_channel from 'node:diagnostics_channel';
+
+const channel = diagnostics_channel.channel('my-channel');
+
+{
+  using subscription = channel.subscribe((message, name) => {
+    // Received data
+  });
+  console.log(channel.hasSubscribers); // true
+}
+console.log(channel.hasSubscribers); // false
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+
+{
+  using subscription = channel.subscribe((message, name) => {
+    // Received data
+  });
+  console.log(channel.hasSubscribers); // true
+}
+console.log(channel.hasSubscribers); // false
+```
+
 #### `channel.unsubscribe(onMessage)`
 
 <!-- YAML
@@ -770,6 +838,10 @@ dynamically.
 added:
  - v19.9.0
  - v18.19.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/65383
+    description: Returns a `Disposable` which removes the handlers.
 -->
 
 * `subscribers` {Object} Set of [TracingChannel Channels][] subscribers
@@ -778,6 +850,8 @@ added:
   * `asyncStart` {Function} The [`asyncStart` event][] subscriber
   * `asyncEnd` {Function} The [`asyncEnd` event][] subscriber
   * `error` {Function} The [`error` event][] subscriber
+* Returns: {Disposable} A Disposable that removes every subscriber the call
+  registered.
 
 Helper to subscribe a collection of functions to the corresponding channels.
 This is the same as calling [`channel.subscribe(onMessage)`][] on each channel
@@ -831,6 +905,46 @@ channels.subscribe({
 });
 ```
 
+The returned Disposable removes every subscriber the call registered, which
+allows the whole set to be scoped with the [`using`][] syntax. Disposing it more
+than once has no further effect.
+
+```mjs
+import diagnostics_channel from 'node:diagnostics_channel';
+
+const channels = diagnostics_channel.tracingChannel('my-channel');
+
+{
+  using subscription = channels.subscribe({
+    start(message) {
+      // Handle start message
+    },
+    end(message) {
+      // Handle end message
+    },
+  });
+}
+// Both handlers are removed on scope exit
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+
+const channels = diagnostics_channel.tracingChannel('my-channel');
+
+{
+  using subscription = channels.subscribe({
+    start(message) {
+      // Handle start message
+    },
+    end(message) {
+      // Handle end message
+    },
+  });
+}
+// Both handlers are removed on scope exit
+```
+
 #### `tracingChannel.unsubscribe(subscribers)`
 
 <!-- YAML
@@ -1208,11 +1322,17 @@ if (wc.hasSubscribers) {
 
 <!-- YAML
 added: v26.1.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/65383
+    description: Returns a `Disposable` which removes the handlers.
 -->
 
 * `handlers` {Object} Set of channel subscribers
   * `start` {Function} The start event subscriber
   * `end` {Function} The end event subscriber
+* Returns: {Disposable} A Disposable that removes every subscriber the call
+  registered.
 
 Subscribe to the bounded channel events. This is equivalent to calling
 [`channel.subscribe(onMessage)`][] on each channel individually.
@@ -1247,6 +1367,46 @@ wc.subscribe({
 });
 ```
 
+The returned Disposable removes every subscriber the call registered, which
+allows the whole set to be scoped with the [`using`][] syntax. Disposing it more
+than once has no further effect.
+
+```mjs
+import { boundedChannel } from 'node:diagnostics_channel';
+
+const wc = boundedChannel('my-operation');
+
+{
+  using subscription = wc.subscribe({
+    start(message) {
+      // Handle start
+    },
+    end(message) {
+      // Handle end
+    },
+  });
+}
+// Both handlers are removed on scope exit
+```
+
+```cjs
+const { boundedChannel } = require('node:diagnostics_channel');
+
+const wc = boundedChannel('my-operation');
+
+{
+  using subscription = wc.subscribe({
+    start(message) {
+      // Handle start
+    },
+    end(message) {
+      // Handle end
+    },
+  });
+}
+// Both handlers are removed on scope exit
+```
+
 #### `boundedChannel.unsubscribe(handlers)`
 
 <!-- YAML
@@ -1986,6 +2146,7 @@ statement, since both are still in use while the event is being delivered; see
 [`process.execve()`]: process.md#processexecvefile-args-env
 [`start` event]: #startevent
 [`statement.close()`]: sqlite.md#statementclose
+[`using`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using
 [`worker_threads.locks`]: worker_threads.md#worker_threadslocks
 [context loss]: async_context.md#troubleshooting-context-loss
 [thenable object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables
diff --git a/lib/diagnostics_channel.js b/lib/diagnostics_channel.js
index 998f17aa61d..94f5a61aaac 100644
--- a/lib/diagnostics_channel.js
+++ b/lib/diagnostics_channel.js
@@ -93,6 +93,27 @@ function maybeMarkInactive(channel) {
   }
 }
 
+class ChannelSubscription {
+  #channel;
+  #subscription;
+
+  constructor(channel, subscription) {
+    this.#channel = channel;
+    this.#subscription = subscription;
+  }
+
+  [SymbolDispose]() {
+    const channel = this.#channel;
+    if (channel === undefined) return;
+
+    const subscription = this.#subscription;
+    this.#channel = undefined;
+    this.#subscription = undefined;
+
+    channel.unsubscribe(subscription);
+  }
+}
+
 class RunStoresScope {
   #stack;
 
@@ -142,6 +163,7 @@ class ActiveChannel {
     ArrayPrototypePush(this._subscribers, subscription);
     channels.incRef(this.name);
     if (this._index !== undefined) dc_binding.subscribers[this._index]++;
+    return new ChannelSubscription(this, subscription);
   }
 
   unsubscribe(subscription) {
@@ -230,7 +252,7 @@ class Channel {
 
   subscribe(subscription) {
     markActive(this);
-    this.subscribe(subscription);
+    return this.subscribe(subscription);
   }
 
   unsubscribe() {
@@ -324,6 +346,27 @@ function channelFromMap(nameOrChannels, name, className) {
                                  nameOrChannels);
 }
 
+class HandlersSubscription {
+  #target;
+  #handlers;
+
+  constructor(target, handlers) {
+    this.#target = target;
+    this.#handlers = handlers;
+  }
+
+  [SymbolDispose]() {
+    const target = this.#target;
+    if (target === undefined) return;
+
+    const handlers = this.#handlers;
+    this.#target = undefined;
+    this.#handlers = undefined;
+
+    target.unsubscribe(handlers);
+  }
+}
+
 class BoundedChannelScope {
   #context;
   #end;
@@ -380,6 +423,12 @@ class BoundedChannel {
 
       this[name]?.subscribe(handlers[name]);
     }
+
+    return new HandlersSubscription(this, {
+      __proto__: null,
+      start: handlers.start,
+      end: handlers.end,
+    });
   }
 
   unsubscribe(handlers) {
@@ -486,6 +535,15 @@ class TracingChannel {
     if (handlers.error) {
       this.error.subscribe(handlers.error);
     }
+
+    return new HandlersSubscription(this, {
+      __proto__: null,
+      start: handlers.start,
+      end: handlers.end,
+      asyncStart: handlers.asyncStart,
+      asyncEnd: handlers.asyncEnd,
+      error: handlers.error,
+    });
   }
 
   unsubscribe(handlers) {
diff --git a/test/parallel/test-diagnostics-channel-subscribe-dispose.js b/test/parallel/test-diagnostics-channel-subscribe-dispose.js
new file mode 100644
index 00000000000..3191b1cdca4
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-subscribe-dispose.js
@@ -0,0 +1,189 @@
+/* eslint-disable no-unused-vars */
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const dc = require('node:diagnostics_channel');
+
+// A subscription can be scoped with `using`
+{
+  const channel = dc.channel('test-subscribe-dispose-using');
+  const subscriber = common.mustCall((message) => {
+    assert.deepStrictEqual(message, { foo: 'bar' });
+  });
+
+  {
+    using subscription = channel.subscribe(subscriber);
+
+    assert.ok(channel.hasSubscribers);
+    channel.publish({ foo: 'bar' });
+  }
+
+  assert.ok(!channel.hasSubscribers);
+  channel.publish({ foo: 'bar' });
+}
+
+// The first subscribe on a channel goes through the inactive prototype and
+// must still return a working disposable
+{
+  const channel = dc.channel('test-subscribe-dispose-first');
+  const subscriber = common.mustNotCall();
+
+  const subscription = channel.subscribe(subscriber);
+  assert.ok(channel.hasSubscribers);
+
+  subscription[Symbol.dispose]();
+  assert.ok(!channel.hasSubscribers);
+
+  channel.publish({ foo: 'bar' });
+}
+
+// Disposing more than once is a no-op
+{
+  const channel = dc.channel('test-subscribe-dispose-idempotent');
+  const subscriber = common.mustNotCall();
+
+  const subscription = channel.subscribe(subscriber);
+  subscription[Symbol.dispose]();
+  subscription[Symbol.dispose]();
+
+  assert.ok(!channel.hasSubscribers);
+}
+
+// Disposing twice must not remove another registration of the same handler
+{
+  const channel = dc.channel('test-subscribe-dispose-duplicate');
+  const subscriber = common.mustCall((message) => {
+    assert.deepStrictEqual(message, { foo: 'bar' });
+  });
+
+  const first = channel.subscribe(subscriber);
+  const second = channel.subscribe(subscriber);
+
+  first[Symbol.dispose]();
+  first[Symbol.dispose]();
+
+  assert.ok(channel.hasSubscribers);
+  channel.publish({ foo: 'bar' });
+
+  second[Symbol.dispose]();
+  assert.ok(!channel.hasSubscribers);
+}
+
+// Disposing after an explicit unsubscribe does not throw
+{
+  const channel = dc.channel('test-subscribe-dispose-after-unsubscribe');
+  const subscriber = common.mustNotCall();
+
+  const subscription = channel.subscribe(subscriber);
+
+  assert.ok(channel.unsubscribe(subscriber));
+  subscription[Symbol.dispose]();
+
+  assert.ok(!channel.hasSubscribers);
+}
+
+// The module level subscribe returns the same disposable
+{
+  const name = 'test-subscribe-dispose-module-level';
+  const subscriber = common.mustNotCall();
+
+  const subscription = dc.subscribe(name, subscriber);
+  assert.ok(dc.hasSubscribers(name));
+
+  subscription[Symbol.dispose]();
+  assert.ok(!dc.hasSubscribers(name));
+}
+
+// Invalid subscribers still throw
+{
+  const channel = dc.channel('test-subscribe-dispose-invalid');
+
+  assert.throws(() => {
+    channel.subscribe(null);
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+}
+
+// tracingChannel disposes every handler it subscribed
+{
+  const channel = dc.tracingChannel('test-subscribe-dispose-tracing');
+  const handler = common.mustNotCall();
+
+  const subscription = channel.subscribe({
+    start: handler,
+    end: handler,
+    asyncStart: handler,
+    asyncEnd: handler,
+    error: handler,
+  });
+
+  assert.ok(channel.start.hasSubscribers);
+  assert.ok(channel.end.hasSubscribers);
+  assert.ok(channel.asyncStart.hasSubscribers);
+  assert.ok(channel.asyncEnd.hasSubscribers);
+  assert.ok(channel.error.hasSubscribers);
+
+  subscription[Symbol.dispose]();
+  subscription[Symbol.dispose]();
+
+  assert.ok(!channel.hasSubscribers);
+  assert.ok(!channel.start.hasSubscribers);
+  assert.ok(!channel.end.hasSubscribers);
+  assert.ok(!channel.asyncStart.hasSubscribers);
+  assert.ok(!channel.asyncEnd.hasSubscribers);
+  assert.ok(!channel.error.hasSubscribers);
+}
+
+// tracingChannel handles partial subscriber sets
+{
+  const channel = dc.tracingChannel('test-subscribe-dispose-tracing-partial');
+  const handler = common.mustNotCall();
+
+  {
+    using subscription = channel.subscribe({ start: handler });
+    assert.ok(channel.start.hasSubscribers);
+  }
+  assert.ok(!channel.hasSubscribers);
+
+  {
+    using subscription = channel.subscribe({ asyncEnd: handler });
+    assert.ok(channel.asyncEnd.hasSubscribers);
+  }
+  assert.ok(!channel.hasSubscribers);
+}
+
+// boundedChannel disposes every handler it subscribed
+{
+  const channel = dc.boundedChannel('test-subscribe-dispose-bounded');
+  const handler = common.mustNotCall();
+
+  const subscription = channel.subscribe({
+    start: handler,
+    end: handler,
+  });
+
+  assert.ok(channel.start.hasSubscribers);
+  assert.ok(channel.end.hasSubscribers);
+
+  subscription[Symbol.dispose]();
+  subscription[Symbol.dispose]();
+
+  assert.ok(!channel.hasSubscribers);
+  assert.ok(!channel.start.hasSubscribers);
+  assert.ok(!channel.end.hasSubscribers);
+}
+
+// boundedChannel handles partial subscriber sets
+{
+  const channel = dc.boundedChannel('test-subscribe-dispose-bounded-partial');
+  const handler = common.mustNotCall();
+
+  {
+    using subscription = channel.subscribe({ start: handler });
+
+    assert.ok(channel.start.hasSubscribers);
+    assert.ok(!channel.end.hasSubscribers);
+  }
+
+  assert.ok(!channel.hasSubscribers);
+}