diff --git a/benchmark/perf_hooks/histogram-snapshot.js b/benchmark/perf_hooks/histogram-snapshot.js
new file mode 100644
index 000000000000..79b13fecb0f6
--- /dev/null
+++ b/benchmark/perf_hooks/histogram-snapshot.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+const { createHistogram } = require('perf_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+  highest: [1e6, Number.MAX_SAFE_INTEGER],
+  figures: [2, 3],
+});
+
+let snapshot;
+
+function main({ n, highest, figures }) {
+  const histogram = createHistogram({ highest, figures });
+  for (let i = 1; i <= 1e4; i++) histogram.record(i);
+
+  bench.start();
+  for (let i = 0; i < n; i++) snapshot = histogram.snapshot();
+  bench.end(n);
+
+  assert.strictEqual(snapshot.count, 1e4);
+}
diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md
index 69a4d6613b9b..307a42eda267 100644
--- a/doc/api/perf_hooks.md
+++ b/doc/api/perf_hooks.md
@@ -2152,6 +2152,52 @@ added:
 Returns the number of recorded values that fall within the equivalent
 value range of the given value.
 
+### `histogram.diff(other)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `other` {Histogram} An earlier snapshot of this histogram.
+* Returns: {Histogram}
+
+Returns a new {Histogram} containing the values recorded in this histogram after
+`other` was taken. Neither histogram is changed. To get the values recorded
+during each interval without calling `reset()`, compute each difference from a
+snapshot and keep that snapshot as the baseline for the next interval:
+
+```js
+const { monitorEventLoopDelay } = require('node:perf_hooks');
+
+const histogram = monitorEventLoopDelay();
+histogram.enable();
+let previous = histogram.snapshot();
+
+setInterval(() => {
+  const current = histogram.snapshot();
+  // After a reset, use everything recorded since the reset.
+  const delta = current.resetCount === previous.resetCount ?
+    current.diff(previous) : current;
+  console.log(delta.percentile(99));
+  previous = current;
+}, 10_000);
+```
+
+The `count`, `exceeds`, and bucket counts of the returned histogram are the
+differences between the two histograms. Its `min` and `max` are computed from
+the buckets of the difference, it has no EWMA state, and its `resetCount` is
+`0`.
+
+This method throws:
+
+* `ERR_INVALID_ARG_VALUE` if `other` has a different `lowest`, `highest`, or
+  `figures` configuration.
+* `ERR_INVALID_STATE` if values have been removed from this histogram since
+  `other` was taken, which is the case when the `resetCount` of the two
+  histograms differs.
+* `ERR_INVALID_ARG_VALUE` if `other` contains values that are not in this
+  histogram, for example because the histograms were passed in the wrong order.
+
 ### `histogram.exceeds`
 
 <!-- YAML
@@ -2604,7 +2650,21 @@ boundaries are equal has an infinite density.
 added: v11.10.0
 -->
 
-Resets the collected histogram data.
+Resets the collected histogram data and increments `histogram.resetCount`.
+
+### `histogram.resetCount`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {number}
+
+The number of times values have been removed from this histogram by `reset()`
+or, for a {RecordableHistogram}, `subtract()`. A snapshot has the `resetCount`
+of its source at the time it was taken, so comparing the `resetCount` of two
+snapshots shows whether the source was reset between them. See
+[`histogram.diff()`][].
 
 ### `histogram.skewness`
 
@@ -2621,6 +2681,38 @@ distribution. A positive value indicates a right-skewed distribution
 (longer right tail, common for latency data); a negative value
 indicates a left-skewed distribution.
 
+### `histogram.snapshot()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {Histogram}
+
+Returns a new, independent {Histogram} containing a copy of this histogram's
+current state: its configuration, recorded values, `exceeds` count, and EWMA
+state. Values recorded into this histogram after this method returns, and later
+calls to `reset()`, do not change the returned histogram. This provides a stable
+view of a histogram that is still recording, such as an enabled {ELDHistogram}.
+
+Values cannot be recorded into the returned histogram. Taking a snapshot copies
+every bucket, so both its time and memory cost depend on the histogram's
+`lowest`, `highest`, and `figures` configuration rather than on the number of
+recorded values.
+
+```js
+const { monitorEventLoopDelay } = require('node:perf_hooks');
+
+const histogram = monitorEventLoopDelay();
+histogram.enable();
+
+setTimeout(() => {
+  const snapshot = histogram.snapshot();
+  console.log(snapshot.percentile(99));
+  histogram.disable();
+}, 1000);
+```
+
 ### `histogram.stddev`
 
 <!-- YAML
@@ -2778,7 +2870,7 @@ added:
 
 Subtracts the values of `other` from this histogram. Both histograms should
 have compatible configurations. Bucket counts that would become negative
-are clamped to zero.
+are clamped to zero. Increments `histogram.resetCount`.
 
 ## Class: `SlidingWindowHistogram`
 
@@ -3257,6 +3349,7 @@ dns.promises.resolve('localhost');
 [Worker threads]: worker_threads.md#worker-threads
 [`'exit'`]: process.md#event-exit
 [`child_process.spawnSync()`]: child_process.md#child_processspawnsynccommand-args-options
+[`histogram.diff()`]: #histogramdiffother
 [`histogram.export()`]: #histogramexport
 [`perf_hooks.createSlidingWindowHistogram()`]: #perf_hookscreateslidingwindowhistogramoptions
 [`perf_hooks.eventLoopUtilization()`]: #perf_hookseventlooputilizationutilization1-utilization2
diff --git a/lib/internal/histogram.js b/lib/internal/histogram.js
index 1cc787404fdc..12c888c54217 100644
--- a/lib/internal/histogram.js
+++ b/lib/internal/histogram.js
@@ -679,6 +679,44 @@ class Histogram {
     this[kHandle]?.reset();
   }
 
+  /**
+   * The number of times values have been removed from the histogram by
+   * `reset()` or `subtract()`.
+   * @readonly
+   * @type {number}
+   */
+  get resetCount() {
+    if (!isHistogram(this))
+      throw new ERR_INVALID_THIS('Histogram');
+    return this[kHandle]?.resetCount();
+  }
+
+  /**
+   * Returns a new, independent histogram containing a copy of this
+   * histogram's current state. Values cannot be recorded into the returned
+   * histogram.
+   * @returns {Histogram}
+   */
+  snapshot() {
+    if (!isHistogram(this))
+      throw new ERR_INVALID_THIS('Histogram');
+    return new ClonedHistogram(this[kHandle].snapshot());
+  }
+
+  /**
+   * Returns a new histogram containing the values recorded in this histogram
+   * after `other`, an earlier snapshot of it, was taken.
+   * @param {Histogram} other
+   * @returns {Histogram}
+   */
+  diff(other) {
+    if (!isHistogram(this))
+      throw new ERR_INVALID_THIS('Histogram');
+    if (!isHistogram(other))
+      throw new ERR_INVALID_ARG_TYPE('other', 'Histogram', other);
+    return new ClonedHistogram(this[kHandle].diff(other[kHandle]));
+  }
+
   [kClone]() {
     const handle = this[kHandle];
     return {
diff --git a/src/histogram-inl.h b/src/histogram-inl.h
index e2704b499f31..87f92c492efb 100644
--- a/src/histogram-inl.h
+++ b/src/histogram-inl.h
@@ -42,6 +42,7 @@ void Histogram::Reset() {
   RwLock::ScopedWriteLock lock(mutex_);
   hdr_reset(histogram_.get());
   InvalidateRecordedSnapshot();
+  reset_count_++;
   exceeds_ = 0;
   prev_ = 0;
   ewma_mean_ = 0;
@@ -90,6 +91,11 @@ size_t Histogram::Exceeds() const {
   return exceeds_;
 }
 
+uint64_t Histogram::ResetCount() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return reset_count_;
+}
+
 int64_t Histogram::Min() const {
   RwLock::ScopedReadLock lock(mutex_);
   return hdr_min(histogram_.get());
diff --git a/src/histogram.cc b/src/histogram.cc
index 63f297936773..568987382798 100644
--- a/src/histogram.cc
+++ b/src/histogram.cc
@@ -76,6 +76,110 @@ std::shared_ptr<Histogram> Histogram::Create(const Options& options) {
   return std::make_shared<Histogram>(HistogramPointer(histogram), options);
 }
 
+namespace {
+// Copies the recorded data of `source` into `target`, which must have been
+// initialized with the same layout. The caller must hold a lock that prevents
+// `source` from being modified during the copy.
+void CopyRecordedData(hdr_histogram* target, const hdr_histogram* source) {
+  CHECK_EQ(target->counts_len, source->counts_len);
+  target->min_value = source->min_value;
+  target->max_value = source->max_value;
+  target->normalizing_index_offset = source->normalizing_index_offset;
+  target->conversion_ratio = source->conversion_ratio;
+  target->total_count = source->total_count;
+  std::memcpy(target->counts,
+              source->counts,
+              source->counts_len * sizeof(*source->counts));
+}
+}  // namespace
+
+std::shared_ptr<Histogram> Histogram::CreateWithSameLayout() const {
+  // The layout is fixed when the histogram is created, so it can be read
+  // without holding the lock.
+  hdr_histogram* histogram;
+  if (hdr_init(histogram_->lowest_discernible_value,
+               histogram_->highest_trackable_value,
+               histogram_->significant_figures,
+               &histogram) != 0) {
+    return {};
+  }
+  return std::make_shared<Histogram>(HistogramPointer(histogram), Options{});
+}
+
+std::shared_ptr<Histogram> Histogram::Clone() const {
+  std::shared_ptr<Histogram> clone = CreateWithSameLayout();
+  if (!clone) return {};
+
+  // Every member that holds recorded or statistical state must be copied
+  // here. The recorded snapshot cache is not copied; the clone builds its own
+  // on demand.
+  RwLock::ScopedReadLock lock(mutex_);
+  CopyRecordedData(clone->histogram_.get(), histogram_.get());
+  clone->prev_ = prev_;
+  clone->exceeds_ = exceeds_;
+  clone->reset_count_ = reset_count_;
+  clone->ewma_alpha_ = ewma_alpha_;
+  clone->ewma_mean_ = ewma_mean_;
+  clone->ewma_variance_ = ewma_variance_;
+  clone->ewma_initialized_ = ewma_initialized_;
+  clone->threshold_ = threshold_;
+  clone->ewma_error_rate_ = ewma_error_rate_;
+  return clone;
+}
+
+std::shared_ptr<Histogram> Histogram::Diff(const Histogram& other,
+                                           DiffError* error) const {
+  // Counts are subtracted index by index, so both histograms must map values
+  // to the same indexes. None of these fields change after creation.
+  if (!IsCompatible(other) || histogram_->normalizing_index_offset !=
+                                  other.histogram_->normalizing_index_offset) {
+    *error = DiffError::kIncompatible;
+    return {};
+  }
+
+  std::shared_ptr<Histogram> diff = CreateWithSameLayout();
+  if (!diff) {
+    *error = DiffError::kOutOfMemory;
+    return {};
+  }
+
+  // Only the recorded values and the exceeds count carry over. EWMA and timing
+  // state cannot be subtracted.
+  uint64_t reset_count;
+  {
+    RwLock::ScopedReadLock lock(mutex_);
+    CopyRecordedData(diff->histogram_.get(), histogram_.get());
+    diff->exceeds_ = exceeds_;
+    reset_count = reset_count_;
+  }
+
+  // `diff` is not shared yet, so only the lock of `other` is needed from here
+  // on. Never holding both locks at once avoids lock ordering issues.
+  RwLock::ScopedReadLock lock(other.mutex_);
+  if (reset_count != other.reset_count_) {
+    *error = DiffError::kReset;
+    return {};
+  }
+  if (diff->exceeds_ < other.exceeds_) {
+    *error = DiffError::kNotEarlier;
+    return {};
+  }
+
+  hdr_histogram* target = diff->histogram_.get();
+  const hdr_histogram* source = other.histogram_.get();
+  for (int32_t i = 0; i < target->counts_len; i++) {
+    if (target->counts[i] < source->counts[i]) {
+      *error = DiffError::kNotEarlier;
+      return {};
+    }
+    target->counts[i] -= source->counts[i];
+  }
+  diff->exceeds_ -= other.exceeds_;
+  hdr_reset_internal_counters(target);
+  *error = DiffError::kNone;
+  return diff;
+}
+
 void Histogram::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackFieldWithSize("histogram", GetMemorySize());
   tracker->TrackFieldWithSize("qrde_snapshot",
@@ -158,16 +262,7 @@ Histogram::RecordedSnapshotSource Histogram::GetRecordedSnapshotSource(
     return source;
   }
 
-  CHECK_EQ(source.histogram->counts_len, histogram_->counts_len);
-  source.histogram->min_value = histogram_->min_value;
-  source.histogram->max_value = histogram_->max_value;
-  source.histogram->normalizing_index_offset =
-      histogram_->normalizing_index_offset;
-  source.histogram->conversion_ratio = histogram_->conversion_ratio;
-  source.histogram->total_count = histogram_->total_count;
-  std::memcpy(source.histogram->counts,
-              histogram_->counts,
-              histogram_->counts_len * sizeof(*histogram_->counts));
+  CopyRecordedData(source.histogram.get(), histogram_.get());
   return source;
 }
 
@@ -277,6 +372,7 @@ double Histogram::Subtract(const Histogram& other) {
     }
     hdr_reset_internal_counters(histogram_.get());
     InvalidateRecordedSnapshot();
+    reset_count_++;
     exceeds_ = (exceeds_ > other.exceeds_) ? exceeds_ - other.exceeds_ : 0;
     return static_cast<double>(dropped);
   };
@@ -1807,6 +1903,9 @@ void HistogramImpl::AddMethods(Isolate* isolate, Local<FunctionTemplate> tmpl) {
                             GetEwmaErrorRate,
                             &fast_get_ewma_error_rate_);
   SetProtoMethodNoSideEffect(isolate, tmpl, "export", DoExport);
+  SetProtoMethodNoSideEffect(isolate, tmpl, "snapshot", DoSnapshot);
+  SetProtoMethodNoSideEffect(isolate, tmpl, "diff", DoDiff);
+  SetProtoMethodNoSideEffect(isolate, tmpl, "resetCount", GetResetCount);
   SetFastMethod(isolate, instance, "reset", DoReset, &fast_reset_);
 }
 
@@ -1856,6 +1955,9 @@ void HistogramImpl::RegisterExternalReferences(
   registry->Register(GetEwmaStddev);
   registry->Register(GetEwmaErrorRate);
   registry->Register(DoExport);
+  registry->Register(DoSnapshot);
+  registry->Register(DoDiff);
+  registry->Register(GetResetCount);
   registry->Register(fast_get_ewma_mean_);
   registry->Register(fast_get_ewma_stddev_);
   registry->Register(fast_get_ewma_error_rate_);
@@ -1875,6 +1977,7 @@ HistogramBase::HistogramBase(Environment* env,
       HistogramImpl::InternalFields::kImplField,
       static_cast<HistogramImpl*>(this),
       EmbedderDataTag::kDefault);
+  ReportExternalMemory();
 }
 
 HistogramBase::HistogramBase(Environment* env,
@@ -1886,6 +1989,21 @@ HistogramBase::HistogramBase(Environment* env,
       HistogramImpl::InternalFields::kImplField,
       static_cast<HistogramImpl*>(this),
       EmbedderDataTag::kDefault);
+  ReportExternalMemory();
+}
+
+HistogramBase::~HistogramBase() {
+  env()->external_memory_accounter()->Decrease(env()->isolate(),
+                                               external_memory_);
+}
+
+// Reports the size of the native histogram to V8 so that the garbage
+// collector accounts for it. Every object that refers to a native histogram
+// reports its full size, including objects that share one after cloning.
+void HistogramBase::ReportExternalMemory() {
+  external_memory_ = histogram()->GetMemorySize();
+  env()->external_memory_accounter()->Increase(env()->isolate(),
+                                               external_memory_);
 }
 
 void HistogramBase::MemoryInfo(MemoryTracker* tracker) const {
@@ -2989,6 +3107,50 @@ void HistogramImpl::DoImport(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(obj);
 }
 
+void HistogramImpl::DoSnapshot(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  HistogramImpl* histogram = HistogramImpl::FromJSObject(args.This());
+  std::shared_ptr<Histogram> snapshot = (*histogram)->Clone();
+  if (!snapshot) return THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
+
+  BaseObjectPtr<HistogramBase> result =
+      HistogramBase::Create(env, std::move(snapshot));
+  if (result) args.GetReturnValue().Set(result->object());
+}
+
+void HistogramImpl::DoDiff(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  HistogramImpl* histogram = HistogramImpl::FromJSObject(args.This());
+  HistogramImpl* other = HistogramImpl::FromJSObject(args[0]);
+  Histogram::DiffError error;
+  std::shared_ptr<Histogram> diff =
+      (*histogram)->Diff(*(other->histogram()), &error);
+  switch (error) {
+    case Histogram::DiffError::kNone:
+      break;
+    case Histogram::DiffError::kOutOfMemory:
+      return THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
+    case Histogram::DiffError::kIncompatible:
+      return THROW_ERR_INVALID_ARG_VALUE(
+          env, "other must have the same configuration as the histogram");
+    case Histogram::DiffError::kReset:
+      return THROW_ERR_INVALID_STATE(
+          env, "Values were removed from the histogram after other was taken");
+    case Histogram::DiffError::kNotEarlier:
+      return THROW_ERR_INVALID_ARG_VALUE(
+          env, "other contains values that are not in the histogram");
+  }
+
+  BaseObjectPtr<HistogramBase> result =
+      HistogramBase::Create(env, std::move(diff));
+  if (result) args.GetReturnValue().Set(result->object());
+}
+
+void HistogramImpl::GetResetCount(const FunctionCallbackInfo<Value>& args) {
+  HistogramImpl* histogram = HistogramImpl::FromJSObject(args.This());
+  args.GetReturnValue().Set(static_cast<double>((*histogram)->ResetCount()));
+}
+
 void HistogramImpl::GetPercentilesAt(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   HistogramImpl* histogram = HistogramImpl::FromJSObject(args.This());
diff --git a/src/histogram.h b/src/histogram.h
index bc72fa36e104..93fe2b267d46 100644
--- a/src/histogram.h
+++ b/src/histogram.h
@@ -61,6 +61,27 @@ class Histogram : public MemoryRetainer {
   // Factory method that returns nullptr on hdr_init failure.
   static std::shared_ptr<Histogram> Create(const Options& options);
 
+  // Returns an independent copy of this histogram's current state, or nullptr
+  // if the copy cannot be allocated.
+  std::shared_ptr<Histogram> Clone() const;
+
+  enum class DiffError {
+    kNone,
+    kOutOfMemory,
+    // `other` has a different layout.
+    kIncompatible,
+    // Values were removed from this histogram after `other` was taken.
+    kReset,
+    // `other` contains values that this histogram does not.
+    kNotEarlier,
+  };
+
+  // Returns a new histogram containing the values recorded in this histogram
+  // after `other`, an earlier copy of it, was taken. Returns nullptr and sets
+  // `error` if the difference cannot be computed.
+  std::shared_ptr<Histogram> Diff(const Histogram& other,
+                                  DiffError* error) const;
+
   Histogram(HistogramPointer histogram, const Options& options);
   virtual ~Histogram() = default;
 
@@ -76,6 +97,7 @@ class Histogram : public MemoryRetainer {
   inline int64_t Percentile(double percentile) const;
   inline size_t Exceeds() const;
   inline size_t Count() const;
+  inline uint64_t ResetCount() const;
 
   inline uint64_t RecordDelta();
 
@@ -161,10 +183,13 @@ class Histogram : public MemoryRetainer {
   inline void UpdateEwma(double value);
   inline void InvalidateRecordedSnapshot();
   size_t GetCachedRecordedSnapshotMemorySize() const;
+  std::shared_ptr<Histogram> CreateWithSameLayout() const;
 
   HistogramPointer histogram_;
   uint64_t prev_ = 0;
   size_t exceeds_ = 0;
+  // Incremented whenever recorded values are removed by Reset() or Subtract().
+  uint64_t reset_count_ = 0;
 
   // EWMA state (active when ewma_alpha_ > 0)
   double ewma_alpha_ = 0;
@@ -237,6 +262,9 @@ class HistogramImpl {
   static void GetEwmaErrorRate(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoExport(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoImport(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoDiff(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetResetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void FastReset(v8::Local<v8::Value> receiver);
   static double FastGetCount(v8::Local<v8::Value> receiver);
@@ -329,6 +357,8 @@ class HistogramBase final : public BaseObject, public HistogramImpl {
       v8::Local<v8::Object> wrap,
       std::shared_ptr<Histogram> histogram);
 
+  ~HistogramBase() override;
+
   BaseObject::TransferMode GetTransferMode() const override {
     return TransferMode::kCloneable;
   }
@@ -356,6 +386,11 @@ class HistogramBase final : public BaseObject, public HistogramImpl {
   };
 
  private:
+  void ReportExternalMemory();
+
+  // The native memory reported to V8 while this object is alive.
+  size_t external_memory_ = 0;
+
   static v8::CFunction fast_record_;
   static v8::CFunction fast_record_delta_;
 };
diff --git a/test/parallel/test-perf-hooks-histogram-diff.js b/test/parallel/test-perf-hooks-histogram-diff.js
new file mode 100644
index 000000000000..45dc375d2d69
--- /dev/null
+++ b/test/parallel/test-perf-hooks-histogram-diff.js
@@ -0,0 +1,169 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { setTimeout: delay } = require('timers/promises');
+const {
+  createHistogram,
+  createSlidingWindowHistogram,
+  importHistogram,
+  monitorEventLoopDelay,
+} = require('perf_hooks');
+
+{
+  const histogram = createHistogram({ highest: 1000, halfLife: 4, threshold: 50 });
+  for (let i = 1; i <= 10; i++) histogram.record(i);
+  histogram.record(2000);
+  const previous = histogram.snapshot();
+  for (let i = 101; i <= 120; i++) histogram.record(i);
+  histogram.record(3000);
+  histogram.record(4000);
+  const current = histogram.snapshot();
+  const exportedPrevious = previous.export();
+  const exportedCurrent = current.export();
+
+  const delta = current.diff(previous);
+  assert.strictEqual(delta.constructor.name, 'Histogram');
+  assert.strictEqual(delta.record, undefined);
+  assert.strictEqual(delta.count, 20);
+  assert.strictEqual(delta.exceeds, 2);
+  assert.strictEqual(delta.min, 101);
+  assert.strictEqual(delta.max, 120);
+  assert.strictEqual(delta.resetCount, 0);
+
+  // The difference has the same distribution as a histogram of the values
+  // recorded between the snapshots, and no EWMA state.
+  const expected = createHistogram({ highest: 1000 });
+  for (let i = 101; i <= 120; i++) expected.record(i);
+  assert.deepStrictEqual(delta.percentiles, expected.percentiles);
+  assert.strictEqual(delta.ewmaMean, 0);
+  assert.strictEqual(delta.ewmaStddev, 0);
+  assert.strictEqual(delta.ewmaErrorRate, 0);
+
+  // Neither histogram is changed.
+  assert.deepStrictEqual(previous.export(), exportedPrevious);
+  assert.deepStrictEqual(current.export(), exportedCurrent);
+
+  assert.strictEqual(histogram.diff(previous).count, 20);
+  assert.strictEqual(histogram.diff(histogram).count, 0);
+  assert.strictEqual(current.diff(current).count, 0);
+
+  // Reversed arguments.
+  assert.throws(() => previous.diff(current), {
+    code: 'ERR_INVALID_ARG_VALUE',
+  });
+}
+
+{
+  // Consumers with different intervals each keep their own previous snapshot.
+  const histogram = createHistogram();
+  const consumers = [3, 10].map((interval) => ({
+    interval,
+    previous: histogram.snapshot(),
+    pending: 0,
+    total: 0,
+  }));
+  for (let i = 1; i <= 100; i++) {
+    histogram.record(i);
+    for (const consumer of consumers) {
+      consumer.pending++;
+      if (i % consumer.interval !== 0) continue;
+      const current = histogram.snapshot();
+      const delta = current.diff(consumer.previous);
+      assert.strictEqual(delta.count, consumer.pending);
+      assert.strictEqual(delta.min, i - consumer.pending + 1);
+      assert.strictEqual(delta.max, i);
+      consumer.total += delta.count;
+      consumer.previous = current;
+      consumer.pending = 0;
+    }
+  }
+  assert.strictEqual(consumers[0].total, 99);
+  assert.strictEqual(consumers[1].total, 100);
+}
+
+{
+  const histogram = createHistogram();
+  assert.strictEqual(histogram.resetCount, 0);
+  histogram.record(1);
+  histogram.recordCorrected(100, 10);
+  histogram.add(createHistogram());
+  assert.strictEqual(histogram.resetCount, 0);
+
+  histogram.reset();
+  assert.strictEqual(histogram.resetCount, 1);
+  histogram.record(1);
+  const previous = histogram.snapshot();
+  histogram.reset();
+  assert.strictEqual(histogram.resetCount, 2);
+  assert.strictEqual(previous.resetCount, 1);
+
+  // A reset is detected even when every count has grown past its previous
+  // value since.
+  for (let i = 0; i < 10; i++) histogram.record(1);
+  assert.throws(() => histogram.diff(previous), {
+    code: 'ERR_INVALID_STATE',
+  });
+
+  // subtract() also removes values. Subtracting an empty histogram leaves
+  // every count unchanged.
+  const snapshot = histogram.snapshot();
+  assert.strictEqual(snapshot.resetCount, 2);
+  histogram.subtract(createHistogram());
+  assert.strictEqual(histogram.resetCount, 3);
+  assert.throws(() => histogram.diff(snapshot), {
+    code: 'ERR_INVALID_STATE',
+  });
+}
+
+{
+  const histogram = createHistogram();
+  for (const options of [{ lowest: 2 }, { highest: 1000 }, { figures: 2 }]) {
+    assert.throws(() => histogram.diff(createHistogram(options)), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  }
+
+  // Histograms with a different normalizing index offset map values to
+  // different indexes.
+  const data = createHistogram().export();
+  const offset = Buffer.from(data).indexOf(Buffer.from([0x06, 0x00, 0x07, 0x00]));
+  assert.notStrictEqual(offset, -1);
+  data[offset + 3] = 1;
+  assert.throws(() => histogram.diff(importHistogram(data)), {
+    code: 'ERR_INVALID_ARG_VALUE',
+  });
+
+  assert.throws(() => histogram.diff.call({}, histogram), {
+    code: 'ERR_INVALID_THIS',
+  });
+  const { get } = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(histogram.snapshot()), 'resetCount');
+  assert.throws(() => get.call({}), { code: 'ERR_INVALID_THIS' });
+  const window = createSlidingWindowHistogram({ chunks: 1, recordsPerChunk: 1 });
+  for (const other of [undefined, null, {}, 1, window]) {
+    assert.throws(() => histogram.diff(other), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+  }
+}
+
+(async () => {
+  const histogram = monitorEventLoopDelay({ samplePerIteration: true });
+  histogram.enable();
+  while (histogram.count < 2) await delay(1);
+  const previous = histogram.snapshot();
+  while (histogram.count < previous.count + 3) await delay(1);
+
+  // Samples are only recorded while the event loop is running.
+  const current = histogram.snapshot();
+  assert.strictEqual(current.diff(previous).count,
+                     current.count - previous.count);
+
+  histogram.disable();
+  histogram.reset();
+  assert.strictEqual(histogram.resetCount, 1);
+  assert.throws(() => histogram.diff(previous), {
+    code: 'ERR_INVALID_STATE',
+  });
+})().then(common.mustCall());
diff --git a/test/parallel/test-perf-hooks-histogram-external-memory.js b/test/parallel/test-perf-hooks-histogram-external-memory.js
new file mode 100644
index 000000000000..0cca4a7a8036
--- /dev/null
+++ b/test/parallel/test-perf-hooks-histogram-external-memory.js
@@ -0,0 +1,38 @@
+'use strict';
+
+// Tests that histogram objects report the memory of their native histogram to
+// V8, so that creating many short-lived histograms triggers garbage
+// collection.
+
+const common = require('../common');
+const assert = require('assert');
+const { setImmediate: setImmediatePromise } = require('timers/promises');
+const {
+  PerformanceObserver,
+  constants: { NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY },
+  createHistogram,
+} = require('perf_hooks');
+
+let externalMemoryGCs = 0;
+const observer = new PerformanceObserver((list) => {
+  for (const entry of list.getEntries()) {
+    if (entry.detail.flags & NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY)
+      externalMemoryGCs++;
+  }
+});
+observer.observe({ entryTypes: ['gc'] });
+
+// With the default options, a histogram holds 45,056 64-bit counts, about
+// 352 KiB. V8 starts a garbage collection once external memory has grown by
+// 64 MiB, so 400 unreferenced snapshots (about 137 MiB) must trigger one.
+const histogram = createHistogram();
+for (let i = 0; i < 400; i++) histogram.snapshot();
+
+(async () => {
+  // Performance entries for garbage collections are delivered asynchronously.
+  for (let i = 0; i < 10 && externalMemoryGCs === 0; i++)
+    await setImmediatePromise();
+  observer.disconnect();
+  assert.ok(externalMemoryGCs > 0,
+            'Expected a garbage collection caused by external memory');
+})().then(common.mustCall());
diff --git a/test/parallel/test-perf-hooks-histogram-snapshot.js b/test/parallel/test-perf-hooks-histogram-snapshot.js
new file mode 100644
index 000000000000..ab554373bbc5
--- /dev/null
+++ b/test/parallel/test-perf-hooks-histogram-snapshot.js
@@ -0,0 +1,138 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { setTimeout: delay } = require('timers/promises');
+const { inspect } = require('util');
+const {
+  createHistogram,
+  monitorEventLoopDelay,
+} = require('perf_hooks');
+
+function assertSameState(actual, expected) {
+  assert.strictEqual(actual.countBigInt, expected.countBigInt);
+  assert.strictEqual(actual.minBigInt, expected.minBigInt);
+  assert.strictEqual(actual.maxBigInt, expected.maxBigInt);
+  assert.strictEqual(actual.exceedsBigInt, expected.exceedsBigInt);
+  assert.strictEqual(actual.mean, expected.mean);
+  assert.strictEqual(actual.stddev, expected.stddev);
+  assert.strictEqual(actual.ewmaMean, expected.ewmaMean);
+  assert.strictEqual(actual.ewmaStddev, expected.ewmaStddev);
+  assert.strictEqual(actual.ewmaErrorRate, expected.ewmaErrorRate);
+  assert.deepStrictEqual(actual.percentilesBigInt, expected.percentilesBigInt);
+  // The export format also covers the layout, the raw min and max values,
+  // every bucket count, and the EWMA configuration.
+  assert.deepStrictEqual(actual.export(), expected.export());
+}
+
+function assertReadOnly(snapshot) {
+  assert.strictEqual(snapshot.constructor.name, 'Histogram');
+  assert.strictEqual(inspect(snapshot, { depth: -1 }), '[Histogram]');
+  for (const name of [
+    'record',
+    'recordDelta',
+    'recordCorrected',
+    'add',
+    'subtract',
+    'enable',
+    'disable',
+  ]) {
+    assert.strictEqual(snapshot[name], undefined);
+  }
+}
+
+{
+  const histogram = createHistogram({
+    lowest: 1,
+    highest: 1000,
+    figures: 2,
+    halfLife: 8,
+    threshold: 50,
+  });
+  for (let i = 1; i <= 100; i++) histogram.record(i * 7);
+  histogram.record(1e6);
+  assert.strictEqual(histogram.exceeds, 1);
+  assert.ok(histogram.ewmaErrorRate > 0);
+
+  const snapshot = histogram.snapshot();
+  assert.notStrictEqual(snapshot, histogram);
+  assertReadOnly(snapshot);
+  assertSameState(snapshot, histogram);
+  assert.strictEqual(histogram.ksTest(snapshot), 0);
+
+  // A snapshot can be snapshotted and cloned.
+  const nested = snapshot.snapshot();
+  assertReadOnly(nested);
+  assertSameState(nested, snapshot);
+  assertSameState(structuredClone(snapshot), snapshot);
+
+  // Changes to the source histogram do not change the snapshot.
+  const exported = snapshot.export();
+  histogram.record(3);
+  histogram.recordCorrected(900, 100);
+  histogram.record(1e6);
+  assert.deepStrictEqual(snapshot.export(), exported);
+  assert.strictEqual(snapshot.count, 100);
+  assert.strictEqual(snapshot.exceeds, 1);
+
+  histogram.reset();
+  assert.strictEqual(histogram.count, 0);
+  assert.deepStrictEqual(snapshot.export(), exported);
+
+  // Resetting a snapshot does not change the source histogram or other
+  // snapshots.
+  histogram.record(5);
+  const current = histogram.snapshot();
+  snapshot.reset();
+  assert.strictEqual(snapshot.count, 0);
+  assert.strictEqual(histogram.count, 1);
+  assert.strictEqual(current.count, 1);
+  assert.deepStrictEqual(nested.export(), exported);
+}
+
+{
+  // Empty histograms, with and without EWMA state.
+  for (const options of [undefined, { halfLife: 10, threshold: 1 }]) {
+    const histogram = createHistogram(options);
+    const snapshot = histogram.snapshot();
+    assertReadOnly(snapshot);
+    assert.strictEqual(snapshot.count, 0);
+    assert.strictEqual(snapshot.minBigInt, 9223372036854775807n);
+    assert.strictEqual(snapshot.maxBigInt, 0n);
+    assertSameState(snapshot, histogram);
+  }
+}
+
+{
+  const histogram = createHistogram();
+  assert.throws(() => histogram.snapshot.call({}), {
+    code: 'ERR_INVALID_THIS',
+  });
+}
+
+async function testEventLoopDelay(options) {
+  const histogram = monitorEventLoopDelay(options);
+  histogram.enable();
+  while (histogram.count < 3) await delay(1);
+
+  // Samples are only recorded while the event loop is running, so none can
+  // be added while this code runs synchronously.
+  const snapshot = histogram.snapshot();
+  assertReadOnly(snapshot);
+  assertSameState(snapshot, histogram);
+
+  const exported = snapshot.export();
+  const count = histogram.count;
+  while (histogram.count === count) await delay(1);
+  assert.deepStrictEqual(snapshot.export(), exported);
+
+  histogram.disable();
+  histogram.reset();
+  assert.strictEqual(histogram.count, 0);
+  assert.deepStrictEqual(snapshot.export(), exported);
+}
+
+(async () => {
+  await testEventLoopDelay({ resolution: 1 });
+  await testEventLoopDelay({ samplePerIteration: true });
+})().then(common.mustCall());
diff --git a/typings/internalBinding/performance.d.ts b/typings/internalBinding/performance.d.ts
index cf3ef0a664f0..dc30eca95310 100644
--- a/typings/internalBinding/performance.d.ts
+++ b/typings/internalBinding/performance.d.ts
@@ -41,6 +41,9 @@ declare namespace InternalPerformanceBinding {
     ewmaMean(): number;
     ewmaStddev(): number;
     ewmaErrorRate(): number;
+    snapshot(): Histogram;
+    diff(other: HistogramBase): Histogram;
+    resetCount(): number;
   }
 
   interface ELDHistogram extends HistogramBase {