diff --git a/doc/api/v8.md b/doc/api/v8.md
index 7ee7a748674cae..a3fa7889dc8291 100644
--- a/doc/api/v8.md
+++ b/doc/api/v8.md
@@ -1617,6 +1617,30 @@ added:
 
 Stopping collecting the profile and the profile will be discarded.
 
+## Class: `SyncHeapProfileHandle`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+### `syncHeapProfileHandle.stop()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {string}
+
+Stopping collecting the profile and return the profile data.
+
+### `syncHeapProfileHandle[Symbol.dispose]()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Stopping collecting the profile and the profile will be discarded.
+
 ## Class: `CPUProfileHandle`
 
 <!-- YAML
@@ -1764,6 +1788,72 @@ const profile = handle.stop();
 console.log(profile);
 ```
 
+## `v8.startHeapProfile([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `options` {Object}
+  * `sampleInterval` {number} The average sampling interval in bytes.
+    **Default:** `524288` (512 KiB).
+  * `stackDepth` {integer} The maximum stack depth for samples.
+    **Default:** `16`.
+  * `forceGC` {boolean} Force garbage collection before taking the profile.
+    **Default:** `false`.
+  * `includeObjectsCollectedByMajorGC` {boolean} Include objects collected
+    by major GC. **Default:** `false`.
+  * `includeObjectsCollectedByMinorGC` {boolean} Include objects collected
+    by minor GC. **Default:** `false`.
+* Returns: {SyncHeapProfileHandle}
+
+Starting a heap profile then return a `SyncHeapProfileHandle` object.
+This API supports `using` syntax.
+
+```cjs
+const v8 = require('node:v8');
+
+const handle = v8.startHeapProfile();
+const profile = handle.stop();
+console.log(profile);
+```
+
+```mjs
+import v8 from 'node:v8';
+
+const handle = v8.startHeapProfile();
+const profile = handle.stop();
+console.log(profile);
+```
+
+With custom parameters:
+
+```cjs
+const v8 = require('node:v8');
+
+const handle = v8.startHeapProfile({
+  sampleInterval: 1024,
+  stackDepth: 8,
+  forceGC: true,
+  includeObjectsCollectedByMajorGC: true,
+});
+const profile = handle.stop();
+console.log(profile);
+```
+
+```mjs
+import v8 from 'node:v8';
+
+const handle = v8.startHeapProfile({
+  sampleInterval: 1024,
+  stackDepth: 8,
+  forceGC: true,
+  includeObjectsCollectedByMajorGC: true,
+});
+const profile = handle.stop();
+console.log(profile);
+```
+
 [CppHeap]: https://v8docs.nodesource.com/node-22.4/d9/dc4/classv8_1_1_cpp_heap.html
 [HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
 [Hook Callbacks]: #hook-callbacks
diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 32024e972932cd..6fee0d8368a914 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -2005,7 +2005,7 @@ w.on('online', async () => {
 });
 ```
 
-### `worker.startHeapProfile()`
+### `worker.startHeapProfile([options])`
 
 <!-- YAML
 added:
@@ -2013,6 +2013,17 @@ added:
   - v22.20.0
 -->
 
+* `options` {Object}
+  * `sampleInterval` {number} The average sampling interval in bytes.
+    **Default:** `524288` (512 KiB).
+  * `stackDepth` {integer} The maximum stack depth for samples.
+    **Default:** `16`.
+  * `forceGC` {boolean} Force garbage collection before taking the profile.
+    **Default:** `false`.
+  * `includeObjectsCollectedByMajorGC` {boolean} Include objects collected
+    by major GC. **Default:** `false`.
+  * `includeObjectsCollectedByMinorGC` {boolean} Include objects collected
+    by minor GC. **Default:** `false`.
 * Returns: {Promise}
 
 Starting a Heap profile then return a Promise that fulfills with an error
@@ -2034,6 +2045,22 @@ worker.on('online', async () => {
 });
 ```
 
+```mjs
+import { Worker } from 'node:worker_threads';
+
+const worker = new Worker(`
+  const { parentPort } = require('node:worker_threads');
+  parentPort.on('message', () => {});
+  `, { eval: true });
+
+worker.on('online', async () => {
+  const handle = await worker.startHeapProfile();
+  const profile = await handle.stop();
+  console.log(profile);
+  worker.terminate();
+});
+```
+
 `await using` example.
 
 ```cjs
@@ -2050,6 +2077,20 @@ w.on('online', async () => {
 });
 ```
 
+```mjs
+import { Worker } from 'node:worker_threads';
+
+const w = new Worker(`
+  const { parentPort } = require('node:worker_threads');
+  parentPort.on('message', () => {});
+  `, { eval: true });
+
+w.on('online', async () => {
+  // Stop profile automatically when return and profile will be discarded
+  await using handle = await w.startHeapProfile();
+});
+```
+
 ### `worker.stderr`
 
 <!-- YAML
diff --git a/lib/internal/v8/heap_profile.js b/lib/internal/v8/heap_profile.js
new file mode 100644
index 00000000000000..ea4679b6c05704
--- /dev/null
+++ b/lib/internal/v8/heap_profile.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const {
+  validateBoolean,
+  validateInteger,
+  validateInt32,
+  validateObject,
+} = require('internal/validators');
+
+const {
+  kSamplingNoFlags,
+  kSamplingForceGC,
+  kSamplingIncludeObjectsCollectedByMajorGC,
+  kSamplingIncludeObjectsCollectedByMinorGC,
+} = internalBinding('v8');
+
+function normalizeHeapProfileOptions(options = {}) {
+  validateObject(options, 'options');
+  const {
+    sampleInterval = 512 * 1024,
+    stackDepth = 16,
+    forceGC = false,
+    includeObjectsCollectedByMajorGC = false,
+    includeObjectsCollectedByMinorGC = false,
+  } = options;
+
+  validateInteger(sampleInterval, 'options.sampleInterval', 1);
+  validateInt32(stackDepth, 'options.stackDepth', 0);
+  validateBoolean(forceGC, 'options.forceGC');
+  validateBoolean(includeObjectsCollectedByMajorGC,
+                  'options.includeObjectsCollectedByMajorGC');
+  validateBoolean(includeObjectsCollectedByMinorGC,
+                  'options.includeObjectsCollectedByMinorGC');
+
+  let flags = kSamplingNoFlags;
+  if (forceGC) flags |= kSamplingForceGC;
+  if (includeObjectsCollectedByMajorGC) {
+    flags |= kSamplingIncludeObjectsCollectedByMajorGC;
+  }
+  if (includeObjectsCollectedByMinorGC) {
+    flags |= kSamplingIncludeObjectsCollectedByMinorGC;
+  }
+
+  return { sampleInterval, stackDepth, flags };
+}
+
+module.exports = {
+  normalizeHeapProfileOptions,
+};
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 2a4caed82cf7c5..0b0d91171f0ba5 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -65,7 +65,13 @@ const {
   constructSharedArrayBuffer,
   kEmptyObject,
 } = require('internal/util');
-const { validateArray, validateString, validateObject, validateNumber } = require('internal/validators');
+const {
+  validateArray,
+  validateString,
+  validateObject,
+  validateNumber,
+} = require('internal/validators');
+let normalizeHeapProfileOptions;
 const {
   throwIfBuildingSnapshot,
 } = require('internal/v8/startup_snapshot');
@@ -582,8 +588,22 @@ class Worker extends EventEmitter {
     });
   }
 
-  startHeapProfile() {
-    const startTaker = this[kHandle]?.startHeapProfile();
+  /**
+   * @param {object} [options]
+   * @param {number} [options.sampleInterval]
+   * @param {number} [options.stackDepth]
+   * @param {boolean} [options.forceGC]
+   * @param {boolean} [options.includeObjectsCollectedByMajorGC]
+   * @param {boolean} [options.includeObjectsCollectedByMinorGC]
+   * @returns {Promise}
+   */
+  startHeapProfile(options) {
+    normalizeHeapProfileOptions ??=
+      require('internal/v8/heap_profile').normalizeHeapProfileOptions;
+    const { sampleInterval, stackDepth, flags } =
+      normalizeHeapProfileOptions(options);
+    const startTaker = this[kHandle]?.startHeapProfile(
+      sampleInterval, stackDepth, flags);
     return new Promise((resolve, reject) => {
       if (!startTaker) return reject(new ERR_WORKER_NOT_RUNNING());
       startTaker.ondone = (err) => {
diff --git a/lib/v8.js b/lib/v8.js
index c0d4074aac21d5..4bea3a9f1d3fbb 100644
--- a/lib/v8.js
+++ b/lib/v8.js
@@ -40,8 +40,8 @@ const {
 const { Buffer } = require('buffer');
 const {
   validateString,
-  validateUint32,
   validateOneOf,
+  validateUint32,
 } = require('internal/validators');
 const {
   Serializer,
@@ -50,6 +50,9 @@ const {
 const {
   namespace: startupSnapshot,
 } = require('internal/v8/startup_snapshot');
+const {
+  normalizeHeapProfileOptions,
+} = require('internal/v8/heap_profile');
 
 let profiler = {};
 if (internalBinding('config').hasInspector) {
@@ -115,6 +118,8 @@ const {
   setFlagsFromString: _setFlagsFromString,
   startCpuProfile: _startCpuProfile,
   stopCpuProfile: _stopCpuProfile,
+  startHeapProfile: _startHeapProfile,
+  stopHeapProfile: _stopHeapProfile,
   isStringOneByteRepresentation: _isStringOneByteRepresentation,
   updateHeapStatisticsBuffer,
   updateHeapSpaceStatisticsBuffer,
@@ -191,6 +196,22 @@ class SyncCPUProfileHandle {
   }
 }
 
+class SyncHeapProfileHandle {
+  #stopped = false;
+
+  stop() {
+    if (this.#stopped) {
+      return;
+    }
+    this.#stopped = true;
+    return _stopHeapProfile();
+  };
+
+  [SymbolDispose]() {
+    this.stop();
+  }
+}
+
 /**
  * Starting CPU Profile.
  * @returns {SyncCPUProfileHandle}
@@ -200,6 +221,23 @@ function startCpuProfile() {
   return new SyncCPUProfileHandle(id);
 }
 
+/**
+ * Starting Heap Profile.
+ * @param {object} [options]
+ * @param {number} [options.sampleInterval]
+ * @param {number} [options.stackDepth]
+ * @param {boolean} [options.forceGC]
+ * @param {boolean} [options.includeObjectsCollectedByMajorGC]
+ * @param {boolean} [options.includeObjectsCollectedByMinorGC]
+ * @returns {SyncHeapProfileHandle}
+ */
+function startHeapProfile(options) {
+  const { sampleInterval, stackDepth, flags } =
+    normalizeHeapProfileOptions(options);
+  _startHeapProfile(sampleInterval, stackDepth, flags);
+  return new SyncHeapProfileHandle();
+}
+
 /**
  * Return whether this string uses one byte as underlying representation or not.
  * @param {string} content
@@ -518,4 +556,5 @@ module.exports = {
   GCProfiler,
   isStringOneByteRepresentation,
   startCpuProfile,
+  startHeapProfile,
 };
diff --git a/src/node_v8.cc b/src/node_v8.cc
index 12972f83ea0f61..059892f772b4a0 100644
--- a/src/node_v8.cc
+++ b/src/node_v8.cc
@@ -280,6 +280,33 @@ void StopCpuProfile(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+void StartHeapProfile(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  auto options = ParseHeapProfileOptions(args);
+
+  if (isolate->GetHeapProfiler()->StartSamplingHeapProfiler(
+          options.sample_interval, options.stack_depth, options.flags)) {
+    return;
+  }
+  THROW_ERR_HEAP_PROFILE_HAVE_BEEN_STARTED(isolate,
+                                           "Heap profile has been started");
+}
+
+void StopHeapProfile(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+  std::ostringstream out_stream;
+  bool success = node::SerializeHeapProfile(isolate, out_stream);
+  if (success) {
+    Local<Value> result;
+    if (ToV8Value(env->context(), out_stream.str(), isolate).ToLocal(&result)) {
+      args.GetReturnValue().Set(result);
+    }
+  } else {
+    THROW_ERR_HEAP_PROFILE_NOT_STARTED(isolate, "heap profile not started");
+  }
+}
+
 static void IsStringOneByteRepresentation(
     const FunctionCallbackInfo<Value>& args) {
   CHECK_EQ(args.Length(), 1);
@@ -740,6 +767,44 @@ void Initialize(Local<Object> target,
 
   SetMethod(context, target, "startCpuProfile", StartCpuProfile);
   SetMethod(context, target, "stopCpuProfile", StopCpuProfile);
+  SetMethod(context, target, "startHeapProfile", StartHeapProfile);
+  SetMethod(context, target, "stopHeapProfile", StopHeapProfile);
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "kSamplingNoFlags"),
+            Uint32::NewFromUnsigned(
+                env->isolate(),
+                static_cast<uint32_t>(
+                    v8::HeapProfiler::SamplingFlags::kSamplingNoFlags)))
+      .Check();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "kSamplingForceGC"),
+            Uint32::NewFromUnsigned(
+                env->isolate(),
+                static_cast<uint32_t>(
+                    v8::HeapProfiler::SamplingFlags::kSamplingForceGC)))
+      .Check();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(),
+                                  "kSamplingIncludeObjectsCollectedByMajorGC"),
+            Uint32::NewFromUnsigned(
+                env->isolate(),
+                static_cast<uint32_t>(
+                    v8::HeapProfiler::SamplingFlags::
+                        kSamplingIncludeObjectsCollectedByMajorGC)))
+      .Check();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(),
+                                  "kSamplingIncludeObjectsCollectedByMinorGC"),
+            Uint32::NewFromUnsigned(
+                env->isolate(),
+                static_cast<uint32_t>(
+                    v8::HeapProfiler::SamplingFlags::
+                        kSamplingIncludeObjectsCollectedByMinorGC)))
+      .Check();
 
   // Export symbols used by v8.isStringOneByteRepresentation()
   SetFastMethodNoSideEffect(context,
@@ -787,6 +852,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(fast_is_string_one_byte_representation_);
   registry->Register(StartCpuProfile);
   registry->Register(StopCpuProfile);
+  registry->Register(StartHeapProfile);
+  registry->Register(StopHeapProfile);
 }
 
 }  // namespace v8_utils
diff --git a/src/node_worker.cc b/src/node_worker.cc
index c8fb93c9313aca..d49b278b19031d 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -20,7 +20,6 @@
 
 using node::kAllowedInEnvvar;
 using node::kDisallowedInEnvvar;
-using v8::AllocationProfile;
 using v8::Array;
 using v8::ArrayBuffer;
 using v8::Boolean;
@@ -33,7 +32,6 @@ using v8::Float64Array;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
-using v8::HeapProfiler;
 using v8::HeapStatistics;
 using v8::Integer;
 using v8::Isolate;
@@ -1046,6 +1044,7 @@ void Worker::StartHeapProfile(const FunctionCallbackInfo<Value>& args) {
   Worker* w;
   ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
   Environment* env = w->env();
+  auto options = ParseHeapProfileOptions(args);
 
   AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
   Local<Object> wrap;
@@ -1058,10 +1057,11 @@ void Worker::StartHeapProfile(const FunctionCallbackInfo<Value>& args) {
   BaseObjectPtr<WorkerHeapProfileTaker> taker =
       MakeDetachedBaseObject<WorkerHeapProfileTaker>(env, wrap);
 
-  bool scheduled = w->RequestInterrupt([taker = std::move(taker),
-                                        env](Environment* worker_env) mutable {
+  bool scheduled = w->RequestInterrupt([taker = std::move(taker), env, options](
+                                           Environment* worker_env) mutable {
     v8::HeapProfiler* profiler = worker_env->isolate()->GetHeapProfiler();
-    bool success = profiler->StartSamplingHeapProfiler();
+    bool success = profiler->StartSamplingHeapProfiler(
+        options.sample_interval, options.stack_depth, options.flags);
     env->SetImmediateThreadsafe(
         [taker = std::move(taker),
          success = success](Environment* env) mutable {
@@ -1086,63 +1086,6 @@ void Worker::StartHeapProfile(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
-static void buildHeapProfileNode(Isolate* isolate,
-                                 const AllocationProfile::Node* node,
-                                 JSONWriter* writer) {
-  size_t selfSize = 0;
-  for (const auto& allocation : node->allocations)
-    selfSize += allocation.size * allocation.count;
-
-  writer->json_keyvalue("selfSize", selfSize);
-  writer->json_keyvalue("id", node->node_id);
-  writer->json_objectstart("callFrame");
-  writer->json_keyvalue("scriptId", node->script_id);
-  writer->json_keyvalue("lineNumber", node->line_number - 1);
-  writer->json_keyvalue("columnNumber", node->column_number - 1);
-  node::Utf8Value name(isolate, node->name);
-  node::Utf8Value script_name(isolate, node->script_name);
-  writer->json_keyvalue("functionName", *name);
-  writer->json_keyvalue("url", *script_name);
-  writer->json_objectend();
-
-  writer->json_arraystart("children");
-  for (const auto* child : node->children) {
-    writer->json_start();
-    buildHeapProfileNode(isolate, child, writer);
-    writer->json_end();
-  }
-  writer->json_arrayend();
-}
-
-static bool serializeProfile(Isolate* isolate, std::ostringstream& out_stream) {
-  HandleScope scope(isolate);
-  HeapProfiler* profiler = isolate->GetHeapProfiler();
-  std::unique_ptr<AllocationProfile> profile(profiler->GetAllocationProfile());
-  if (!profile) {
-    return false;
-  }
-  profiler->StopSamplingHeapProfiler();
-  JSONWriter writer(out_stream, true);
-  writer.json_start();
-
-  writer.json_arraystart("samples");
-  for (const auto& sample : profile->GetSamples()) {
-    writer.json_start();
-    writer.json_keyvalue("size", sample.size * sample.count);
-    writer.json_keyvalue("nodeId", sample.node_id);
-    writer.json_keyvalue("ordinal", static_cast<double>(sample.sample_id));
-    writer.json_end();
-  }
-  writer.json_arrayend();
-
-  writer.json_objectstart("head");
-  buildHeapProfileNode(isolate, profile->GetRootNode(), &writer);
-  writer.json_objectend();
-
-  writer.json_end();
-  return true;
-}
-
 void Worker::StopHeapProfile(const FunctionCallbackInfo<Value>& args) {
   Worker* w;
   ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
@@ -1162,7 +1105,8 @@ void Worker::StopHeapProfile(const FunctionCallbackInfo<Value>& args) {
   bool scheduled = w->RequestInterrupt([taker = std::move(taker),
                                         env](Environment* worker_env) mutable {
     std::ostringstream out_stream;
-    bool success = serializeProfile(worker_env->isolate(), out_stream);
+    bool success =
+        node::SerializeHeapProfile(worker_env->isolate(), out_stream);
     env->SetImmediateThreadsafe(
         [taker = std::move(taker),
          out_stream = std::move(out_stream),
diff --git a/src/node_worker.h b/src/node_worker.h
index 3ad318803d8ae0..fd02b1d381edc1 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -8,6 +8,7 @@
 #include "json_utils.h"
 #include "node_exit_code.h"
 #include "node_messaging.h"
+#include "util.h"
 #include "uv.h"
 
 namespace node {
diff --git a/src/util.cc b/src/util.cc
index 1ea51cf7012963..6d08d8e71145a1 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -26,6 +26,7 @@
 
 #include "debug_utils-inl.h"
 #include "env-inl.h"
+#include "json_utils.h"
 #include "node_buffer.h"
 #include "node_errors.h"
 #include "node_internals.h"
@@ -85,10 +86,13 @@ constexpr int kMaximumCopyMode =
 
 namespace node {
 
+using v8::AllocationProfile;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::Context;
 using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::HeapProfiler;
 using v8::Isolate;
 using v8::Local;
 using v8::Object;
@@ -812,4 +816,82 @@ v8::Maybe<int> GetValidFileMode(Environment* env,
   return v8::Just(mode);
 }
 
+static void BuildHeapProfileNode(Isolate* isolate,
+                                 const AllocationProfile::Node* node,
+                                 JSONWriter* writer) {
+  size_t selfSize = 0;
+  for (const auto& allocation : node->allocations)
+    selfSize += allocation.size * allocation.count;
+
+  writer->json_keyvalue("selfSize", selfSize);
+  writer->json_keyvalue("id", node->node_id);
+  writer->json_objectstart("callFrame");
+  writer->json_keyvalue("scriptId", node->script_id);
+  writer->json_keyvalue("lineNumber", node->line_number - 1);
+  writer->json_keyvalue("columnNumber", node->column_number - 1);
+  Utf8Value name(isolate, node->name);
+  Utf8Value script_name(isolate, node->script_name);
+  writer->json_keyvalue("functionName", *name);
+  writer->json_keyvalue("url", *script_name);
+  writer->json_objectend();
+
+  writer->json_arraystart("children");
+  for (const auto* child : node->children) {
+    writer->json_start();
+    BuildHeapProfileNode(isolate, child, writer);
+    writer->json_end();
+  }
+  writer->json_arrayend();
+}
+
+bool SerializeHeapProfile(Isolate* isolate, std::ostringstream& out_stream) {
+  HandleScope scope(isolate);
+  HeapProfiler* profiler = isolate->GetHeapProfiler();
+  std::unique_ptr<AllocationProfile> profile(profiler->GetAllocationProfile());
+  if (!profile) {
+    return false;
+  }
+  profiler->StopSamplingHeapProfiler();
+  JSONWriter writer(out_stream, true);
+  writer.json_start();
+
+  writer.json_arraystart("samples");
+  for (const auto& sample : profile->GetSamples()) {
+    writer.json_start();
+    writer.json_keyvalue("size", sample.size * sample.count);
+    writer.json_keyvalue("nodeId", sample.node_id);
+    writer.json_keyvalue("ordinal", static_cast<double>(sample.sample_id));
+    writer.json_end();
+  }
+  writer.json_arrayend();
+
+  writer.json_objectstart("head");
+  BuildHeapProfileNode(isolate, profile->GetRootNode(), &writer);
+  writer.json_objectend();
+
+  writer.json_end();
+  return true;
+}
+
+HeapProfileOptions ParseHeapProfileOptions(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  HeapProfileOptions options;
+  CHECK_LE(args.Length(), 3);
+  if (args.Length() > 0) {
+    CHECK(args[0]->IsNumber());
+    options.sample_interval =
+        static_cast<uint64_t>(args[0].As<v8::Number>()->Value());
+  }
+  if (args.Length() > 1) {
+    CHECK(args[1]->IsInt32());
+    options.stack_depth = args[1].As<v8::Int32>()->Value();
+  }
+  if (args.Length() > 2) {
+    CHECK(args[2]->IsUint32());
+    options.flags = static_cast<v8::HeapProfiler::SamplingFlags>(
+        args[2].As<v8::Uint32>()->Value());
+  }
+  return options;
+}
+
 }  // namespace node
diff --git a/src/util.h b/src/util.h
index 873a204f9cd794..ac4686c9b2d57b 100644
--- a/src/util.h
+++ b/src/util.h
@@ -1066,6 +1066,17 @@ inline v8::Local<v8::String> Uint32ToString(v8::Local<v8::Context> context,
       ->ToString(context)
       .ToLocalChecked();
 }
+bool SerializeHeapProfile(v8::Isolate* isolate, std::ostringstream& out_stream);
+
+struct HeapProfileOptions {
+  uint64_t sample_interval = 512 * 1024;
+  int stack_depth = 16;
+  v8::HeapProfiler::SamplingFlags flags =
+      v8::HeapProfiler::SamplingFlags::kSamplingNoFlags;
+};
+
+HeapProfileOptions ParseHeapProfileOptions(
+    const v8::FunctionCallbackInfo<v8::Value>& args);
 
 }  // namespace node
 
diff --git a/test/parallel/test-v8-heap-profile.js b/test/parallel/test-v8-heap-profile.js
new file mode 100644
index 00000000000000..d1c611212509d4
--- /dev/null
+++ b/test/parallel/test-v8-heap-profile.js
@@ -0,0 +1,75 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+assert.throws(() => v8.startHeapProfile('bad'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+
+assert.throws(() => v8.startHeapProfile({ sampleInterval: '1024' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+assert.throws(() => v8.startHeapProfile({ sampleInterval: 1.1 }), {
+  code: 'ERR_OUT_OF_RANGE',
+});
+assert.throws(() => v8.startHeapProfile({ sampleInterval: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+});
+assert.throws(() => v8.startHeapProfile({ sampleInterval: -1 }), {
+  code: 'ERR_OUT_OF_RANGE',
+});
+
+
+assert.throws(() => v8.startHeapProfile({ stackDepth: '16' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+assert.throws(() => v8.startHeapProfile({ stackDepth: 1.1 }), {
+  code: 'ERR_OUT_OF_RANGE',
+});
+assert.throws(() => v8.startHeapProfile({ stackDepth: -1 }), {
+  code: 'ERR_OUT_OF_RANGE',
+});
+
+assert.throws(() => v8.startHeapProfile({ forceGC: 'true' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+assert.throws(
+  () => v8.startHeapProfile({ includeObjectsCollectedByMajorGC: 1 }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+assert.throws(
+  () => v8.startHeapProfile({ includeObjectsCollectedByMinorGC: 1 }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+
+// Default params.
+{
+  const handle = v8.startHeapProfile();
+  const profile = handle.stop();
+  JSON.parse(profile);
+}
+
+// Custom params with all flags.
+{
+  const handle = v8.startHeapProfile({
+    sampleInterval: 1024,
+    stackDepth: 8,
+    forceGC: true,
+    includeObjectsCollectedByMajorGC: true,
+    includeObjectsCollectedByMinorGC: true,
+  });
+  assert.throws(() => v8.startHeapProfile(), {
+    code: 'ERR_HEAP_PROFILE_HAVE_BEEN_STARTED',
+  });
+  const profile = handle.stop();
+  JSON.parse(profile);
+}
+
+// Second stop returns undefined.
+{
+  const handle = v8.startHeapProfile();
+  JSON.parse(handle.stop());
+  assert.strictEqual(handle.stop(), undefined);
+}
diff --git a/test/parallel/test-worker-heap-profile.js b/test/parallel/test-worker-heap-profile.js
index e5aff1f78978ef..2a466dc2f186e1 100644
--- a/test/parallel/test-worker-heap-profile.js
+++ b/test/parallel/test-worker-heap-profile.js
@@ -9,10 +9,55 @@ const worker = new Worker(`
   `, { eval: true });
 
 worker.on('online', common.mustCall(async () => {
+  assert.throws(() => worker.startHeapProfile('bad'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+
+  assert.throws(() => worker.startHeapProfile({ sampleInterval: '1024' }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+  assert.throws(() => worker.startHeapProfile({ sampleInterval: 1.1 }), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  assert.throws(() => worker.startHeapProfile({ sampleInterval: 0 }), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  assert.throws(() => worker.startHeapProfile({ sampleInterval: -1 }), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+
+  assert.throws(() => worker.startHeapProfile({ stackDepth: '16' }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+  assert.throws(() => worker.startHeapProfile({ stackDepth: 1.1 }), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  assert.throws(() => worker.startHeapProfile({ stackDepth: -1 }), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+
+  assert.throws(() => worker.startHeapProfile({ forceGC: 'true' }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+  assert.throws(
+    () => worker.startHeapProfile({ includeObjectsCollectedByMajorGC: 1 }), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+  assert.throws(
+    () => worker.startHeapProfile({ includeObjectsCollectedByMinorGC: 1 }), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+
   {
-    const handle = await worker.startHeapProfile();
+    const handle = await worker.startHeapProfile({
+      sampleInterval: 1024,
+      stackDepth: 8,
+      forceGC: true,
+      includeObjectsCollectedByMajorGC: true,
+      includeObjectsCollectedByMinorGC: true,
+    });
     JSON.parse(await handle.stop());
-    // Stop again
+    // Stop again returns cached result.
     JSON.parse(await handle.stop());
   }