Skip to content
logo

Argon2 Password Hash

The winner of the Password Hashing Competition (PHC). Argon2 is a memory-hard function resistant to GPU cracking.

Result will appear here
Recommended: 3 iterations, 64MB memory, 4 threads.

What is Argon2?

Argon2 is a modern password-hashing function that won the Password Hashing Competition (PHC) in 2015. It was designed to provide both maximum security and high performance, specifically resisting brute-force attacks from GPUs and ASICs.

Memory-hard design — requires a large amount of RAM during hashing, making it extremely expensive for attackers to parallelize using specialized hardware.
Side-channel resistance — provides protection against side-channel attacks through its different variants (Argon2i).
Tunable parameters — iterations (time), memory size, and parallelism (threads) allow fine-grained control over security levels.
Three variants — Argon2id (hybrid), Argon2i (side-channel resistant), and Argon2d (data-dependent).

Zero-Server Tool Data Guarantee

All hashing happens locally in your browser. Your password and parameters never leave your device.

How to Use

01

Enter Password & Salt

Input the password you wish to hash and a unique salt. Using a random salt is critical for security.

02

Tune Parameters

Adjust the memory size, iterations, and parallelism to fit your security requirements. Higher values are more secure but slower.

03

Copy Encoded Hash

The resulting PHC-formatted string contains all parameters, salt, and the hash itself, making it easy to store and verify.

Common Use Cases

User Password Storage

The industry-standard choice for securing user accounts in modern web applications.

Key Derivation

Securely derive encryption keys from a user's master passphrase for local data encryption.

Cryptocurrency

Used by various privacy-focused blockchains for secure wallet encryption and proof-of-work.

Secure Communications

Derive shared secrets in protocols where resistance to hardware-accelerated cracking is required.

Implementation Examples

JavaScriptNode.js (argon2)
const argon2 = require('argon2');


// Hash a password
const hash = await argon2.hash('mySecurePassword');
// $argon2id$v=19$m=65536,t=3,p=4$somesalt...


// Verify a password
const isMatch = await argon2.verify(hash, 'mySecurePassword');
console.log(isMatch); // true

Argon2 vs Bcrypt vs Scrypt

FeatureArgon2idBcryptScrypt
Memory hardnessVery High (tunable)Low (4KB)High (tunable)
GPU/ASIC resistanceHighestModerateHigh
Tunable parametersMemory, Time, ParallelismCost factorN, r, p
PHC Winner?Yes (2015)NoNo
Recommended forModern projectsLegacy supportHigh memory systems

Production Best Practices & Security

Use Argon2id — it is the recommended default for most applications, providing the best balance of security against both side-channel and GPU-based attacks. Why:It combines the strengths of Argon2i and Argon2d, protecting against different types of threats in a single algorithm.
Iterate appropriately — at least 3 iterations are recommended for most systems to ensure sufficient time-cost. Why:More iterations increase the time an attacker must spend per guess, making brute-force unfeasible even with powerful hardware.
Allocate enough memory — 64MB (65536 KiB) is a standard baseline for password hashing. Why:Argon2 is "memory-hard." By requiring significant RAM, it prevents attackers from using cheap, specialized hardware (ASICs) or GPUs to try millions of passwords in parallel.
Set parallelism to match your cores — usually 4 or 8 threads depending on your target server environment. Why:Parallelism allows you to utilize modern multi-core CPUs efficiently to compute the hash quickly for legitimate users while still maintaining high security.
Use a unique salt — always use a random salt of at least 16 bytes for every password. Why:Unique salts prevent attackers from using precomputed "Rainbow Tables" and ensure that identical passwords result in different hashes.

Frequently Asked Questions

Argon2 is a modern password-hashing function that won the Password Hashing Competition (PHC) in 2015. It is designed to be highly resistant to GPU and ASIC cracking attacks by being memory-hard.

Switch to the 'Verify' tab in our tool, paste the PHC-formatted Argon2 hash (e.g., $argon2id$v=19$m=65536,t=3,p=4$...), and enter the candidate password. The tool will automatically parse the parameters from the hash and check for a match.

Argon2i is optimized to resist side-channel attacks. Argon2d is optimized to resist GPU cracking attacks. Argon2id is a hybrid version that combines both, making it the recommended default for most applications.

OWASP and the PHC recommend at least 3 iterations, 64MB of memory (65536 KiB), and 4 threads for typical user password hashing.

Yes, Argon2 is generally considered superior because it is memory-hard, meaning it requires significant RAM to compute. This makes it much harder to crack using specialized hardware like GPUs compared to Bcrypt.