⌘ K
nanoid · url-safe · bulk · local

Generate Nano IDs in bulk

Compact, URL-safe random identifiers — configurable size and alphabet. 21 chars matches UUID v4 entropy in 36% less space. Runs entirely in your browser.

Nano ID Generator
Count
0
5 requested
Length
21
default
Output
0 B
idle
Status
loading
csprng
Count:
input · options
Count
Length
Custom alphabet

Default alphabet is A-Za-z0-9_- (URL-safe). Length 21 ≈ 126 bits of entropy.

output · nano ids (0)

Click Generate to mint Nano IDs

Quick Start

How to generate Nano IDs

Nano ID uses cryptographic randomness mapped onto a 64-character URL-safe alphabet. 21 chars gives ~126 bits — basically the same entropy as UUID v4 at 36% the length.

  1. 01

    Pick a length

    21 is the default. Shorter for shorter URLs; longer for stronger entropy.

    Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.

    lengthUTF-8TextEncoderlosslesslive
    len · raw bytes21 · UTF-8
    v3LzS_Q9xN0nW4qP…
    loaded · UTF-8MIME · ready
  2. 02

    Customize alphabet

    Leave blank for the default, or pass a custom alphabet (digits only, hex, etc.).

    Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.

    alphabetWeb Cryptosubtledeterministiclive
    set · optionscustom · live
    0123456789ABCDEF
    options applied · livelive
  3. 03

    Bulk generate

    Mint up to 500 at once.

    Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.

    bulkmemoisedoptionsinstantreactive
    count · encoded5 · ready
    5 fresh Nano IDs
    encoded · livelossless
  4. 04

    Copy or download

    One click to clipboard. Download as .txt.

    Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.

    exportclipboardblobMIME-correctclient-side
    ok · copiedready · done
    Copied
    shipped · ready to shipsuccess
Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Related toolsUUIDUUID v7ULIDAPI KeySnowflake IDHashids
Use Cases

When to use Nano ID

Short URLs, IDs that fit in tweets, primary keys.

Short URLs

Compact, URL-safe slugs for redirectors. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Document IDs

Replace long UUIDs in URLs. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Public-facing IDs

Looks like an opaque key, not a sequence. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Anchor IDs

Unique fragments for SPA deep links. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Idempotency keys

Lighter than UUIDs in request headers. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Form session keys

Tie multi-step submissions together. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready
FAQ

Frequently asked questions

Yes — it uses crypto.getRandomValues. At length 21 it has ~126 bits of randomness, comparable to UUID v4.
The default alphabet only uses characters that don't need percent-encoding in URLs (A-Z, a-z, 0-9, _, -).
Yes. Provide any character set — only digits, only hex, emoji, anything. The library handles modulo bias correctly.
A 21-character Nano ID has ~126 bits of randomness vs UUID v4's 122 — slightly more entropy in 36% fewer characters.
No. Generation runs locally in your browser using the nanoid library — IDs never leave the device.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!