diff --git a/doc/api/process.md b/doc/api/process.md
index 0a7f85700ae85a..f447aa66914ca4 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1513,6 +1513,18 @@ emitMyWarning();
 // Emits nothing
 ```
 
+## `process.entrypoint`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {URL | undefined}
+
+The entry point that Node.js was started with. Worker threads inherit this
+value. If Node.js was started without an entry point, such as in the REPL, the
+value is {undefined}.
+
 ## `process.env`
 
 <!-- YAML
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 8a58dc0cba0f49..42bf1ee805fe2e 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -14,6 +14,7 @@ const {
 } = primordials;
 
 const {
+  defineEntrypoint,
   prepareWorkerThreadExecution,
   initializeModuleLoaders,
   markBootstrapComplete,
@@ -95,6 +96,7 @@ port.on('message', (message) => {
       argv,
       cwdCounter,
       doEval,
+      entrypoint,
       environmentData,
       filename,
       hasStdin,
@@ -103,6 +105,10 @@ port.on('message', (message) => {
       mainThreadPort,
     } = message;
 
+    const { URL } = require('internal/url');
+    defineEntrypoint(entrypoint === undefined ?
+      undefined : new URL(entrypoint));
+
     if (doEval !== 'internal') {
       if (argv !== undefined) {
         ArrayPrototypePushApply(process.argv, argv);
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 804d588b62ba19..b09ff3d3169e3f 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -27,6 +27,7 @@ const {
   setupCoverageHooks,
   emitExperimentalWarning,
   deprecate,
+  getCWDURL,
 } = require('internal/util');
 
 const {
@@ -254,6 +255,16 @@ function refreshRuntimeOptions() {
   refreshOptions();
 }
 
+function defineEntrypoint(entrypoint) {
+  ObjectDefineProperty(process, 'entrypoint', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: true,
+    value: entrypoint,
+  });
+}
+
 /**
  * Patch the process object with legacy properties and normalizations.
  * Replace `process.argv[0]` with `process.execPath`, preserving the original `argv[0]` value as `process.argv0`.
@@ -294,6 +305,16 @@ function patchProcessObject(expandArgv1) {
     }
   }
 
+  let entrypoint;
+  if (mainEntry !== undefined) {
+    const { pathToFileURL } = require('internal/url');
+    entrypoint = pathToFileURL(mainEntry);
+  } else if (getOptionValue('--entry-url') && process.argv[1]) {
+    const { URL } = require('internal/url');
+    entrypoint = new URL(process.argv[1], getCWDURL());
+  }
+  defineEntrypoint(entrypoint);
+
   // We need to initialize the global console here again with process.stdout
   // and friends for snapshot deserialization.
   const globalConsole = require('internal/console/global');
@@ -824,6 +845,7 @@ function getHeapSnapshotFilename(diagnosticDir) {
 }
 
 module.exports = {
+  defineEntrypoint,
   initializeModuleLoaders,
   prepareMainThreadExecution,
   prepareWorkerThreadExecution,
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 3afd2180d705f6..d7bd9feb5e7afe 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -362,6 +362,7 @@ class Worker extends EventEmitter {
 
     this[kPort].postMessage({
       argv,
+      entrypoint: process.entrypoint?.href,
       type: messageTypes.LOAD_SCRIPT,
       filename,
       doEval,
diff --git a/test/fixtures/entrypoint/check-commonjs.cjs b/test/fixtures/entrypoint/check-commonjs.cjs
new file mode 100644
index 00000000000000..9e11d41631d79f
--- /dev/null
+++ b/test/fixtures/entrypoint/check-commonjs.cjs
@@ -0,0 +1,5 @@
+'use strict';
+
+const assert = require('node:assert');
+
+assert.strictEqual(process.entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/check-module.mjs b/test/fixtures/entrypoint/check-module.mjs
new file mode 100644
index 00000000000000..07f18768647c57
--- /dev/null
+++ b/test/fixtures/entrypoint/check-module.mjs
@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/commonjs.cjs b/test/fixtures/entrypoint/commonjs.cjs
new file mode 100644
index 00000000000000..f1c28fad08aea1
--- /dev/null
+++ b/test/fixtures/entrypoint/commonjs.cjs
@@ -0,0 +1 @@
+console.log(process.entrypoint.href);
diff --git a/test/fixtures/entrypoint/loader.mjs b/test/fixtures/entrypoint/loader.mjs
new file mode 100644
index 00000000000000..07f18768647c57
--- /dev/null
+++ b/test/fixtures/entrypoint/loader.mjs
@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/module.mjs b/test/fixtures/entrypoint/module.mjs
new file mode 100644
index 00000000000000..f1c28fad08aea1
--- /dev/null
+++ b/test/fixtures/entrypoint/module.mjs
@@ -0,0 +1 @@
+console.log(process.entrypoint.href);
diff --git a/test/fixtures/entrypoint/worker.cjs b/test/fixtures/entrypoint/worker.cjs
new file mode 100644
index 00000000000000..9ace1cf2a8d805
--- /dev/null
+++ b/test/fixtures/entrypoint/worker.cjs
@@ -0,0 +1,9 @@
+'use strict';
+
+const { isMainThread, workerData, Worker } = require('node:worker_threads');
+
+if (isMainThread || workerData === 'nested') {
+  new Worker(__filename, { workerData: isMainThread ? 'nested' : 'leaf' });
+} else {
+  console.log(process.entrypoint.href);
+}
diff --git a/test/parallel/test-process-entrypoint.js b/test/parallel/test-process-entrypoint.js
new file mode 100644
index 00000000000000..ed054ac50898eb
--- /dev/null
+++ b/test/parallel/test-process-entrypoint.js
@@ -0,0 +1,118 @@
+'use strict';
+
+const { spawnPromisified } = require('../common');
+const fixtures = require('../common/fixtures');
+
+const assert = require('node:assert');
+const { execPath } = require('node:process');
+const { describe, it } = require('node:test');
+
+const cjsFixture = fixtures.path('entrypoint', 'commonjs.cjs');
+const cjsFixtureURL = fixtures.fileURL('entrypoint', 'commonjs.cjs').href;
+
+const mjsFixture = fixtures.path('entrypoint', 'module.mjs');
+const mjsFixtureURL = fixtures.fileURL('entrypoint', 'module.mjs').href;
+
+const workerFixture = fixtures.path('entrypoint', 'worker.cjs');
+const workerFixtureURL = fixtures.fileURL('entrypoint', 'worker.cjs').href;
+
+const cjsPreload = fixtures.path('entrypoint', 'check-commonjs.cjs');
+const esmPreload = fixtures.fileURL('entrypoint', 'check-module.mjs').href;
+const loader = fixtures.fileURL('entrypoint', 'loader.mjs').href;
+
+const printEntrypoint = 'console.log(process.entrypoint?.href)';
+
+async function getEntrypoint(args, options, expected) {
+  const { code, signal, stderr, stdout } = await spawnPromisified(
+    execPath,
+    args,
+    {
+      ...options,
+      env: {
+        ...process.env,
+        NODE_TEST_ENTRYPOINT: expected,
+      },
+    },
+  );
+  assert.strictEqual(code, 0, stderr);
+  assert.strictEqual(signal, null);
+
+  return stdout.trim();
+}
+
+const testCases = [
+  {
+    name: 'is the file URL of a CommonJS entry point',
+    args: [cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'is the file URL of an ES module entry point',
+    args: [mjsFixture],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'is absolute when passed a relative path',
+    args: ['./commonjs.cjs'],
+    options: { cwd: fixtures.path('entrypoint') },
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --require',
+    args: ['--require', cjsPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --import',
+    args: ['--import', esmPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --loader',
+    args: ['--loader', loader, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when combining preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      mjsFixture,
+    ],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'is inherited by worker threads and their preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      workerFixture,
+    ],
+    expected: workerFixtureURL,
+  },
+  {
+    name: 'supports non-file --entry-url entry points',
+    args: ['--entry-url', `data:text/javascript,${printEntrypoint}`],
+    expected: `data:text/javascript,${printEntrypoint}`,
+  },
+  {
+    name: 'is undefined when evaluating CommonJS without an entry point',
+    args: ['--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+  {
+    name: 'is undefined when evaluating an ES module without an entry point',
+    args: ['--input-type=module', '--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+];
+
+describe('process.entrypoint', { concurrency: true }, () => {
+  for (const { name, args, options, expected } of testCases) {
+    it(name, async () => {
+      assert.strictEqual(await getEntrypoint(args, options, expected), expected);
+    });
+  }
+});