Password Generator
A random password at the length and character mix you set.
Generate a cryptographically secure random token in hex, Base64 or URL-safe Base64. It comes from the browser's CSPRNG, so you can use it for real secrets.
Your browser is preparing the tool. It runs 100% locally.
Choose a number of random bytes (4 to 128, default 32) and a format (hex, Base64 or URL-safe Base64), and the tool returns a fresh secure token. It draws from the browser's cryptographic random generator (crypto.getRandomValues), so the result is suitable for real secrets like API keys, session IDs and CSRF tokens. The security comes from the bytes: 32 bytes is 256 bits of entropy. The Random Token Generator runs in your browser and uploads nothing.
This tool produces a random token of the length and format you choose. You set how many bytes of randomness you want and whether to encode them as hexadecimal, standard Base64, or URL-safe Base64, and it returns a fresh value each time you generate.
Use it when a web application needs an unguessable value, such as an API key, a session or CSRF token, a password-reset link, a nonce or a salt, and you don't want to write code for it.
The tool asks the browser's cryptographic random number generator for the number of random bytes you specify. This is a CSPRNG, a cryptographically secure source and the right one for secrets. Ordinary random functions are predictable and must never be used for security.
It then encodes those raw bytes into readable text. Hexadecimal uses two characters per byte; Base64 packs them more compactly; and URL-safe Base64 swaps the characters that would cause trouble in a URL or filename and drops the padding. The randomness, and so the security, is the same in every format. Only the presentation differs.
entropy in bits = bytes × 8
hex length = bytes × 2 characters
base64 length ≈ bytes × 4 ÷ 3 characters32 bytes → 256 bits of entropy → 64 hex characters (or about 43 URL-safe Base64 characters)The security is in the byte count, not the character length. 16 bytes is 128 bits whether shown as 32 hex characters or about 22 Base64 characters, so don't judge a token's strength by how long it looks.
Your token is generated entirely on your device. There is no network request, so the value is never transmitted or stored anywhere by the tool.
The token is created on your device, so only you have it when it appears. Treat it as a secret: copy it into your secure store and don't share it.
The page keeps nothing between sessions. Close the tab and the token is gone, so save any token you want to keep.
Because the bytes come from a cryptographically secure generator, the tokens are fit for real security use: each value is unpredictable and effectively unique. Tools built on ordinary random functions can't promise that.
The strength is set by the byte count, not the format. 16 bytes is 128 bits of entropy and 32 bytes is 256 bits, whether you display them as hex or Base64. A longer-looking hex string is not stronger than a shorter Base64 one with the same bytes.
A token is just random bytes with no built-in meaning, expiry or signature. It is not a JWT (which has a payload and signature) and not a UUID (which has a defined structure). Pair it with your own storage and expiry logic.
Treat every generated token as a live secret. It is shown in your browser only, but once you use it for an API key or session it must be stored and transmitted securely, and rotated if exposed.
Generate an unguessable key for a service or integration.
Create secure identifiers for web sessions and form protection.
Produce a one-time token for a password-reset or email-verification URL.
Get random values for cryptographic nonces or password salts.
For a standard structured ID, use a UUID generator. For a signed token carrying data, use a JWT. For something a person must type or remember, use a passphrase. This tool is for raw, high-entropy secret values.
Generates tokens from the browser's cryptographic random source (crypto.getRandomValues), not Math.random. Strength comes from the byte count, not the encoded character length.
A random password at the length and character mix you set.
An entropy estimate in bits, with tips to make it stronger.
Whole numbers in any range from a cryptographic source.
The SHA-256 hash of any text, computed in your browser.
Random words joined into a passphrase you can remember.
The MD5 checksum of any text.
Your browser generates and checks everything locally, so nothing secret is sent. No account needed.