diff --git a/doc/api/process.md b/doc/api/process.md
index a4296b6d974d94..f269e2961d14fe 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -2260,6 +2260,29 @@ process.kill(process.pid, 'SIGHUP');
 When `SIGUSR1` is received by a Node.js process, Node.js will start the
 debugger. See [Signal Events][].
 
+## `process.loadEnvFile(path)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development
+
+* `path` {string | URL | Buffer | undefined}. **Default:** `'./.env'`
+
+Loads the `.env` file into `process.env`. Usage of `NODE_OPTIONS`
+in the `.env` file will not have any effect on Node.js.
+
+```cjs
+const { loadEnvFile } = require('node:process');
+loadEnvFile();
+```
+
+```mjs
+import { loadEnvFile } from 'node:process';
+loadEnvFile();
+```
+
 ## `process.mainModule`
 
 <!-- YAML
diff --git a/doc/api/util.md b/doc/api/util.md
index 4e7cb2e6dd1629..8b168ab9b4b0e9 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -1593,6 +1593,36 @@ $ node negate.js --no-logfile --logfile=test.log --color --no-color
 { logfile: 'test.log', color: false }
 ```
 
+## `util.parseEnv(content)`
+
+> Stability: 1.1 - Active development
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `content` {string}
+
+The raw contents of a `.env` file.
+
+* Returns: {Object}
+
+Given an example `.env` file:
+
+```cjs
+const { parseEnv } = require('node:util');
+
+parseEnv('HELLO=world\nHELLO=oh my\n');
+// Returns: { HELLO: 'oh my' }
+```
+
+```mjs
+import { parseEnv } from 'node:util';
+
+parseEnv('HELLO=world\nHELLO=oh my\n');
+// Returns: { HELLO: 'oh my' }
+```
+
 ## `util.promisify(original)`
 
 <!-- YAML
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 7a773d5208e250..8812c3b35184b2 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -172,6 +172,7 @@ const rawMethods = internalBinding('process_methods');
   process._kill = rawMethods._kill;
 
   const wrapped = perThreadSetup.wrapProcessMethods(rawMethods);
+  process.loadEnvFile = wrapped.loadEnvFile;
   process._rawDebug = wrapped._rawDebug;
   process.cpuUsage = wrapped.cpuUsage;
   process.resourceUsage = wrapped.resourceUsage;
diff --git a/lib/internal/process/per_thread.js b/lib/internal/process/per_thread.js
index 89428cf916aa29..b45f2a61e0ddaf 100644
--- a/lib/internal/process/per_thread.js
+++ b/lib/internal/process/per_thread.js
@@ -46,6 +46,8 @@ const {
   validateNumber,
   validateObject,
 } = require('internal/validators');
+const { getValidatedPath } = require('internal/fs/utils');
+const { toNamespacedPath } = require('path');
 const constants = internalBinding('constants').os.signals;
 
 const kInternal = Symbol('internal properties');
@@ -100,6 +102,7 @@ function wrapProcessMethods(binding) {
     memoryUsage: _memoryUsage,
     rss,
     resourceUsage: _resourceUsage,
+    loadEnvFile: _loadEnvFile,
   } = binding;
 
   function _rawDebug(...args) {
@@ -250,6 +253,19 @@ function wrapProcessMethods(binding) {
     };
   }
 
+  /**
+   * Loads the `.env` file to process.env.
+   * @param {string | URL | Buffer | undefined} path
+   */
+  function loadEnvFile(path = undefined) { // Provide optional value so that `loadEnvFile.length` returns 0
+    if (path != null) {
+      path = getValidatedPath(path);
+      _loadEnvFile(toNamespacedPath(path));
+    } else {
+      _loadEnvFile();
+    }
+  }
+
 
   return {
     _rawDebug,
@@ -258,6 +274,7 @@ function wrapProcessMethods(binding) {
     memoryUsage,
     kill,
     exit,
+    loadEnvFile,
   };
 }
 
diff --git a/lib/util.js b/lib/util.js
index 633807c6419b83..276d26e8a75aa0 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -67,9 +67,11 @@ const { debuglog } = require('internal/util/debuglog');
 const {
   validateFunction,
   validateNumber,
+  validateString,
 } = require('internal/validators');
 const { isBuffer } = require('buffer').Buffer;
 const types = require('internal/util/types');
+const binding = internalBinding('util');
 
 const {
   deprecate,
@@ -371,6 +373,16 @@ function _exceptionWithHostPort(...args) {
   return new ExceptionWithHostPort(...args);
 }
 
+/**
+ * Parses the content of a `.env` file.
+ * @param {string} content
+ * @returns {Record<string, string>}
+ */
+function parseEnv(content) {
+  validateString(content, 'content');
+  return binding.parseEnv(content);
+}
+
 // Keep the `exports =` so that various functions can still be monkeypatched
 module.exports = {
   _errnoException,
@@ -424,6 +436,7 @@ module.exports = {
     return lazyAbortController().aborted;
   },
   types,
+  parseEnv,
 };
 
 defineLazyProperties(
diff --git a/src/node.cc b/src/node.cc
index c2ae191bdc18a0..117b4d8e71439d 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -867,9 +867,18 @@ static ExitCode InitializeNodeWithArgsInternal(
     CHECK(!per_process::v8_initialized);
 
     for (const auto& file_path : file_paths) {
-      bool path_exists = per_process::dotenv_file.ParsePath(file_path);
-
-      if (!path_exists) errors->push_back(file_path + ": not found");
+      switch (per_process::dotenv_file.ParsePath(file_path)) {
+        case Dotenv::ParseResult::Valid:
+          break;
+        case Dotenv::ParseResult::InvalidContent:
+          errors->push_back(file_path + ": invalid format");
+          break;
+        case Dotenv::ParseResult::FileError:
+          errors->push_back(file_path + ": not found");
+          break;
+        default:
+          UNREACHABLE();
+      }
     }
 
     per_process::dotenv_file.AssignNodeOptionsIfAvailable(&node_options);
diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc
index 7376a97636f1b1..718e5407040505 100644
--- a/src/node_dotenv.cc
+++ b/src/node_dotenv.cc
@@ -5,7 +5,9 @@
 
 namespace node {
 
+using v8::Local;
 using v8::NewStringType;
+using v8::Object;
 using v8::String;
 
 std::vector<std::string> Dotenv::GetPathFromArgs(
@@ -64,14 +66,47 @@ void Dotenv::SetEnvironment(node::Environment* env) {
   }
 }
 
-bool Dotenv::ParsePath(const std::string_view path) {
+Local<Object> Dotenv::ToObject(Environment* env) {
+  Local<Object> result = Object::New(env->isolate());
+
+  for (const auto& entry : store_) {
+    auto key = entry.first;
+    auto value = entry.second;
+
+    result
+        ->Set(
+            env->context(),
+            v8::String::NewFromUtf8(
+                env->isolate(), key.data(), NewStringType::kNormal, key.size())
+                .ToLocalChecked(),
+            v8::String::NewFromUtf8(env->isolate(),
+                                    value.data(),
+                                    NewStringType::kNormal,
+                                    value.size())
+                .ToLocalChecked())
+        .Check();
+  }
+
+  return result;
+}
+
+void Dotenv::ParseContent(const std::string_view content) {
+  using std::string_view_literals::operator""sv;
+  auto lines = SplitString(content, "\n"sv);
+
+  for (const auto& line : lines) {
+    ParseLine(line);
+  }
+}
+
+Dotenv::ParseResult Dotenv::ParsePath(const std::string_view path) {
   uv_fs_t req;
   auto defer_req_cleanup = OnScopeLeave([&req]() { uv_fs_req_cleanup(&req); });
 
   uv_file file = uv_fs_open(nullptr, &req, path.data(), 0, 438, nullptr);
   if (req.result < 0) {
     // req will be cleaned up by scope leave.
-    return false;
+    return ParseResult::FileError;
   }
   uv_fs_req_cleanup(&req);
 
@@ -89,7 +124,7 @@ bool Dotenv::ParsePath(const std::string_view path) {
     auto r = uv_fs_read(nullptr, &req, file, &buf, 1, -1, nullptr);
     if (req.result < 0) {
       // req will be cleaned up by scope leave.
-      return false;
+      return ParseResult::InvalidContent;
     }
     uv_fs_req_cleanup(&req);
     if (r <= 0) {
@@ -98,13 +133,8 @@ bool Dotenv::ParsePath(const std::string_view path) {
     result.append(buf.base, r);
   }
 
-  using std::string_view_literals::operator""sv;
-  auto lines = SplitString(result, "\n"sv);
-
-  for (const auto& line : lines) {
-    ParseLine(line);
-  }
-  return true;
+  ParseContent(result);
+  return ParseResult::Valid;
 }
 
 void Dotenv::AssignNodeOptionsIfAvailable(std::string* node_options) {
diff --git a/src/node_dotenv.h b/src/node_dotenv.h
index cc87008d149f43..f2a9ce56f41570 100644
--- a/src/node_dotenv.h
+++ b/src/node_dotenv.h
@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "util-inl.h"
+#include "v8.h"
 
 #include <map>
 
@@ -11,6 +12,8 @@ namespace node {
 
 class Dotenv {
  public:
+  enum ParseResult { Valid, FileError, InvalidContent };
+
   Dotenv() = default;
   Dotenv(const Dotenv& d) = default;
   Dotenv(Dotenv&& d) noexcept = default;
@@ -18,9 +21,11 @@ class Dotenv {
   Dotenv& operator=(const Dotenv& d) = default;
   ~Dotenv() = default;
 
-  bool ParsePath(const std::string_view path);
+  void ParseContent(const std::string_view content);
+  ParseResult ParsePath(const std::string_view path);
   void AssignNodeOptionsIfAvailable(std::string* node_options);
   void SetEnvironment(Environment* env);
+  v8::Local<v8::Object> ToObject(Environment* env);
 
   static std::vector<std::string> GetPathFromArgs(
       const std::vector<std::string>& args);
diff --git a/src/node_process.h b/src/node_process.h
index ee6e6a81676bd6..0a1f65e9bdfa24 100644
--- a/src/node_process.h
+++ b/src/node_process.h
@@ -84,6 +84,8 @@ class BindingData : public SnapshotableObject {
 
   static void SlowBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+  static void LoadEnvFile(const v8::FunctionCallbackInfo<v8::Value>& args);
+
  private:
   // Buffer length in uint32.
   static constexpr size_t kHrTimeBufferLength = 3;
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index cdbe07947b01d1..e8d621ddb48bd2 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -4,6 +4,7 @@
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
+#include "node_dotenv.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
@@ -463,6 +464,38 @@ static void ReallyExit(const FunctionCallbackInfo<Value>& args) {
   env->Exit(code);
 }
 
+static void LoadEnvFile(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  std::string path = ".env";
+  if (args.Length() == 1) {
+    Utf8Value path_value(args.GetIsolate(), args[0]);
+    path = path_value.ToString();
+  }
+
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kFileSystemRead, path);
+
+  Dotenv dotenv{};
+
+  switch (dotenv.ParsePath(path)) {
+    case dotenv.ParseResult::Valid: {
+      dotenv.SetEnvironment(env);
+      break;
+    }
+    case dotenv.ParseResult::InvalidContent: {
+      THROW_ERR_INVALID_ARG_TYPE(
+          env, "Contents of '%s' should be a valid string.", path.c_str());
+      break;
+    }
+    case dotenv.ParseResult::FileError: {
+      env->ThrowUVException(UV_ENOENT, "Failed to load '%s'.", path.c_str());
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+}
+
 namespace process {
 
 BindingData::BindingData(Realm* realm,
@@ -616,6 +649,8 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "reallyExit", ReallyExit);
   SetMethodNoSideEffect(isolate, target, "uptime", Uptime);
   SetMethod(isolate, target, "patchProcessObject", PatchProcessObject);
+
+  SetMethod(isolate, target, "loadEnvFile", LoadEnvFile);
 }
 
 static void CreatePerContextProperties(Local<Object> target,
@@ -653,6 +688,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(ReallyExit);
   registry->Register(Uptime);
   registry->Register(PatchProcessObject);
+
+  registry->Register(LoadEnvFile);
 }
 
 }  // namespace process
diff --git a/src/node_util.cc b/src/node_util.cc
index dfdd87d297e1e2..8fb7426605869d 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -1,4 +1,5 @@
 #include "base_object-inl.h"
+#include "node_dotenv.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "util-inl.h"
@@ -237,6 +238,16 @@ static uint32_t FastGuessHandleType(Local<Value> receiver, const uint32_t fd) {
 
 CFunction fast_guess_handle_type_(CFunction::Make(FastGuessHandleType));
 
+static void ParseEnv(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK_EQ(args.Length(), 1);  // content
+  CHECK(args[0]->IsString());
+  Utf8Value content(env->isolate(), args[0]);
+  Dotenv dotenv{};
+  dotenv.ParseContent(content.ToStringView());
+  args.GetReturnValue().Set(dotenv.ToObject(env));
+}
+
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetPromiseDetails);
   registry->Register(GetProxyDetails);
@@ -251,6 +262,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GuessHandleType);
   registry->Register(FastGuessHandleType);
   registry->Register(fast_guess_handle_type_.GetTypeInfo());
+  registry->Register(ParseEnv);
 }
 
 void Initialize(Local<Object> target,
@@ -348,6 +360,7 @@ void Initialize(Local<Object> target,
       context, target, "getConstructorName", GetConstructorName);
   SetMethodNoSideEffect(context, target, "getExternalValue", GetExternalValue);
   SetMethod(context, target, "sleep", Sleep);
+  SetMethod(context, target, "parseEnv", ParseEnv);
 
   SetMethod(
       context, target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
diff --git a/test/fixtures/dotenv/.env b/test/fixtures/dotenv/.env
new file mode 100644
index 00000000000000..f098ff6c5e8258
--- /dev/null
+++ b/test/fixtures/dotenv/.env
@@ -0,0 +1 @@
+BASIC=basic
diff --git a/test/fixtures/dotenv/basic-valid.env b/test/fixtures/dotenv/basic-valid.env
new file mode 100644
index 00000000000000..8b7407914c7404
--- /dev/null
+++ b/test/fixtures/dotenv/basic-valid.env
@@ -0,0 +1 @@
+BASIC=overriden
diff --git a/test/parallel/test-process-load-env-file.js b/test/parallel/test-process-load-env-file.js
new file mode 100644
index 00000000000000..a07ba6771bb381
--- /dev/null
+++ b/test/parallel/test-process-load-env-file.js
@@ -0,0 +1,89 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../../test/common/fixtures');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+const basicValidEnvFilePath = fixtures.path('dotenv/basic-valid.env');
+const validEnvFilePath = fixtures.path('dotenv/valid.env');
+const missingEnvFile = fixtures.path('dotenv/non-existent-file.env');
+
+describe('process.loadEnvFile()', () => {
+
+  it('supports passing path', async () => {
+    const code = `
+      process.loadEnvFile(${JSON.stringify(validEnvFilePath)});
+      const assert = require('assert');
+      assert.strictEqual(process.env.BASIC, 'basic');
+    `.trim();
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ '--eval', code ],
+      { cwd: __dirname },
+    );
+    assert.strictEqual(child.stderr, '');
+    assert.strictEqual(child.code, 0);
+  });
+
+  it('supports not-passing a path', async () => {
+    // Uses `../fixtures/dotenv/.env` file.
+    const code = `
+      process.loadEnvFile();
+      const assert = require('assert');
+      assert.strictEqual(process.env.BASIC, 'basic');
+    `.trim();
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ '--eval', code ],
+      { cwd: fixtures.path('dotenv/') },
+    );
+    assert.strictEqual(child.stderr, '');
+    assert.strictEqual(child.code, 0);
+  });
+
+  it('should throw when file does not exist', async () => {
+    assert.throws(() => {
+      process.loadEnvFile(missingEnvFile);
+    }, { code: 'ENOENT' });
+  });
+
+  it('should throw when `.env` does not exist', async () => {
+    assert.throws(() => {
+      process.loadEnvFile();
+    }, { code: 'ENOENT' });
+  });
+
+  it('should check for permissions', async () => {
+    const code = `
+      process.loadEnvFile(${JSON.stringify(missingEnvFile)});
+    `.trim();
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ '--eval', code, '--experimental-permission' ],
+      { cwd: __dirname },
+    );
+    assert.match(child.stderr, /Error: Access to this API has been restricted/);
+    assert.match(child.stderr, /code: 'ERR_ACCESS_DENIED'/);
+    assert.match(child.stderr, /permission: 'FileSystemRead'/);
+    if (!common.isWindows) {
+      assert(child.stderr.includes(`resource: '${JSON.stringify(missingEnvFile).replaceAll('"', '')}'`));
+    }
+    assert.strictEqual(child.code, 1);
+  });
+
+  it('loadEnvFile does not mutate --env-file output', async () => {
+    const code = `
+      process.loadEnvFile(${JSON.stringify(basicValidEnvFilePath)});
+      require('assert')(process.env.BASIC === 'basic');
+    `.trim();
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ `--env-file=${validEnvFilePath}`, '--eval', code ],
+      { cwd: __dirname },
+    );
+    assert.strictEqual(child.stdout, '');
+    assert.strictEqual(child.stderr, '');
+    assert.strictEqual(child.code, 0);
+  });
+});
diff --git a/test/parallel/util-parse-env.js b/test/parallel/util-parse-env.js
new file mode 100644
index 00000000000000..54488e50da91c8
--- /dev/null
+++ b/test/parallel/util-parse-env.js
@@ -0,0 +1,59 @@
+'use strict';
+
+require('../common');
+const fixtures = require('../../test/common/fixtures');
+const assert = require('node:assert');
+const util = require('node:util');
+const fs = require('node:fs');
+
+{
+  const validEnvFilePath = fixtures.path('dotenv/valid.env');
+  const validContent = fs.readFileSync(validEnvFilePath, 'utf8');
+
+  assert.deepStrictEqual(util.parseEnv(validContent), {
+    AFTER_LINE: 'after_line',
+    BACKTICKS: 'backticks',
+    BACKTICKS_INSIDE_DOUBLE: '`backticks` work inside double quotes',
+    BACKTICKS_INSIDE_SINGLE: '`backticks` work inside single quotes',
+    BACKTICKS_SPACED: '    backticks    ',
+    BASIC: 'basic',
+    DOUBLE_AND_SINGLE_QUOTES_INSIDE_BACKTICKS: 'double "quotes" and single \'quotes\' work inside backticks',
+    DOUBLE_QUOTES: 'double_quotes',
+    DOUBLE_QUOTES_INSIDE_BACKTICKS: 'double "quotes" work inside backticks',
+    DOUBLE_QUOTES_INSIDE_SINGLE: 'double "quotes" work inside single quotes',
+    DOUBLE_QUOTES_SPACED: '    double quotes    ',
+    DOUBLE_QUOTES_WITH_NO_SPACE_BRACKET: '{ port: $MONGOLAB_PORT}',
+    EMAIL: 'therealnerdybeast@example.tld',
+    EMPTY: '',
+    EMPTY_BACKTICKS: '',
+    EMPTY_DOUBLE_QUOTES: '',
+    EMPTY_SINGLE_QUOTES: '',
+    EQUAL_SIGNS: 'equals==',
+    INLINE_COMMENTS: 'inline comments',
+    INLINE_COMMENTS_BACKTICKS: 'inline comments outside of #backticks',
+    INLINE_COMMENTS_DOUBLE_QUOTES: 'inline comments outside of #doublequotes',
+    INLINE_COMMENTS_SINGLE_QUOTES: 'inline comments outside of #singlequotes',
+    INLINE_COMMENTS_SPACE: 'inline comments start with a',
+    RETAIN_INNER_QUOTES: '{"foo": "bar"}',
+    RETAIN_INNER_QUOTES_AS_BACKTICKS: '{"foo": "bar\'s"}',
+    RETAIN_INNER_QUOTES_AS_STRING: '{"foo": "bar"}',
+    SINGLE_QUOTES: 'single_quotes',
+    SINGLE_QUOTES_INSIDE_BACKTICKS: "single 'quotes' work inside backticks",
+    SINGLE_QUOTES_INSIDE_DOUBLE: "single 'quotes' work inside double quotes",
+    SINGLE_QUOTES_SPACED: '    single quotes    ',
+    SPACED_KEY: 'parsed',
+    TRIM_SPACE_FROM_UNQUOTED: 'some spaced out string'
+  });
+}
+
+assert.deepStrictEqual(util.parseEnv(''), {});
+assert.deepStrictEqual(util.parseEnv('FOO=bar\nFOO=baz\n'), { FOO: 'baz' });
+
+// Test for invalid input.
+assert.throws(() => {
+  for (const value of [null, undefined, {}, []]) {
+    util.parseEnv(value);
+  }
+}, {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
diff --git a/typings/internalBinding/util.d.ts b/typings/internalBinding/util.d.ts
index 9034b892b26549..9963d07d7f87c2 100644
--- a/typings/internalBinding/util.d.ts
+++ b/typings/internalBinding/util.d.ts
@@ -43,4 +43,5 @@ export interface UtilBinding {
   shouldAbortOnUncaughtToggle: [shouldAbort: 0 | 1];
   WeakReference: typeof InternalUtilBinding.WeakReference;
   guessHandleType(fd: number): 'TCP' | 'TTY' | 'UDP' | 'FILE' | 'PIPE' | 'UNKNOWN';
+  parseEnv(content: string): Record<string, string>;
 }