diff --git a/doc/api/fs.md b/doc/api/fs.md
index 4421d80b3341ff..0cbc75602d5418 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1001,6 +1001,82 @@ The times in the stat object have the following semantics:
 Prior to Node.js 0.12, the `ctime` held the `birthtime` on Windows systems. As
 of 0.12, `ctime` is not "creation time", and on Unix systems, it never was.
 
+## Class: `fs.StatFs`
+
+Provides information about a mounted filesystem.
+
+Objects returned from [`fs.statfs()`][] and its synchronous counterpart are of
+this type. If `bigint` in the `options` passed to those methods is `true`, the
+numeric values will be `bigint` instead of `number`.
+
+```console
+StatFs {
+  type: 1397114950,
+  bsize: 4096,
+  blocks: 121938943,
+  bfree: 61058895,
+  bavail: 61058895,
+  files: 999,
+  ffree: 1000000
+}
+```
+
+`bigint` version:
+
+```console
+StatFs {
+  type: 1397114950n,
+  bsize: 4096n,
+  blocks: 121938943n,
+  bfree: 61058895n,
+  bavail: 61058895n,
+  files: 999n,
+  ffree: 1000000n
+}
+```
+
+### `statfs.bavail`
+
+* {number|bigint}
+
+Free blocks available to unprivileged user.
+
+### `statfs.bfree`
+
+* {number|bigint}
+
+Free blocks in filesystem.
+
+### `statfs.blocks`
+
+* {number|bigint}
+
+Total data blocks in filesystem.
+
+### `statfs.bsize`
+
+* {number|bigint}
+
+Optimal transfer block size.
+
+### `statfs.ffree`
+
+* {number|bigint}
+
+Free file nodes in filesystem.
+
+### `statfs.files`
+
+* {number|bigint}
+
+Total file nodes in filesystem.
+
+### `statfs.type`
+
+* {number|bigint}
+
+Type of filesystem.
+
 ## Class: `fs.WriteStream`
 <!-- YAML
 added: v0.1.93
@@ -3465,6 +3541,39 @@ changes:
 
 Synchronous stat(2).
 
+## `fs.statfs(path[, options], callback)`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    [`fs.StatFs`][] object should be `bigint`. **Default:** `false`.
+* `callback` {Function}
+  * `err` {Error}
+  * `stats` {fs.StatFs}
+
+Asynchronous statfs(2). The callback gets two arguments `(err, stats)` where
+`stats` is an [`fs.StatFs`][] object.
+
+Returns information about the mounted filesystem which contains `path`.
+
+In case of an error, the `err.code` will be one of [Common System Errors][].
+
+## `fs.statfsSync(path[, options])`
+<!-- YAML
+added: REPLACME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    [`fs.StatFs`][] object should be `bigint`. **Default:** `false`.
+* Returns: {fs.StatFs}
+
+Synchronous statfs(2).
+
 ## `fs.symlink(target, path[, type], callback)`
 <!-- YAML
 added: v0.1.31
@@ -5124,6 +5233,19 @@ changes:
 
 The `Promise` is resolved with the [`fs.Stats`][] object for the given `path`.
 
+### `fsPromises.statfs(path[, options])`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    [`fs.StatFs`][] object should be `bigint`. **Default:** `false`.
+* Returns: {Promise}
+
+The `Promise` is resolved with the [`fs.StatFs`][] object for the given `path`.
+
 ### `fsPromises.symlink(target, path[, type])`
 <!-- YAML
 added: v10.0.0
@@ -5586,6 +5708,7 @@ the file contents.
 [`fs.Dirent`]: #fs_class_fs_dirent
 [`fs.FSWatcher`]: #fs_class_fs_fswatcher
 [`fs.Stats`]: #fs_class_fs_stats
+[`fs.StatFs`]: #fs_class_fs_statfs
 [`fs.access()`]: #fs_fs_access_path_mode_callback
 [`fs.chmod()`]: #fs_fs_chmod_path_mode_callback
 [`fs.chown()`]: #fs_fs_chown_path_uid_gid_callback
@@ -5609,6 +5732,7 @@ the file contents.
 [`fs.realpath()`]: #fs_fs_realpath_path_options_callback
 [`fs.rmdir()`]: #fs_fs_rmdir_path_options_callback
 [`fs.stat()`]: #fs_fs_stat_path_options_callback
+[`fs.statfs()`]: #fs_fs_statfs_path_options_callback
 [`fs.symlink()`]: #fs_fs_symlink_target_path_type_callback
 [`fs.utimes()`]: #fs_fs_utimes_path_atime_mtime_callback
 [`fs.watch()`]: #fs_fs_watch_filename_options_listener
diff --git a/lib/fs.js b/lib/fs.js
index a85b8ab29ebd1a..1c4eee3d223f8a 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -76,6 +76,7 @@ const {
   Dirent,
   getDirents,
   getOptions,
+  getStatFsFromBinding,
   getValidatedPath,
   getValidMode,
   handleErrorFromBinding,
@@ -936,6 +937,24 @@ function stat(path, options = { bigint: false }, callback) {
   binding.stat(pathModule.toNamespacedPath(path), options.bigint, req);
 }
 
+function statfs(path, options = { bigint: false }, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  callback = maybeCallback(callback);
+
+  const oncompleteCallback = (err, statsArray) => {
+    if (err) return callback(err);
+    callback(err, getStatFsFromBinding(statsArray));
+  };
+  path = getValidatedPath(path);
+  const req = new FSReqCallback(options.bigint);
+  req.oncomplete = oncompleteCallback;
+  binding.statfs(pathModule.toNamespacedPath(path), options.bigint, req);
+}
+
 function fstatSync(fd, options = { bigint: false }) {
   validateInt32(fd, 'fd', 0);
   const ctx = { fd };
@@ -962,6 +981,15 @@ function statSync(path, options = { bigint: false }) {
   return getStatsFromBinding(stats);
 }
 
+function statfsSync(path, options = { bigint: false }) {
+  path = getValidatedPath(path);
+  const ctx = { path };
+  const stats = binding.statfs(pathModule.toNamespacedPath(path),
+                               options.bigint, undefined, ctx);
+  handleErrorFromBinding(ctx);
+  return getStatFsFromBinding(stats);
+}
+
 function readlink(path, options, callback) {
   callback = makeCallback(typeof options === 'function' ? options : callback);
   options = getOptions(options, {});
@@ -1920,7 +1948,9 @@ module.exports = fs = {
   rmdir,
   rmdirSync,
   stat,
+  statfs,
   statSync,
+  statfsSync,
   symlink,
   symlinkSync,
   truncate,
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 6517a5ef4be056..91c7c9d0a9eef7 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -33,6 +33,7 @@ const {
   getDirents,
   getOptions,
   getStatsFromBinding,
+  getStatFsFromBinding,
   getValidatedPath,
   getValidMode,
   nullCheck,
@@ -405,6 +406,13 @@ async function stat(path, options = { bigint: false }) {
   return getStatsFromBinding(result);
 }
 
+async function statfs(path, options = { bigint: false }) {
+  path = getValidatedPath(path);
+  const result = await binding.statfs(pathModule.toNamespacedPath(path),
+                                      options.bigint, kUsePromises);
+  return getStatFsFromBinding(result);
+}
+
 async function link(existingPath, newPath) {
   existingPath = getValidatedPath(existingPath, 'existingPath');
   newPath = getValidatedPath(newPath, 'newPath');
@@ -536,6 +544,7 @@ module.exports = {
     symlink,
     lstat,
     stat,
+    statfs,
     link,
     unlink,
     chmod,
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 763a940f6e98a7..acdf0842b711a6 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -458,6 +458,24 @@ function getStatsFromBinding(stats, offset = 0) {
   );
 }
 
+function StatFs(type, bsize, blocks, bfree,
+                bavail, files, ffree) {
+  this.type = type;
+  this.bsize = bsize;
+  this.blocks = blocks;
+  this.bfree = bfree;
+  this.bavail = bavail;
+  this.files = files;
+  this.ffree = ffree;
+}
+
+function getStatFsFromBinding(stats) {
+  return new StatFs(
+    stats[0], stats[1], stats[2], stats[3],
+    stats[4], stats[5], stats[6]
+  );
+}
+
 function stringToFlags(flags) {
   if (typeof flags === 'number') {
     return flags;
@@ -669,6 +687,7 @@ module.exports = {
   getDirent,
   getDirents,
   getOptions,
+  getStatFsFromBinding,
   getValidatedPath,
   getValidMode,
   handleErrorFromBinding,
diff --git a/src/env-inl.h b/src/env-inl.h
index 3c7b83795d723a..f54dcb5346c150 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -615,6 +615,14 @@ inline AliasedBigUint64Array* Environment::fs_stats_field_bigint_array() {
   return &fs_stats_field_bigint_array_;
 }
 
+inline AliasedFloat64Array* Environment::fs_statfs_field_array() {
+  return &fs_statfs_field_array_;
+}
+
+inline AliasedBigUint64Array* Environment::fs_statfs_field_bigint_array() {
+  return &fs_statfs_field_bigint_array_;
+}
+
 inline std::vector<std::unique_ptr<fs::FileHandleReadWrap>>&
 Environment::file_handle_read_wrap_freelist() {
   return file_handle_read_wrap_freelist_;
diff --git a/src/env.cc b/src/env.cc
index 36b41c5fac56c4..d8d6dbed9e87ed 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -309,6 +309,8 @@ Environment::Environment(IsolateData* isolate_data,
       thread_id_(thread_id == kNoThreadId ? AllocateThreadId() : thread_id),
       fs_stats_field_array_(isolate_, kFsStatsBufferLength),
       fs_stats_field_bigint_array_(isolate_, kFsStatsBufferLength),
+      fs_statfs_field_array_(isolate_, kFsStatfsBufferLength),
+      fs_statfs_field_bigint_array_(isolate_, kFsStatfsBufferLength),
       context_(context->GetIsolate(), context) {
   // We'll be creating new objects so make sure we've entered the context.
   HandleScope handle_scope(isolate());
@@ -1068,6 +1070,9 @@ void Environment::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("fs_stats_field_array", fs_stats_field_array_);
   tracker->TrackField("fs_stats_field_bigint_array",
                       fs_stats_field_bigint_array_);
+  tracker->TrackField("fs_statfs_field_array", fs_statfs_field_array_);
+  tracker->TrackField("fs_statfs_field_bigint_array",
+                      fs_statfs_field_bigint_array_);
   tracker->TrackField("cleanup_hooks", cleanup_hooks_);
   tracker->TrackField("async_hooks", async_hooks_);
   tracker->TrackField("immediate_info", immediate_info_);
diff --git a/src/env.h b/src/env.h
index b1ec84bd75d1ba..eba1819cb17bd5 100644
--- a/src/env.h
+++ b/src/env.h
@@ -135,6 +135,20 @@ enum class FsStatsOffset {
 constexpr size_t kFsStatsBufferLength =
     static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber) * 2;
 
+enum class FsStatfsOffset {
+  kType = 0,
+  kBSize,
+  kBlocks,
+  kBFree,
+  kBAvail,
+  kFiles,
+  kFFree,
+  kFsStatFsFieldsNumber
+};
+
+constexpr size_t kFsStatfsBufferLength =
+    static_cast<size_t>(FsStatfsOffset::kFsStatFsFieldsNumber);
+
 // PER_ISOLATE_* macros: We have a lot of per-isolate properties
 // and adding and maintaining their getters and setters by hand would be
 // difficult so let's make the preprocessor generate them for us.
@@ -1025,6 +1039,9 @@ class Environment : public MemoryRetainer {
   inline AliasedFloat64Array* fs_stats_field_array();
   inline AliasedBigUint64Array* fs_stats_field_bigint_array();
 
+  inline AliasedFloat64Array* fs_statfs_field_array();
+  inline AliasedBigUint64Array* fs_statfs_field_bigint_array();
+
   inline std::vector<std::unique_ptr<fs::FileHandleReadWrap>>&
       file_handle_read_wrap_freelist();
 
@@ -1386,6 +1403,9 @@ class Environment : public MemoryRetainer {
   AliasedFloat64Array fs_stats_field_array_;
   AliasedBigUint64Array fs_stats_field_bigint_array_;
 
+  AliasedFloat64Array fs_statfs_field_array_;
+  AliasedBigUint64Array fs_statfs_field_bigint_array_;
+
   std::vector<std::unique_ptr<fs::FileHandleReadWrap>>
       file_handle_read_wrap_freelist_;
 
diff --git a/src/node_file-inl.h b/src/node_file-inl.h
index e9ed18a75fa48b..c8ac9d8d4c38cd 100644
--- a/src/node_file-inl.h
+++ b/src/node_file-inl.h
@@ -129,6 +129,37 @@ v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
   }
 }
 
+template <typename NativeT, typename V8T>
+void FillStatfsArray(AliasedBufferBase<NativeT, V8T>* fields,
+                     const uv_statfs_t* s) {
+#define SET_FIELD(field, stat)                                                \
+  fields->SetValue(static_cast<size_t>(FsStatfsOffset::field),                \
+                   static_cast<NativeT>(stat))
+
+  SET_FIELD(kType, s->f_type);
+  SET_FIELD(kBSize, s->f_bsize);
+  SET_FIELD(kBlocks, s->f_blocks);
+  SET_FIELD(kBFree, s->f_bfree);
+  SET_FIELD(kBAvail, s->f_bavail);
+  SET_FIELD(kFiles, s->f_files);
+  SET_FIELD(kFFree, s->f_ffree);
+#undef SET_FIELD
+}
+
+v8::Local<v8::Value> FillGlobalStatfsArray(Environment* env,
+                                           const bool use_bigint,
+                                           const uv_statfs_t* s) {
+  if (use_bigint) {
+    auto* const arr = env->fs_statfs_field_bigint_array();
+    FillStatfsArray(arr, s);
+    return arr->GetJSArray();
+  } else {
+    auto* const arr = env->fs_statfs_field_array();
+    FillStatfsArray(arr, s);
+    return arr->GetJSArray();
+  }
+}
+
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>*
 FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
@@ -160,7 +191,10 @@ FSReqPromise<AliasedBufferT>::FSReqPromise(
   : FSReqBase(env, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
     stats_field_array_(
         env->isolate(),
-        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
+        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)),
+    statfs_field_array_(
+        env->isolate(),
+        static_cast<size_t>(FsStatfsOffset::kFsStatFsFieldsNumber)) {}
 
 template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
@@ -192,6 +226,12 @@ void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
   Resolve(stats_field_array_.GetJSArray());
 }
 
+template <typename AliasedBufferT>
+void FSReqPromise<AliasedBufferT>::ResolveStatfs(const uv_statfs_t* stat) {
+  FillStatfsArray(&statfs_field_array_, stat);
+  Resolve(statfs_field_array_.GetJSArray());
+}
+
 template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::SetReturnValue(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
@@ -206,6 +246,7 @@ template <typename AliasedBufferT>
 void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
   FSReqBase::MemoryInfo(tracker);
   tracker->TrackField("stats_field_array", stats_field_array_);
+  tracker->TrackField("statfs_field_array", statfs_field_array_);
 }
 
 FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
diff --git a/src/node_file.cc b/src/node_file.cc
index 2f66080e5caa14..09e1500c5c20c3 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -502,6 +502,10 @@ void FSReqCallback::ResolveStat(const uv_stat_t* stat) {
   Resolve(FillGlobalStatsArray(env(), use_bigint(), stat));
 }
 
+void FSReqCallback::ResolveStatfs(const uv_statfs_t* stat) {
+  Resolve(FillGlobalStatfsArray(env(), use_bigint(), stat));
+}
+
 void FSReqCallback::Resolve(Local<Value> value) {
   Local<Value> argv[2] {
     Null(env()->isolate()),
@@ -578,6 +582,15 @@ void AfterStat(uv_fs_t* req) {
   }
 }
 
+void AfterStatfs(uv_fs_t* req) {
+  FSReqBase* req_wrap = FSReqBase::from_req(req);
+  FSReqAfterScope after(req_wrap, req);
+
+  if (after.Proceed()) {
+    req_wrap->ResolveStatfs(static_cast<uv_statfs_t*>(req->ptr));
+  }
+}
+
 void AfterInteger(uv_fs_t* req) {
   FSReqBase* req_wrap = FSReqBase::from_req(req);
   FSReqAfterScope after(req_wrap, req);
@@ -1020,6 +1033,38 @@ static void FStat(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+static void Statfs(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  const int argc = args.Length();
+  CHECK_GE(argc, 2);
+
+  BufferValue path(env->isolate(), args[0]);
+  CHECK_NOT_NULL(*path);
+
+  bool use_bigint = args[1]->IsTrue();
+  FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);
+  if (req_wrap_async != nullptr) {  // statfs(path, use_bigint, req)
+    AsyncCall(env, req_wrap_async, args, "statfs", UTF8, AfterStatfs,
+              uv_fs_statfs, *path);
+  } else {
+    CHECK_EQ(argc, 4);
+    FSReqWrapSync req_wrap_sync;
+    FS_SYNC_TRACE_BEGIN(statfs);
+    int err = SyncCall(env, args[3], &req_wrap_sync, "statfs", uv_fs_statfs,
+                       *path);
+    FS_SYNC_TRACE_END(statfs);
+
+    if (err != 0) {
+      return;  // error info is in ctx
+    }
+
+    Local<Value> arr = FillGlobalStatfsArray(env, use_bigint,
+        static_cast<const uv_statfs_t*>(req_wrap_sync.req.ptr));
+    args.GetReturnValue().Set(arr);
+  }
+}
+
 static void Symlink(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -2254,6 +2299,7 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "stat", Stat);
   env->SetMethod(target, "lstat", LStat);
   env->SetMethod(target, "fstat", FStat);
+  env->SetMethod(target, "statfs", Statfs);
   env->SetMethod(target, "link", Link);
   env->SetMethod(target, "symlink", Symlink);
   env->SetMethod(target, "readlink", ReadLink);
diff --git a/src/node_file.h b/src/node_file.h
index 1ebfe06c1fbdbf..a8f28ade7e9a94 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -59,6 +59,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   virtual void Reject(v8::Local<v8::Value> reject) = 0;
   virtual void Resolve(v8::Local<v8::Value> value) = 0;
   virtual void ResolveStat(const uv_stat_t* stat) = 0;
+  virtual void ResolveStatfs(const uv_statfs_t* stat) = 0;
   virtual void SetReturnValue(
       const v8::FunctionCallbackInfo<v8::Value>& args) = 0;
 
@@ -104,6 +105,7 @@ class FSReqCallback final : public FSReqBase {
   void Reject(v8::Local<v8::Value> reject) override;
   void Resolve(v8::Local<v8::Value> value) override;
   void ResolveStat(const uv_stat_t* stat) override;
+  void ResolveStatfs(const uv_statfs_t* stat) override;
   void SetReturnValue(const v8::FunctionCallbackInfo<v8::Value>& args) override;
 
   SET_MEMORY_INFO_NAME(FSReqCallback)
@@ -123,6 +125,14 @@ inline v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
                                                  const uv_stat_t* s,
                                                  const bool second = false);
 
+template <typename NativeT, typename V8T>
+void FillStatfsArray(AliasedBufferBase<NativeT, V8T>* fields,
+                     const uv_statfs_t* s);
+
+inline v8::Local<v8::Value> FillGlobalStatfsArray(Environment* env,
+                                                  const bool use_bigint,
+                                                  const uv_statfs_t* s);
+
 template <typename AliasedBufferT>
 class FSReqPromise final : public FSReqBase {
  public:
@@ -132,6 +142,7 @@ class FSReqPromise final : public FSReqBase {
   inline void Reject(v8::Local<v8::Value> reject) override;
   inline void Resolve(v8::Local<v8::Value> value) override;
   inline void ResolveStat(const uv_stat_t* stat) override;
+  inline void ResolveStatfs(const uv_statfs_t* stat) override;
   inline void SetReturnValue(
       const v8::FunctionCallbackInfo<v8::Value>& args) override;
   inline void MemoryInfo(MemoryTracker* tracker) const override;
@@ -151,6 +162,7 @@ class FSReqPromise final : public FSReqBase {
 
   bool finished_ = false;
   AliasedBufferT stats_field_array_;
+  AliasedBufferT statfs_field_array_;
 };
 
 class FSReqAfterScope final {
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index f23df685eac072..99d7266d66cc61 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -26,6 +26,7 @@ const {
   rename,
   rmdir,
   stat,
+  statfs,
   symlink,
   truncate,
   unlink,
@@ -82,6 +83,19 @@ function verifyStatObject(stat) {
   assert.strictEqual(typeof stat.mode, 'number');
 }
 
+function verifyStatfsObject(stat, isBigint = false) {
+  const valueType = isBigint ? 'bigint' : 'number';
+
+  assert.strictEqual(typeof stat, 'object');
+  assert.strictEqual(typeof stat.type, valueType);
+  assert.strictEqual(typeof stat.bsize, valueType);
+  assert.strictEqual(typeof stat.blocks, valueType);
+  assert.strictEqual(typeof stat.bfree, valueType);
+  assert.strictEqual(typeof stat.bavail, valueType);
+  assert.strictEqual(typeof stat.files, valueType);
+  assert.strictEqual(typeof stat.ffree, valueType);
+}
+
 async function getHandle(dest) {
   await copyFile(fixtures.path('baz.js'), dest);
   await access(dest);
@@ -126,6 +140,18 @@ async function getHandle(dest) {
       await handle.close();
     }
 
+    // File system stats
+    {
+      const statFs = await statfs(dest);
+      verifyStatfsObject(statFs);
+    }
+
+    // File system stats bigint
+    {
+      const statFs = await statfs(dest, { bigint: true });
+      verifyStatfsObject(statFs, true);
+    }
+
     // Test fs.read promises when length to read is zero bytes
     {
       const dest = path.resolve(tmpDir, 'test1.js');
diff --git a/test/parallel/test-fs-statfs.js b/test/parallel/test-fs-statfs.js
new file mode 100644
index 00000000000000..2b6afb0c3fc677
--- /dev/null
+++ b/test/parallel/test-fs-statfs.js
@@ -0,0 +1,67 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const fs = require('fs');
+
+function verifyStatFsObject(statfs, isBigint = false) {
+  const valueType = isBigint ? 'bigint' : 'number';
+
+  [
+    'type', 'bsize', 'blocks', 'bfree', 'bavail', 'files', 'ffree'
+  ].forEach((k) => {
+    assert.ok(statfs.hasOwnProperty(k));
+    assert.strictEqual(typeof statfs[k], valueType,
+                       `${k} should be a ${valueType}`);
+  });
+}
+
+fs.statfs(__filename, common.mustCall(function(err, stats) {
+  assert.ifError(err);
+  verifyStatFsObject(stats);
+  // Confirm that we are not running in the context of the internal binding
+  // layer.
+  // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
+  assert.strictEqual(this, undefined);
+}));
+
+fs.statfs(__filename, { bigint: true }, function(err, stats) {
+  assert.ifError(err);
+  verifyStatFsObject(stats, true);
+  // Confirm that we are not running in the context of the internal binding
+  // layer.
+  // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
+  assert.strictEqual(this, undefined);
+});
+
+// Synchronous
+{
+  const statFsObj = fs.statfsSync(__filename);
+  verifyStatFsObject(statFsObj);
+}
+
+// Synchronous Bigint
+{
+  const statFsBigIntObj = fs.statfsSync(__filename, { bigint: true });
+  verifyStatFsObject(statFsBigIntObj, true);
+}
+
+[false, 1, {}, [], null, undefined].forEach((input) => {
+  assert.throws(
+    () => fs.statfs(input, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.statfsSync(input),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
+
+// Should not throw an error
+fs.statfs(__filename, undefined, common.mustCall(() => {}));
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.js
index 02b59d37ffd278..19fad88a70700a 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.js
@@ -79,6 +79,7 @@ const customTypesMap = {
   'fs.FSWatcher': 'fs.html#fs_class_fs_fswatcher',
   'fs.ReadStream': 'fs.html#fs_class_fs_readstream',
   'fs.Stats': 'fs.html#fs_class_fs_stats',
+  'fs.StatFs': 'fs.html#fs_class_fs_statfs',
   'fs.WriteStream': 'fs.html#fs_class_fs_writestream',
 
   'http.Agent': 'http.html#http_class_http_agent',