About

A 6-digit number occupies the range 100000 to 999999, yielding exactly 900,000 possible values. Selecting uniformly from this space matters. Math.random() in most JS engines uses xorshift128+ which is deterministic and predictable given enough samples. This tool uses the Web Crypto API (crypto.getRandomValues), a CSPRNG seeded by OS entropy, making output suitable for PINs, verification codes, lottery picks, and test data where statistical bias or predictability constitutes a real risk. Rejection sampling eliminates modulo bias that would otherwise skew the distribution toward lower values.

The generator supports bulk output up to 10,000 numbers with optional uniqueness enforcement. When uniqueness is active, the tool draws from the pool of 900,000 distinct values using a Set for O(1) collision detection. Note: requesting more than 900,000 unique 6-digit numbers is mathematically impossible. Results can be copied or exported as plain text. This tool approximates true randomness under the assumption that the browser's entropy source is healthy.

Formulas

A cryptographically secure 6-digit number is produced via rejection sampling over the Web Crypto API output:

raw = crypto.getRandomValues(Uint32Array[1])[0]

The raw 32-bit unsigned integer is mapped to the target range using rejection to avoid modulo bias:

range = 900000
limit = 2³² − (2³² mod range)
if raw ≥ limit → reject, redraw
result = (raw mod range) + 100000

Entropy per 6-digit number:

H = log₂(900000) ≈ 19.78 bits

Where raw is a uniformly distributed 32-bit unsigned integer from the OS CSPRNG, range is the count of valid 6-digit numbers (999999 − 100000 + 1), limit is the rejection threshold that eliminates modulo bias, and H is the Shannon entropy in bits per generated number.

Reference Data

Digit Count	Range	Total Possible Values	Bits of Entropy	Common Use Cases
1	0 - 9	10	3.32	Single digit index
2	10 - 99	90	6.49	Short codes
3	100 - 999	900	9.81	Area codes, CVV
4	1000 - 9999	9,000	13.14	PIN codes, years
5	10000 - 99999	90,000	16.46	ZIP codes (US)
6	100000 - 999999	900,000	19.78	OTP, verification codes
7	1000000 - 9999999	9,000,000	23.10	Phone numbers (local)
8	10000000 - 99999999	90,000,000	26.42	Account numbers
9	100000000 - 999999999	900,000,000	29.74	SSN (US), routing numbers
10	1000000000 - 9999999999	9,000,000,000	33.07	Phone numbers (intl)
12	10¹¹ - 10¹²−1	9×10¹¹	39.71	UPC barcodes
16	10¹⁵ - 10¹⁶−1	9×10¹⁵	52.99	Credit card numbers

Frequently Asked Questions

When mapping a 32-bit integer (range 0-4,294,967,295) to 900,000 values, naive modulo produces bias because 2^32 is not evenly divisible by 900,000. The remainder (2^32 mod 900,000 = 167,296) means the first 167,296 values appear with probability slightly higher than the rest. This tool computes a rejection threshold: any raw value ≥ (2^32 − 167,296) is discarded and redrawn. The probability of rejection is ~0.004%, so performance impact is negligible while ensuring perfectly uniform distribution.

Exactly 900,000. The 6-digit range spans 100000 to 999999 inclusive. If you request more than 900,000 unique numbers, the tool will cap the request and notify you. In practice, generating above ~100,000 unique values will slow down due to increasing collision rates in the Set lookup, though the tool handles this efficiently.

It is a cryptographically secure pseudorandom number generator (CSPRNG) seeded by operating system entropy sources (hardware interrupts, thermal noise, etc.). It is not truly random in the quantum sense, but it is computationally indistinguishable from true randomness. It meets NIST SP 800-90A requirements and is suitable for cryptographic key generation, making it more than adequate for 6-digit number generation.

No. By definition, a 6-digit number ranges from 100000 to 999999. Numbers starting with zero (e.g., 012345) are 5-digit numbers with a leading zero, which is a string representation, not a 6-digit integer. This tool generates integers in the strict 6-digit range. If you need zero-padded 6-character strings, you would need a different tool.

The tool uses a JavaScript Set for O(1) average-case insertion and lookup. For 10,000 unique numbers from a pool of 900,000, the expected collision rate is approximately 1.1% (birthday problem approximation: n²/2m where n=10,000 and m=900,000). This means roughly 110 extra draws per 10,000 numbers - negligible overhead. At 100,000 numbers, the collision rate rises to ~11%, still manageable. The algorithm degrades gracefully rather than failing.

The tool supports newline, comma, space, semicolon, and tab separators. Results can be copied to clipboard or downloaded as a .txt file. The separator choice affects both the on-screen display and the exported content. For CSV import into spreadsheets, use comma separator. For line-by-line processing, use newline.