Can a bcrypt hash be reversed back into the password?

No. Bcrypt is a one-way function — the only way to recover a password is brute force, and the deliberately high iteration count makes that expensive. At cost 12, each attempt takes around 250ms, so testing billions of guesses is impractical.

What's the difference between $2a$ and $2b$ in a bcrypt hash?

$2a$ is the original 1999 spec, which had a bug affecting certain characters above 127 bytes. $2b$ fixed that bug and is today's standard prefix. $2y$ is PHP's own variant, functionally equivalent to $2b$.

Does bcrypt support passwords longer than 72 characters?

It only processes the first 72 bytes of input — everything after that is silently ignored, not rejected. If your users can create longer passphrases, pre-hash them with SHA-256 before bcrypt, or use Argon2id, which has no length cap.

Should I use bcrypt or Argon2id for a new project?

OWASP recommends Argon2id as the first choice for new systems — it's memory-hard, which makes it far more resistant to GPU and ASIC cracking, and has no password length limit. Bcrypt with cost 12 or higher remains sound for systems already built on it.

How do I verify a bcrypt hash online without a server?

Use the Verify Hash tab above: paste the plaintext password and the stored hash, and bcryptjs runs the comparison entirely in your browser. Nothing is sent over the network, so it's safe to test with real production hashes.

Bcrypt Generator

Free bcrypt hash generator and verifier — 100% client-side. Real-time cost benchmark, hash parser, code snippets for Node.js, Python, PHP, Go. No signup.

Updated June 2026

Zero Network Activity — 100% Browser-side

Input Password CLIENT-SIDE SECURE

Cost Factor

4 — testing Default is 12 (OWASP). Higher = more secure but slower. 18 — very slow

Local Benchmark

Processing time on your current hardware

Cost 8

—

Cost 10

—

Cost 12

—

Cost 14

—

Implementation Snippets

const bcrypt = require('bcryptjs');
const SALT_ROUNDS = 12; // OWASP recommended

async function hashPassword(plaintext) {
  return await bcrypt.hash(plaintext, SALT_ROUNDS);
}

async function verifyPassword(plaintext, hash) {
  return await bcrypt.compare(plaintext, hash);
}

const hash = await hashPassword('user_password');
// '$2b$12$...' (60 chars, always different due to random salt)

const isValid = await verifyPassword('user_password', hash);
// true

How this bcrypt hash generator works

Generate a hash in under five seconds

1. Paste your password

The "CLIENT-SIDE SECURE" badge confirms no network request is ever made.

2. Adjust the cost factor

Slider from 4 to 18 — cost 12 is the OWASP-recommended default.

3. Generate and copy

The hash appears with the exact time it took on your hardware; copy it with one click.

What this bcrypt tool does

Beyond just generating the hash

Verifies an existing hash

The Verify Hash tab compares a password against a hash and shows a green check or a red X in milliseconds.

Benchmarks the cost factor

Measures the actual hashing time on your own hardware for each cost value, not a generic estimate.

Decodes an existing hash

Paste any bcrypt hash to see its version, cost, salt, and checksum broken apart into labeled pieces.

Ready-made code snippets

Generates equivalent hashing and verification code for Node.js, Python, PHP, Go, Java, Ruby, C#, and Rust.

100% client-side with bcryptjs

No password ever leaves your browser — confirm it yourself in the DevTools Network tab.

Examples

The same password never produces the same hash twice

Input

Bcrypt hash (cost 12)

mysecretpassword

$2b$12$nOUIs5kJ7naTuTFkBy1veuK0kSxUFXfuaOKdOKf9xYT0KKIGSJwFa

mysecretpassword (generated again)

$2b$12$aBcDeFgHiJkLmNoPqRsTuv... — different salt, both valid

72 vs. 100 'a' characters

produce equivalent hashes — bytes past 72 are silently ignored

When you'll reach for a bcrypt generator

The most common scenarios among people who use this tool

Authentication

Hash passwords before storing them; bcrypt.compare() confirms the match in constant time at login.

Migrating off a weak algorithm

Progressively re-hash MD5 or SHA-1 passwords to bcrypt the next time each user logs in successfully.

Calibrating the cost factor

Run the benchmark on production-equivalent hardware to find the highest cost that stays under your UX threshold.

Security audits

Paste an existing hash to verify its version, cost, and salt/checksum lengths without touching a database.

Check this before shipping to production

Cost 4–8 in production

These finish in under 1ms — no real resistance to brute force. Use cost 10 as an absolute minimum and 12 as the default.

Hashing an already-hashed hash

Produces a string that can never be verified again. Always hash the original plaintext password, never a previous hash.

The 72-byte limit

Bcrypt silently truncates anything past 72 bytes — long passphrases need a SHA-256 pre-hash or a switch to Argon2id.

Storing the salt separately

Unnecessary — bcrypt already embeds the salt inside the hash's 60 characters, so a separate salt column just adds complexity.

Why generate bcrypt hashes here

All hashing runs in your browser with bcryptjs, a pure JavaScript implementation — open DevTools and confirm the Network tab stays empty while you type.

The benchmark measures real time on your own hardware instead of a generic estimate, and ready-made snippets for eight languages skip the step of writing the library call by hand.

Bcrypt vs. Argon2id

Both solve password hashing; pick based on your project

Bcrypt

Argon2id

Current OWASP recommendation

solid alternative

first choice

Resistant to GPU/ASIC cracking (memory-hard)

yes

Password length limit

72 bytes

none

Broad language support

yes

growing

Adjustable cost factor

yes

yes (memory + time)

Frequently asked questions

OWASP recommends cost 12 as a starting point, targeting roughly 250ms per hash on modern hardware. Use this page's benchmark to measure your own server and pick the highest cost that stays under your UX threshold (300ms–1s).

References

OWASP Password Storage Cheat Sheet

The authoritative guide on recommended password hashing algorithms and cost factors.

bcryptjs on GitHub

The pure JavaScript library that powers this tool.

Salt, Pepper, Bcrypt and Argon2id: How to Actually Protect Passwords