diff --git a/doc/api/fs.md b/doc/api/fs.md
index de86c355efecd9..f55778af69f4b1 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1368,6 +1368,9 @@ closed after the iterator exits.
 <!-- YAML
 added: v10.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/52553
+    description: New option `skipSymlinkDir` was added.
   - version:
     - v20.1.0
     - v18.17.0
@@ -1385,6 +1388,9 @@ changes:
   * `recursive` {boolean} If `true`, reads the contents of a directory
     recursively. In recursive mode, it will list all files, sub files, and
     directories. **Default:** `false`.
+  * `skipSymlinkDir` {boolean} This option is only effective when `recursive`
+    is set to `true`. If `true`, symbolic link directories are skipped. If
+    `false`, symbolic link directories are included. **Default:** `false`.
 * Returns: {Promise}  Fulfills with an array of the names of the files in
   the directory excluding `'.'` and `'..'`.
 
@@ -3728,6 +3734,9 @@ above values.
 <!-- YAML
 added: v0.1.8
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/52553
+    description: New option `skipSymlinkDir` was added.
   - version:
     - v20.1.0
     - v18.17.0
@@ -3765,6 +3774,9 @@ changes:
   * `recursive` {boolean} If `true`, reads the contents of a directory
     recursively. In recursive mode, it will list all files, sub files and
     directories. **Default:** `false`.
+  * `skipSymlinkDir` {boolean} This option is only effective when `recursive`
+    is set to `true`. If `true`, symbolic link directories are skipped. If
+    `false`, symbolic link directories are included. **Default:** `false`.
 * `callback` {Function}
   * `err` {Error}
   * `files` {string\[]|Buffer\[]|fs.Dirent\[]}
@@ -5857,6 +5869,9 @@ this API: [`fs.open()`][].
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/52553
+    description: New option `skipSymlinkDir` was added.
   - version:
     - v20.1.0
     - v18.17.0
@@ -5878,6 +5893,9 @@ changes:
   * `recursive` {boolean} If `true`, reads the contents of a directory
     recursively. In recursive mode, it will list all files, sub files, and
     directories. **Default:** `false`.
+  * `skipSymlinkDir` {boolean} This option is only effective when `recursive`
+    is set to `true`. If `true`, symbolic link directories are skipped. If
+    `false`, symbolic link directories are included. **Default:** `false`.
 * Returns: {string\[]|Buffer\[]|fs.Dirent\[]}
 
 Reads the contents of the directory.
diff --git a/lib/fs.js b/lib/fs.js
index e857ac47f45c81..d92753d8c52697 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -1389,13 +1389,19 @@ function mkdirSync(path, options) {
 function readdirSyncRecursive(basePath, options) {
   const withFileTypes = Boolean(options.withFileTypes);
   const encoding = options.encoding;
-
+  const skipSymlinkDir = options.skipSymlinkDir || false;
   const readdirResults = [];
   const pathsQueue = [basePath];
 
   function read(path) {
+    const namespacePath = pathModule.toNamespacedPath(path);
+    if (skipSymlinkDir) {
+      if (lstatSync(namespacePath).isSymbolicLink()) {
+        return;
+      }
+    }
     const readdirResult = binding.readdir(
-      pathModule.toNamespacedPath(path),
+      namespacePath,
       encoding,
       withFileTypes,
     );
@@ -1413,7 +1419,14 @@ function readdirSyncRecursive(basePath, options) {
       for (let i = 0; i < length; i++) {
         const dirent = getDirent(path, readdirResult[0][i], readdirResult[1][i]);
         ArrayPrototypePush(readdirResults, dirent);
-        if (dirent.isDirectory()) {
+        if (skipSymlinkDir) {
+          if (dirent.isSymbolicLink()) {
+            continue;
+          }
+        }
+        const resultPath = pathModule.join(path, dirent.name);
+        const stat = binding.internalModuleStat(resultPath);
+        if (stat === 1) {
           ArrayPrototypePush(pathsQueue, pathModule.join(dirent.parentPath, dirent.name));
         }
       }
@@ -1421,8 +1434,13 @@ function readdirSyncRecursive(basePath, options) {
       for (let i = 0; i < readdirResult.length; i++) {
         const resultPath = pathModule.join(path, readdirResult[i]);
         const relativeResultPath = pathModule.relative(basePath, resultPath);
-        const stat = binding.internalModuleStat(resultPath);
         ArrayPrototypePush(readdirResults, relativeResultPath);
+        if (skipSymlinkDir) {
+          if (lstatSync(resultPath).isSymbolicLink()) {
+            continue;
+          }
+        }
+        const stat = binding.internalModuleStat(resultPath);
         // 1 indicates directory
         if (stat === 1) {
           ArrayPrototypePush(pathsQueue, resultPath);
@@ -1497,7 +1515,9 @@ function readdirSync(path, options) {
   if (options.recursive != null) {
     validateBoolean(options.recursive, 'options.recursive');
   }
-
+  if (options.skipSymlinkDir != null) {
+    validateBoolean(options.skipSymlinkDir, 'options.skipSymlinkDir');
+  }
   if (options.recursive) {
     return readdirSyncRecursive(path, options);
   }
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index a5df1f00b2e2bf..dc2a933c0a33b5 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -868,6 +868,14 @@ async function mkdir(path, options) {
 
 async function readdirRecursive(originalPath, options) {
   const result = [];
+  const skipSymlinkDir = options.skipSymlinkDir || false;
+
+  if (skipSymlinkDir) {
+    const stats = await lstat(originalPath);
+    if (stats.isSymbolicLink()) {
+      return result;
+    }
+  }
   const queue = [
     [
       originalPath,
@@ -890,8 +898,15 @@ async function readdirRecursive(originalPath, options) {
       // If we want to implement BFS make this a `shift` call instead of `pop`
       const { 0: path, 1: readdir } = ArrayPrototypePop(queue);
       for (const dirent of getDirents(path, readdir)) {
+        if (skipSymlinkDir) {
+          if (dirent.isSymbolicLink()) {
+            continue;
+          }
+        }
         ArrayPrototypePush(result, dirent);
-        if (dirent.isDirectory()) {
+        const direntPath = pathModule.join(path, dirent.name);
+        const stat = binding.internalModuleStat(direntPath);
+        if (stat === 1) {
           const direntPath = pathModule.join(path, dirent.name);
           ArrayPrototypePush(queue, [
             direntPath,
@@ -919,6 +934,12 @@ async function readdirRecursive(originalPath, options) {
           result,
           pathModule.relative(originalPath, direntPath),
         );
+        if (skipSymlinkDir) {
+          const stats = await lstat(direntPath);
+          if (stats.isSymbolicLink()) {
+            continue;
+          }
+        }
         if (stat === 1) {
           ArrayPrototypePush(queue, [
             direntPath,
diff --git a/test/sequential/test-fs-readdir-recursive.js b/test/sequential/test-fs-readdir-recursive.js
index 2775573837786d..6d20d6278e933f 100644
--- a/test/sequential/test-fs-readdir-recursive.js
+++ b/test/sequential/test-fs-readdir-recursive.js
@@ -84,8 +84,10 @@ const symlinksRootPath = pathModule.join(readdirDir, 'symlinks');
 const symlinkTargetFile = pathModule.join(symlinksRootPath, 'symlink-target-file');
 const symlinkTargetDir = pathModule.join(symlinksRootPath, 'symlink-target-dir');
 fs.mkdirSync(symlinksRootPath);
+fs.symlinkSync(symlinksRootPath, pathModule.join(readdirDir, 'symlinks-src'));
 fs.writeFileSync(symlinkTargetFile, '');
 fs.mkdirSync(symlinkTargetDir);
+fs.writeFileSync(pathModule.join(symlinkTargetDir, 'symlink-target-dir-file'), '');
 fs.symlinkSync(symlinkTargetFile, pathModule.join(symlinksRootPath, 'symlink-src-file'));
 fs.symlinkSync(symlinkTargetDir, pathModule.join(symlinksRootPath, 'symlink-src-dir'));
 
@@ -110,8 +112,19 @@ const expected = [
   'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
   'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
   's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
-  'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
-  'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
+  'symlinks', 'symlinks-src',
+  'symlinks-src/symlink-src-dir',
+  'symlinks-src/symlink-src-dir/symlink-target-dir-file',
+  'symlinks-src/symlink-src-file',
+  'symlinks-src/symlink-target-dir',
+  'symlinks-src/symlink-target-dir/symlink-target-dir-file',
+  'symlinks-src/symlink-target-file',
+  'symlinks/symlink-src-dir',
+  'symlinks/symlink-src-dir/symlink-target-dir-file',
+  'symlinks/symlink-src-file',
+  'symlinks/symlink-target-dir',
+  'symlinks/symlink-target-dir/symlink-target-dir-file',
+  'symlinks/symlink-target-file',
   't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
   'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
   'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
@@ -121,16 +134,30 @@ const expected = [
   'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
 ];
 
+const symlinkFiles = [
+  'symlinks-src/symlink-src-dir',
+  'symlinks-src/symlink-src-dir/symlink-target-dir-file',
+  'symlinks-src/symlink-src-file',
+  'symlinks-src/symlink-target-dir',
+  'symlinks-src/symlink-target-dir/symlink-target-dir-file',
+  'symlinks-src/symlink-target-file',
+  'symlinks/symlink-src-dir/symlink-target-dir-file',
+];
+const skipSymlinkExpected = expected.filter((file) => !symlinkFiles.includes(file));
+
 // Normalize paths once for non POSIX platforms
 for (let i = 0; i < expected.length; i++) {
   expected[i] = pathModule.normalize(expected[i]);
 }
+for (let i = 0; i < symlinkFiles.length; i++) {
+  symlinkFiles[i] = pathModule.normalize(symlinkFiles[i]);
+}
 
 function getDirentPath(dirent) {
   return pathModule.relative(readdirDir, pathModule.join(dirent.path, dirent.name));
 }
 
-function assertDirents(dirents) {
+function assertDirents(dirents, expected) {
   assert.strictEqual(dirents.length, expected.length);
   dirents.sort((a, b) => (getDirentPath(a) < getDirentPath(b) ? -1 : 1));
   assert.deepStrictEqual(
@@ -154,7 +181,13 @@ function assertDirents(dirents) {
 // readdirSync { recursive, withFileTypes }
 {
   const result = fs.readdirSync(readdirDir, { recursive: true, withFileTypes: true });
-  assertDirents(result);
+  assertDirents(result, expected);
+}
+
+// readdirSync { recursive, skipSymlinkDir }
+{
+  const result = fs.readdirSync(readdirDir, { recursive: true, skipSymlinkDir: true });
+  assert.deepStrictEqual(result.sort(), skipSymlinkExpected);
 }
 
 // readdir
@@ -171,7 +204,15 @@ function assertDirents(dirents) {
 {
   fs.readdir(readdirDir, { recursive: true, withFileTypes: true },
              common.mustSucceed((result) => {
-               assertDirents(result);
+               assertDirents(result, expected);
+             }));
+}
+
+// Readdir { recursive, skipSymlinkDir } callback
+{
+  fs.readdir(readdirDir, { recursive: true, skipSymlinkDir: true },
+             common.mustSucceed((result) => {
+               assert.deepStrictEqual(result.sort(), skipSymlinkExpected);
              }));
 }
 
@@ -191,7 +232,17 @@ function assertDirents(dirents) {
 {
   async function test() {
     const result = await fs.promises.readdir(readdirDir, { recursive: true, withFileTypes: true });
-    assertDirents(result);
+    assertDirents(result, expected);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive, skipSymlinkDir }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, { recursive: true, skipSymlinkDir: true });
+    assert.deepStrictEqual(result.sort(), skipSymlinkExpected);
   }
 
   test().then(common.mustCall());