Node.js 58 🟢 Cryptographic Operations with the node:crypto and Web Crypto APIs
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
| Environment | node:crypto | Web Crypto |
|---|---|---|
| Node.js | Yes | Yes |
| Browser | No | Yes |
| Cloudflare Workers | Partial | Yes |
| Vercel Edge | Partial | Yes |
| Deno | Via node:crypto | Yes |
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
| Aspect | node:crypto | Web Crypto |
|---|---|---|
| Runtime | Node.js | Everywhere |
| Sync/async | Sync (mostly) | Async (always) |
| Key format | String/Buffer | CryptoKey |
| Algorithm coverage | Full OpenSSL | Standardized set |
| Event loop | Blocks | Non-blocking |
| Extractable keys | Always | Opt-in |
| API style | Object with methods | Promise-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
| Function | Purpose |
|---|---|
createHash | Create a hash object |
createHmac | Create an HMAC object |
createCipheriv | Create a cipher with key and IV |
createDecipheriv | Create a decipher |
createSign | Create a signer |
createVerify | Create a verifier |
scrypt | Derive a key from a password |
randomBytes | Generate random data |
generateKeyPairSync | Generate a key pair |
The Web Crypto Methods
| Method | Purpose |
|---|---|
subtle.digest | Compute a hash |
subtle.sign | Sign or HMAC |
subtle.verify | Verify a signature |
subtle.encrypt | Encrypt |
subtle.decrypt | Decrypt |
subtle.importKey | Import a key |
subtle.generateKey | Generate a key |
subtle.deriveBits | Derive key material |
getRandomValues | Generate random data |
The Algorithm Coverage
| Algorithm | node:crypto | Web Crypto |
|---|---|---|
| SHA-256 | Yes | Yes |
| SHA-3 | Yes | Yes |
| HMAC | Yes | Yes |
| AES-GCM | Yes | Yes |
| ChaCha20-Poly1305 | Yes | Yes |
| RSA-OAEP | Yes | Yes |
| ECDSA | Yes | Yes |
| Ed25519 | Yes | Yes |
| PBKDF2 | Yes | Yes |
| scrypt | Yes | No |
| Diffie-Hellman | Yes | Limited |
The Key Representation
| Aspect | node:crypto | Web Crypto |
|---|---|---|
| Key type | String/Buffer | CryptoKey |
| Extractable | Always | Opt-in |
| Serializable | Yes | Export required |
| Loggable | Yes | No |
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
| Pitfall | Why It Happens | Fix |
|---|---|---|
| Hash reuse | digest called twice | Create a new hash |
| Event loop block | Long sync hash | Use Web Crypto |
| Key leak | Logged a Buffer key | Use CryptoKey |
| GCM failure | Missing auth tag | Call setAuthTag |
| IV reuse | Static IV | Generate a random IV |
| Encoding mismatch | String vs Uint8Array | Use TextEncoder |
| Interop failure | Different key formats | Convert 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
| Item | Value |
|---|---|
node:crypto | Node.js’s original cryptographic module |
| Web Crypto | The standardized browser and Node.js API |
createHash | Node.js hash constructor |
subtle.digest | Web Crypto hash method |
createHmac | Node.js HMAC constructor |
subtle.sign | Web Crypto signing method |
createCipheriv | Node.js cipher with key and IV |
subtle.encrypt | Web Crypto encryption method |
randomBytes | Node.js random generation |
getRandomValues | Web Crypto random generation |
CryptoKey | Web Crypto opaque key object |
TextEncoder | String to Uint8Array |
Key takeaways:
node:cryptoand 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:cryptocannot 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:cryptoblocks 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:cryptokey is a string or Buffer that can be logged or serialized. A Web CryptoCryptoKeyis 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
getAuthTaginnode:cryptoand verified withsetAuthTagon decryption. The Web Crypto API verifies it automatically . - The algorithms are not identical.
node:cryptoexposes the full OpenSSL surface, includingscryptand 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 theArrayBufferresult 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.
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!