Create a salted Argon2id password hash using memory-hard, interoperable defaults.
Runs in your browser — your input is processed on this device and never uploaded.
Results appear here.
Argon2id is a password hashing function: deliberately slow, deliberately memory-hungry, and built for exactly one job, which is storing passwords so that a stolen database is not the same thing as a stolen list of passwords.
Enter a password and the tool returns a hash in PHC string format, using interoperable defaults. A fresh cryptographic salt is generated every time, so the same password produces different output on every run.
An ordinary hash is fast, which means an attacker with your database can try billions of candidate passwords per second, and specialised hardware makes that worse. Graphics cards are enormously good at running many small identical computations at once, which is precisely what cracking a fast hash looks like.
Argon2id defends by requiring a large block of memory for each computation. Memory is the resource that does not parallelise cheaply: a GPU with thousands of cores cannot give each of them a big working buffer. That turns the attacker's hardware advantage into a much smaller one.
The id in the name marks the hybrid variant, blending a version resistant to side-channel observation with one tuned against GPU attacks. It is the variant recommended for password storage.
Argon2 Hash Verifier is the matching tool for checking a password against a hash produced here.
What is not an alternative is any general-purpose hash. SHA256, BLAKE3, and the rest are fast by design, and that speed is the attacker's asset. Salting them does not fix it.
The salt is why the same password hashes differently each time. Without it, identical passwords produce identical hashes, which lets an attacker spot shared passwords across accounts and attack them all at once with precomputed tables.
The PHC string carries the variant, the parameters, and the salt inside the output, so a verifier needs nothing but the string itself. That is what makes stored hashes portable across implementations, and it is why the cost parameters can be raised later without invalidating existing hashes.
Find similar tools by category or tag.