Free Bcrypt Password Hash Generator

What is bcrypt — and why not just use SHA-256?

Bcrypt is a password hashing function designed by Niels Provos and David Mazières in 1999, based on the Blowfish block cipher. Unlike general-purpose hash functions like SHA-256, bcrypt was purpose-built for one job: making password verification deliberately slow.

The core problem with using SHA-256 for passwords is speed. A modern GPU can compute over 10 billion SHA-256 hashes per second. That means an attacker who steals a database of SHA-256 hashed passwords can try every possible 8-character password in under an hour. Bcrypt solves this by being orders of magnitude slower — at cost factor 12, a single bcrypt hash takes roughly 300 milliseconds, limiting an attacker to just 3–4 attempts per second per CPU core.

Bcrypt also includes a built-in salt — a random 128-bit value generated for each password. The salt is stored as part of the hash output, so no separate salt column is needed in your database. Salting ensures that two users with the same password get different hashes, defeating precomputed rainbow table attacks. For a deeper comparison of password hashing algorithms, see our guide on bcrypt vs Argon2 vs scrypt.

Anatomy of a bcrypt hash string

Every bcrypt hash is exactly 60 characters long and follows a fixed format. Understanding this format helps when debugging authentication issues or migrating between systems:

$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy
 ├──┤├┤├────────────────────┤├─────────────────────────────┤
  │   │          │                         │
  │   │          │                    Hash (31 chars)
  │   │     Salt (22 chars, Base64)
  │  Cost factor (2^10 = 1024 rounds)
 Algorithm identifier (2a)

Algorithm identifiers

The prefix $2a$ is the most common. Other variants include $2b$ (fixed a wrapping bug in the OpenBSD implementation) and $2y$ (PHP-specific fix for an early crypt_blowfish bug). In practice, all three are interchangeable for modern implementations — the output of $2a$, $2b$, and $2y$ is identical for valid UTF-8 passwords under 72 bytes.

The 72-byte password limit

Bcrypt truncates passwords to 72 bytes before hashing. For ASCII passwords (1 byte per character), this means 72 characters. For UTF-8 passwords with multi-byte characters (accented letters, emoji), the effective limit is lower. Passwords beyond this limit are silently truncated — characters after byte 72 are ignored. This is rarely a practical issue (few users choose 72+ character passwords), but if it matters, a common workaround is to pre-hash the password with SHA-256 before passing it to bcrypt: bcrypt(sha256(password)).

Choosing the right cost factor

The cost factor is the single most important parameter in bcrypt. It determines the computational cost of hashing and should be tuned to your hardware and latency budget:

* Approximate times on a 2023 x86-64 server CPU (single core). Browser JavaScript is 3–5× slower. GPU times are similar — bcrypt is CPU-hard but not memory-hard, so GPUs offer modest speedup compared to SHA-256.

The ideal approach: benchmark on your production hardware and pick the highest cost that keeps hash time under 250–500 ms. As hardware gets faster, increase the cost. You can do this transparently by rehashing each password with the new cost on the user's next successful login — bcrypt stores the cost in the hash itself, so old and new cost hashes coexist in the same database column.

Bcrypt vs Argon2 vs scrypt — which should you use?

For existing codebases using bcrypt: there is no urgent reason to migrate. Bcrypt at cost 12+ remains secure and is not cryptographically broken. Migration to Argon2id is a future-proofing decision, not a security emergency. If you do migrate, use the "rehash on login" strategy — check if the stored hash is bcrypt, and if so, rehash with Argon2id on successful authentication.

Common bcrypt mistakes to avoid

Using bcrypt in popular languages

const bcrypt = require('bcryptjs');
const hash = await bcrypt.hash(password, 12);
const match = await bcrypt.compare(password, hash);

import bcrypt
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))
match = bcrypt.checkpw(password.encode(), hashed)

$hash = password_hash($password, PASSWORD_BCRYPT, ['cost' => 12]);
$match = password_verify($password, $hash);

require 'bcrypt'
hash = BCrypt::Password.create(password, cost: 12)
match = BCrypt::Password.new(hash) == password

hash, _ := bcrypt.GenerateFromPassword([]byte(password), 12)
err := bcrypt.CompareHashAndPassword(hash, []byte(password))