diff --git a/doc/api/errors.md b/doc/api/errors.md
index a03b1f6fc2572a..89bf8b044eb573 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1108,6 +1108,14 @@ The JS execution context is not associated with a Node.js environment.
 This may occur when Node.js is used as an embedded library and some hooks
 for the JS engine are not set up properly.
 
+<a id="ERR_FAILED_IMPORT_ASSERTION"></a>
+### `ERR_FAILED_IMPORT_ASSERTION`
+<!-- YAML
+added: REPLACEME
+-->
+
+An import assertion has failed, preventing the specified module to be imported.
+
 <a id="ERR_FALSY_VALUE_REJECTION"></a>
 ### `ERR_FALSY_VALUE_REJECTION`
 
@@ -1659,6 +1667,14 @@ for more information.
 
 An invalid HTTP token was supplied.
 
+<a id="ERR_INVALID_IMPORT_ASSERTION"></a>
+### `ERR_INVALID_IMPORT_ASSERTION`
+<!-- YAML
+added: REPLACEME
+-->
+
+An import assertion is not supported by this version of Node.js.
+
 <a id="ERR_INVALID_IP_ADDRESS"></a>
 ### `ERR_INVALID_IP_ADDRESS`
 
diff --git a/doc/api/esm.md b/doc/api/esm.md
index 9d7792441ca6fd..15158dcaca3031 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -5,6 +5,9 @@
 <!-- YAML
 added: v8.5.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Add support for import assertions.
   - version:
     - REPLACEME
     pr-url: https://github.com/nodejs/node/pull/37468
@@ -228,6 +231,25 @@ absolute URL strings.
 import fs from 'node:fs/promises';
 ```
 
+## Import assertions
+<!-- YAML
+added: REPLACEME
+-->
+
+The [Import Assertions proposal][] adds an inline syntax for module import
+statements to pass on more information alongside the module specifier.
+
+```js
+import json from './foo.json' assert { type: "json" };
+await import('foo.json', { assert: { type: "json" } });
+```
+
+Node.js supports the following `type` values:
+
+| `type`   | Resolves to      |
+| -------- | ---------------- |
+| `"json"` | [JSON modules][] |
+
 ## Builtin modules
 
 [Core modules][] provide named exports of their public API. A
@@ -516,9 +538,8 @@ same path.
 
 Assuming an `index.mjs` with
 
-<!-- eslint-skip -->
 ```js
-import packageConfig from './package.json';
+import packageConfig from './package.json' assert { type: 'json' };
 ```
 
 The `--experimental-json-modules` flag is needed for the module
@@ -1367,6 +1388,8 @@ success!
 [Dynamic `import()`]: https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports
 [ECMAScript Top-Level `await` proposal]: https://github.com/tc39/proposal-top-level-await/
 [ES Module Integration Proposal for Web Assembly]: https://github.com/webassembly/esm-integration
+[Import Assertions proposal]: https://github.com/tc39/proposal-import-assertions
+[JSON modules]: #json-modules
 [Node.js Module Resolution Algorithm]: #resolver-algorithm-specification
 [Terminology]: #terminology
 [URL]: https://url.spec.whatwg.org/
diff --git a/doc/api/vm.md b/doc/api/vm.md
index cff8c9b6e23bf3..2929dffa0d435f 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -54,6 +54,10 @@ executed in specific contexts.
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
   - version: v10.6.0
     pr-url: https://github.com/nodejs/node/pull/20300
     description: The `produceCachedData` is deprecated in favour of
@@ -91,6 +95,8 @@ changes:
     using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
     * `script` {vm.Script}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -642,6 +648,13 @@ The `vm.SourceTextModule` class provides the [Source Text Module Record][] as
 defined in the ECMAScript specification.
 
 ### `new vm.SourceTextModule(code[, options])`
+<!-- YAML
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
+-->
 
 * `code` {string} JavaScript Module code to parse
 * `options`
@@ -667,6 +680,8 @@ defined in the ECMAScript specification.
     `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
     * `specifier` {string} specifier passed to `import()`
     * `module` {vm.Module}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -852,6 +867,10 @@ const vm = require('vm');
 <!-- YAML
 added: v10.10.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
   - version: v15.9.0
     pr-url: https://github.com/nodejs/node/pull/35431
     description: Added `importModuleDynamically` option again.
@@ -893,6 +912,8 @@ changes:
     considered stable.
     * `specifier` {string} specifier passed to `import()`
     * `function` {Function}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -1068,6 +1089,10 @@ vm.measureMemory({ mode: 'detailed', execution: 'eager' })
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
   - version: v6.3.0
     pr-url: https://github.com/nodejs/node/pull/6635
     description: The `breakOnSigint` option is supported now.
@@ -1113,6 +1138,8 @@ changes:
     using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
     * `script` {vm.Script}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -1145,6 +1172,10 @@ console.log(contextObject);
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
   - version: v14.6.0
     pr-url: https://github.com/nodejs/node/pull/34023
     description: The `microtaskMode` option is supported now.
@@ -1211,6 +1242,8 @@ changes:
     using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
     * `script` {vm.Script}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -1247,6 +1280,10 @@ console.log(contextObject);
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/39921
+    description: Added suppoort of import assertions to the
+                 `importModuleDynamically` parameter.
   - version: v6.3.0
     pr-url: https://github.com/nodejs/node/pull/6635
     description: The `breakOnSigint` option is supported now.
@@ -1290,6 +1327,8 @@ changes:
     using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
     * `script` {vm.Script}
+    * `import_assertions` {Object} The `"assert"` value passed to the
+      `optionExpression` optional parameter.
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 84431fe811d9fc..5801de21b50778 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -953,6 +953,9 @@ E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',
   RangeError);
 E('ERR_EVAL_ESM_CANNOT_PRINT', '--print cannot be used with ESM input', Error);
 E('ERR_EVENT_RECURSION', 'The event "%s" is already being dispatched', Error);
+E('ERR_FAILED_IMPORT_ASSERTION', (request, key, expectedValue, actualValue) => {
+  return `Failed to load module "${request}", expected ${key} to be ${JSONStringify(expectedValue)}, got ${JSONStringify(actualValue)} instead`;
+}, TypeError);
 E('ERR_FALSY_VALUE_REJECTION', function(reason) {
   this.reason = reason;
   return 'Promise was rejected with falsy value';
@@ -1250,6 +1253,9 @@ E('ERR_INVALID_FILE_URL_HOST',
 E('ERR_INVALID_FILE_URL_PATH', 'File URL path %s', TypeError);
 E('ERR_INVALID_HANDLE_TYPE', 'This handle type cannot be sent', TypeError);
 E('ERR_INVALID_HTTP_TOKEN', '%s must be a valid HTTP token ["%s"]', TypeError);
+E('ERR_INVALID_IMPORT_ASSERTION',
+  (type, value) => `Invalid ${JSONStringify(type)} import assertion: ${JSONStringify(value)}`,
+  TypeError);
 E('ERR_INVALID_IP_ADDRESS', 'Invalid IP address: %s', TypeError);
 E('ERR_INVALID_MODULE_SPECIFIER', (request, reason, base = undefined) => {
   return `Invalid module "${request}" ${reason}${base ?
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index b8eff0440624a4..141dc724b96b85 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -1021,9 +1021,10 @@ function wrapSafe(filename, content, cjsModuleInstance) {
       filename,
       lineOffset: 0,
       displayErrors: true,
-      importModuleDynamically: async (specifier) => {
+      importModuleDynamically: async (specifier, _, import_assertions) => {
         const loader = asyncESM.esmLoader;
-        return loader.import(specifier, normalizeReferrerURL(filename));
+        return loader.import(specifier, normalizeReferrerURL(filename),
+                             import_assertions);
       },
     });
   }
@@ -1036,9 +1037,10 @@ function wrapSafe(filename, content, cjsModuleInstance) {
       '__dirname',
     ], {
       filename,
-      importModuleDynamically(specifier) {
+      importModuleDynamically(specifier, _, import_assertions) {
         const loader = asyncESM.esmLoader;
-        return loader.import(specifier, normalizeReferrerURL(filename));
+        return loader.import(specifier, normalizeReferrerURL(filename),
+                             import_assertions);
       },
     });
   } catch (err) {
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index b12a87a9021242..dc3fcefb03cf19 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -6,11 +6,13 @@ require('internal/modules/cjs/loader');
 const {
   Array,
   ArrayIsArray,
+  ArrayPrototypeIncludes,
   ArrayPrototypeJoin,
   ArrayPrototypePush,
   FunctionPrototypeBind,
   FunctionPrototypeCall,
   ObjectCreate,
+  ObjectFreeze,
   ObjectSetPrototypeOf,
   PromiseAll,
   RegExpPrototypeExec,
@@ -20,8 +22,10 @@ const {
 } = primordials;
 
 const {
+  ERR_FAILED_IMPORT_ASSERTION,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_IMPORT_ASSERTION,
   ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
   ERR_INVALID_RETURN_VALUE,
@@ -44,6 +48,10 @@ const { translators } = require(
   'internal/modules/esm/translators');
 const { getOptionValue } = require('internal/options');
 
+const importAssertionTypeCache = new SafeWeakMap();
+const finalFormatCache = new SafeWeakMap();
+const supportedTypes = ObjectFreeze([undefined, 'json']);
+
 /**
  * An ESMLoader instance is used as the main entry point for loading ES modules.
  * Currently, this is a singleton -- there is only one used for loading
@@ -202,8 +210,8 @@ class ESMLoader {
       const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
       const module = new ModuleWrap(url, undefined, source, 0, 0);
       callbackMap.set(module, {
-        importModuleDynamically: (specifier, { url }) => {
-          return this.import(specifier, url);
+        importModuleDynamically: (specifier, { url }, import_assertions) => {
+          return this.import(specifier, url, import_assertions);
         }
       });
 
@@ -211,6 +219,7 @@ class ESMLoader {
     };
     const job = new ModuleJob(this, url, evalInstance, false, false);
     this.moduleMap.set(url, job);
+    finalFormatCache.set(job, 'module');
     const { module } = await job.run();
 
     return {
@@ -218,17 +227,49 @@ class ESMLoader {
     };
   }
 
-  async getModuleJob(specifier, parentURL) {
+  async getModuleJob(specifier, parentURL, import_assertions) {
+    if (!ArrayPrototypeIncludes(supportedTypes, import_assertions.type)) {
+      throw new ERR_INVALID_IMPORT_ASSERTION('type', import_assertions.type);
+    }
+
     const { format, url } = await this.resolve(specifier, parentURL);
     let job = this.moduleMap.get(url);
     // CommonJS will set functions for lazy job evaluation.
     if (typeof job === 'function') this.moduleMap.set(url, job = job());
 
-    if (job !== undefined) return job;
+    if (job != null) {
+      const currentImportAssertionType = importAssertionTypeCache.get(job);
+      if (currentImportAssertionType === import_assertions.type) return job;
+
+      try {
+        // To avoid race conditions, wait for previous module to fulfill first.
+        await job.modulePromise;
+      } catch {
+        // If the other job failed with a different `type` assertion, we got
+        // another chance.
+        job = undefined;
+      }
+
+      if (job !== undefined) {
+        const finalFormat = finalFormatCache.get(job);
+        if (
+          import_assertions.type == null ||
+              (import_assertions.type === 'json' && finalFormat === 'json')
+        ) return job;
+        throw new ERR_FAILED_IMPORT_ASSERTION(
+          url, 'type', import_assertions.type, finalFormat);
+      }
+    }
 
     const moduleProvider = async (url, isMain) => {
       const { format: finalFormat, source } = await this.load(url, { format });
 
+      if (import_assertions.type === 'json' && finalFormat !== 'json') {
+        throw new ERR_FAILED_IMPORT_ASSERTION(
+          url, 'type', import_assertions.type, finalFormat);
+      }
+      finalFormatCache.set(job, finalFormat);
+
       const translator = translators.get(finalFormat);
 
       if (!translator) throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat);
@@ -249,6 +290,7 @@ class ESMLoader {
       inspectBrk
     );
 
+    importAssertionTypeCache.set(job, import_assertions.type);
     this.moduleMap.set(url, job);
 
     return job;
@@ -262,10 +304,11 @@ class ESMLoader {
    * loader module.
    *
    * @param {string | string[]} specifiers Path(s) to the module
-   * @param {string} [parentURL] Path of the parent importing the module
-   * @returns {object | object[]} A list of module export(s)
+   * @param {string} parentURL Path of the parent importing the module
+   * @param {Record<string, Record<string, string>>} import_assertions
+   * @returns {Promise<object | object[]>} A list of module export(s)
    */
-  async import(specifiers, parentURL) {
+  async import(specifiers, parentURL, import_assertions) {
     const wasArr = ArrayIsArray(specifiers);
     if (!wasArr) specifiers = [specifiers];
 
@@ -273,7 +316,7 @@ class ESMLoader {
     const jobs = new Array(count);
 
     for (let i = 0; i < count; i++) {
-      jobs[i] = this.getModuleJob(specifiers[i], parentURL)
+      jobs[i] = this.getModuleJob(specifiers[i], parentURL, import_assertions)
         .then((job) => job.run())
         .then(({ module }) => module.getNamespace());
     }
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 2f699376d6eaea..c67b816657715a 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -72,8 +72,8 @@ class ModuleJob {
       // so that circular dependencies can't cause a deadlock by two of
       // these `link` callbacks depending on each other.
       const dependencyJobs = [];
-      const promises = this.module.link(async (specifier) => {
-        const jobPromise = this.loader.getModuleJob(specifier, url);
+      const promises = this.module.link(async (specifier, assertions) => {
+        const jobPromise = this.loader.getModuleJob(specifier, url, assertions);
         ArrayPrototypePush(dependencyJobs, jobPromise);
         const job = await jobPromise;
         return job.modulePromise;
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index ba00041c417706..157e23044b07fb 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -107,8 +107,8 @@ function errPath(url) {
   return url;
 }
 
-async function importModuleDynamically(specifier, { url }) {
-  return asyncESM.esmLoader.import(specifier, url);
+async function importModuleDynamically(specifier, { url }, assertions) {
+  return asyncESM.esmLoader.import(specifier, url, assertions);
 }
 
 function createImportMetaResolve(defaultParentUrl) {
diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js
index d0c08b75e7a524..9a0263024144fb 100644
--- a/lib/internal/modules/run_main.js
+++ b/lib/internal/modules/run_main.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ObjectCreate,
   StringPrototypeEndsWith,
 } = primordials;
 const CJSLoader = require('internal/modules/cjs/loader');
@@ -46,9 +47,8 @@ function runMainESM(mainPath) {
 
   handleMainPromise(loadESM((esmLoader) => {
     const main = path.isAbsolute(mainPath) ?
-      pathToFileURL(mainPath).href :
-      mainPath;
-    return esmLoader.import(main);
+      pathToFileURL(mainPath).href : mainPath;
+    return esmLoader.import(main, undefined, ObjectCreate(null));
   }));
 }
 
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 0f04ca97751ef6..73385a85b4e106 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,5 +1,9 @@
 'use strict';
 
+const {
+  ObjectCreate,
+} = primordials;
+
 const {
   ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,
 } = require('internal/errors').codes;
@@ -22,13 +26,14 @@ exports.initializeImportMetaObject = function(wrap, meta) {
   }
 };
 
-exports.importModuleDynamicallyCallback = async function(wrap, specifier) {
+exports.importModuleDynamicallyCallback =
+async function importModuleDynamicallyCallback(wrap, specifier, assertions) {
   const { callbackMap } = internalBinding('module_wrap');
   if (callbackMap.has(wrap)) {
     const { importModuleDynamically } = callbackMap.get(wrap);
     if (importModuleDynamically !== undefined) {
       return importModuleDynamically(
-        specifier, getModuleFromWrap(wrap) || wrap);
+        specifier, getModuleFromWrap(wrap) || wrap, assertions);
     }
   }
   throw new ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING();
@@ -69,6 +74,7 @@ async function initializeLoader() {
   const exports = await internalEsmLoader.import(
     customLoaders,
     pathToFileURL(cwd).href,
+    ObjectCreate(null),
   );
 
   // Hooks must then be added to external/public loader
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 48c525057f7477..103d7cc7fcfd46 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -82,9 +82,9 @@ function evalScript(name, body, breakFirstLine, print) {
       filename: name,
       displayErrors: true,
       [kVmBreakFirstLineSymbol]: !!breakFirstLine,
-      async importModuleDynamically(specifier) {
-        const loader = await asyncESM.esmLoader;
-        return loader.import(specifier, baseUrl);
+      importModuleDynamically(specifier, _, import_assertions) {
+        const loader = asyncESM.esmLoader;
+        return loader.import(specifier, baseUrl, import_assertions);
       }
     }));
   if (print) {
diff --git a/lib/repl.js b/lib/repl.js
index 4ee8e24d47588c..2e9f0a307588cf 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -454,8 +454,9 @@ function REPLServer(prompt,
             vm.createScript(fallbackCode, {
               filename: file,
               displayErrors: true,
-              importModuleDynamically: async (specifier) => {
-                return asyncESM.esmLoader.import(specifier, parentURL);
+              importModuleDynamically: (specifier, _, import_assertions) => {
+                return asyncESM.esmLoader.import(specifier, parentURL,
+                                                 import_assertions);
               }
             });
           } catch (fallbackError) {
@@ -496,8 +497,9 @@ function REPLServer(prompt,
           script = vm.createScript(code, {
             filename: file,
             displayErrors: true,
-            importModuleDynamically: async (specifier) => {
-              return asyncESM.esmLoader.import(specifier, parentURL);
+            importModuleDynamically: (specifier, _, import_assertions) => {
+              return asyncESM.esmLoader.import(specifier, parentURL,
+                                               import_assertions);
             }
           });
         } catch (e) {
diff --git a/lib/vm.js b/lib/vm.js
index d8e3d6586036f3..92afa9f6964acf 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -378,7 +378,7 @@ function compileFunction(code, params, options = {}) {
     const wrapped = importModuleDynamicallyWrap(importModuleDynamically);
     const func = result.function;
     callbackMap.set(result.cacheKey, {
-      importModuleDynamically: (s, _k) => wrapped(s, func),
+      importModuleDynamically: (s, _k, i) => wrapped(s, func, i),
     });
   }
 
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index f45ee7627b0a9b..a9defba217626d 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -602,9 +602,20 @@ static MaybeLocal<Promise> ImportModuleDynamically(
     UNREACHABLE();
   }
 
+  Local<Object> assertions =
+    Object::New(isolate, v8::Null(env->isolate()), nullptr, nullptr, 0);
+  for (int i = 0; i < import_assertions->Length(); i += 2) {
+    assertions
+        ->Set(env->context(),
+              Local<String>::Cast(import_assertions->Get(env->context(), i)),
+              Local<Value>::Cast(import_assertions->Get(env->context(), i + 1)))
+        .ToChecked();
+  }
+
   Local<Value> import_args[] = {
     object,
     Local<Value>(specifier),
+    assertions,
   };
 
   Local<Value> result;
diff --git a/src/node.cc b/src/node.cc
index acf4f0fac03c0b..19de2d6e68a411 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -803,11 +803,11 @@ int ProcessGlobalArgs(std::vector<std::string>* args,
     return 12;
   }
 
-  // TODO(mylesborins): remove this when the harmony-top-level-await flag
+  // TODO(mylesborins): remove this when the harmony-import-assertions flag
   // is removed in V8
   if (std::find(v8_args.begin(), v8_args.end(),
-                "--no-harmony-top-level-await") == v8_args.end()) {
-    v8_args.push_back("--harmony-top-level-await");
+                "--no-harmony-import-assertions") == v8_args.end()) {
+    v8_args.push_back("--harmony-import-assertions");
   }
 
   auto env_opts = per_process::cli_options->per_isolate->per_env;
diff --git a/test/es-module/test-esm-dynamic-import-assertion.js b/test/es-module/test-esm-dynamic-import-assertion.js
new file mode 100644
index 00000000000000..c5555336b91413
--- /dev/null
+++ b/test/es-module/test-esm-dynamic-import-assertion.js
@@ -0,0 +1,78 @@
+// Flags: --experimental-json-modules
+'use strict';
+const common = require('../common');
+const { rejects, strictEqual } = require('assert');
+
+const jsModuleDataUrl = 'data:text/javascript,export{}';
+
+async function test() {
+  await rejects(
+    import(`data:text/javascript,import${JSON.stringify(jsModuleDataUrl)}assert{type:"json"}`),
+    { code: 'ERR_FAILED_IMPORT_ASSERTION' }
+  );
+
+  await rejects(
+    import(jsModuleDataUrl, { assert: { type: 'json' } }),
+    { code: 'ERR_FAILED_IMPORT_ASSERTION' }
+  );
+
+  await rejects(
+    import('specifier', { assert: { type: 'unsupported' } }),
+    { code: 'ERR_INVALID_IMPORT_ASSERTION' }
+  );
+
+  await rejects(
+    import('specifier', { assert: { type: 'undefined' } }),
+    { code: 'ERR_INVALID_IMPORT_ASSERTION' }
+  );
+
+  {
+    const [secret0, secret1] = await Promise.all([
+      import('../fixtures/experimental.json'),
+      import(
+        '../fixtures/experimental.json',
+        { assert: { type: 'json' } }
+      ),
+    ]);
+
+    strictEqual(secret0.default.ofLife, 42);
+    strictEqual(secret1.default.ofLife, 42);
+    strictEqual(secret0.default, secret1.default);
+    strictEqual(secret0, secret1);
+  }
+
+  {
+    const [secret0, secret1] = await Promise.all([
+      import('data:application/json,{"ofLife":42}'),
+      import(
+        'data:application/json,{"ofLife":42}',
+        { assert: { type: 'json' } }
+      ),
+    ]);
+
+    strictEqual(secret0.default.ofLife, 42);
+    strictEqual(secret1.default.ofLife, 42);
+  }
+
+  {
+    const results = await Promise.allSettled([
+      import('../fixtures/empty.js', { assert: { type: 'json' } }),
+      import('../fixtures/empty.js'),
+    ]);
+
+    strictEqual(results[0].status, 'rejected');
+    strictEqual(results[1].status, 'fulfilled');
+  }
+
+  {
+    const results = await Promise.allSettled([
+      import('../fixtures/empty.js'),
+      import('../fixtures/empty.js', { assert: { type: 'json' } }),
+    ]);
+
+    strictEqual(results[0].status, 'fulfilled');
+    strictEqual(results[1].status, 'rejected');
+  }
+}
+
+test().then(common.mustCall());
diff --git a/test/es-module/test-esm-dynamic-import-assertion.mjs b/test/es-module/test-esm-dynamic-import-assertion.mjs
new file mode 100644
index 00000000000000..f509042b8a46f1
--- /dev/null
+++ b/test/es-module/test-esm-dynamic-import-assertion.mjs
@@ -0,0 +1,73 @@
+// Flags: --experimental-json-modules
+import '../common/index.mjs';
+import { rejects, strictEqual } from 'assert';
+
+const jsModuleDataUrl = 'data:text/javascript,export{}';
+
+await rejects(
+  import(`data:text/javascript,import${JSON.stringify(jsModuleDataUrl)}assert{type:"json"}`),
+  { code: 'ERR_FAILED_IMPORT_ASSERTION' }
+);
+
+await rejects(
+  import(jsModuleDataUrl, { assert: { type: 'json' } }),
+  { code: 'ERR_FAILED_IMPORT_ASSERTION' }
+);
+
+await rejects(
+  import('specifier', { assert: { type: 'unsupported' } }),
+  { code: 'ERR_INVALID_IMPORT_ASSERTION' }
+);
+
+await rejects(
+  import('specifier', { assert: { type: 'undefined' } }),
+  { code: 'ERR_INVALID_IMPORT_ASSERTION' }
+);
+
+{
+  const [secret0, secret1] = await Promise.all([
+    import('../fixtures/experimental.json'),
+    import(
+      '../fixtures/experimental.json',
+      { assert: { type: 'json' } }
+    ),
+  ]);
+
+  strictEqual(secret0.default.ofLife, 42);
+  strictEqual(secret1.default.ofLife, 42);
+  strictEqual(secret0.default, secret1.default);
+  strictEqual(secret0, secret1);
+}
+
+{
+  const [secret0, secret1] = await Promise.all([
+    import('data:application/json,{"ofLife":42}'),
+    import(
+      'data:application/json,{"ofLife":42}',
+      { assert: { type: 'json' } }
+    ),
+  ]);
+
+  strictEqual(secret0.default.ofLife, 42);
+  strictEqual(secret1.default.ofLife, 42);
+}
+
+{
+  const results = await Promise.allSettled([
+    import('../fixtures/empty.js', { assert: { type: 'json' } }),
+    import('../fixtures/empty.js'),
+  ]);
+
+  strictEqual(results[0].status, 'rejected');
+  strictEqual(results[1].status, 'fulfilled');
+}
+
+{
+  const results = await Promise.allSettled([
+    import('../fixtures/empty.js'),
+    import('../fixtures/empty.js', { assert: { type: 'json' } }),
+  ]);
+
+  strictEqual(results[0].status, 'fulfilled');
+  strictEqual(results[1].status, 'rejected');
+}
diff --git a/test/es-module/test-esm-import-assertion-2.mjs b/test/es-module/test-esm-import-assertion-2.mjs
new file mode 100644
index 00000000000000..3598f353a3f9d5
--- /dev/null
+++ b/test/es-module/test-esm-import-assertion-2.mjs
@@ -0,0 +1,8 @@
+// Flags: --experimental-json-modules
+import '../common/index.mjs';
+import { strictEqual } from 'assert';
+
+// eslint-disable-next-line max-len
+import secret from '../fixtures/experimental.json' assert { type: 'json', unsupportedAssertion: 'should ignore' };
+
+strictEqual(secret.ofLife, 42);
diff --git a/test/es-module/test-esm-import-assertion-3.mjs b/test/es-module/test-esm-import-assertion-3.mjs
new file mode 100644
index 00000000000000..79d6cf05a1d1e6
--- /dev/null
+++ b/test/es-module/test-esm-import-assertion-3.mjs
@@ -0,0 +1,10 @@
+// Flags: --experimental-json-modules
+import '../common/index.mjs';
+import { strictEqual } from 'assert';
+
+import secret0 from '../fixtures/experimental.json' assert { type: 'json' };
+const secret1 = await import('../fixtures/experimental.json');
+
+strictEqual(secret0.ofLife, 42);
+strictEqual(secret1.default.ofLife, 42);
+strictEqual(secret1.default, secret0);
diff --git a/test/es-module/test-esm-import-assertion-4.mjs b/test/es-module/test-esm-import-assertion-4.mjs
new file mode 100644
index 00000000000000..b7400bca9d42f9
--- /dev/null
+++ b/test/es-module/test-esm-import-assertion-4.mjs
@@ -0,0 +1,12 @@
+// Flags: --experimental-json-modules
+import '../common/index.mjs';
+import { strictEqual } from 'assert';
+
+import secret0 from '../fixtures/experimental.json';
+const secret1 = await import('../fixtures/experimental.json', {
+  assert: { type: 'json' },
+  });
+
+strictEqual(secret0.ofLife, 42);
+strictEqual(secret1.default.ofLife, 42);
+strictEqual(secret1.default, secret0);
diff --git a/test/es-module/test-esm-import-assertion.mjs b/test/es-module/test-esm-import-assertion.mjs
new file mode 100644
index 00000000000000..f011c948d8edea
--- /dev/null
+++ b/test/es-module/test-esm-import-assertion.mjs
@@ -0,0 +1,7 @@
+// Flags: --experimental-json-modules
+import '../common/index.mjs';
+import { strictEqual } from 'assert';
+
+import secret from '../fixtures/experimental.json' assert { type: 'json' };
+
+strictEqual(secret.ofLife, 42);
diff --git a/test/message/esm_import_assertion_failing.mjs b/test/message/esm_import_assertion_failing.mjs
new file mode 100644
index 00000000000000..30ea65c3e34ee3
--- /dev/null
+++ b/test/message/esm_import_assertion_failing.mjs
@@ -0,0 +1,2 @@
+import '../common/index.mjs';
+import 'data:text/javascript,export{}' assert {type:'json'};
diff --git a/test/message/esm_import_assertion_failing.out b/test/message/esm_import_assertion_failing.out
new file mode 100644
index 00000000000000..32024344e45581
--- /dev/null
+++ b/test/message/esm_import_assertion_failing.out
@@ -0,0 +1,10 @@
+node:internal/errors:*
+    ErrorCaptureStackTrace(err);
+    ^
+
+TypeError [ERR_FAILED_IMPORT_ASSERTION]: Failed to load module "data:text/javascript,export{}", expected type to be "json", got "module" instead
+    at new NodeError (node:internal/errors:*:*)
+    at ESMLoader.moduleProvider (node:internal/modules/esm/loader:*:*) {
+  code: 'ERR_FAILED_IMPORT_ASSERTION'
+}
+Node.js *
diff --git a/test/message/esm_import_assertion_unsupported.mjs b/test/message/esm_import_assertion_unsupported.mjs
new file mode 100644
index 00000000000000..4876aa263d1786
--- /dev/null
+++ b/test/message/esm_import_assertion_unsupported.mjs
@@ -0,0 +1,2 @@
+import '../common/index.mjs';
+import 'specifier' assert { type: 'unsupported' };
diff --git a/test/message/esm_import_assertion_unsupported.out b/test/message/esm_import_assertion_unsupported.out
new file mode 100644
index 00000000000000..65579f4dc7cbcd
--- /dev/null
+++ b/test/message/esm_import_assertion_unsupported.out
@@ -0,0 +1,13 @@
+node:internal/errors:*
+    ErrorCaptureStackTrace(err);
+    ^
+
+TypeError [ERR_INVALID_IMPORT_ASSERTION]: Invalid "type" import assertion: "unsupported"
+    at new NodeError (node:internal/errors:*:*)
+    at ESMLoader.getModuleJob (node:internal/modules/esm/loader:*:*)
+    at ModuleWrap.<anonymous> (node:internal/modules/esm/module_job:*:*)
+    at link (node:internal/modules/esm/module_job:*:*) {
+  code: 'ERR_INVALID_IMPORT_ASSERTION'
+}
+
+Node.js *
diff --git a/test/parallel/test-vm-module-link.js b/test/parallel/test-vm-module-link.js
index 9805d8fe3eee9c..16694d5d846075 100644
--- a/test/parallel/test-vm-module-link.js
+++ b/test/parallel/test-vm-module-link.js
@@ -1,6 +1,6 @@
 'use strict';
 
-// Flags: --experimental-vm-modules --harmony-import-assertions
+// Flags: --experimental-vm-modules
 
 const common = require('../common');
 
diff --git a/tools/code_cache/mkcodecache.cc b/tools/code_cache/mkcodecache.cc
index 3a1d0ee50e5078..babf8535dbb3e7 100644
--- a/tools/code_cache/mkcodecache.cc
+++ b/tools/code_cache/mkcodecache.cc
@@ -28,7 +28,7 @@ int main(int argc, char* argv[]) {
 #endif  // _WIN32
 
   v8::V8::SetFlagsFromString("--random_seed=42");
-  v8::V8::SetFlagsFromString("--harmony-top-level-await");
+  v8::V8::SetFlagsFromString("--harmony-import-assertions");
 
   if (argc < 2) {
     std::cerr << "Usage: " << argv[0] << " <path/to/output.cc>\n";