Configuration
Preseti Loads one of the four frozen tier configurations; every control stays editable afterwards, so use a preset as a starting point you can modify. Minimum: full 36-symbol alphanumeric, no checksum, hyphen grouped in threes, 2,176,782,336 codes. Light: light visual and spoken safety, 2 checksums, hyphen grouped in fours, 887,503,681 codes. Medium: medium safety, 2 checksums, hyphen grouped in fours, 481,890,304 codes (the documented default). Heavy: heavy safety, 2 checksums, hyphen grouped in fours, 308,915,776 codes. All four run the profanity blocklist and ship with permutation on. Choose Custom to keep whatever you have set by hand.
Custom
Expandable (starts at 4, grows)
Minimum (2.18B, no checksum)
Light (887M)
Medium (482M, fixed default)
Heavy (309M)
Modei Expandable codes start at the minimum length and grow one symbol at a time as issuance fills each generation, so the namespace never runs out; the body alphabet never contains 0 or O and the checksum alphabet gains the 0. Fixed codes keep a constant width forever and can be exhausted; pick fixed when a downstream system needs every code to be the same length.
Expandable (grows as needed)
Fixed width
Namespace label (optional)
Base alphabeti The pool of symbols the encoder draws body characters from. Digits only: 0-9, 10 symbols, needs the longest codes for a given capacity. Uppercase letters: 26 symbols. Alphanumeric: digits plus uppercase, up to 36 symbols before safety exclusions. Custom: type your own ASCII symbol list. Visual safety exclusions are applied on top of whichever mode you pick, and the exact resulting alphabet is always shown in the live preview.
Digits only
Uppercase letters only
Alphanumeric
Custom
Custom alphabet
Visual safetyi Removes look-alike symbols from the generated alphabet so printed or on-screen codes are harder to misread. None: keep everything. Light: drop O, I and L when digits are present, since 0 and 1 already cover them. Medium: also drop B and S, which blur into 8 and 5 in many fonts. Heavy is not cumulative: it replaces the alphabet outright with the fully reviewed 32-symbol set, which keeps B and S but drops U. Smaller alphabets need a longer body for the same capacity; the trade-off is shown live on the right.
None
Light (drop O, I, L)
Medium (also drop B, S)
Heavy (safe 32 alphabet)
Spoken safetyi For codes read out over the phone. For each sound-alike pair, one letter is removed from the alphabet so it can never appear in a new code, and a code that contains it anyway decodes automatically as the kept letter: no ambiguity, no guessing. Light removes D (decodes as B) and T (decodes as P). Medium also removes N (decodes as M) and W (decodes as V). Heavy also removes S (decodes as F) and G (decodes as C). Pairs run from the most common confusions at Light to the least at Heavy. Each removed letter shrinks the alphabet by one, so capacity falls slightly at higher levels.
None
Light (drop D, T)
Medium (also drop N, W)
Heavy (also drop S, G)
Profanityi Profanity controls keep codes customer-safe. Strip vowels removes A, E, I, O and U from the alphabets so no English word can ever be spelled; capacity falls accordingly. Blocklist keeps the full alphabet but refuses to issue any code containing a common English profanity; those identifiers are reserved and marked as blocked in the examples. None applies no check.
None
Strip vowels
Blocklist
Minimum length (starts at)i The total code length (checksum included) while the namespace is small. When issuance fills a generation the code gains one symbol automatically; it must exceed the checksum length. The frozen expandable tier starts at 4.
Separator from lengthi Expandable codes are shown bare below this total length and grouped by the separator from this length up, so short codes stay uncluttered. The frozen expandable tier hyphenates from 6 characters.
Short checksumi Expandable mode can carry fewer checksum symbols on its shortest, most-typed generations: codes through the window length validate against fewer checksum symbols, longer codes use the full checksum length. The opening generation holds 34 times as many identifiers in exchange for weaker typo detection there (about 1 in 35 random matches instead of 1 in 1,225). "0 symbols" is a zero-checksum window: those codes are all body with no typo detection at all. The frozen expandable tier ships 1 symbol through length 5; Off keeps the full checksum on every generation.
Off
0 symbols (no typo detection in the window)
1 symbol (frozen tier)
2 symbols
Short checksum through lengthi The last total length that uses the short checksum; longer codes use the full checksum length. The window must start at the minimum length and may reach at most length 8. Off turns the short checksum off entirely.
Off
4
5
6
7
8
Body length 6
Checksum lengthi Appended validation symbols; they detect typos but add no identifier capacity. 0: typed errors are never detected and silently hit wrong records. 1: catches all but about 1 in 26 random mistakes and about 98.8% of single-symbol substitutions; suited to assisted support, where a human resolves the misses. 2: modulus 676 checksum, provably catches every single-symbol substitution and every adjacent transposition; the right choice for unattended self-service. 3: stronger still against random corruption.
0 (no detection)
1 (assisted support)
2 (self-service)
3
Repetition filteri Refuses to issue any code with a run of identical symbols this long or longer, because humans mis-count long runs (00000 read as 0000) and no checksum can catch a symbol that was never typed. Runs are measured on the raw code, ignoring delimiters, so a run may straddle one. Blocked identifiers are reserved and skipped, marked as blocked in the examples; the capacity figure still counts them (well under 0.5% of ids). 4 is what every frozen tier ships; Off disables the filter.
Off
3
4 (frozen tiers)
Separator (optional)
Permutation
Hides obvious sequence in the preview. It is not access control: the preview key is public and a real application's key must never reach a browser. It also costs compute: with permutation off, encode is about 20x faster and decode about 13x faster (1 microsecond per code instead of tens of microseconds), so it matters for bulk encoding, not per request.