diff --git a/doc/api/util.md b/doc/api/util.md
index 0d4dac9885a1eb..2d041874b6ce93 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -2870,6 +2870,48 @@ Returns the `string` after replacing any surrogate code points
 (or equivalently, any unpaired surrogate code units) with the
 Unicode "replacement character" U+FFFD.
 
+## `util.table(tabularData[, properties][, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `tabularData` {any} The data to render. Arrays, objects, `Map`s and `Set`s
+  are rendered as tables; any other value is returned as inspected text.
+* `properties` {string\[]} An alternate list of properties to use as the table's
+  columns. By default every own enumerable property of the rows is used.
+* `options` {Object} Options forwarded to [`util.inspect()`][] when formatting
+  each cell.
+* Returns: {string}
+
+Returns tabular data formatted with the same layout as [`console.table()`][],
+but as a string instead of writing it to a stream. This is useful for logging,
+writing to a file, or building output without a console.
+
+```mjs
+import { table } from 'node:util';
+
+console.log(table([
+  { name: 'alice', age: 30 },
+  { name: 'bob', age: 25 },
+]));
+// ┌─────────┬─────────┬─────┐
+// │ (index) │ name    │ age │
+// ├─────────┼─────────┼─────┤
+// │ 0       │ 'alice' │ 30  │
+// │ 1       │ 'bob'   │ 25  │
+// └─────────┴─────────┴─────┘
+```
+
+```cjs
+const { table } = require('node:util');
+
+console.log(table([
+  { name: 'alice', age: 30 },
+  { name: 'bob', age: 25 },
+]));
+```
+
 ## `util.transferableAbortController()`
 
 <!-- YAML
@@ -3914,6 +3956,7 @@ npx codemod@latest @nodejs/util-is
 [`Runtime.ScriptId`]: https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#type-ScriptId
 [`assert.deepStrictEqual()`]: assert.md#assertdeepstrictequalactual-expected-message
 [`console.error()`]: console.md#consoleerrordata-args
+[`console.table()`]: console.md#consoletabletabulardata-properties
 [`mime.toString()`]: #mimetostring
 [`mimeParams.entries()`]: #mimeparamsentries
 [`napi_create_external()`]: n-api.md#napi_create_external
diff --git a/lib/internal/console/constructor.js b/lib/internal/console/constructor.js
index bb79678001ec66..b71190010f66ac 100644
--- a/lib/internal/console/constructor.js
+++ b/lib/internal/console/constructor.js
@@ -4,10 +4,7 @@
 // console. It's exported for backwards compatibility.
 
 const {
-  ArrayFrom,
-  ArrayIsArray,
   ArrayPrototypeForEach,
-  ArrayPrototypePush,
   ArrayPrototypeUnshift,
   Boolean,
   ErrorCaptureStackTrace,
@@ -17,8 +14,6 @@ const {
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectKeys,
-  ObjectPrototypeHasOwnProperty,
-  ObjectValues,
   ReflectApply,
   ReflectConstruct,
   ReflectOwnKeys,
@@ -49,14 +44,12 @@ const {
   validateObject,
   validateOneOf,
 } = require('internal/validators');
-const { previewEntries } = internalBinding('util');
-const { Buffer: { isBuffer } } = require('buffer');
 const {
   inspect,
   formatWithOptions,
 } = require('internal/util/inspect');
 const {
-  isTypedArray, isSet, isMap, isSetIterator, isMapIterator,
+  isMap,
 } = require('internal/util/types');
 const {
   CHAR_UPPERCASE_C: kTraceCount,
@@ -76,7 +69,7 @@ const kTraceConsoleCategory = 'node,node.console';
 const kMaxGroupIndentation = 1000;
 
 // Lazy loaded for startup performance.
-let cliTable;
+let buildTable;
 
 let utilColors;
 function lazyUtilColors() {
@@ -558,120 +551,13 @@ const consoleMethods = {
     if (tabularData === null || typeof tabularData !== 'object')
       return this.log(tabularData);
 
-    cliTable ??= require('internal/cli_table');
-    const final = (k, v) => this.log(cliTable(k, v));
-
-    const _inspect = (v) => {
-      const depth = v !== null &&
-                    typeof v === 'object' &&
-                    !isArray(v) &&
-                    ObjectKeys(v).length > 2 ? -1 : 0;
-      const opt = {
-        depth,
-        maxArrayLength: 3,
-        breakLength: Infinity,
-        ...this[kGetInspectOptions](this._stdout),
-      };
-      return inspect(v, opt);
-    };
-    const getIndexArray = (length) => ArrayFrom(
-      { length }, (_, i) => _inspect(i));
-
-    const mapIter = isMapIterator(tabularData);
-    let isKeyValue = false;
-    let i = 0;
-    if (mapIter) {
-      const res = previewEntries(tabularData, true);
-      tabularData = res[0];
-      isKeyValue = res[1];
-    }
-
-    if (isKeyValue || isMap(tabularData)) {
-      const keys = [];
-      const values = [];
-      let length = 0;
-      if (mapIter) {
-        for (; i < tabularData.length / 2; ++i) {
-          ArrayPrototypePush(keys, _inspect(tabularData[i * 2]));
-          ArrayPrototypePush(values, _inspect(tabularData[i * 2 + 1]));
-          length++;
-        }
-      } else {
-        for (const { 0: k, 1: v } of tabularData) {
-          ArrayPrototypePush(keys, _inspect(k));
-          ArrayPrototypePush(values, _inspect(v));
-          length++;
-        }
-      }
-      return final([
-        iterKey, keyKey, valuesKey,
-      ], [
-        getIndexArray(length),
-        keys,
-        values,
-      ]);
-    }
-
-    const setIter = isSetIterator(tabularData);
-    if (setIter)
-      tabularData = previewEntries(tabularData);
-
-    const setlike = setIter || mapIter || isSet(tabularData);
-    if (setlike) {
-      const values = [];
-      let length = 0;
-      for (const v of tabularData) {
-        ArrayPrototypePush(values, _inspect(v));
-        length++;
-      }
-      return final([iterKey, valuesKey], [getIndexArray(length), values]);
-    }
-
-    const map = { __proto__: null };
-    let hasPrimitives = false;
-    const valuesKeyArray = [];
-    const indexKeyArray = ObjectKeys(tabularData);
-
-    for (; i < indexKeyArray.length; i++) {
-      const item = tabularData[indexKeyArray[i]];
-      const primitive = item === null ||
-          (typeof item !== 'function' && typeof item !== 'object');
-      if (properties === undefined && primitive) {
-        hasPrimitives = true;
-        valuesKeyArray[i] = _inspect(item);
-      } else {
-        const keys = properties || ObjectKeys(item);
-        for (const key of keys) {
-          map[key] ??= [];
-          if ((primitive && properties) ||
-               !ObjectPrototypeHasOwnProperty(item, key))
-            map[key][i] = '';
-          else
-            map[key][i] = _inspect(item[key]);
-        }
-      }
-    }
-
-    const keys = ObjectKeys(map);
-    const values = ObjectValues(map);
-    if (hasPrimitives) {
-      ArrayPrototypePush(keys, valuesKey);
-      ArrayPrototypePush(values, valuesKeyArray);
-    }
-    ArrayPrototypeUnshift(keys, indexKey);
-    ArrayPrototypeUnshift(values, indexKeyArray);
-
-    return final(keys, values);
+    buildTable ??= require('internal/util/table');
+    return this.log(
+      buildTable(tabularData, properties, this[kGetInspectOptions](this._stdout)),
+    );
   },
 };
 
-const keyKey = 'Key';
-const valuesKey = 'Values';
-const indexKey = '(index)';
-const iterKey = '(iteration index)';
-
-const isArray = (v) => ArrayIsArray(v) || isTypedArray(v) || isBuffer(v);
-
 function noop() {}
 
 for (const method of ReflectOwnKeys(consoleMethods))
diff --git a/lib/internal/util/table.js b/lib/internal/util/table.js
new file mode 100644
index 00000000000000..a7f7a924052f15
--- /dev/null
+++ b/lib/internal/util/table.js
@@ -0,0 +1,143 @@
+'use strict';
+
+const {
+  ArrayFrom,
+  ArrayIsArray,
+  ArrayPrototypePush,
+  ArrayPrototypeUnshift,
+  ObjectKeys,
+  ObjectPrototypeHasOwnProperty,
+  ObjectValues,
+} = primordials;
+
+const { previewEntries } = internalBinding('util');
+const { Buffer: { isBuffer } } = require('buffer');
+const { inspect } = require('internal/util/inspect');
+const {
+  isTypedArray, isSet, isMap, isSetIterator, isMapIterator,
+} = require('internal/util/types');
+
+const keyKey = 'Key';
+const valuesKey = 'Values';
+const indexKey = '(index)';
+const iterKey = '(iteration index)';
+
+const isArray = (v) => ArrayIsArray(v) || isTypedArray(v) || isBuffer(v);
+
+/**
+ * Builds the rows of a table from tabular data and renders them into a string.
+ * Shared by `console.table` and `util.table`.
+ * @param {any} tabularData The data to tabulate.
+ * @param {string[]} [properties] The subset of properties to include as columns.
+ * @param {object} [inspectOptions] Base options merged into each cell's inspect call.
+ * @returns {string} The rendered table.
+ */
+function table(tabularData, properties, inspectOptions) {
+  // Lazy require to avoid a cycle with the console bootstrap path.
+  const cliTable = require('internal/cli_table');
+
+  const _inspect = (v) => {
+    const depth = v !== null &&
+                  typeof v === 'object' &&
+                  !isArray(v) &&
+                  ObjectKeys(v).length > 2 ? -1 : 0;
+    const opt = {
+      depth,
+      maxArrayLength: 3,
+      breakLength: Infinity,
+      ...inspectOptions,
+    };
+    return inspect(v, opt);
+  };
+  const getIndexArray = (length) => ArrayFrom(
+    { length }, (_, i) => _inspect(i));
+
+  const mapIter = isMapIterator(tabularData);
+  let isKeyValue = false;
+  let i = 0;
+  if (mapIter) {
+    const res = previewEntries(tabularData, true);
+    tabularData = res[0];
+    isKeyValue = res[1];
+  }
+
+  if (isKeyValue || isMap(tabularData)) {
+    const keys = [];
+    const values = [];
+    let length = 0;
+    if (mapIter) {
+      for (; i < tabularData.length / 2; ++i) {
+        ArrayPrototypePush(keys, _inspect(tabularData[i * 2]));
+        ArrayPrototypePush(values, _inspect(tabularData[i * 2 + 1]));
+        length++;
+      }
+    } else {
+      for (const { 0: k, 1: v } of tabularData) {
+        ArrayPrototypePush(keys, _inspect(k));
+        ArrayPrototypePush(values, _inspect(v));
+        length++;
+      }
+    }
+    return cliTable([
+      iterKey, keyKey, valuesKey,
+    ], [
+      getIndexArray(length),
+      keys,
+      values,
+    ]);
+  }
+
+  const setIter = isSetIterator(tabularData);
+  if (setIter)
+    tabularData = previewEntries(tabularData);
+
+  const setlike = setIter || mapIter || isSet(tabularData);
+  if (setlike) {
+    // `setIter`/`mapIter` already yield arrays from `previewEntries`; a real
+    // Set is materialized once so the values can be read by index below.
+    const array = setIter || mapIter ? tabularData : ArrayFrom(tabularData);
+    const values = [];
+    for (let j = 0; j < array.length; j++)
+      ArrayPrototypePush(values, _inspect(array[j]));
+    return cliTable([iterKey, valuesKey], [getIndexArray(array.length), values]);
+  }
+
+  const map = { __proto__: null };
+  let hasPrimitives = false;
+  const valuesKeyArray = [];
+  const indexKeyArray = ObjectKeys(tabularData);
+
+  for (; i < indexKeyArray.length; i++) {
+    const item = tabularData[indexKeyArray[i]];
+    const primitive = item === null ||
+        (typeof item !== 'function' && typeof item !== 'object');
+    if (properties === undefined && primitive) {
+      hasPrimitives = true;
+      valuesKeyArray[i] = _inspect(item);
+    } else {
+      const keys = properties || ObjectKeys(item);
+      for (let k = 0; k < keys.length; k++) {
+        const key = keys[k];
+        map[key] ??= [];
+        if ((primitive && properties) ||
+             !ObjectPrototypeHasOwnProperty(item, key))
+          map[key][i] = '';
+        else
+          map[key][i] = _inspect(item[key]);
+      }
+    }
+  }
+
+  const keys = ObjectKeys(map);
+  const values = ObjectValues(map);
+  if (hasPrimitives) {
+    ArrayPrototypePush(keys, valuesKey);
+    ArrayPrototypePush(values, valuesKeyArray);
+  }
+  ArrayPrototypeUnshift(keys, indexKey);
+  ArrayPrototypeUnshift(values, indexKeyArray);
+
+  return cliTable(keys, values);
+}
+
+module.exports = table;
diff --git a/lib/util.js b/lib/util.js
index e828229380d9e8..c38bf2cd4f867a 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -63,6 +63,7 @@ const {
 } = require('internal/util/inspect');
 const { debuglog } = require('internal/util/debuglog');
 const {
+  validateArray,
   validateBoolean,
   validateFunction,
   validateNumber,
@@ -326,6 +327,29 @@ function styleText(format, text, options) {
   return `${openCodes}${processedText}${closeCodes}`;
 }
 
+let buildTable;
+/**
+ * Renders tabular data as a string using the same layout as `console.table`,
+ * but returns it instead of writing to a stream.
+ * @param {any} tabularData The data to tabulate.
+ * @param {string[]} [properties] The subset of properties to render as columns.
+ * @param {object} [options] Options forwarded to `util.inspect` for each cell.
+ * @returns {string} The rendered table, or the inspected value when the input
+ *   is not tabular (e.g. a primitive).
+ */
+function table(tabularData, properties, options) {
+  if (properties !== undefined)
+    validateArray(properties, 'properties');
+  if (options !== undefined)
+    validateObject(options, 'options');
+
+  if (tabularData === null || typeof tabularData !== 'object')
+    return inspect(tabularData, options);
+
+  buildTable ??= require('internal/util/table');
+  return buildTable(tabularData, properties, options);
+}
+
 /**
  * Inherit the prototype methods from one constructor into another.
  *
@@ -603,6 +627,7 @@ module.exports = {
   deprecate,
   format,
   styleText,
+  table,
   formatWithOptions,
   getCallSites,
   getSystemErrorMap,
diff --git a/test/parallel/test-util-table.js b/test/parallel/test-util-table.js
new file mode 100644
index 00000000000000..72f4c77a355d53
--- /dev/null
+++ b/test/parallel/test-util-table.js
@@ -0,0 +1,78 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const util = require('util');
+
+// `util.table` returns the rendered table as a string instead of writing it.
+assert.strictEqual(typeof util.table([{ a: 1 }]), 'string');
+
+// Array of objects.
+assert.strictEqual(
+  util.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]),
+  '┌─────────┬─────┬─────┐\n' +
+  '│ (index) │ a   │ b   │\n' +
+  '├─────────┼─────┼─────┤\n' +
+  "│ 0       │ 1   │ 'Y' │\n" +
+  "│ 1       │ 'Z' │ 2   │\n" +
+  '└─────────┴─────┴─────┘',
+);
+
+// Properties subset selects the columns to render.
+assert.strictEqual(
+  util.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']),
+  '┌─────────┬─────┐\n' +
+  '│ (index) │ a   │\n' +
+  '├─────────┼─────┤\n' +
+  '│ 0       │ 1   │\n' +
+  "│ 1       │ 'Z' │\n" +
+  '└─────────┴─────┘',
+);
+
+// Map.
+assert.strictEqual(
+  util.table(new Map([['a', 1], ['b', 2]])),
+  '┌───────────────────┬─────┬────────┐\n' +
+  '│ (iteration index) │ Key │ Values │\n' +
+  '├───────────────────┼─────┼────────┤\n' +
+  "│ 0                 │ 'a' │ 1      │\n" +
+  "│ 1                 │ 'b' │ 2      │\n" +
+  '└───────────────────┴─────┴────────┘',
+);
+
+// Set.
+assert.strictEqual(
+  util.table(new Set([1, 2])),
+  '┌───────────────────┬────────┐\n' +
+  '│ (iteration index) │ Values │\n' +
+  '├───────────────────┼────────┤\n' +
+  '│ 0                 │ 1      │\n' +
+  '│ 1                 │ 2      │\n' +
+  '└───────────────────┴────────┘',
+);
+
+// Non-tabular input falls back to `util.inspect`.
+assert.strictEqual(util.table(42), '42');
+assert.strictEqual(util.table('hi'), "'hi'");
+assert.strictEqual(util.table(null), 'null');
+
+// `options` is forwarded to inspect for each cell.
+assert.strictEqual(
+  util.table([{ a: 'abcdef' }], undefined, { maxStringLength: 3 }),
+  '┌─────────┬────────────────────────────┐\n' +
+  '│ (index) │ a                          │\n' +
+  '├─────────┼────────────────────────────┤\n' +
+  "│ 0       │ 'abc'... 3 more characters │\n" +
+  '└─────────┴────────────────────────────┘',
+);
+
+// Argument validation.
+assert.throws(() => util.table([], 'nope'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+});
+assert.throws(() => util.table([], undefined, 'nope'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+});