diff --git a/doc/api/webcrypto.md b/doc/api/webcrypto.md
index ce31a590f1138b..c99ef491285a93 100644
--- a/doc/api/webcrypto.md
+++ b/doc/api/webcrypto.md
@@ -1112,6 +1112,9 @@ The algorithms currently supported include:
 <!-- YAML
 added: v15.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60933
+    description: ML-KEM jwk format is now supported.
   - version: v24.8.0
     pr-url: https://github.com/nodejs/node/pull/59647
     description: KMAC algorithms are now supported.
@@ -1170,9 +1173,9 @@ specification.
 | `'ML-DSA-44'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'ML-DSA-65'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'ML-DSA-87'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
-| `'ML-KEM-512'`[^modern-algos]        | ✔        | ✔         |         |         |                | ✔              | ✔            |
-| `'ML-KEM-768'`[^modern-algos]        | ✔        | ✔         |         |         |                | ✔              | ✔            |
-| `'ML-KEM-1024'`[^modern-algos]       | ✔        | ✔         |         |         |                | ✔              | ✔            |
+| `'ML-KEM-512'`[^modern-algos]        | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
+| `'ML-KEM-768'`[^modern-algos]        | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
+| `'ML-KEM-1024'`[^modern-algos]       | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'RSA-OAEP'`                         | ✔        | ✔         | ✔       |         |                |                |              |
 | `'RSA-PSS'`                          | ✔        | ✔         | ✔       |         |                |                |              |
 | `'RSASSA-PKCS1-v1_5'`                | ✔        | ✔         | ✔       |         |                |                |              |
@@ -1260,6 +1263,9 @@ The {CryptoKey} (secret key) generating algorithms supported include:
 <!-- YAML
 added: v15.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60933
+    description: ML-KEM jwk format is now supported.
   - version: v24.8.0
     pr-url: https://github.com/nodejs/node/pull/59647
     description: KMAC algorithms are now supported.
@@ -1329,9 +1335,9 @@ The algorithms currently supported include:
 | `'ML-DSA-44'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'ML-DSA-65'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'ML-DSA-87'`[^modern-algos]         | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
-| `'ML-KEM-512'`[^modern-algos]        | ✔        | ✔         |         |         |                | ✔              | ✔            |
-| `'ML-KEM-768'`[^modern-algos]        | ✔        | ✔         |         |         |                | ✔              | ✔            |
-| `'ML-KEM-1024'`[^modern-algos]       | ✔        | ✔         |         |         |                | ✔              | ✔            |
+| `'ML-KEM-512'`[^modern-algos]        | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
+| `'ML-KEM-768'`[^modern-algos]        | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
+| `'ML-KEM-1024'`[^modern-algos]       | ✔        | ✔         | ✔       |         |                | ✔              | ✔            |
 | `'PBKDF2'`                           |          |           |         | ✔       | ✔              |                |              |
 | `'RSA-OAEP'`                         | ✔        | ✔         | ✔       |         |                |                |              |
 | `'RSA-PSS'`                          | ✔        | ✔         | ✔       |         |                |                |              |
diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js
index a3609690adeb36..698fd53d48ae47 100644
--- a/lib/internal/crypto/keys.js
+++ b/lib/internal/crypto/keys.js
@@ -539,11 +539,27 @@ function getKeyTypes(allowKeyObject, bufferOnly = false) {
   return types;
 }
 
-function mlDsaPubLen(alg) {
+function pqcPubLen(alg) {
   switch (alg) {
     case 'ML-DSA-44': return 1312;
     case 'ML-DSA-65': return 1952;
     case 'ML-DSA-87': return 2592;
+    case 'ML-KEM-512': return 800;
+    case 'ML-KEM-768': return 1184;
+    case 'ML-KEM-1024': return 1568;
+  }
+}
+
+function pqcSeedLen(alg) {
+  switch (alg) {
+    case 'ML-DSA-44':
+    case 'ML-DSA-65':
+    case 'ML-DSA-87':
+      return 32;
+    case 'ML-KEM-512':
+    case 'ML-KEM-768':
+    case 'ML-KEM-1024':
+      return 64;
   }
 }
 
@@ -560,19 +576,20 @@ function getKeyObjectHandleFromJwk(key, ctx) {
 
   if (key.kty === 'AKP') {
     validateOneOf(
-      key.alg, 'key.alg', ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']);
+      key.alg, 'key.alg', ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87',
+                           'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']);
     validateString(key.pub, 'key.pub');
 
     let keyData;
     if (isPublic) {
       keyData = Buffer.from(key.pub, 'base64url');
-      if (keyData.byteLength !== mlDsaPubLen(key.alg)) {
+      if (keyData.byteLength !== pqcPubLen(key.alg)) {
         throw new ERR_CRYPTO_INVALID_JWK();
       }
     } else {
       validateString(key.priv, 'key.priv');
       keyData = Buffer.from(key.priv, 'base64url');
-      if (keyData.byteLength !== 32) {
+      if (keyData.byteLength !== pqcSeedLen(key.alg)) {
         throw new ERR_CRYPTO_INVALID_JWK();
       }
     }
diff --git a/lib/internal/crypto/ml_kem.js b/lib/internal/crypto/ml_kem.js
index f6eb76cef10b20..02740f3ab323ef 100644
--- a/lib/internal/crypto/ml_kem.js
+++ b/lib/internal/crypto/ml_kem.js
@@ -8,6 +8,8 @@ const {
   Uint8Array,
 } = primordials;
 
+const { Buffer } = require('buffer');
+
 const {
   kCryptoJobAsync,
   KEMDecapsulateJob,
@@ -21,9 +23,16 @@ const {
   kWebCryptoKeyFormatSPKI,
 } = internalBinding('crypto');
 
+const {
+  codes: {
+    ERR_CRYPTO_INVALID_JWK,
+  },
+} = require('internal/errors');
+
 const {
   getUsagesUnion,
   hasAnyNotIn,
+  validateKeyOps,
   kHandle,
   kKeyObject,
 } = require('internal/crypto/util');
@@ -193,6 +202,63 @@ function mlKemImportKey(
       }
       break;
     }
+    case 'jwk': {
+      if (!keyData.kty)
+        throw lazyDOMException('Invalid keyData', 'DataError');
+      if (keyData.kty !== 'AKP')
+        throw lazyDOMException('Invalid JWK "kty" Parameter', 'DataError');
+      if (keyData.alg !== name)
+        throw lazyDOMException(
+          'JWK "alg" Parameter and algorithm name mismatch', 'DataError');
+      const isPublic = keyData.priv === undefined;
+
+      if (usagesSet.size > 0 && keyData.use !== undefined) {
+        if (keyData.use !== 'enc')
+          throw lazyDOMException('Invalid JWK "use" Parameter', 'DataError');
+      }
+
+      validateKeyOps(keyData.key_ops, usagesSet);
+
+      if (keyData.ext !== undefined &&
+          keyData.ext === false &&
+          extractable === true) {
+        throw lazyDOMException(
+          'JWK "ext" Parameter and extractable mismatch',
+          'DataError');
+      }
+
+      if (!isPublic && typeof keyData.pub !== 'string') {
+        throw lazyDOMException('Invalid JWK', 'DataError');
+      }
+
+      verifyAcceptableMlKemKeyUse(
+        name,
+        isPublic,
+        usagesSet);
+
+      try {
+        const publicKeyObject = createMlKemRawKey(
+          name,
+          Buffer.from(keyData.pub, 'base64url'),
+          true);
+
+        if (isPublic) {
+          keyObject = publicKeyObject;
+        } else {
+          keyObject = createMlKemRawKey(
+            name,
+            Buffer.from(keyData.priv, 'base64url'),
+            false);
+
+          if (!createPublicKey(keyObject).equals(publicKeyObject)) {
+            throw new ERR_CRYPTO_INVALID_JWK();
+          }
+        }
+      } catch (err) {
+        throw lazyDOMException('Invalid keyData', { name: 'DataError', cause: err });
+      }
+      break;
+    }
     case 'raw-public':
     case 'raw-seed': {
       const isPublic = format === 'raw-public';
diff --git a/lib/internal/crypto/webcrypto.js b/lib/internal/crypto/webcrypto.js
index 2333919e06a2fe..35ab93281c8414 100644
--- a/lib/internal/crypto/webcrypto.js
+++ b/lib/internal/crypto/webcrypto.js
@@ -611,6 +611,12 @@ async function exportKeyJWK(key) {
     case 'ML-DSA-65':
       // Fall through
     case 'ML-DSA-87':
+      // Fall through
+    case 'ML-KEM-512':
+      // Fall through
+    case 'ML-KEM-768':
+      // Fall through
+    case 'ML-KEM-1024':
       break;
     case 'Ed25519':
       // Fall through
diff --git a/node.gyp b/node.gyp
index c236d20e2bd37e..fa5965e703fb83 100644
--- a/node.gyp
+++ b/node.gyp
@@ -372,7 +372,7 @@
       'src/crypto/crypto_cipher.cc',
       'src/crypto/crypto_context.cc',
       'src/crypto/crypto_ec.cc',
-      'src/crypto/crypto_ml_dsa.cc',
+      'src/crypto/crypto_pqc.cc',
       'src/crypto/crypto_kem.cc',
       'src/crypto/crypto_hmac.cc',
       'src/crypto/crypto_kmac.cc',
@@ -408,7 +408,7 @@
       'src/crypto/crypto_clienthello.h',
       'src/crypto/crypto_context.h',
       'src/crypto/crypto_ec.h',
-      'src/crypto/crypto_ml_dsa.h',
+      'src/crypto/crypto_pqc.h',
       'src/crypto/crypto_hkdf.h',
       'src/crypto/crypto_pbkdf2.h',
       'src/crypto/crypto_sig.h',
diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index e805a984322c83..f7c2e2bd88c3be 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -5,7 +5,7 @@
 #include "crypto/crypto_dh.h"
 #include "crypto/crypto_dsa.h"
 #include "crypto/crypto_ec.h"
-#include "crypto/crypto_ml_dsa.h"
+#include "crypto/crypto_pqc.h"
 #include "crypto/crypto_rsa.h"
 #include "crypto/crypto_util.h"
 #include "env-inl.h"
@@ -183,7 +183,13 @@ bool ExportJWKAsymmetricKey(Environment* env,
     case EVP_PKEY_ML_DSA_65:
       // Fall through
     case EVP_PKEY_ML_DSA_87:
-      return ExportJwkMlDsaKey(env, key, target);
+      // Fall through
+    case EVP_PKEY_ML_KEM_512:
+      // Fall through
+    case EVP_PKEY_ML_KEM_768:
+      // Fall through
+    case EVP_PKEY_ML_KEM_1024:
+      return ExportJwkPqcKey(env, key, target);
 #endif
   }
   THROW_ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE(env);
diff --git a/src/crypto/crypto_ml_dsa.cc b/src/crypto/crypto_pqc.cc
similarity index 78%
rename from src/crypto/crypto_ml_dsa.cc
rename to src/crypto/crypto_pqc.cc
index 65f7053cc1fa1d..a456c2b58ee8f9 100644
--- a/src/crypto/crypto_ml_dsa.cc
+++ b/src/crypto/crypto_pqc.cc
@@ -1,4 +1,4 @@
-#include "crypto/crypto_ml_dsa.h"
+#include "crypto/crypto_pqc.h"
 #include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "string_bytes.h"
@@ -15,7 +15,7 @@ using v8::Value;
 namespace crypto {
 
 #if OPENSSL_WITH_PQC
-constexpr const char* GetMlDsaAlgorithmName(int id) {
+constexpr const char* GetPqcAlgorithmName(int id) {
   switch (id) {
     case EVP_PKEY_ML_DSA_44:
       return "ML-DSA-44";
@@ -23,27 +23,33 @@ constexpr const char* GetMlDsaAlgorithmName(int id) {
       return "ML-DSA-65";
     case EVP_PKEY_ML_DSA_87:
       return "ML-DSA-87";
+    case EVP_PKEY_ML_KEM_512:
+      return "ML-KEM-512";
+    case EVP_PKEY_ML_KEM_768:
+      return "ML-KEM-768";
+    case EVP_PKEY_ML_KEM_1024:
+      return "ML-KEM-1024";
     default:
       return nullptr;
   }
 }
 
 /**
- * Exports an ML-DSA key to JWK format.
+ * Exports a PQC key (ML-DSA or ML-KEM) to JWK format.
  *
  * The resulting JWK object contains:
  * - "kty": "AKP" (Asymmetric Key Pair - required)
- * - "alg": "ML-DSA-XX" (Algorithm identifier - required for "AKP")
+ * - "alg": "ML-(KEM|DSA)-..." (Algorithm identifier - required for "AKP")
  * - "pub": "<Base64URL-encoded raw public key>" (required)
  * - "priv": <"Base64URL-encoded raw seed>" (required for private keys only)
  */
-bool ExportJwkMlDsaKey(Environment* env,
-                       const KeyObjectData& key,
-                       Local<Object> target) {
+bool ExportJwkPqcKey(Environment* env,
+                     const KeyObjectData& key,
+                     Local<Object> target) {
   Mutex::ScopedLock lock(key.mutex());
   const auto& pkey = key.GetAsymmetricKey();
 
-  const char* alg = GetMlDsaAlgorithmName(pkey.id());
+  const char* alg = GetPqcAlgorithmName(pkey.id());
   CHECK(alg);
 
   static constexpr auto trySetKey = [](Environment* env,
diff --git a/src/crypto/crypto_ml_dsa.h b/src/crypto/crypto_pqc.h
similarity index 53%
rename from src/crypto/crypto_ml_dsa.h
rename to src/crypto/crypto_pqc.h
index e4739fcdd7fda7..921fba990a0485 100644
--- a/src/crypto/crypto_ml_dsa.h
+++ b/src/crypto/crypto_pqc.h
@@ -1,5 +1,5 @@
-#ifndef SRC_CRYPTO_CRYPTO_ML_DSA_H_
-#define SRC_CRYPTO_CRYPTO_ML_DSA_H_
+#ifndef SRC_CRYPTO_CRYPTO_PQC_H_
+#define SRC_CRYPTO_CRYPTO_PQC_H_
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
@@ -10,12 +10,12 @@
 namespace node {
 namespace crypto {
 #if OPENSSL_WITH_PQC
-bool ExportJwkMlDsaKey(Environment* env,
-                       const KeyObjectData& key,
-                       v8::Local<v8::Object> target);
+bool ExportJwkPqcKey(Environment* env,
+                     const KeyObjectData& key,
+                     v8::Local<v8::Object> target);
 #endif
 }  // namespace crypto
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_ML_DSA_H_
+#endif  // SRC_CRYPTO_CRYPTO_PQC_H_
diff --git a/src/node_crypto.h b/src/node_crypto.h
index e5e29544b57a81..25fcb0bfe919fb 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -46,8 +46,8 @@
 #endif
 #include "crypto/crypto_keygen.h"
 #include "crypto/crypto_keys.h"
-#include "crypto/crypto_ml_dsa.h"
 #include "crypto/crypto_pbkdf2.h"
+#include "crypto/crypto_pqc.h"
 #include "crypto/crypto_random.h"
 #include "crypto/crypto_rsa.h"
 #include "crypto/crypto_scrypt.h"
diff --git a/test/parallel/test-crypto-encap-decap.js b/test/parallel/test-crypto-encap-decap.js
index 2c2ccd42ca2365..b080b0a42b04be 100644
--- a/test/parallel/test-crypto-encap-decap.js
+++ b/test/parallel/test-crypto-encap-decap.js
@@ -128,13 +128,10 @@ for (const [name, { supported, publicKey, privateKey, sharedSecretLength, cipher
     },
   ];
 
-  // TODO(@panva): ML-KEM does not have a JWK format defined yet, add once standardized
-  if (!keyObjects.privateKey.asymmetricKeyType.startsWith('ml')) {
-    keyPairs.push({
-      publicKey: formatKeyAs(keyObjects.publicKey, { format: 'jwk' }),
-      privateKey: formatKeyAs(keyObjects.privateKey, { format: 'jwk' })
-    });
-  }
+  keyPairs.push({
+    publicKey: formatKeyAs(keyObjects.publicKey, { format: 'jwk' }),
+    privateKey: formatKeyAs(keyObjects.privateKey, { format: 'jwk' })
+  });
 
   for (const kp of keyPairs) {
     // sync
diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js
index 293c0c87265eea..be0ca15ffd8fba 100644
--- a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js
+++ b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js
@@ -18,7 +18,9 @@ function getKeyFileName(type, suffix) {
   return `${type.replaceAll('-', '_')}_${suffix}.pem`;
 }
 
-for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
+for (const [asymmetricKeyType, pubLen] of [
+  ['ml-kem-512', 800], ['ml-kem-768', 1184], ['ml-kem-1024', 1568],
+]) {
   const keys = {
     public: fixtures.readKey(getKeyFileName(asymmetricKeyType, 'public'), 'ascii'),
     private: fixtures.readKey(getKeyFileName(asymmetricKeyType, 'private'), 'ascii'),
@@ -26,6 +28,24 @@ for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
     private_priv_only: fixtures.readKey(getKeyFileName(asymmetricKeyType, 'private_priv_only'), 'ascii'),
   };
 
+  function assertJwk(jwk) {
+    assert.strictEqual(jwk.kty, 'AKP');
+    assert.strictEqual(jwk.alg, asymmetricKeyType.toUpperCase());
+    assert.ok(jwk.pub);
+    assert.strictEqual(Buffer.from(jwk.pub, 'base64url').byteLength, pubLen);
+  }
+
+  function assertPublicJwk(jwk) {
+    assertJwk(jwk);
+    assert.ok(!jwk.priv);
+  }
+
+  function assertPrivateJwk(jwk) {
+    assertJwk(jwk);
+    assert.ok(jwk.priv);
+    assert.strictEqual(Buffer.from(jwk.priv, 'base64url').byteLength, 64);
+  }
+
   function assertKey(key) {
     assert.deepStrictEqual(key.asymmetricKeyDetails, {});
     assert.strictEqual(key.asymmetricKeyType, asymmetricKeyType);
@@ -38,8 +58,9 @@ for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
     assert.strictEqual(key.type, 'public');
     assert.strictEqual(key.export({ format: 'pem', type: 'spki' }), keys.public);
     key.export({ format: 'der', type: 'spki' });
-    assert.throws(() => key.export({ format: 'jwk' }),
-                  { code: 'ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE', message: 'Unsupported JWK Key Type.' });
+    const jwk = key.export({ format: 'jwk' });
+    assertPublicJwk(jwk);
+    assert.strictEqual(key.equals(createPublicKey({ format: 'jwk', key: jwk })), true);
   }
 
   function assertPrivateKey(key, hasSeed) {
@@ -52,8 +73,15 @@ for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
     } else {
       assert.strictEqual(key.export({ format: 'pem', type: 'pkcs8' }), keys.private_priv_only);
     }
-    assert.throws(() => key.export({ format: 'jwk' }),
-                  { code: 'ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE', message: 'Unsupported JWK Key Type.' });
+    if (hasSeed) {
+      const jwk = key.export({ format: 'jwk' });
+      assertPrivateJwk(jwk);
+      assert.strictEqual(key.equals(createPrivateKey({ format: 'jwk', key: jwk })), true);
+      assert.ok(createPublicKey({ format: 'jwk', key: jwk }));
+    } else {
+      assert.throws(() => key.export({ format: 'jwk' }),
+                    { code: 'ERR_CRYPTO_OPERATION_FAILED', message: 'key does not have an available seed' });
+    }
   }
 
   if (!hasOpenSSL(3, 5)) {
@@ -84,3 +112,37 @@ for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
     }
   }
 }
+
+{
+  const format = 'jwk';
+  const jwk = {
+    kty: 'AKP',
+    alg: 'ML-KEM-512',
+    priv: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+    // eslint-disable-next-line @stylistic/js/max-len
+    pub: '3xeEhndBbpVNZvmwnhKBUyoujwxqvgA35-gRkJfJ7IRaoGmFwIhVLEG2FRc2QsECUcBukaJcJDwCY7Z1xyB9WHAdE6Uuq5JWXvGh3vuu_kwLA_UERKO-ILFxMQuj8ghS86KhjnIpQHAVZGBS0uc6vuMY11WJnHhKb7WqsXyQLLaK-jZXuQEuG7i2qsJomqSMLUJiuyljsGokIoJUHPYUGdkOK9NmvuekNptyQaZr8mRdjpBMP3swDAQdVoc5PSypKXXL_cAY3cYK9WIAnrCIjloFdiRqznRbsWNAi1qa48GUqFwhkHs3sWKOzZoV7CAkhzAnNESwovRU-bRzDzORUEdu4HCY9rwbl8wb07jBousOUKeC8hFd9hdJb2xvjAmwX4iNnpM9KHdGxjGzEIcmsMSnyIsJyGCs11I1cMgCvThyQxYtEoyiKUyDQxjMIfsU0qs3PyJOP9SYQ4WVCfTKGhpWbAVniKOqSEqqvfGgjxtEx1arKgyLxYUe4usjA0wuqlrBX4l1G9XK4dWQidUAK7Gzv8pK3gmCrWeD6dN_s-MgrJhV32Zr_Xxrh6mkbiWXElYRYVB-FzWY-YistvmrOhCSYyRGiMcIeHWP9NQxO3Zk8PUQ6RPKAcUrOhtGU1FE4tsMrOimRmYAzyqHg1AH4WqlB4Adhrc4Xmab-va6HfVoMWPC1XBTL9dDkFRkDyRMUocTWdKEL8M3oGADOvBeqgAcNPx72PkQKeRsKUM2J2RdZ4ZkIdZhryV0gFMriHhQ3Emf_tWxQJigM3Jeggpb4UAKDLcDdBynS0eGc6rPhRZu6KGE2yxYVJwiQLgwjCe-ukDDudcp7bGMwgaOzbJ9oiss0-eguqUwxRk808hr-GpE8HmeUVWwm-JQmIUjs6cx3YkbwgBgEaBlwKtX8abBeIlV4BNfpcqPPlLHXTcWlzovsiwOsXwbMoUp2fp2VtdN6nQNnweXd8NsF6GcGViehNK45NG8MQfL0ngUIkg1SERsiZMUd0SqnsHFk-wtW6rIagr2SoXpCd-OKBZgXSC044KzC7thvzpfghoLXbqa0-c',
+  };
+
+  if (hasOpenSSL(3, 5)) {
+    assert.throws(() => createPrivateKey({ format, key: { ...jwk, alg: 'ml-kem-512' } }),
+                  { code: 'ERR_INVALID_ARG_VALUE', message: /must be one of: 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024'/ });
+    assert.throws(() => createPrivateKey({ format, key: { ...jwk, alg: undefined } }),
+                  { code: 'ERR_INVALID_ARG_VALUE', message: /must be one of: 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024'/ });
+    assert.throws(() => createPrivateKey({ format, key: { ...jwk, pub: undefined } }),
+                  { code: 'ERR_INVALID_ARG_TYPE', message: /The "key\.pub" property must be of type string/ });
+    assert.throws(() => createPrivateKey({ format, key: { ...jwk, priv: undefined } }),
+                  { code: 'ERR_INVALID_ARG_TYPE', message: /The "key\.priv" property must be of type string/ });
+    assert.throws(() => createPrivateKey({ format, key: { ...jwk, priv: Buffer.alloc(65).toString('base64url') } }),
+                  { code: 'ERR_CRYPTO_INVALID_JWK' });
+    assert.throws(() => createPublicKey({ format, key: { ...jwk, pub: Buffer.alloc(801).toString('base64url') } }),
+                  { code: 'ERR_CRYPTO_INVALID_JWK' });
+
+    assert.ok(createPrivateKey({ format, key: jwk }));
+    assert.ok(createPublicKey({ format, key: jwk }));
+  } else {
+    assert.throws(() => createPrivateKey({ format, key: jwk }),
+                  { code: 'ERR_INVALID_ARG_VALUE', message: /must be one of: 'RSA', 'EC', 'OKP'\. Received 'AKP'/ });
+    assert.throws(() => createPublicKey({ format, key: jwk }),
+                  { code: 'ERR_INVALID_ARG_VALUE', message: /must be one of: 'RSA', 'EC', 'OKP'\. Received 'AKP'/ });
+  }
+}
diff --git a/test/parallel/test-crypto-pqc-keygen-ml-kem.js b/test/parallel/test-crypto-pqc-keygen-ml-kem.js
index adb5fcb56ce6ef..70fdd78c550e66 100644
--- a/test/parallel/test-crypto-pqc-keygen-ml-kem.js
+++ b/test/parallel/test-crypto-pqc-keygen-ml-kem.js
@@ -19,7 +19,28 @@ if (!hasOpenSSL(3, 5)) {
     });
   }
 } else {
-  for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) {
+  for (const [asymmetricKeyType, pubLen] of [
+    ['ml-kem-512', 800], ['ml-kem-768', 1184], ['ml-kem-1024', 1568],
+  ]) {
+
+    function assertJwk(jwk) {
+      assert.strictEqual(jwk.kty, 'AKP');
+      assert.strictEqual(jwk.alg, asymmetricKeyType.toUpperCase());
+      assert.ok(jwk.pub);
+      assert.strictEqual(Buffer.from(jwk.pub, 'base64url').byteLength, pubLen);
+    }
+
+    function assertPublicJwk(jwk) {
+      assertJwk(jwk);
+      assert.ok(!jwk.priv);
+    }
+
+    function assertPrivateJwk(jwk) {
+      assertJwk(jwk);
+      assert.ok(jwk.priv);
+      assert.strictEqual(Buffer.from(jwk.priv, 'base64url').byteLength, 64);
+    }
+
     for (const [publicKeyEncoding, validate] of [
       /* eslint-disable node-core/must-call-assert */
       [undefined, (publicKey) => {
@@ -27,6 +48,7 @@ if (!hasOpenSSL(3, 5)) {
         assert.strictEqual(publicKey.asymmetricKeyType, asymmetricKeyType);
         assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {});
       }],
+      [{ format: 'jwk' }, (publicKey) => assertPublicJwk(publicKey)],
       [{ format: 'pem', type: 'spki' }, (publicKey) => assert.strictEqual(typeof publicKey, 'string')],
       [{ format: 'der', type: 'spki' }, (publicKey) => assert.strictEqual(Buffer.isBuffer(publicKey), true)],
       /* eslint-enable node-core/must-call-assert */
@@ -40,6 +62,7 @@ if (!hasOpenSSL(3, 5)) {
         assert.strictEqual(privateKey.asymmetricKeyType, asymmetricKeyType);
         assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {});
       }],
+      [{ format: 'jwk' }, (_, privateKey) => assertPrivateJwk(privateKey)],
       [{ format: 'pem', type: 'pkcs8' }, (_, privateKey) => assert.strictEqual(typeof privateKey, 'string')],
       [{ format: 'der', type: 'pkcs8' }, (_, privateKey) => assert.strictEqual(Buffer.isBuffer(privateKey), true)],
       /* eslint-enable node-core/must-call-assert */
diff --git a/test/parallel/test-webcrypto-export-import-ml-kem.js b/test/parallel/test-webcrypto-export-import-ml-kem.js
index 887875a2a8b580..2763befcb08c04 100644
--- a/test/parallel/test-webcrypto-export-import-ml-kem.js
+++ b/test/parallel/test-webcrypto-export-import-ml-kem.js
@@ -24,6 +24,7 @@ function toDer(pem) {
   return Buffer.alloc(Buffer.byteLength(der, 'base64'), der, 'base64');
 }
 
+/* eslint-disable @stylistic/js/max-len */
 const keyData = {
   'ML-KEM-512': {
     pkcs8_seed_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-512', 'private_seed_only'), 'ascii')),
@@ -31,6 +32,12 @@ const keyData = {
     pkcs8_priv_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-512', 'private_priv_only'), 'ascii')),
     spki: toDer(fixtures.readKey(getKeyFileName('ml-kem-512', 'public'), 'ascii')),
     pub_len: 800,
+    jwk: {
+      kty: 'AKP',
+      alg: 'ML-KEM-512',
+      pub: '2yWZ7mEhbKJopHmZYXjGERQrHBHCQqBThjwVU5gvTPWqPuqAo6cHWrOrHCBt9aGSyPO2BrM0w7O1UZJsadMmhRJaOvN42AvD6OuebvYke_ITOyi2rbE_zww648ox1JF8ZMsTR8ppj_qX_qiAYaFCzpqGG5x_swuYBshuwnSZ2pilOTQ577dcOHNUDUZ5tjdPecuxkpQ_QOhhGJHKzoVY1Yiw4zpPD9kKLxO7BzUbTLcNZSs5VBJ5Ukawy4sfjQa4QNRooMIVCgG7IbVYT-yvgXljdEGxfBYpsewdHXWCF7EHtEmlYsIp3xlPjSbE6FFLQLdqQsiI5qotm4JGPCGvlQsi1AHDyaPC1ZImL4hDG8IXsPxPfwfMS7On5Atn98wxMQo9VSizpps7LFfOMYRH6FmYljbP9BlWesYxGXkZ1DRza0tKrPaZMjAkoRSrGbsHahwdyNtMVnirVyS3OwWmHHSHOyNfwKo2WWVLK2u8pxiVi0d7BCEx7mW4otGhL_iPn8sjieYWGRvJ7Ly0U8areAsFe3KbuHudnAMFw6A38HsIWbbFUjkFb7IJv4WONuUoCqpDknOYjBKUW2U-qtafz-OrLDbPOtBC0iDGTjx90sLHG7WgCbuwfOS1GVcjwNIctqxjXLB-VsEGXOmdzXvJ69MllEB9asBc1AtA86JH8fVMyAYW1xsEbDO6KspBcEtcusJevSKSFGgg0TxrJWWZXtyZ83XBLqVn2AG6WcqE46Zx5tNhrRY7bSIVLPALa6fLPHxmO0CG0lCTlDi-ZwB_GUB7xYBsTcigoIBtNdg_BlqAEVG67jm0zlg3KDMNbyfCBVEpWjAxq4mm5DjMcFaYaXiUv0RnamoSMmG5TXU6HbIC3ZcXs8FX-5N-susyj0wrKkyJI6vCvIOmAnGIvEQj5rc-0qRZZUXIiOdj2rBYk-nAYvqw6pt9h9FVS2g4siaHIZRsjzo5R0h0atWP0ckqTOe13XGM07kvS4wjjYMgawcAfNCUPnR-uMdsy5wuGDx-FWb6gRnhWsPg1S7W-B2grxSPIwotTjc1sKB3eUq0pa4',
+      priv: 'sjVhZaMDzdhH7rMaw7Z9HH-7LfipY2weXpCqr0I3CMzOt_jB1xtlVqz7oLTcOAx1JNA-E7yXLnGPgZdplLmOaA',
+    },
   },
   'ML-KEM-768': {
     pkcs8_seed_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-768', 'private_seed_only'), 'ascii')),
@@ -38,6 +45,12 @@ const keyData = {
     pkcs8_priv_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-768', 'private_priv_only'), 'ascii')),
     spki: toDer(fixtures.readKey(getKeyFileName('ml-kem-768', 'public'), 'ascii')),
     pub_len: 1184,
+    jwk: {
+      kty: 'AKP',
+      alg: 'ML-KEM-768',
+      pub: 'z9U_gZgaizCOmrqIThIwjRqvJlO8UoFKVrJ3hOQ-Unq9jMKHMJwxsGzDLOAyu-aVbQtJ4slhn8KtXUfF16ln2dxF2cvJDlUHQrrLKLipMKAx5KJh8YMwMhJzUwoRySHGitCikgRDMQozJ-SLmiZd4UY6WfaRL2RHYNkRWxS9I7iIegW3LFc_r-UqP3uew6dcXQXKYOjMg1u9NYg_DLO6f6vB80QnxJI9iMezKmiQHaSokWFuTsYzzHQcbsIg6YoCGvSQQnShzhRJJdhUFxoTZmxZABaGJ1yW0El7N_BWqLBlAVPGbJyGKvOQ4Pos0jGM79Gs_UObJfRykTFK6Ti9fGATnVS98lJu9fkbCYGZTsebqvFED6Ge-QcMu5NTtGiGsDyDY6iqNsS1rqfA-kJ-SaoWDuocAUFqkRHG1nVmEZG4xFZnAjlsO2duiDvD7CrE6CNfVRaapyZh8QbPXmVe5EQH0jEZONc6I7bOeLaznSrCcty1xoF2tCigxOQMbrxlnSanrZgisBpsrxVWpiQD3OXDw4e9njWgiEJhhPcFJpWYS1W0SuUoVJkUT6yR-puk_ENq92Ce6XWFirVwHyWmGCai-acl1_KShFJC_AcuHVQLWACJGxyIVSwQEpMTh1B8sjR6wVafCJKk0eTNuqQwCgd9m7UKK-y61UxpN9RrxffBnKlchpMJkaoimIxUhEEpT1OLh2Zo0QIeYwWn52JxDOh7FlGPZ4N8axsEbzVKAxMuiHWxH-ZJTaWZUzjK-VmW-WmMdJCfCaF63DwGLTYdWiBh3IYqKREx61sJT8F3CsknL_mMLLlHn2Z7L1lztfVtOXckoYR5mwN1ybwnkrxJ_pOqv8GgblEU1GQnBjHGBdaE8sGsqFmDn_rPSmqL2Lpmv_e41LQj7Gxb8XNMtAqDoOM0CBF4KUcPmjm-XjZSDJOFVxoc7NcYWkWiybmW9RSTgVAdzYkep7CAihqMD_R0eiGqehWC1ZTB5_mkJhstbWyjJ7Qs6bdlzqy_hWdeZeQy9sGxnNyF_lik2qfGAKTLwSVhJzBnj2pngBKiYUmq8Mxl2Pg3xjVX73ys51gXX3fES1LCWuXGVtx9dblnYSA2LOCZqqZwZXWPNWCkEvSYQywHM-RwN2dan4F7v1O53bcD2iLGOxXO9-m7bMB7txwpBRdS5aLD9VJjYCmnymcXGOQX9tSdstddX7o5UfB6xrZeXKg-FMyYtnAzM8eJ2vZn1-IYyWoilrzPxftCf2uVU9w2BLZmLCdHvPRPtInFJ8S802KDBvJhJrUAmHgoI9uorjSwOboDpjrIANpoi_t7IpoiS1RAkofDwTxy_wcXt2kBQ1aHSoBhukaIjZZCBwhlE3E-rcaLptUfwGkg3XULcLuxg3F-GSNYWVAffuQS-oUnIrZOmCrCT3xk4tIzy4QX2PlDpuoYjmCsJQQ6o6gfmTYNZzfIZ-hEoxwfFeGyDNZZj-pygbpaOiY2t1dyE0I6PMp3mUKsHMkaXplYoYG7sLy1RvjAISFkmXyC6zmCh5k3QhB7YfygA-qz0Z3cUbIfezcJdafgaqMyR8tSsGyKJO0',
+      priv: 'kTfye65c20Ez4T1rDv5YsC_kLexfNxNQHRZohALP3OhhjjiwFoBsHg0-HRLIWO3Nx5OwGhsUToPjfW0OWIU34A',
+    },
   },
   'ML-KEM-1024': {
     pkcs8_seed_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-1024', 'private_seed_only'), 'ascii')),
@@ -45,8 +58,15 @@ const keyData = {
     pkcs8_priv_only: toDer(fixtures.readKey(getKeyFileName('ml-kem-1024', 'private_priv_only'), 'ascii')),
     spki: toDer(fixtures.readKey(getKeyFileName('ml-kem-1024', 'public'), 'ascii')),
     pub_len: 1568,
+    jwk: {
+      kty: 'AKP',
+      alg: 'ML-KEM-1024',
+      pub: 'DdeBJ4eqvZcmMWheoVWLNhEF81a4GZCrE3Zc2aNgyvY0adJyciCEsFsEvfy3WSXAuRkChxyZtale1ZC0RcVXouFbHEt6mAimzfgaXAojEkVylpOIOppPUZkV8IRiZ4IutPurDNqRXdY3fQmYWwExVSFfoSFDgTgnCUvKvTk79yQoNQucORZ9HFwPj_K7-TpyGbgC7GElMtui4rBHSny0BCJMZeafG8wqK9BcXRN06SmxqRNqsRx9HLJNwphr7IFcMlZTCIxrxoMckfkMe0BiVSAjVNaIB5RvciJbcmR2xqZPEYNTVVKAuIyaJvmLHQEv-ObKfwUnz6WN0NGZjhp7_KYAxYowXjpuThMGGuuSbVyGh8JYzCMx2ng_T0ZxeDG_lAcmHKRTpcdzNThXnsuh9YVzD6aQpyCcaYqxeGVQoex-euQEyPc6PqcsyfHLWxlgPuoCx4p_BAunJCASz_tjClUheiQcCaYAmMmSylOElQwsovdX9uy_NOJ9BmY9cDSMPnaJhFhvIxFR1jNg09ZCuXRYJDiIyWBK2czA3vt9ZVo9o1QnM1SZjvYyCoBO23LHGSZKuHw_ISOeTcMv76qE_4kNlpXLktBxxXmPNBJ7rZC_xaemvkGS8zjGX2Bqf7cGDzKQbEhWk3ovptV1FmN2XykR7DkEa7pOn6iKpCB5yCOr4AHM0ViKqoa7Z3MysSinTianEKVsVLBH0TwKt4c8g0ihCQaITTOtF2QtjYMSIGzHnqVNacJ8yNxDRVLBOqY7G2qXLTp8YUuZ2fCXevBcCQYQNeYQlWURtPMvtiIvpIiIZgc732fFGThZ38bH4xG5KRxD1xq1gLWQZwkYFvhoFSNsVSpfjIJJSaPD76nLk_KfAlQMpQY0SXCzjKGVeoehT7eHrwpQy-oZoThCmYZTI8E5khTCk6h8fis8WAwKnTKLVVuHL2BVDZVG34lp3uR_bUGNDtgNQjJW1LctC6awz0nAtsZUVukbs4VM_Mt-kzZBPtoDPdTDZKGGGiQ3UJAuzisNgdomiloOFlWDWAmSvcYE_qAVnVw66LchMtkGZmEGSCWtIWpxQlNDNvY0nqwGUhzH8ruqlsti30jKu8yE8_J2RdkPKoQre3JcQlZnWaLOvoJ9nhplc7UgG_e229x1XgiTSSy_vLTFPWg_opM6ZhGDwMZwFMORgcExj2HEnlkyVImZeKAtU-GRCgCBKFPLJiNeLSCfNFSGu1NFoBYPxkOBCrUCX5lZt5Um1rYpeemR5otK7Kh_tGJIQUlogeMJTIGS7dZLz0EimmGaaeXAwhN5JPBXkiKPhVhXX4tYb3uaSYsQbtRiw0RdEhysp6EyUrolf-OqOEwbiLJoJiN3hgcP-tuX8ZXIdhNmmyMzD4lIdpZmkkAxD9M64CkK6YFDthCAkHt2E6qgB2liwiwbXNdqU7gH99V2wlycYrKMaKJU5xyzyaQMMUMscapGB8GGRKNhVJwzzka2AxG2tKo-mhllI8ZrcQuHOMQo21jJYkob6xgOhFulAlZ-_icTQGdZ4-g6pzk40ih9rDWfxUYyJNN67-g50jvLIOJrJQEYjcg4TXDBuFahMtTNqOpvAazHFDeqV1iQz0mHBpMMPvGi-Gs5GvBG4kK8m9dMXFtUHvRbToemW2jAzXFjzmW0BEkWs-WMvbwBL3p8mElHZzuNZCsp5EpEzIqDsgktvLHCa5IVN5CrPUzJC9VnMYYrDXIBF4yOLmtFxQmxQdF8RUJc0Oy1aKCA0bchkiuLIiW35tNMd6wDFJctpLoMGxIlNthoWTYYYeFNAEepvZdO_iM4NBd5lACS9pqyuvVx5GmGpFSsPHlyuMWMHQuyH5tf5tCMbgTCkFsvAxo0attaSVkYK6atSBlS8XB0pLQqd_cj4agOy5YSLbACpsI2KfJ1epKFgyB27_yVf7aa4xQt8ksu-ymrgBufVjg92pNzG2dSC0WZR4smS_RmTxZJjvBTVBbNwrilplZROHtWjjkIBNyzNbNu7Ds1c-Jo7WA39WE0awyYc4EVITG1khNS5oULg-AXvXTtwXmUn7GtGxXtlfBpE37RJhm21PYl7WQppG3c0Pk',
+      priv: 'XwegslUGcMnzu1c1NccsyRmBaObWSESIGO-ftccj5MvAwjLDAJV_u5KhD_rnJLoLOu0eNGt4p3Oh6Mg5ttxICw',
+    },
   },
 };
+/* eslint-enable @stylistic/js/max-len */
 
 const testVectors = [
   {
@@ -294,6 +314,128 @@ async function testImportRawSeed({ name, privateUsages }, extractable) {
     { message: 'Invalid keyData' });
 }
 
+async function testImportJwk({ name, publicUsages, privateUsages }, extractable) {
+  const jwk = keyData[name].jwk;
+
+  const [
+    publicKey,
+    privateKey,
+  ] = await Promise.all([
+    subtle.importKey(
+      'jwk',
+      {
+        kty: jwk.kty,
+        alg: jwk.alg,
+        pub: jwk.pub,
+      },
+      { name },
+      extractable,
+      publicUsages),
+    subtle.importKey(
+      'jwk',
+      { ...jwk },
+      { name },
+      extractable,
+      privateUsages),
+  ]);
+
+  assert.strictEqual(publicKey.type, 'public');
+  assert.strictEqual(privateKey.type, 'private');
+  assert.strictEqual(publicKey.extractable, extractable);
+  assert.strictEqual(privateKey.extractable, extractable);
+  assert.strictEqual(publicKey.algorithm.name, name);
+  assert.strictEqual(privateKey.algorithm.name, name);
+  assert.strictEqual(privateKey.algorithm, privateKey.algorithm);
+  assert.strictEqual(privateKey.usages, privateKey.usages);
+  assert.strictEqual(publicKey.algorithm, publicKey.algorithm);
+  assert.strictEqual(publicKey.usages, publicKey.usages);
+
+  if (extractable) {
+    const [
+      pubJwk,
+      pvtJwk,
+    ] = await Promise.all([
+      subtle.exportKey('jwk', publicKey),
+      subtle.exportKey('jwk', privateKey),
+    ]);
+
+    assert.strictEqual(pubJwk.kty, 'AKP');
+    assert.strictEqual(pvtJwk.kty, 'AKP');
+    assert.strictEqual(pubJwk.alg, name);
+    assert.strictEqual(pvtJwk.alg, name);
+    assert.strictEqual(pubJwk.pub, jwk.pub);
+    assert.strictEqual(pvtJwk.pub, jwk.pub);
+    assert.strictEqual(pvtJwk.priv, jwk.priv);
+    assert.strictEqual(pubJwk.priv, undefined);
+  } else {
+    await assert.rejects(
+      subtle.exportKey('jwk', publicKey), {
+        message: /key is not extractable/
+      });
+    await assert.rejects(
+      subtle.exportKey('jwk', privateKey), {
+        message: /key is not extractable/
+      });
+  }
+
+  // Invalid use parameter
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { kty: jwk.kty, alg: jwk.alg, pub: jwk.pub, use: 'sig' },
+      { name },
+      extractable,
+      publicUsages),
+    { message: 'Invalid JWK "use" Parameter' });
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { ...jwk, use: 'sig' },
+      { name },
+      extractable,
+      privateUsages),
+    { message: 'Invalid JWK "use" Parameter' });
+
+  // Algorithm mismatch
+  const wrongAlg = name === 'ML-KEM-512' ? 'ML-KEM-768' : 'ML-KEM-512';
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { kty: jwk.kty, alg: wrongAlg, pub: jwk.pub },
+      { name },
+      extractable,
+      publicUsages),
+    { message: 'JWK "alg" Parameter and algorithm name mismatch' });
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { ...jwk, alg: wrongAlg },
+      { name },
+      extractable,
+      privateUsages),
+    { message: 'JWK "alg" Parameter and algorithm name mismatch' });
+
+  // Empty usages for private key
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { ...jwk },
+      { name },
+      extractable,
+      [/* empty usages */]),
+    { name: 'SyntaxError', message: 'Usages cannot be empty when importing a private key.' });
+
+  // Missing pub for private key
+  await assert.rejects(
+    subtle.importKey(
+      'jwk',
+      { kty: jwk.kty, alg: jwk.alg, priv: jwk.priv },
+      { name },
+      extractable,
+      privateUsages),
+    { message: 'Invalid JWK' });
+}
+
 (async function() {
   const tests = [];
   for (const vector of testVectors) {
@@ -304,6 +446,7 @@ async function testImportRawSeed({ name, privateUsages }, extractable) {
       tests.push(testImportPkcs8PrivOnly(vector, extractable));
       tests.push(testImportRawSeed(vector, extractable));
       tests.push(testImportRawPublic(vector, extractable));
+      tests.push(testImportJwk(vector, extractable));
     }
   }
   await Promise.all(tests);