Create Argon2id, Argon2i or Argon2d password hashes with the memory, iterations, parallelism and salt you choose, or check a password against an existing $argon2 hash. Everything runs on your device; the password never leaves the page.
Last updated:
Loading Argon2 engine…
Variant
64 MiB
passes over memory
lanes / threads
256-bit tag
Secret key (pepper), optional
A secret is mixed into the hash but not stored in it. You need the same secret to verify. Most password libraries do not use one.
0%
Secret key (pepper), if the hash used one
0%
Advertisement
Advertisement
How to use the Argon2 Hash Generator
Type the password you want to hash in the Generate tab.
Pick a variant and preset: Argon2id with the OWASP or RFC 9106 settings suits most logins; switch to Custom to set memory, iterations and parallelism yourself.
Keep the random salt or enter your own as text, hex or Base64 (at least 8 bytes).
Press Generate hash and copy the encoded string into your database, or the raw hex if you need a derived key.
To check a password, open the Verify tab, paste an $argon2 hash, type the password and press Verify password.
How Argon2 works
Argon2 (RFC 9106) turns a password and a salt into a fixed-length tag in three steps:
Initial hash: the password, salt, optional secret and associated data, and every parameter (p, tag length, m, t, version, type) are hashed with BLAKE2b into a 64-byte seed H0.
Memory filling: the memory is split into p lanes of 1 KiB blocks. Each new block is computed from the previous block and a pseudo-randomly chosen earlier block with a BLAKE2b-based compression function. This is repeated for t passes, so the full m KiB must be held in RAM.
Finalisation: the last block of every lane is XORed together and hashed to the requested tag length.
Because every pass touches every block, an attacker who tries to save memory must recompute blocks over and over. That trade-off is what makes Argon2 expensive on GPUs and custom hardware.
Argon2id, Argon2i and Argon2d compared
Variant
Memory access
Strength
Use it for
Argon2id
Data-independent for the first half of pass 1, data-dependent afterwards
Resists both side-channel and GPU trade-off attacks
Password hashing (the default choice)
Argon2i
Always data-independent
Best side-channel resistance, needs more passes against trade-off attacks
Key derivation where timing leaks matter
Argon2d
Always data-dependent
Strongest against GPU cracking, but leaks timing information
Cryptocurrency proof-of-work and back-end systems with no side-channel exposure
Recommended parameters
Source
Memory (m)
Iterations (t)
Parallelism (p)
OWASP Password Storage Cheat Sheet (minimum)
19 MiB (19,456 KiB)
2
1
OWASP alternative
46 MiB (47,104 KiB)
1
1
RFC 9106 first recommendation
2 GiB
1
4
RFC 9106 second recommendation
64 MiB (65,536 KiB)
3
4
Use a 16-byte random salt and a 32-byte tag. Memory is the parameter that hurts attackers most, so raise it first and then add iterations until a hash takes roughly 0.1 to 0.5 seconds on your server. Browser timings shown by this tool are a rough guide only: servers with native libraries are usually faster.
Reading an encoded Argon2 hash
Example: $argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ$CTFhFdXPJO1aFaMaO6Mm5c8y7cJHAph8ArZWb2GRPPc is the password password with the salt somesalt. Press Load example in the Verify tab to check it.
Part
Example
Meaning
Variant
$argon2id
argon2id, argon2i or argon2d
Version
$v=19
19 = 0x13 = Argon2 1.3 (missing means the older 1.0)
Parameters
$m=65536,t=2,p=1
Memory in KiB, iterations, lanes
Salt
$c29tZXNhbHQ
Base64 without padding
Hash
$CTFhFdXPJO1a…
The tag, Base64 without padding
Frequently asked questions
What is Argon2?
Argon2 is the password hashing function that won the Password Hashing Competition in 2015 and is standardised in RFC 9106. It is deliberately slow and memory-hard: every hash must fill a configurable amount of RAM, which makes large-scale guessing on GPUs and ASICs expensive.
Which Argon2 variant should I use?
Use Argon2id. It runs the first half of the first pass with data-independent memory access (like Argon2i, resisting side-channel attacks) and the rest with data-dependent access (like Argon2d, resisting GPU trade-off attacks). RFC 9106 and OWASP both recommend Argon2id for passwords.
What parameters are recommended?
OWASP's Password Storage Cheat Sheet suggests Argon2id with at least 19 MiB of memory, 2 iterations and parallelism 1 (or equivalent trade-offs such as 46 MiB with 1 iteration). RFC 9106 recommends 2 GiB, 1 iteration and 4 lanes where memory allows, or 64 MiB, 3 iterations and 4 lanes otherwise. Tune so that one hash takes a fraction of a second on your server.
Why does the same password give a different hash each time?
A new random salt is generated for every hash and stored inside the encoded string. This makes identical passwords produce different hashes and defeats precomputed tables. Verification reads the salt and parameters back out of the stored hash.
What does the encoded hash $argon2id$v=19$m=65536,t=3,p=4$… mean?
It is the PHC string format: the variant, the version (19 = Argon2 1.3), memory in KiB (m), iterations (t), parallelism (p), then the salt and the hash, both in Base64 without padding. Libraries such as PHP password_hash, argon2-cffi, node argon2 and libsodium read and write this format.
Is it safe to type a real password here?
Hashing runs entirely in your browser. The password and the hash are never uploaded or stored. For production secrets it is still good practice to hash on the server that will verify them.
Can an Argon2 hash be decrypted?
No. Argon2 is a one-way function. The only way to recover a password is to guess candidates and hash each one with the stored salt and parameters, which Argon2 makes slow and memory-hungry by design.
Are all the tools on FreeToolCabin tested for quality and accuracy?
Yes! Every tool on our site undergoes automated Q/A testing in real browser environments to ensure high precision, correct output, and zero errors. If you happen to spot a bug or have a suggestion, please contact us at [email protected] and our team will review it right away.