diff --git a/doc/api/path.md b/doc/api/path.md
index e5d6fd7ef68304..5b433b88a9d7bd 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -165,6 +165,22 @@ path.dirname('/foo/bar/baz/asdf/quux');
 
 A [`TypeError`][] is thrown if `path` is not a string.
 
+## `path.escapeGlob(pattern)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `pattern` {string}
+* Returns: {string}
+
+The `path.escapeGlob()` method escapes glob characters in a `pattern`.
+
+```js
+path.escapeGlob('foo*bar');
+// Returns: 'foo[*]bar'
+```
+
 ## `path.extname(path)`
 
 <!-- YAML
@@ -283,35 +299,6 @@ path.format({
 // Returns: 'C:\\path\\dir\\file.txt'
 ```
 
-## `path.matchesGlob(path, pattern)`
-
-<!-- YAML
-added:
-  - v22.5.0
-  - v20.17.0
-changes:
-  - version:
-    - v24.8.0
-    - v22.20.0
-    pr-url: https://github.com/nodejs/node/pull/59572
-    description: Marking the API stable.
--->
-
-* `path` {string} The path to glob-match against.
-* `pattern` {string} The glob to check the path against.
-* Returns: {boolean} Whether or not the `path` matched the `pattern`.
-
-The `path.matchesGlob()` method determines if `path` matches the `pattern`.
-
-For example:
-
-```js
-path.matchesGlob('/foo/bar', '/foo/*'); // true
-path.matchesGlob('/foo/bar*', 'foo/bird'); // false
-```
-
-A [`TypeError`][] is thrown if `path` or `pattern` are not strings.
-
 ## `path.isAbsolute(path)`
 
 <!-- YAML
@@ -376,6 +363,35 @@ path.join('foo', {}, 'bar');
 
 A [`TypeError`][] is thrown if any of the path segments is not a string.
 
+## `path.matchesGlob(path, pattern)`
+
+<!-- YAML
+added:
+  - v22.5.0
+  - v20.17.0
+changes:
+  - version:
+    - v24.8.0
+    - v22.20.0
+    pr-url: https://github.com/nodejs/node/pull/59572
+    description: Marking the API stable.
+-->
+
+* `path` {string} The path to glob-match against.
+* `pattern` {string} The glob to check the path against.
+* Returns: {boolean} Whether or not the `path` matched the `pattern`.
+
+The `path.matchesGlob()` method determines if `path` matches the `pattern`.
+
+For example:
+
+```js
+path.matchesGlob('/foo/bar', '/foo/*'); // true
+path.matchesGlob('/foo/bar*', 'foo/bird'); // false
+```
+
+A [`TypeError`][] is thrown if `path` or `pattern` are not strings.
+
 ## `path.normalize(path)`
 
 <!-- YAML
@@ -640,6 +656,22 @@ modifications.
 This method is meaningful only on Windows systems. On POSIX systems, the
 method is non-operational and always returns `path` without modifications.
 
+## `path.unescapeGlob(pattern)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `pattern` {string}
+* Returns: {string}
+
+The `path.unescapeGlob()` method unescapes the given glob pattern.
+
+```js
+path.unescapeGlob('foo[*]bar');
+// Returns: 'foo*bar'
+```
+
 ## `path.win32`
 
 <!-- YAML
diff --git a/lib/internal/fs/glob.js b/lib/internal/fs/glob.js
index 1bfa39150e5196..43b203fce94de2 100644
--- a/lib/internal/fs/glob.js
+++ b/lib/internal/fs/glob.js
@@ -794,8 +794,36 @@ function matchGlobPattern(path, pattern, windows = isWindows) {
   });
 }
 
+/**
+ * Escape special glob characters in a pattern
+ * @param {string} pattern the glob pattern to escape
+ * @returns {string} the escaped glob pattern
+ */
+function escapeGlobPattern(pattern) {
+  validateString(pattern, 'pattern');
+  return lazyMinimatch().escape(pattern, {
+    windowsPathsNoEscape: true,
+    magicalBraces: true,
+  });
+}
+
+/**
+ * Restore special glob characters in a pattern
+ * @param {string} pattern the glob pattern to unescape
+ * @returns {string} the unescaped glob pattern
+ */
+function unescapeGlobPattern(pattern) {
+  validateString(pattern, 'pattern');
+  return lazyMinimatch().unescape(pattern, {
+    windowsPathsNoEscape: true,
+    magicalBraces: true,
+  });
+}
+
 module.exports = {
   __proto__: null,
   Glob,
+  escapeGlobPattern,
   matchGlobPattern,
+  unescapeGlobPattern,
 };
diff --git a/lib/path.js b/lib/path.js
index 63b037cddfb986..88fc2342d3bf06 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -60,7 +60,7 @@ const {
   getLazy,
 } = require('internal/util');
 
-const lazyMatchGlobPattern = getLazy(() => require('internal/fs/glob').matchGlobPattern);
+const lazyGlobPattern = getLazy(() => require('internal/fs/glob'));
 
 function isPathSeparator(code) {
   return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -1212,7 +1212,15 @@ const win32 = {
   },
 
   matchesGlob(path, pattern) {
-    return lazyMatchGlobPattern()(path, pattern, true);
+    return lazyGlobPattern().matchGlobPattern(path, pattern, true);
+  },
+
+  escapeGlob(pattern) {
+    return lazyGlobPattern().escapeGlobPattern(pattern);
+  },
+
+  unescapeGlob(pattern) {
+    return lazyGlobPattern().unescapeGlobPattern(pattern);
   },
 
   sep: '\\',
@@ -1694,7 +1702,15 @@ const posix = {
   },
 
   matchesGlob(path, pattern) {
-    return lazyMatchGlobPattern()(path, pattern, false);
+    return lazyGlobPattern().matchGlobPattern(path, pattern, false);
+  },
+
+  escapeGlob(pattern) {
+    return lazyGlobPattern().escapeGlobPattern(pattern);
+  },
+
+  unescapeGlob(pattern) {
+    return lazyGlobPattern().unescapeGlobPattern(pattern);
   },
 
   sep: '/',
diff --git a/test/parallel/test-path-escapeglob.js b/test/parallel/test-path-escapeglob.js
new file mode 100644
index 00000000000000..6b94363e9582a2
--- /dev/null
+++ b/test/parallel/test-path-escapeglob.js
@@ -0,0 +1,24 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+const samples = [
+  ['file*.txt', 'file[*].txt'],
+  ['file?.txt', 'file[?].txt'],
+  ['file[abc].txt', 'file[[]abc[]].txt'],
+  ['folder/**/*.txt', 'folder/[*][*]/[*].txt'],
+  ['file{1,2}.txt', 'file[{]1,2[}].txt'],
+  ['file[0-9]?.txt', 'file[[]0-9[]][?].txt'],
+  ['C:\\Users\\*.txt', 'C:\\Users\\[*].txt'],
+  ['?[]', '[?][[][]]'],
+];
+
+for (const [pattern, expected] of samples) {
+  const actual = path.escapeGlob(pattern);
+  assert.strictEqual(actual, expected, `Expected ${pattern} to be escaped as ${expected}, got ${actual} instead`);
+}
+
+// Test for non-string input
+assert.throws(() => path.escapeGlob(123), /.*must be of type string.*/);
diff --git a/test/parallel/test-path-glob.js b/test/parallel/test-path-matchesglob.js
similarity index 97%
rename from test/parallel/test-path-glob.js
rename to test/parallel/test-path-matchesglob.js
index 47647e12784e5a..de30479f29e326 100644
--- a/test/parallel/test-path-glob.js
+++ b/test/parallel/test-path-matchesglob.js
@@ -9,7 +9,8 @@ const globs = {
     ['foo\\bar\\baz', 'foo\\[bcr]ar\\baz', true], // Matches 'bar' or 'car' in 'foo\\bar'
     ['foo\\bar\\baz', 'foo\\[!bcr]ar\\baz', false], // Matches anything except 'bar' or 'car' in 'foo\\bar'
     ['foo\\bar\\baz', 'foo\\[bc-r]ar\\baz', true], // Matches 'bar' or 'car' using range in 'foo\\bar'
-    ['foo\\bar\\baz', 'foo\\*\\!bar\\*\\baz', false], // Matches anything with 'foo' and 'baz' but not 'bar' in between
+    ['foo\\bar\\baz', 'foo\\*\\!bar\\*\\baz', false], // Matches anything with 'foo' and 'baz' but not 'bar'
+    // in between
     ['foo\\bar1\\baz', 'foo\\bar[0-9]\\baz', true], // Matches 'bar' followed by any digit in 'foo\\bar1'
     ['foo\\bar5\\baz', 'foo\\bar[0-9]\\baz', true], // Matches 'bar' followed by any digit in 'foo\\bar5'
     ['foo\\barx\\baz', 'foo\\bar[a-z]\\baz', true], // Matches 'bar' followed by any lowercase letter in 'foo\\barx'
diff --git a/test/parallel/test-path-unescapeglob.js b/test/parallel/test-path-unescapeglob.js
new file mode 100644
index 00000000000000..316d9167397b6f
--- /dev/null
+++ b/test/parallel/test-path-unescapeglob.js
@@ -0,0 +1,24 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+const samples = [
+  ['file*.txt', 'file[*].txt'],
+  ['file?.txt', 'file[?].txt'],
+  ['file[abc].txt', 'file[[]abc[]].txt'],
+  ['folder/**/*.txt', 'folder/[*][*]/[*].txt'],
+  ['file{1,2}.txt', 'file[{]1,2[}].txt'],
+  ['file[0-9]?.txt', 'file[[]0-9[]][?].txt'],
+  ['C:\\Users\\*.txt', 'C:\\Users\\[*].txt'],
+  ['?[]', '[?][[][]]'],
+];
+
+for (const [expected, escapedPattern] of samples) {
+  const actual = path.unescapeGlob(escapedPattern);
+  assert.strictEqual(actual, expected, `Expected ${escapedPattern} to be unescaped as ${expected}, got ${actual} instead`);
+}
+
+// Test for non-string input
+assert.throws(() => path.unescapeGlob(123), /.*must be of type string.*/);