Argon2 Generator + Verifier

How to use it

1. On the Hash tab, type the password — the counter reports UTF-8 bytes and code points, all of them keyed.
2. Take a preset chip (m=19456, t=2, p=1 argon2id by default) or set m, t, p and the two lengths yourself.
3. Read the estimate well: it scales a measured 8 MiB run by your m and t.
4. Press Hash (⌘/Ctrl + Enter) and copy the string; its fourth field is that run's 16 random salt bytes.
5. On the Verify tab, paste a hash, enter the candidate and press Verify for a verdict beside a labelled field breakdown.

Hash a password with Argon2id, Argon2i or Argon2d at memory, pass and lane settings you choose, or paste an encoded hash and check a candidate against it. The work runs in this tab through WebAssembly: nothing is uploaded, nothing is kept between visits. OWASP's published parameter rows sit one chip away, and the readout times each run on your own hardware.

How it works

Argon2 fills m KiB of memory with BLAKE2b-derived blocks and passes over it t times, so one guess costs memory times passes: m=19456 with t=2 is 38,912 KiB-passes. An attacker running thousands of candidates at once funds that memory per candidate — the pressure a GPU or ASIC farm cannot design away. The p lanes split the fill into strips built concurrently.

The variants differ in how addresses are chosen. Argon2id picks them independently of the password for the first half-pass, from the data afterwards; RFC 9106 §4 names it the primary choice. Argon2i addresses independently throughout, resisting an observer of memory access but conceding ground to time-memory trade-off attacks; argon2d trades the other way.

The encoded string holds what a verifier needs in five $-separated fields: variant id, v=19, the m/t/p triple, then salt and tag in Base64 without padding. Parameters are a latency decision: take the largest m your service holds at its concurrency, raising t only when memory runs out first.

Examples

correct horse battery staple

$argon2id$v=19$m=19456,t=2,p=1$SXRob21pYVNhbHQuMDAwMQ$/DpphslK1611EFRdVmEoHbIBYb7mhLHDbtpizMcFzok

$argon2id$v=19$m=19456,t=2,p=1$SXRob21pYVNhbHQuMDAwMQ$/DpphslK1611EFRdVmEoHbIBYb7mhLHDbtpizMcFzok

MATCH

pässwörd🔑漢字

$argon2id$v=19$m=256,t=2,p=1$SXRob21pYVNhbHQuMDAwOA$62SkcEuVLcsqqhvSwBgMzfuWMEkWoZyNSNsIBCm9x+g
m=256 is below the 19,456 KiB of current OWASP guidance — rehash on next login

$argon2d$v=19$m=256,t=3,p=1$c29tZXNhbHQ=$C4HDqoDeOZUE9sDeh2cX0IzXRkkObcRzv3XgHRwP9Ew=

MATCH
Base64 padding removed — the PHC string format writes salt and tag unpadded
This hash uses argon2d — argon2d addresses memory from the data itself, which leaks through side channels on a shared machine. RFC 9106 §4 recommends argon2id for password storage.
m=256 is below the 19,456 KiB of current OWASP guidance — rehash on next login

Every example on this page is executed against the same engine that powers the tool, on every build.

Common errors

Password is empty — this tool's Argon2 core refuses zero-length passwords, so there is nothing to hash. Enter at least one character.

Argon2 allows it; this core does not.

The hash field is empty — there is nothing to verify against. Paste an encoded Argon2 hash, e.g. "$argon2id$v=19$m=19456,t=2,p=1$…".

Verify pressed with no hash.

This is a bcrypt hash ($2a$, $2b$, $2x$ or $2y$), not Argon2 — Argon2 hashes start with $argon2id$, $argon2i$ or $argon2d$. Paste an Argon2 hash here.

Fifteen foreign formats are named outright, bcrypt among them.

"ARGON2ID" is not an Argon2 variant id — the PHC string format spells them in lower case as argon2id, argon2i or argon2d. Correct the first field.

PHC ids are lower case.

An encoded Argon2 hash has five $-separated fields — variant, version, parameters, salt and tag ($argon2id$v=19$m=19456,t=2,p=1$salt$tag) — but this input has 6. Check for a missing or extra "$".

A trailing $ or a clipped field.

There is no $v= field, which marks a hash written before Argon2 version 1.3 (0x10) — this core computes version 19 (0x13) only, so it cannot reproduce that digest. Verify it with the implementation that produced it.

The four-field pre-1.3 shape.

Version field "v=16" is not one this core computes — it computes Argon2 version 19 (0x13) only, so any other version would produce a different digest. Verify that hash with the implementation that produced it.

Needs a 1.0-era build.

Parameter "tt" at position 24 is not readable — each parameter is a name, "=", then digits, comma-separated, as in "m=19456,t=2,p=1". Fix that entry.

Missing its = and digits.

The parameter field is missing "p=" — Argon2 needs all three of m (memory in KiB), t (passes) and p (lanes) to reproduce a digest, as in "m=19456,t=2,p=1". Add the missing one.

All three feed the tag.

Parameter "t" appears twice at position 32 — each of m, t and p may appear exactly once, so which value applies is undefined. Remove the duplicate.

Two values for one parameter.

Parameter "keyid" at position 32 is not one this tool accepts — it reads m, t and p only. "keyid" marks a hash made with a secret key or associated data; those inputs cannot be supplied here, so such a hash cannot be verified in this tool. Verify that hash with the implementation that produced it.

The keyed case above.

Parameter "m=4" is below Argon2's minimum of 8 KiB — the specification requires at least 8 KiB per lane, so no Argon2 implementation could have produced this hash. Check the parameter field.

Catch-all range refusal: also t below 1, lanes outside 1–16,777,215, values above 2³²−1.

m=64 is below 8×p — the Argon2 specification requires at least 8 KiB of memory per lane, so with p=16 the minimum is m=128. Raise m or lower p.

The per-lane floor.

Character "-" at position 42 is not Base64 — the salt field uses the standard Base64 alphabet A–Z a–z 0–9 + /. "-" and "_" belong to the base64url alphabet; the PHC string format uses standard Base64, so "-" would be "+" and "_" would be "/". Correct that character.

A base64url salt, re-encoded upstream.

The salt in this hash decodes to 4 bytes, below the 8-byte minimum Argon2 accepts — a hash with a shorter salt cannot be recomputed here. Check that the salt field was copied in full.

A copy that stopped early.

Character "_" at position 86 is not Base64 — the tag field uses the standard Base64 alphabet A–Z a–z 0–9 + /. "-" and "_" belong to the base64url alphabet; the PHC string format uses standard Base64, so "-" would be "+" and "_" would be "/". Correct that character.

Same alphabet rule, last field.

The tag in this hash decodes to 3 bytes, below the 4-byte minimum Argon2 accepts — a comparison against it would be meaningless. Check that the last field was copied in full.

Four bytes is the legal floor.

Password is longer than the 4,096-character limit for this tool — Argon2 keys on every byte you type, so nothing is silently dropped and nothing is truncated. Shorten the input to 4,096 characters or fewer.

A page cap, not an algorithm cap.

The pasted hash is 517 characters, above this tool's 512-character limit — an encoded Argon2 hash with a 64-byte salt and a 64-byte tag fits in about 200. Paste one hash on its own, with nothing appended.

A shadow line, or several hashes.

m=2,097,152 KiB (2 GiB) is above this tool's 1 GiB ceiling — one Argon2 run allocates that whole amount in this browser tab, which a phone cannot do. Use 1 GiB or less here, or run the argon2 CLI for larger settings.

The RFC 9106 first-option case.

m=1,048,576 with t=4 is 4,194,304 KiB-passes of work, above this tool's ceiling of 2,097,152 — Argon2 reads the whole memory once per pass, so that run would take minutes in a browser tab. Lower m or t, or run the argon2 CLI.

The guard is on m×t; a confirm step comes first at 262,144.

A random salt could not be generated — this context has no crypto.getRandomValues, and this tool will not fall back to a weaker random source. Reload the page over https and try again.

Refuses rather than degrading.

Keyboard shortcuts

⌘/Ctrl + Enter

Runs whichever tab is open — hashing, or checking the pasted hash.

⌘/Ctrl + S

Saves the hash as .txt rather than letting the browser save the page.

⌘/Ctrl + C

With nothing selected and focus in the tool, takes the hash or verdict; the password is never copied.

⌘/Ctrl + Shift + C

Takes that artifact even while something else is selected.

? or ⌘/Ctrl + /

Opens the overlay listing these bindings.