diff --git a/doc/api/net.md b/doc/api/net.md
index 9d7ad185549cb7..4fd15f547faccc 100644
--- a/doc/api/net.md
+++ b/doc/api/net.md
@@ -471,6 +471,9 @@ Listening on a file descriptor is not supported on Windows.
 <!-- YAML
 added: v0.11.14
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/55408
+    description: The `reusePort` option is supported.
   - version: v15.6.0
     pr-url: https://github.com/nodejs/node/pull/36623
     description: AbortSignal support was added.
@@ -487,6 +490,11 @@ changes:
   * `ipv6Only` {boolean} For TCP servers, setting `ipv6Only` to `true` will
     disable dual-stack support, i.e., binding to host `::` won't make
     `0.0.0.0` be bound. **Default:** `false`.
+  * `reusePort` {boolean} For TCP servers, setting `reusePort` to `true` allows
+    bind to a port cross multiple socket if they all set `reusePort`. Incoming
+    connections are distributed across the listener sockets. This flag is available
+    only on some platforms, such as Linux 3.9+, DragonFlyBSD 3.6+,
+    FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+. **Default:** `false`.
   * `path` {string} Will be ignored if `port` is specified. See
     [Identifying paths for IPC connections][].
   * `port` {number}
diff --git a/lib/net.js b/lib/net.js
index 185ba6126d23db..52085df6ba0574 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -164,8 +164,15 @@ const {
 } = require('internal/perf/observe');
 const { getDefaultHighWaterMark } = require('internal/streams/state');
 
-function getFlags(ipv6Only) {
-  return ipv6Only === true ? TCPConstants.UV_TCP_IPV6ONLY : 0;
+function getFlags(options) {
+  let flags = 0;
+  if (options.ipv6Only === true) {
+    flags |= TCPConstants.UV_TCP_IPV6ONLY;
+  }
+  if (options.reusePort === true) {
+    flags |= TCPConstants.UV_TCP_REUSEPORT;
+  }
+  return flags;
 }
 
 function createHandle(fd, is_server) {
@@ -1833,12 +1840,12 @@ function createServerHandle(address, port, addressType, fd, flags) {
       if (err) {
         handle.close();
         // Fallback to ipv4
-        return createServerHandle(DEFAULT_IPV4_ADDR, port);
+        return createServerHandle(DEFAULT_IPV4_ADDR, port, undefined, undefined, flags);
       }
     } else if (addressType === 6) {
       err = handle.bind6(address, port, flags);
     } else {
-      err = handle.bind(address, port);
+      err = handle.bind(address, port, flags);
     }
   }
 
@@ -2022,7 +2029,7 @@ Server.prototype.listen = function(...args) {
     toNumber(args.length > 2 && args[2]);  // (port, host, backlog)
 
   options = options._handle || options.handle || options;
-  const flags = getFlags(options.ipv6Only);
+  const flags = getFlags(options);
   //  Refresh the id to make the previous call invalid
   this._listeningId++;
   // (handle[, backlog][, cb]) where handle is an object with a handle
@@ -2055,6 +2062,9 @@ Server.prototype.listen = function(...args) {
   if (typeof options.port === 'number' || typeof options.port === 'string') {
     validatePort(options.port, 'options.port');
     backlog = options.backlog || backlogFromArgs;
+    if (options.reusePort === true) {
+      options.exclusive = true;
+    }
     // start TCP server listening on host:port
     if (options.host) {
       lookupAndListen(this, options.port | 0, options.host, backlog,
@@ -2062,7 +2072,7 @@ Server.prototype.listen = function(...args) {
     } else { // Undefined host, listens on unspecified address
       // Default addressType 4 will be used to search for primary server
       listenInCluster(this, null, options.port | 0, 4,
-                      backlog, undefined, options.exclusive);
+                      backlog, undefined, options.exclusive, flags);
     }
     return this;
   }
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index 6c70f270baf63d..f730c371a195bd 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -123,6 +123,7 @@ void TCPWrap::Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, SOCKET);
   NODE_DEFINE_CONSTANT(constants, SERVER);
   NODE_DEFINE_CONSTANT(constants, UV_TCP_IPV6ONLY);
+  NODE_DEFINE_CONSTANT(constants, UV_TCP_REUSEPORT);
   target->Set(context,
               env->constants_string(),
               constants).Check();
@@ -246,9 +247,13 @@ void TCPWrap::Bind(
   int port;
   unsigned int flags = 0;
   if (!args[1]->Int32Value(env->context()).To(&port)) return;
-  if (family == AF_INET6 &&
-      !args[2]->Uint32Value(env->context()).To(&flags)) {
-    return;
+  if (args.Length() >= 3) {
+    if (!args[2]->Uint32Value(env->context()).To(&flags))
+      return;
+    // Can not set IPV6 flags on IPV4 socket
+    if (family == AF_INET) {
+      flags &= ~UV_TCP_IPV6ONLY;
+    }
   }
 
   T addr;
diff --git a/test/common/net.js b/test/common/net.js
new file mode 100644
index 00000000000000..d4ad6867f86bda
--- /dev/null
+++ b/test/common/net.js
@@ -0,0 +1,24 @@
+'use strict';
+const net = require('net');
+
+const options = { port: 0, reusePort: true };
+
+function checkSupportReusePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer().listen(options);
+    server.on('listening', () => {
+      server.close();
+      resolve();
+    });
+    server.on('error', (err) => {
+      console.log('don not support reusePort flag: ', err.message);
+      server.close();
+      reject();
+    });
+  });
+}
+
+module.exports = {
+  checkSupportReusePort,
+  options,
+};
diff --git a/test/parallel/test-child-process-net-reuseport.js b/test/parallel/test-child-process-net-reuseport.js
new file mode 100644
index 00000000000000..224e1e8fbee027
--- /dev/null
+++ b/test/parallel/test-child-process-net-reuseport.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const { checkSupportReusePort, options } = require('../common/net');
+const assert = require('assert');
+const child_process = require('child_process');
+const net = require('net');
+
+if (!process.env.isWorker) {
+  checkSupportReusePort().then(() => {
+    const server = net.createServer();
+    server.listen(options, common.mustCall(() => {
+      const port = server.address().port;
+      const workerOptions = { env: { 'isWorker': 1, port } };
+      let count = 2;
+      for (let i = 0; i < 2; i++) {
+        const worker = child_process.fork(__filename, workerOptions);
+        worker.on('exit', common.mustCall((code) => {
+          assert.strictEqual(code, 0);
+          if (--count === 0) {
+            server.close();
+          }
+        }));
+      }
+    }));
+    server.on('error', common.mustNotCall());
+  }, process.exit);
+  return;
+}
+
+const server = net.createServer();
+
+server.listen({ ...options, port: +process.env.port }, common.mustCall(() => {
+  server.close(common.mustCall(() => {
+    process.exit(0);
+  }));
+})).on('error', common.mustNotCall());
diff --git a/test/parallel/test-cluster-net-reuseport.js b/test/parallel/test-cluster-net-reuseport.js
new file mode 100644
index 00000000000000..f087d1ec253154
--- /dev/null
+++ b/test/parallel/test-cluster-net-reuseport.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+
+const { checkSupportReusePort, options } = require('../common/net');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  checkSupportReusePort().then(() => {
+    cluster.fork().on('exit', common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    }));
+  }, process.exit);
+  return;
+}
+
+let waiting = 2;
+function close() {
+  if (--waiting === 0)
+    cluster.worker.disconnect();
+}
+
+const server1 = net.createServer();
+const server2 = net.createServer();
+
+server1.listen(options, common.mustCall(() => {
+  const port = server1.address().port;
+  server2.listen({ ...options, port }, common.mustCall(() => {
+    server1.close(close);
+    server2.close(close);
+  }));
+}));
+
+server1.on('error', common.mustNotCall());
+server2.on('error', common.mustNotCall());
diff --git a/test/parallel/test-net-reuseport.js b/test/parallel/test-net-reuseport.js
new file mode 100644
index 00000000000000..1f5ed277282a19
--- /dev/null
+++ b/test/parallel/test-net-reuseport.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const { checkSupportReusePort, options } = require('../common/net');
+const net = require('net');
+
+function test() {
+  const server1 = net.createServer();
+  const server2 = net.createServer();
+  server1.listen(options, common.mustCall(() => {
+    const port = server1.address().port;
+    server2.listen({ ...options, port }, common.mustCall(() => {
+      server1.close();
+      server2.close();
+    }));
+  }));
+  server1.on('error', common.mustNotCall());
+  server2.on('error', common.mustNotCall());
+}
+
+checkSupportReusePort().then(test, process.exit);