WebToolsPlanet
generator Tools

List Randomizer

Shuffle any list, pick N random winners, or run a fair lottery using the Fisher-Yates algorithm.

Last updated: March 25, 2026

Client-Side Processing
Input Data Stays on Device
Instant Local Execution

Find this tool useful? Support the project to keep it free!

Buy me a coffee

What is List Randomizer?

Random selection from a list is needed constantly: picking a lottery winner from participants, assigning team members to projects fairly, shuffling a quiz question order, selecting a random recipe for dinner, deciding presentation order impartially, or picking a random daily standup facilitator. A proper random selection requires a statistically unbiased algorithm — one where every item has an exactly equal probability of appearing at any position or being selected.

The gold standard algorithm for list shuffling is the Fisher-Yates shuffle (also known as the Knuth shuffle), which has O(n) time complexity and guarantees a perfectly uniform distribution of outcomes — every permutation of the list is equally likely. For selection of N winners from M participants, the algorithm picks N items without replacement, meaning the same item cannot be selected twice. This tool uses the Fisher-Yates algorithm with the browser's built-in Math.random() pseudo-random number generator.

How to Use List Randomizer

1

Enter your items in the text area — one item per line (names, options, questions, etc.)

2

Choose your mode: "Shuffle All" to randomize the full list, or "Pick Random" to select N specific items

3

For "Pick Random", set how many items to select (e.g., "pick 3 winners from 50 participants")

4

Click "Randomize" or "Pick" — results appear instantly in the output panel

5

Click "Randomize Again" to get a fresh draw with the same input list, or "Copy Results" to copy the selected items

Common Use Cases

  • Picking random winners for a social media giveaway from a list of participants
  • Randomly assigning 20 team members into 4 equal groups for a workshop or hackathon
  • Shuffling quiz questions to deliver them in random order to each quiz taker
  • Randomly selecting a recipe from a meal planning list to decide what's for dinner
  • Fairly picking presentation order for a class or team where everyone must go
  • Randomly assigning code review responsibilities from a list of available engineers
  • Shuffling a flashcard deck to create a new study sequence each session
  • Picking a random standup lead from the team roster each morning

Example Input and Output

Picking 3 random winners from a list of 8 participants:

Input: 8 participants (one per line)
Alice Johnson
Bob Martinez
Carol Chen
David Kim
Eva Petersen
Frank Okafor
Grace Williams
Henry Müller
Output: 3 randomly selected winners
🎲 Randomizing 3 winners from 8 participants...

🏆 1st Place:  Carol Chen
🥈 2nd Place:  Frank Okafor
🥉 3rd Place:  Alice Johnson

Remaining (did not win):
  Bob Martinez, David Kim, Eva Petersen, Grace Williams, Henry Müller

Algorithm: Fisher-Yates | Items: 8 | Selected: 3 | Unique: ✓

Client-Side Processing

All randomization runs locally in your browser. Your participant list — which may include real names — is never transmitted to our servers. This tool works fully offline.

Crypto-quality Randomness

For higher-stakes draws, enable "Use Cryptographic Randomness" to use window.crypto.getRandomValues() instead of Math.random(). This uses the operating system's cryptographically secure pseudo-random number generator (CSPRNG), which is suitable for security-sensitive applications. Both options produce statistically equivalent results for typical lottery and team assignments.

No Seeded Reproducibility in Browser

Browser Math.random() cannot be seeded with a custom value (unlike Python's random.seed() or NumPy). Each call to Math.random() advances an internal state opaquely. For reproducible random sequences (same seed = same sequence), use a seeded PRNG library like Seedrandom.js, which accepts an explicit seed string and produces deterministic output — critical for verifiable lottery auditing.

Frequently Asked Questions

Is the randomization truly fair and unbiased?
Algorithmically: yes. The Fisher-Yates shuffle produces a uniformly random permutation — every possible ordering has exactly equal probability of occurring. Math.random() is a pseudo-random number generator (PRNG) seeded by the browser. For non-cryptographic use cases (lotteries, team shuffles, quiz order), Math.random() provides sufficient randomness. For cryptographic or high-stakes purposes, use crypto.getRandomValues() (available as an option in this tool).
What is the Fisher-Yates shuffle algorithm?
The Fisher-Yates shuffle works by iterating from the last element to the first, swapping each element with a randomly chosen element from the unprocessed portion. In pseudocode: for i from n-1 down to 1: j = random integer from 0 to i; swap(array[i], array[j]). After completion, every element has been placed in a random position with equal probability. Time complexity: O(n). Space: O(1).
Does the same item ever get picked twice?
No. "Pick N random items" uses sampling without replacement — each picked item is removed from the pool before the next selection. This ensures no duplicate winners. If you need "with replacement" sampling (where the same item can win multiple times, like a slot machine), enable the "Allow Duplicates" toggle., which re-samples from the full list for each pick.
How do I run a transparent, verifiable lottery?
For a provably fair lottery, share the participant list before the draw (so it cannot be edited after), run the draw live or screen-share it, and record the session. Cryptographically verifiable draws use a commitment scheme: hash a secret seed before the draw, reveal the seed after, show that the hash matches. This tool's "Download Seed" feature records the random seed used — auditors can verify the draw by replaying the Fisher-Yates algorithm with that seed.
Can I divide a list into equal groups?
Yes. Use "Shuffle All" to randomize the list, then divide the shuffled list into equal segments. Group 1 = items 1-5, Group 2 = items 6-10, etc. After shuffling the full list, each group is a random selection without overlap. This is the standard approach for creating balanced teams or assigning participants to breakout rooms in Zoom/Meet.
What is the maximum list size this tool supports?
The Fisher-Yates algorithm runs in O(n) time and O(1) auxiliary space on top of the list storage. The list is stored in browser memory as a JavaScript array. Lists of up to 100,000 items shuffle in under 50ms on a modern laptop. The practical limit is browser memory constraints — a list of 1 million short strings would use approximately 50MB of RAM, which is feasible on most devices.

How This Tool Works

The input text is split by newlines to produce an array of strings. For "Shuffle All" mode, the Fisher-Yates algorithm iterates from the last index to the first; for each index i, it generates a random integer j between 0 and i using Math.random() (or crypto.getRandomValues() in secure mode), and swaps array[i] with array[j]. For "Pick N" mode, only the first N iterations are performed and the first N elements of the result are returned as the selection.

Technical Stack

Fisher-Yates shuffle (O(n))Math.random() PRNGcrypto.getRandomValues() (optional)Client-side only

Related Tools

UUID Generator
Generate random UUID v4 identifiers instantly — single or bulk, with format options.
Password Generator
Generate cryptographically secure random passwords using crypto.getRandomValues() — customizable length, character sets, and entropy calculation.
Hash Generator
Generate MD5, SHA-1, SHA-256, and SHA-512 hashes from text.
QR Code Generator
Generate QR codes from text, URLs, or any data.
Random Test Data Generator
Generate realistic placeholder data (users, addresses, UUIDs) in JSON or CSV for testing APIs and databases.
Mock API Response Generator
Generate structured mock JSON API responses from a schema — for frontend testing and component prototyping.