Argon2 Hash Generator & Verifier
Hash and verify passwords with Argon2id, the modern password-hashing standard.
Hash a password
Type a password: its hash appears here.
Parameters
m=19456 in the hash (KiB)
Lanes of memory. They run one after another here; a server may run them in parallel. It changes the hash, so match the server.
16 new random bytes for every hash.
Check a password against a hash
A PHC string: $argon2id$, $argon2i$ or $argon2d$. The parameters are read from it.
Enter a password and a hash to check them.
Argon2 won the Password Hashing Competition and is standardized in RFC 9106. It is deliberately slow and memory-hungry, which makes guessing passwords on GPUs expensive. This page makes an Argon2 hash with the parameters you choose, as the PHC string that password libraries store ($argon2id$v=19$m=…,t=…,p=…$salt$hash) and as raw hex, and checks a password against an existing PHC string. It runs in your browser, so the password never leaves your device; it's free and needs no sign-up.
How to generate and verify an Argon2 hash
- Type the password. The hash appears as you type, with how long it took on your device.
- Choose a preset, or set memory, iterations and parallelism to match your server.
- Copy the PHC string, or the raw hash and salt in hex.
- To check a stored hash, paste it with the password under Check a password against a hash: you see Match or No match.
Features
- Argon2id (default), Argon2i and Argon2d, version 19
- Presets: OWASP minimum (19 MiB, t=2, p=1), RFC 9106 low memory (64 MiB, t=3, p=4) and High (256 MiB, t=3, p=4)
- Memory 1 MiB–1 GiB, iterations 1–16, parallelism 1–16, hash length 4–128 bytes
- A random 16-byte salt, or your own as text, hex or Base64 (8–1024 bytes)
- The PHC string, plus the raw hash and the salt in hex, each with a Copy button
- Verifies $argon2id$, $argon2i$ and $argon2d$ strings (v=19 or v=16), reading the parameters from the hash
Is it private?
Yes. Argon2 runs in your browser with WebAssembly, in a background worker, and the salt comes from your browser's secure random generator. The password is never uploaded or stored.
Frequently asked questions
Argon2id, Argon2i or Argon2d?
Use Argon2id. RFC 9106 and OWASP both recommend it for passwords: it combines Argon2i's resistance to side-channel attacks with Argon2d's resistance to GPU cracking. Choose another variant only to match an existing system.
What memory, iterations and parallelism should I use?
OWASP's minimum for Argon2id is 19 MiB, 2 iterations, 1 lane. RFC 9106 suggests 64 MiB, 3 iterations, 4 lanes when memory is limited. More memory is the stronger protection; raise it until one hash takes as long as your server can afford per sign-in.
Argon2 or bcrypt?
Argon2id for a new system. Both are slow on purpose, but Argon2 also needs a lot of memory, which makes cracking on GPUs expensive, and it has no 72-byte password limit. Bcrypt is older and supported almost everywhere, and still a reasonable choice where Argon2 isn't available.
What is the $argon2id$ PHC string?
It is how the Argon2 reference implementation stores a hash: variant, version (v=19), memory in KiB (m), iterations (t), lanes (p), then the salt and the hash in Base64 without padding. Strings made here are character for character what the reference library (libargon2) writes for the same inputs, and libsodium's crypto_pwhash_str_verify accepts them (Argon2id and Argon2i, with a hash of 16 bytes or more).
Why can't I use more than 1 GiB of memory?
The hash runs inside your browser tab, where WebAssembly memory is limited: one allocation can't reach 2 GiB, and phones often refuse much less. So this page stops at 1 GiB, and hashes that ask for more (such as RFC 9106's 2 GiB option) can't be made or checked here.