Argon2 Hash Generator
Generate a real RFC 9106 Argon2id, Argon2i, or Argon2d hash from a password or message, with configurable memory cost, iterations, and parallelism. Runs entirely in your browser — nothing is sent to a server.
Input
Argon2id (recommended) is a hybrid resistant to both side-channel and GPU attacks. Argon2i resists side-channel attacks; Argon2d maximizes GPU resistance.
Memory used during hashing, in KiB. Higher is more secure but slower. 19456 KiB (19 MiB) is OWASP's current minimum recommendation. Capped at 65536 KiB (64 MiB) here — this runs as pure JS on the main thread, not native/WASM code, so very large values can freeze the page for tens of seconds.
Number of passes over memory (time cost). Higher is more secure but slower.
Number of parallel lanes. Lanes run sequentially in-browser, so this mainly affects the derived output, not speed.
Length of the derived key in bytes. 32 bytes (256 bits) is a common default.
A random salt is generated for every hash by default — recommended. Choose Custom only when you need a reproducible salt.
PHC encoded string includes the variant, parameters, and salt — the portable, verifiable format. Hex / Base64 output the raw derived key only.
Output
The salt used for this hash, hex-encoded. The PHC-encoded output above already includes it.
Guides
What this tool does
It computes a real Argon2 hash — Argon2id, Argon2i, or Argon2d, as specified in RFC 9106 — from a password or message you enter, with configurable memory cost, iterations, parallelism, hash length, and salt. Output is available as a PHC-encoded string (the portable $argon2id$v=19$m=...,t=...,p=...$salt$hash format most libraries expect), hex, or Base64.
What is Argon2?
Argon2 is a memory-hard key derivation function — the winner of the 2015 Password Hashing Competition, and the current best-practice choice (per OWASP) for hashing passwords before storing them. Unlike a plain hash function (MD5, SHA-256), Argon2 is deliberately slow and memory-intensive, which makes brute-force and GPU/ASIC cracking attacks far more expensive without meaningfully slowing down a single legitimate login check.
Argon2id (the default here, and the recommended variant for almost all use cases) is a hybrid of the other two: resistant to both GPU cracking (like Argon2d) and side-channel timing attacks (like Argon2i). Argon2i favors side-channel resistance; Argon2d favors maximum GPU/ASIC resistance but is more vulnerable to certain side-channel attacks — it's typically used for cryptocurrency or non-interactive settings rather than password storage.
The parameters
- Memory cost (m), in KiB — how much RAM the computation uses. Higher is more secure but slower. 19456 KiB (19 MiB) is OWASP's current minimum recommendation for interactive use (e.g. a login form).
- Iterations (t) — how many passes are made over that memory. Also trades security for speed.
- Parallelism (p) — the number of independent lanes the algorithm's internal computation is split into. This changes the derived output (it's a real Argon2 parameter, not just a speed knob), so hashing the same password with a different
pproduces a different hash. - Hash length — the size, in bytes, of the derived key/hash itself. 32 bytes (256 bits) is typical.
- Salt — a random value mixed into every hash so identical passwords don't produce identical hashes. Leave it on auto-generate unless you specifically need a reproducible salt for testing.
How to use it
- Enter the password or message to hash.
- Adjust the Argon2 parameters if needed — the defaults are a reasonable, OWASP-aligned starting point.
- Choose a salt mode and output format.
- Click Generate hash.
- Copy the result, or download it as a text file.
FAQ
Is this safe to use for real passwords?
The computation runs entirely in your browser — your password is never sent anywhere. The underlying Argon2 implementation is @noble/hashes, an independently audited, open-source library; this tool doesn't reimplement the algorithm itself.
Why is Generate slower than other tools on this site? That's by design — Argon2 is meant to be computationally expensive, so that trying millions of password guesses is expensive too. Raising memory cost or iterations makes it slower still (and more secure); this tool caps both to keep the browser responsive.
Can I verify a password against an existing Argon2 hash here?
Not currently — this tool focuses on generating hashes. To verify, most languages have a built-in or well-known Argon2 verify function (e.g. PHP's password_verify()).
Why does the PHC string not always match other tools with the "same" settings?
If the salt differs, the hash differs — that's the point of a salt. Compare the parameters (m, t, p, v) inside the PHC string instead, or set a custom salt on both sides for a like-for-like comparison.
Privacy
Everything happens client-side in your browser. Nothing you type here — the password, salt, or resulting hash — is transmitted to or stored on our servers.
Use it from code
From 3 credits per callREST API
curl -X POST https://api.iotools.cloud/v1/tool/argon2-hash-generator \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"password": "correct horse battery staple",
"variant": "argon2id",
"memoryCost": "19456",
"iterations": "2",
"parallelism": "1",
"hashLength": "32",
"saltMode": "custom",
"customSalt": "argon2-tool-salt",
"outputFormat": "encoded"
}'Swap in your own key from your account. The tool's fields are the body — no wrapper.
Ask an AI agent
Use the IOTools `argon2-hash-generator` tool (Argon2 Hash Generator) on this input:
YOUR_INPUT_HEREPaste this at any agent connected to the IOTools MCP server, then add your input.