Merkle Tree Generator Online | Build & Verify Proofs (SHA-256/Keccak)

This tool builds Merkle trees from a list of leaf data and generates cryptographic proofs entirely in your browser. It supports SHA-256/SHA-512 (Web Crypto API) and Keccak-256 (@noble/hashes, loaded as a lazy chunk). Choose between duplicate or promote odd-leaf rules, raw or sorted-pair concatenation (OpenZeppelin compatible), then click any leaf to get its authentication path or paste a proof to verify membership.

Algorithm Comparison

Algorithm	Output Size	Used by	Best for
SHA-256	256-bit (32 bytes)	Bitcoin, TLS, general-purpose	Standard Merkle trees, blockchain
SHA-512	512-bit (64 bytes)	High-security systems	Larger digest, collision resistance
Keccak-256	256-bit (32 bytes)	Ethereum, Solidity	EVM compatibility, smart contracts

Code Examples

Build and verify a Merkle tree with @noble/hashes:

// Browser — SHA-256 Merkle tree
import { sha256 } from '@noble/hashes/sha256';

// Hash leaves
const leaves = ['a', 'b', 'c', 'd'].map(
  x => sha256(new TextEncoder().encode(x))
);

// Build tree (duplicate odd-leaf rule)
let level = leaves;
while (level.length > 1) {
  const next = [];
  for (let i = 0; i < level.length; i += 2) {
    const left = level[i];
    const right = level[i + 1] || level[i];  // duplicate
    next.push(sha256(new Uint8Array([...left, ...right])));
  }
  level = next;
}
const root = level[0];
console.log('Merkle root:', Array.from(root).map(b => b.toString(16).padStart(2, '0')).join(''));

# Python — SHA-256 Merkle tree
import hashlib

def merkle_root(leaves):
    if not leaves:
        return None
    level = [hashlib.sha256(l.encode()).digest() for l in leaves]
    while len(level) > 1:
        next_level = []
        for i in range(0, len(level), 2):
            left = level[i]
            right = level[i + 1] if i + 1 < len(level) else level[i]
            next_level.append(hashlib.sha256(left + right).digest())
        level = next_level
    return level[0].hex()

print(merkle_root(['a', 'b', 'c', 'd']))

Security Notes

• Merkle proofs are logarithmic — for N leaves, proof size is O(log N), making them efficient for large datasets.
• Root is tamper-evident — changing any single leaf produces a completely different root.
• Match conventions exactly — hash function, leaf encoding, odd-leaf rule, and concatenation mode must all match between tree builder and verifier.
• Sorted-pair simplifies verification — OpenZeppelin mode eliminates left/right position tracking in smart contracts.

Related Tools

Need to generate a plain hash? Try the SHA Hash Generator. For HMAC generation with a secret key, see the HMAC Generator. You can also verify digital signatures with the Digital Signature & Verify tool.