| |

Node.js 58 🟢 Cryptographic Operations with the node:crypto and Web Crypto APIs

⏱️ Estimated read: 16 min | |

Node.js ships with two cryptographic interfaces that share a common goal but differ in history, API shape, and runtime compatibility. The node:crypto module is the original interface, a synchronous wrapper around OpenSSL that has served Node.js since its earliest releases. The Web Crypto API is the web standard, available in browsers, in Edge runtimes, and in Node.js through node:crypto.webcrypto or the global crypto object. The two are not interchangeable. They use different key representations, different call conventions, and different threading models. Understanding when to use each is the difference between code that runs everywhere and code that locks an application to one runtime.

Key point: node:crypto is Node-specific and synchronous. The Web Crypto API is standardized and asynchronous. For new code that must run in browsers, on the edge, or in Node.js, Web Crypto is the default. For Node-only code that needs the broader OpenSSL surface or synchronous calls, node:crypto remains the right choice.


Why two cryptographic APIs exist

The history problem. node:crypto predates the Web Crypto specification. It was designed for Node.js’s server-side model, where synchronous calls are acceptable because the caller controls the event loop. Its API reflects OpenSSL’s structure: hash objects, cipher objects, sign objects, each with an update method and a final or digest call .

The standardization problem. The Web Crypto API was created after browsers had shipped incompatible cryptographic interfaces. The W3C standardized the API around a single SubtleCrypto interface, and every major browser adopted it. The result is an API that works the same in a browser, a Cloudflare Worker, a Vercel edge function, and Node.js .

The async problem. The Web Crypto API is entirely Promise-based. Every operation returns a Promise, and the underlying implementation can offload work to a background thread. The node:crypto module is synchronous for most operations, which means a long hash or an expensive key derivation blocks the event loop .

The key representation problem. node:crypto represents keys as strings or Buffers. The Web Crypto API represents keys as CryptoKey objects, which are opaque, non-extractable by default, and cannot be serialized without an explicit export step. This is a security feature: a private key that is imported into Web Crypto cannot be accidentally logged .

The compatibility problem. Code that uses node:crypto cannot run in a browser. Code that uses the Web Crypto API can run in both, with the exception of algorithms that are not part of the standard. For libraries that must work across environments, Web Crypto is the only choice .

The algorithm problem. node:crypto exposes the full OpenSSL algorithm surface, including algorithms that are not part of the Web Crypto standard: Diffie-Hellman groups, custom cipher modes, and the entire set of OpenSSL signing algorithms . The Web Crypto API covers a narrower, standardized set .


a. The node:crypto module

The node:crypto module is imported with require('node:crypto') or import from 'node:crypto'. It exposes hash, HMAC, cipher, decipher, sign, verify, key derivation, and random generation functions .

The hashing

A hash is created with createHash, updated with update, and finalized with digest. The object cannot be used after digest is called .

const { createHash } = require('node:crypto');

const hash = createHash('sha256');
hash.update('hello world');
const digest = hash.digest('hex');
// digest is the 64-character hex string

The copy method creates a deep copy of the hash state, which is useful for computing a rolling hash over multiple prefixes .

The HMAC

An HMAC is created with createHmac and takes a key as the second argument.

const { createHmac } = require('node:crypto');

const hmac = createHmac('sha256', 'secret-key');
hmac.update('message');
const digest = hmac.digest('hex');

The HMAC is used to authenticate a message with a shared secret. It is the correct primitive for API request signing and webhook verification .

The symmetric encryption

Symmetric encryption uses createCipheriv, which takes the algorithm, the key, and the initialization vector. The update method produces ciphertext, and the final method produces the last block.

const { createCipheriv, randomBytes } = require('node:crypto');

const algorithm = 'aes-256-gcm';
const key = randomBytes(32);
const iv = randomBytes(12);

const cipher = createCipheriv(algorithm, key, iv);
let encrypted = cipher.update('plaintext', 'utf8', 'hex');
encrypted += cipher.final('hex');
const authTag = cipher.getAuthTag();

The AES-GCM mode is authenticated: it produces an auth tag that must be verified on decryption. The tag is retrieved with getAuthTag after final .

The signing and verification

The Sign class signs data with a private key, and the Verify class verifies with a public key. Both use a two-step API: update to supply the data, and sign or verify to produce or check the signature .

const { createSign, createVerify, generateKeyPairSync } = require('node:crypto');

const { privateKey, publicKey } = generateKeyPairSync('rsa', {
  modulusLength: 2048,
});

const sign = createSign('sha256');
sign.update('message');
const signature = sign.sign(privateKey, 'hex');

const verify = createVerify('sha256');
verify.update('message');
const isValid = verify.verify(publicKey, signature, 'hex');

The key derivation

The scrypt function derives a key from a password. It is asynchronous and takes the password, salt, key length, and a callback.

const { scrypt } = require('node:crypto');

scrypt('password', 'salt', 32, (err, key) => {
  if (err) throw err;
  // key is a 32-byte Buffer
});

The random generation

The randomBytes function generates cryptographically secure random data.

const { randomBytes } = require('node:crypto');

const token = randomBytes(32).toString('hex');

b. The Web Crypto API

The Web Crypto API is available in Node.js as crypto.webcrypto or as the global crypto object. The interface is crypto.subtle, which exposes the cryptographic operations .

The digest

The subtle.digest method computes a hash. It takes the algorithm name and the data as an ArrayBuffer or TypedArray, and returns a Promise that resolves to an ArrayBuffer.

const data = new TextEncoder().encode('hello world');
const digest = await crypto.subtle.digest('SHA-256', data);
const hex = Array.from(new Uint8Array(digest))
  .map((b) => b.toString(16).padStart(2, '0'))
  .join('');

The result is the same hash as createHash('sha256'), but the call is asynchronous and the input must be a Uint8Array .

The HMAC

The HMAC is created by importing a key with the HMAC algorithm and then calling subtle.sign. The key is a CryptoKey object, not a string.

const key = await crypto.subtle.importKey(
  'raw',
  new TextEncoder().encode('secret-key'),
  { name: 'HMAC', hash: 'SHA-256' },
  false,
  ['sign']
);

const signature = await crypto.subtle.sign('HMAC', key, data);

The symmetric encryption

Symmetric encryption uses subtle.encrypt with an imported key and an algorithm object that carries the IV.

const key = await crypto.subtle.importKey(
  'raw',
  rawKey,
  { name: 'AES-GCM' },
  false,
  ['encrypt']
);

const encrypted = await crypto.subtle.encrypt(
  { name: 'AES-GCM', iv },
  key,
  new TextEncoder().encode('plaintext')
);

The AES-GCM encryption appends the authentication tag to the ciphertext. The decryption verifies the tag automatically and rejects if it does not match .

The signing and verification

The subtle.sign and subtle.verify methods use a CryptoKey and an algorithm object.

const key = await crypto.subtle.generateKey(
  { name: 'ECDSA', namedCurve: 'P-256' },
  true,
  ['sign', 'verify']
);

const signature = await crypto.subtle.sign(
  { name: 'ECDSA', hash: 'SHA-256' },
  key.privateKey,
  data
);

const isValid = await crypto.subtle.verify(
  { name: 'ECDSA', hash: 'SHA-256' },
  key.publicKey,
  signature,
  data
);

The key derivation

The subtle.deriveBits method derives key material. The PBKDF2 and HKDF algorithms are supported .

const key = await crypto.subtle.importKey(
  'raw',
  new TextEncoder().encode('password'),
  'PBKDF2',
  false,
  ['deriveBits']
);

const bits = await crypto.subtle.deriveBits(
  { name: 'PBKDF2', salt, iterations: 600000, hash: 'SHA-256' },
  key,
  256
);

The random generation

The crypto.getRandomValues method fills a TypedArray with random values. It is synchronous and is the Web Crypto replacement for randomBytes.

const array = new Uint8Array(32);
crypto.getRandomValues(array);

c. Choosing between the two

The choice depends on the runtime, the threading model, and the algorithms required.

The runtime compatibility

Environmentnode:cryptoWeb Crypto
Node.jsYesYes
BrowserNoYes
Cloudflare WorkersPartialYes
Vercel EdgePartialYes
DenoVia node:cryptoYes

A library that must run in a browser or an edge runtime cannot use node:crypto. The Web Crypto API is the only option that works everywhere .

The threading model

node:crypto is synchronous for hashing, HMAC, and cipher operations. A long hash blocks the event loop. The Web Crypto API is asynchronous for every operation, and the implementation can offload work to a background thread. For a server that handles many concurrent requests, the async model is the right choice .

The algorithm coverage

node:crypto covers the full OpenSSL surface: all digest algorithms, all cipher modes, all signing algorithms, Diffie-Hellman groups, and the post-quantum algorithms that Node.js has added. The Web Crypto API covers a standardized set: SHA-2, SHA-3, AES, HMAC, RSA, ECDSA, Ed25519, HKDF, and PBKDF2 .

The key representation

A node:crypto key is a string or a Buffer. It can be logged, serialized, or compared. A Web Crypto CryptoKey is an opaque object. It cannot be read without an explicit export, and the export is only allowed if the key was created with extractable: true. This is a deliberate security property: a private key that is imported into Web Crypto is harder to leak accidentally .

The interoperability

The two APIs are not interoperable at the key level. A signature created with node:crypto cannot be verified with Web Crypto without converting the key and the signature format. The conversion is possible but requires care with encodings and algorithm parameters .

The comparison table

Aspectnode:cryptoWeb Crypto
RuntimeNode.jsEverywhere
Sync/asyncSync (mostly)Async (always)
Key formatString/BufferCryptoKey
Algorithm coverageFull OpenSSLStandardized set
Event loopBlocksNon-blocking
Extractable keysAlwaysOpt-in
API styleObject with methodsPromise-based functions

Complete Example Session

// ============================================
// PART 1: HASHING WITH node:crypto
// ============================================

const { createHash } = require('node:crypto');

const hash = createHash('sha256').update('hello').digest('hex');
console.log(hash);

// ============================================
// PART 2: HASHING WITH WEB CRYPTO
// ============================================

async function hashWebCrypto(text) {
  const data = new TextEncoder().encode(text);
  const digest = await crypto.subtle.digest('SHA-256', data);
  return Array.from(new Uint8Array(digest))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
}

hashWebCrypto('hello').then(console.log);

// ============================================
// PART 3: HMAC WITH node:crypto
// ============================================

const { createHmac } = require('node:crypto');

const mac = createHmac('sha256', 'secret').update('message').digest('hex');
console.log(mac);

// ============================================
// PART 4: HMAC WITH WEB CRYPTO
// ============================================

async function hmacWebCrypto(message, secret) {
  const key = await crypto.subtle.importKey(
    'raw',
    new TextEncoder().encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign']
  );
  const signature = await crypto.subtle.sign(
    'HMAC',
    key,
    new TextEncoder().encode(message)
  );
  return Array.from(new Uint8Array(signature))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
}

hmacWebCrypto('message', 'secret').then(console.log);

// ============================================
// PART 5: AES-GCM WITH node:crypto
// ============================================

const { createCipheriv, createDecipheriv, randomBytes } = require('node:crypto');

function encryptNode(plaintext, key) {
  const iv = randomBytes(12);
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  let encrypted = cipher.update(plaintext, 'utf8');
  encrypted = Buffer.concat([encrypted, cipher.final()]);
  const tag = cipher.getAuthTag();
  return { encrypted, iv, tag };
}

function decryptNode(encrypted, key, iv, tag) {
  const decipher = createDecipheriv('aes-256-gcm', key, iv);
  decipher.setAuthTag(tag);
  let decrypted = decipher.update(encrypted);
  decrypted = Buffer.concat([decrypted, decipher.final()]);
  return decrypted.toString('utf8');
}

const key = randomBytes(32);
const { encrypted, iv, tag } = encryptNode('secret message', key);
console.log(decryptNode(encrypted, key, iv, tag));

// ============================================
// PART 6: AES-GCM WITH WEB CRYPTO
// ============================================

async function encryptWebCrypto(plaintext, rawKey) {
  const key = await crypto.subtle.importKey(
    'raw',
    rawKey,
    { name: 'AES-GCM' },
    false,
    ['encrypt']
  );
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const encrypted = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv },
    key,
    new TextEncoder().encode(plaintext)
  );
  return { encrypted, iv };
}

async function decryptWebCrypto(encrypted, rawKey, iv) {
  const key = await crypto.subtle.importKey(
    'raw',
    rawKey,
    { name: 'AES-GCM' },
    false,
    ['decrypt']
  );
  const decrypted = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv },
    key,
    encrypted
  );
  return new TextDecoder().decode(decrypted);
}

// ============================================
// PART 7: SIGNING WITH node:crypto
// ============================================

const { generateKeyPairSync, sign, verify } = require('node:crypto');

const { privateKey, publicKey } = generateKeyPairSync('ec', {
  namedCurve: 'P-256',
});

const signature = sign('sha256', Buffer.from('message'), privateKey);
const isValid = verify('sha256', Buffer.from('message'), publicKey, signature);
console.log(isValid);

// ============================================
// PART 8: SIGNING WITH WEB CRYPTO
// ============================================

async function signWebCrypto(message) {
  const key = await crypto.subtle.generateKey(
    { name: 'ECDSA', namedCurve: 'P-256' },
    true,
    ['sign', 'verify']
  );
  const signature = await crypto.subtle.sign(
    { name: 'ECDSA', hash: 'SHA-256' },
    key.privateKey,
    new TextEncoder().encode(message)
  );
  const valid = await crypto.subtle.verify(
    { name: 'ECDSA', hash: 'SHA-256' },
    key.publicKey,
    signature,
    new TextEncoder().encode(message)
  );
  return valid;
}

signWebCrypto('message').then(console.log);

// ============================================
// PART 9: THE MIGRATION PATTERN
// ============================================

// Old: node:crypto
// const hash = createHash('sha256').update(data).digest('hex');

// New: Web Crypto
// const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(data));
// const hash = Buffer.from(digest).toString('hex');

// The migration is mechanical: replace the sync call with an async one,
// convert strings to Uint8Array, and convert the ArrayBuffer result back.

// ============================================
// PART 10: THE DECISION
// ============================================

// Use node:crypto when:
// - The code runs only in Node.js.
// - A synchronous call is required.
// - The algorithm is not in the Web Crypto standard.

// Use Web Crypto when:
// - The code must run in a browser or an edge runtime.
// - The event loop must not be blocked.
// - The algorithm is standardized.

The ten parts showed hashing with both APIs, HMAC with both, AES-GCM with both, signing with both, the migration pattern, and the decision criteria.


Quick Reference

The node:crypto Functions

FunctionPurpose
createHashCreate a hash object
createHmacCreate an HMAC object
createCipherivCreate a cipher with key and IV
createDecipherivCreate a decipher
createSignCreate a signer
createVerifyCreate a verifier
scryptDerive a key from a password
randomBytesGenerate random data
generateKeyPairSyncGenerate a key pair

The Web Crypto Methods

MethodPurpose
subtle.digestCompute a hash
subtle.signSign or HMAC
subtle.verifyVerify a signature
subtle.encryptEncrypt
subtle.decryptDecrypt
subtle.importKeyImport a key
subtle.generateKeyGenerate a key
subtle.deriveBitsDerive key material
getRandomValuesGenerate random data

The Algorithm Coverage

Algorithmnode:cryptoWeb Crypto
SHA-256YesYes
SHA-3YesYes
HMACYesYes
AES-GCMYesYes
ChaCha20-Poly1305YesYes
RSA-OAEPYesYes
ECDSAYesYes
Ed25519YesYes
PBKDF2YesYes
scryptYesNo
Diffie-HellmanYesLimited

The Key Representation

Aspectnode:cryptoWeb Crypto
Key typeString/BufferCryptoKey
ExtractableAlwaysOpt-in
SerializableYesExport required
LoggableYesNo

Best Practices

✅ Do This:

// Use node:crypto for Node-only synchronous work.
const hash = createHash('sha256').update(data).digest('hex');  // ✅

// Use Web Crypto for cross-platform code.
const digest = await crypto.subtle.digest('SHA-256', data);  // ✅

// Use AES-GCM for authenticated encryption.
const cipher = createCipheriv('aes-256-gcm', key, iv);  // ✅

// Use the auth tag on decryption.
decipher.setAuthTag(tag);  // ✅

// Use getRandomValues for random data in Web Crypto.
const array = new Uint8Array(32);
crypto.getRandomValues(array);  // ✅

// Convert strings with TextEncoder and TextDecoder.
const data = new TextEncoder().encode(text);  // ✅

❌ Don’t Do This:

// Don't use node:crypto in browser code.
const { createHash } = require('crypto');  // ❌ Breaks in browsers

// Don't block the event loop with long sync hashes.
const hash = createHash('sha512').update(hugeData).digest();  // ❌ Blocks

// Don't reuse a Hash after digest.
hash.digest();
hash.update('more');  // ❌ Throws

// Don't skip the auth tag check on AES-GCM.
decipher.final();  // ❌ Without setAuthTag, integrity is not verified

// Don't use a static IV.
const iv = Buffer.alloc(12, 0);  // ❌ Reuse is catastrophic for GCM

// Don't compare secrets with ===.
if (a === b) { }  // ❌ Use timingSafeEqual

Common Pitfalls

PitfallWhy It HappensFix
Hash reusedigest called twiceCreate a new hash
Event loop blockLong sync hashUse Web Crypto
Key leakLogged a Buffer keyUse CryptoKey
GCM failureMissing auth tagCall setAuthTag
IV reuseStatic IVGenerate a random IV
Encoding mismatchString vs Uint8ArrayUse TextEncoder
Interop failureDifferent key formatsConvert explicitly

Real-World Examples

1. Hashing with node:crypto

const hash = createHash('sha256').update('data').digest('hex');

2. Hashing with Web Crypto

const digest = await crypto.subtle.digest('SHA-256', data);

3. HMAC with node:crypto

const mac = createHmac('sha256', key).update(msg).digest('hex');

4. HMAC with Web Crypto

const signature = await crypto.subtle.sign('HMAC', key, data);

5. AES-GCM with node:crypto

const cipher = createCipheriv('aes-256-gcm', key, iv);

6. AES-GCM with Web Crypto

const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, data);

7. Signing with node:crypto

const signature = sign('sha256', data, privateKey);

8. Signing with Web Crypto

const signature = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, key, data);

9. Random with node:crypto

const token = randomBytes(32).toString('hex');

10. Random with Web Crypto

const array = new Uint8Array(32);
crypto.getRandomValues(array);

Visual

The Two APIs

┌────────────────────────────────────────────────────────────┐
│  node:crypto vs WEB CRYPTO                                 │
│                                                            │
│  node:crypto                    Web Crypto                 │
│  ┌──────────────────┐          ┌──────────────────┐       │
│  │  Synchronous     │          │  Asynchronous    │       │
│  │  Node.js only    │          │  Everywhere      │       │
│  │  OpenSSL surface │          │  Standardized    │       │
│  │  String keys     │          │  CryptoKey       │       │
│  └──────────────────┘          └──────────────────┘       │
│                                                            │
│  The choice is runtime and threading.                      │
└────────────────────────────────────────────────────────────┘

The Hash Flow

┌────────────────────────────────────────────────────────────┐
│  HASHING                                                   │
│                                                            │
│  node:crypto                                               │
│  ┌──────────────────────────────────────────────────┐     │
│  │  createHash('sha256')                             │     │
│  │    .update(data)                                  │     │
│  │    .digest('hex')                                 │     │
│  │  → string                                         │     │
│  └──────────────────────────────────────────────────┘     │
│                                                            │
│  Web Crypto                                                │
│  ┌──────────────────────────────────────────────────┐     │
│  │  crypto.subtle.digest('SHA-256', data)            │     │
│  │    → Promise<ArrayBuffer>                         │     │
│  │    → Uint8Array → hex string                      │     │
│  └──────────────────────────────────────────────────┘     │
│                                                            │
│  Same result. Different shape.                             │
└────────────────────────────────────────────────────────────┘

The Key Representation

┌────────────────────────────────────────────────────────────┐
│  KEY REPRESENTATION                                        │
│                                                            │
│  node:crypto                                               │
│  ┌──────────────────────────────────────────────────┐     │
│  │  const key = randomBytes(32);                     │     │
│  │  console.log(key);  // <Buffer ...>               │     │
│  │                                                   │     │
│  │  The key is a Buffer. It can be logged.           │     │
│  └──────────────────────────────────────────────────┘     │
│                                                            │
│  Web Crypto                                                │
│  ┌──────────────────────────────────────────────────┐     │
│  │  const key = await crypto.subtle.generateKey(...);│     │
│  │  console.log(key);  // CryptoKey { type: ... }    │     │
│  │                                                   │     │
│  │  The key is opaque. It cannot be logged as bytes. │     │
│  └──────────────────────────────────────────────────┘     │
│                                                            │
│  Web Crypto is safer by default.                           │
└────────────────────────────────────────────────────────────┘

The Migration

┌────────────────────────────────────────────────────────────┐
│  MIGRATION PATTERN                                         │
│                                                            │
│  BEFORE (node:crypto)                                      │
│  ┌──────────────────────────────────────────────────┐     │
│  │  const hash = createHash('sha256')                │     │
│  │    .update(data)                                  │     │
│  │    .digest('hex');                                │     │
│  └──────────────────────────────────────────────────┘     │
│                        │                                   │
│                        │  Convert                           │
│                        v                                   │
│  AFTER (Web Crypto)                                        │
│  ┌──────────────────────────────────────────────────┐     │
│  │  const digest = await crypto.subtle.digest(       │     │
│  │    'SHA-256',                                     │     │
│  │    new TextEncoder().encode(data)                 │     │
│  │  );                                               │     │
│  │  const hash = Buffer.from(digest).toString('hex');│     │
│  └──────────────────────────────────────────────────┘     │
│                                                            │
│  The migration is mechanical.                              │
└────────────────────────────────────────────────────────────┘

Summary

ItemValue
node:cryptoNode.js’s original cryptographic module
Web CryptoThe standardized browser and Node.js API
createHashNode.js hash constructor
subtle.digestWeb Crypto hash method
createHmacNode.js HMAC constructor
subtle.signWeb Crypto signing method
createCipherivNode.js cipher with key and IV
subtle.encryptWeb Crypto encryption method
randomBytesNode.js random generation
getRandomValuesWeb Crypto random generation
CryptoKeyWeb Crypto opaque key object
TextEncoderString to Uint8Array

Key takeaways:

  • node:crypto and Web Crypto are different interfaces for the same primitives. The first is Node-specific and synchronous; the second is standardized and asynchronous. The choice depends on the runtime and the threading model .
  • The Web Crypto API is the only choice for cross-platform code. Code that uses node:crypto cannot run in a browser. Code that uses Web Crypto runs in browsers, edge runtimes, and Node.js .
  • The async model avoids blocking the event loop. A long hash or a key derivation with node:crypto blocks the event loop. The Web Crypto API returns Promises and can offload work to a background thread .
  • The key representation is a security difference. A node:crypto key is a string or Buffer that can be logged or serialized. A Web Crypto CryptoKey is opaque and non-extractable by default, which makes accidental leaks harder .
  • AES-GCM is the authenticated encryption mode for both APIs. The auth tag must be retrieved with getAuthTag in node:crypto and verified with setAuthTag on decryption. The Web Crypto API verifies it automatically .
  • The algorithms are not identical. node:crypto exposes the full OpenSSL surface, including scrypt and Diffie-Hellman. The Web Crypto API covers a standardized set that excludes some of these .
  • The migration is mechanical. Replace the sync call with an async one, convert strings with TextEncoder, and convert the ArrayBuffer result back to the desired format. The primitives are the same .

Remember: Node.js ships with two cryptographic interfaces. The node:crypto module is the original, a synchronous OpenSSL wrapper that is Node-specific. The Web Crypto API is the standardized, asynchronous interface that works in browsers, edge runtimes, and Node.js. The choice depends on the runtime and the threading model. For code that must run everywhere, Web Crypto is the only option. For Node-only code that needs the full OpenSSL surface or synchronous calls, node:crypto remains the right tool. Both provide hashing, HMAC, symmetric encryption, signing, key derivation, and random generation. The migration between them is mechanical, and the primitives are the same.


Was this helpful?


Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!