Argon2 Password Hash Generator & Verifier (free, no upload)
Hash a password with Argon2id, Argon2i or Argon2d at your own memory, time and parallelism cost, or verify one against an existing hash. Free, in your browser.
Generate an Argon2 hash
Higher memory is more resistant to GPU cracking — but slower, and it runs on your device, so very high values take a noticeable moment.
Argon2 is deliberately slow and memory-hard: each guess costs an attacker both CPU time and RAM. The encoded string carries the variant, salt and all cost parameters, so it is all you need to verify later.
Verify a password against a hash
🔒 Everything runs in your browser — nothing is uploaded.
Free Argon2 hash generator & verifier — nothing uploaded
Argon2 won the 2015 Password Hashing Competition and is today's first-choice algorithm for storing passwords. This tool does the two everyday jobs: generate an Argon2 hash from a password, and verify whether a password matches an existing hash. Both run entirely in your browser with the WebAssembly build of Argon2 — no password ever leaves your device. It is the modern, memory-hard companion to bcrypt.
Why Argon2 is memory-hard
Fast hashes like MD5 or SHA-256 let an attacker try billions of guesses per second on cheap GPUs. Argon2 deliberately spends a large, tunable amount of memory as well as CPU time on every single guess, which is expensive to parallelise on GPUs and ASICs. Every hash also embeds a random salt, so the same password produces a different hash each time and can only be checked by re-running the algorithm — you cannot "decrypt" it.
Argon2id, Argon2i and Argon2d
Argon2id is the recommended default for password storage: it blends the data-independent memory access of Argon2i (resistant to side-channel timing attacks) with the data-dependent access of Argon2d (resistant to GPU cracking). Choose Argon2i only when side-channel resistance is the sole concern, and Argon2d for workloads with no untrusted side channels, such as proof-of-work.
Choosing memory, iterations and parallelism
The three cost parameters trade security against speed. Memory (in KiB) is the strongest lever — OWASP suggests at least 19456 KiB (19 MiB) with 2 iterations for Argon2id. Iterations (the time cost) is how many passes are made over that memory, and parallelism is the number of lanes. Higher values are harder to crack but slower, and because the work happens on your own device, very high memory takes a noticeable moment in the browser.
Anatomy of the encoded hash
The output is a standard PHC string such as $argon2id$v=19$m=19456,t=2,p=1$<salt>$<hash>: the variant, the version, the memory / time / parallelism costs, then the base64 salt and hash. Everything the verifier needs sits inside that one line, so you can store it as-is and check passwords against it later.
Private by design
Passwords are sensitive, so nothing you type is sent anywhere — hashing and verification happen locally in your browser. That is why there is no sign-up.
Frequently asked questions
Can I decrypt or reverse an Argon2 hash?
No. Argon2 is a one-way hash, not encryption — there is no key that turns it back into the password. The only way to check a password is to hash the candidate with the salt and parameters stored inside the encoded string and compare, which is exactly what the Verify box does.
Argon2id, Argon2i or Argon2d — which should I use?
Use Argon2id for password storage; it is the recommended default and combines the strengths of the other two variants. Pick Argon2i only when resistance to side-channel timing attacks is your one concern, and Argon2d for workloads with no untrusted side channels, such as proof-of-work.
Is my password uploaded anywhere?
No. Both hashing and verification run entirely in your browser with a WebAssembly build of Argon2. Your password and hash never leave your device and nothing is sent to a server, which is why there is no sign-up.