List Randomizer & Picker
Shuffle a list, draw random winners, or split people into balanced teams. Supports weighted entries, reproducible seeds, sequential raffle draws with history, and a shareable link — all in your browser, with no data sent anywhere.
Input
Tip: You can also load a list from a text file (.txt, .csv, .json) using the "Load from File" button above.
Randomized List
Randomized list will appear here
Enter your list and click "Randomize" to start
About List Randomizer & Picker
The List Randomizer & Picker does three jobs: it shuffles a list into a random order, draws N random winners from it, and splits it into balanced teams. It reads five input formats (one-per-line, comma, semicolon, space, and JSON arrays), imports .txt/.csv/.json files, supports weighted entries (Alice:3), and offers an "extra-fair" mode backed by your operating system's cryptographic random number generator. Draws are logged with timestamps, winners can be removed from the pool for sequential raffles, and the whole history exports as CSV. All processing happens in your browser; nothing is uploaded.
Why use a List Randomizer & Picker?
Random ordering and fair picking are surprisingly hard to do well by hand — humans subconsciously favour familiar items and adjacent positions. This tool runs the Fisher–Yates shuffle (the algorithm card-shuffling researchers consider the gold standard) so every item has an exactly equal chance of landing in every position. Use it to draw raffle winners without bias, randomise survey question order to defeat order effects, assign students to balanced project groups, randomise A/B-test cohorts, or break ties in any decision where fairness matters — with an auditable draw history you can export.
Who is it for?
Built for educators picking students and forming project groups, marketers running giveaways with multi-round draws, researchers needing unbiased random samples, event organisers assigning teams or seats, content creators randomising playlists, developers seeding test fixtures, and anyone who needs a fair coin-flip-equivalent for a decision. The Advanced panel (custom seed, original positions, shareable seeded link) makes it equally useful for QA engineers and data-science workflows.
How to use the tool
Choose a mode: Randomize (shuffle the whole list), Random Picker (draw N winners), or Team Splitter (build balanced groups)
Type or paste your list, click "Load Sample", load a .txt / .csv / .json file, or reload one of your last 5 lists from the "Recent lists" picker
Pick the input format that matches your data — one-per-line, comma, semicolon, space, or JSON array
Turn on "Remove duplicates" if repeats should collapse first (deduplication always runs before the shuffle or pick), and "Weighted entries" if you want Alice:3 / Alice*3 syntax to triple an entry's chance
For Random Picker, set how many items to draw; for Team Splitter, choose "Split into N groups" or "Groups of N members" and optionally name the groups
For raffles, tick "Extra-fair shuffle" to switch to your operating system's cryptographic random source
Click the action button — after a draw you can hit "Remove winner & draw again" for the next round, Undo a draw, or export the full history as CSV
Open Advanced settings for a reproducible custom seed, original-position markers, a shareable seeded link, and the "Clear saved data" control
Key Features
Three modes — shuffle, pick, or split into teams
Randomize reorders every item; Random Picker draws N items without replacement; Team Splitter builds balanced groups either as "N groups" or "groups of N". Switch modes with one click — your list and settings carry over.
Fisher–Yates shuffle
Uses the mathematically proven Fisher–Yates algorithm — every item has an exactly equal probability of ending up in every position, with no order or position bias.
Weighted entries
Write Alice:3 or Alice*3 to give an entry three times the chance of being drawn. Weights are opt-in so ordinary values containing a colon (URLs, timestamps) are never misread, and picked entries show their weight as a badge.
Sequential raffle draws with history
Every draw is logged with a timestamp, the seed used, and whether it was weighted. "Remove winner & draw again" takes the winners out of the pool for the next round — ideal for 1st / 2nd / 3rd place draws. Undo reverses the last draw, and the whole history exports as CSV.
Extra-fair (raffle-grade) randomness
A one-click toggle switches from the standard browser random to your operating system's cryptographic RNG (the same source used by banks and password managers). Recommended whenever the result matters — prize draws, contest winners, audit-quality random sampling.
Five input formats, including JSON arrays
Reads one-per-line, comma, semicolon, space-separated text and genuine JSON arrays — strings and numbers become items directly, objects are kept as compact JSON so nothing is silently lost. Output can be emitted in any of those formats.
Saved lists and settings
Your list, mode and options are remembered in this browser's localStorage, and the last 5 lists are one click away in the "Recent lists" picker (each deletable). A "Clear saved data" button wipes everything the tool has stored.
Shareable seeded links
Create a link that carries the mode and seed so a colleague can reproduce your exact draw. Including the list itself is opt-in and travels in the URL fragment (never sent to a server), with a warning when the link grows past ~2 KB.
Common Use Cases
Multi-round raffle / giveaway draw
Scenario: You have a list of entries and need to draw 1st, 2nd and 3rd place live, without the same person winning twice.
✓ Enable Extra-fair shuffle, draw the first winner, then hit "Remove winner & draw again" for each subsequent place. The history panel shows every draw with a timestamp and exports to CSV as your audit trail.
Classroom groups and random selection
Scenario: You need to split 27 students into 6 project groups, or pick someone to answer the next question, without showing favouritism.
✓ Paste the roster and use Team Splitter for balanced groups (sizes differ by at most one), or Random Picker for the day's volunteer — seconds instead of spreadsheet formulas.
Weighted prize draws
Scenario: Premium members get three entries, standard members get one, and you do not want to paste duplicate rows to fake the weighting.
✓ Turn on Weighted entries and write Alice:3 — the draw samples proportionally to weight, and every pick shows its weight so the result is easy to explain to participants.
Survey / experiment randomisation
Scenario: You are running a survey or A/B test and need to randomise question order or assign respondents to cohorts to defeat order effects.
✓ Generate a fresh random order per respondent, or use a custom seed to reproduce the exact ordering for a given respondent ID — important for replicable research.
QA / test-fixture seeding
Scenario: Your test suite needs deterministic-but-shuffled input data to exercise sort-order-independent code paths.
✓ Set a fixed seed, choose JSON output and optionally include original positions — your fixture is reproducible across CI runs without committing a hand-written random ordering.
Fisher–Yates shuffle, optional cryptographic-grade randomness
100% client-side — your list never leaves your device
Static site — no backend dependency
Frequently Asked Questions
How do I shuffle a list or pick a random winner?
Paste your list into the text area (one item per line is the least ambiguous format), then choose a mode. Randomize reorders the whole list with a Fisher–Yates shuffle. Random Picker asks how many items to draw and returns that many distinct items without replacement. Team Splitter builds balanced groups. Every mode reads the same list, so you can switch between them without re-pasting. Results appear in the right-hand panel with Copy and Download buttons, and picker draws are additionally logged in a timestamped history you can export as CSV.
What is the difference between Randomize, Random Picker and Team Splitter?
Randomize returns every item in a new random order — nothing is dropped. Random Picker returns a subset: you ask for N items and it draws N distinct entries without replacement, which is what you want for raffles and spot checks. Team Splitter shuffles first and then deals the shuffled list into balanced groups: either a fixed number of groups ("split into 3 groups") or a target group size ("groups of 4"). Group sizes always differ by at most one item, so 10 people across 3 groups become 4 / 3 / 3 rather than 4 / 4 / 2.
Does this tool send my list anywhere?
No. Shuffling, picking, splitting and CSV export all run in your browser — verify in DevTools' Network tab: using the tool produces zero HTTP requests. Two things are stored locally: your current list and settings, plus your last five lists, are kept in this browser's localStorage so the page survives a refresh. Nothing is uploaded, and the "Clear saved data" button in Advanced settings removes all of it. If you create a share link with "Include list in link" enabled, the list is encoded into the URL fragment — browsers never transmit fragments to servers, but anyone holding the link can read it, so do not share lists containing personal data.
Extra-fair shuffle or a custom seed — which should I use for a raffle?
Use Extra-fair shuffle when unpredictability matters most: it draws from your operating system's cryptographic RNG (crypto.getRandomValues), the same source behind password managers and TLS, so nobody can predict or replay the result. Use a custom seed when verifiability matters more than unpredictability: publish the seed before the draw (a stock close, a block hash, a livestream timestamp), then anyone can re-run the draw with the same list and seed and confirm the winners. You cannot have both at once — a seeded draw is deterministic by definition, so the tool disables Extra-fair while a seed is set.
How random is a seeded shuffle, really?
Seeds are hashed into a 32-bit value that drives a mulberry32 PRNG, so a seeded run can reach at most 2³² (about 4.3 billion) distinct orderings. That is more than enough for reproducible fixtures and publicly verifiable draws, and every item still has a fair chance at every position. But a list of 13 items already has 13! ≈ 6.2 billion permutations, so for lists longer than 12 some orderings can never be produced by any seed. When every permutation must be reachable — cryptographic sampling, large-scale randomised trials — leave the seed empty and tick Extra-fair shuffle instead, which draws fresh entropy at every step.
How do weighted entries work?
Turn on "Weighted entries" and append a weight with a colon or asterisk: Alice:3 or Alice*3 gives that entry three times the chance of an unweighted entry. Entries without a weight count as 1, and decimals (Bob:1.5) work too. Selection is sequential roulette-wheel sampling without replacement: the first pick is chosen with probability weight ÷ total weight, then the winner is removed and the remaining weights are renormalised. Because the syntax is opt-in, ordinary values containing a colon — URLs, timestamps, "Room 4:30" — are never misinterpreted while the toggle is off. Each pick displays its weight as a badge so the outcome is easy to explain.
How does "Remove duplicates" interact with shuffling and picking?
Deduplication runs before the shuffle or the pick, never after. With [Alice, Alice, Alice, Bob, Carol] and the option on, the pool becomes [Alice, Bob, Carol] and "pick 3" returns all three distinct names — you never get a short result because duplicates were stripped from the winners afterwards. The first occurrence of a value wins, and in weighted mode it keeps that occurrence's weight. With the option off, the duplicates stay in the pool and act as extra entries, which is the classic poor-man's weighting; the live Total / Unique / Duplicate counters show exactly what the pool looks like before you draw.
Is there a list-size limit, and what about the draw history?
There is no hard item cap: Fisher–Yates is linear, so 100,000 items shuffle in milliseconds. The limits are your browser's memory and the 10 MB file-import cap. Typing is kept responsive by parsing the list on a deferred copy of the input, so statistics never block your keystrokes. Draw history lives in memory for the session: each entry records the picks, timestamp, seed and whether the winners were removed from the pool, and exports to CSV as one row per picked item. Need random numbers rather than list items? Use the random number generator; for random secrets, the random password generator.
Technical Specifications
Supported Formats
- ✓Input formats: one-per-line, comma-separated, semicolon-separated, space-separated, JSON array
- ✓Output formats: one-per-line, comma-separated, semicolon-separated, space-separated, JSON array
- ✓File import: .txt, .csv, .json (any text/* MIME type), up to 10 MB
- ✓Weighted syntax: Name:3 or Name*3 (positive integers or decimals; default weight 1)
- ✓Standard randomness: Math.random (fast, non-cryptographic)
- ✓Extra-fair randomness: crypto.getRandomValues (cryptographic-grade, OS-provided)
- ✓Reproducible randomness: mulberry32 PRNG seeded from a 32-bit hash of any text seed
- ✓Shuffle algorithm: Fisher–Yates, O(n) time, O(1) extra space
- ✓Weighted picking: sequential roulette-wheel selection without replacement
- ✓Team splitting: balanced by construction — group sizes differ by at most 1
- ✓Exports: draw history CSV (one row per pick) and team CSV (group, position, item)
- ✓Persistence: localStorage for list, settings and the last 5 lists — clearable in one click
Limits & Performance
- •File Size: Up to 10 MB per file import; no per-item count cap (tested to 100k items)
- •Validations: Live total / unique / duplicate (and total weight) counts as you type
- •Response Time: Synchronous, in-browser — typically < 5 ms for 1,000 items
- •Browsers: All modern browsers (Chrome, Firefox, Safari, Edge); works offline once loaded
Pro Tips
- For prize draws and any pick where the outcome matters publicly, always enable Extra-fair shuffle — the speed cost is invisible and the integrity gain is real.
- When you need a verifiable draw, publish your seed before running it (e.g. announce "we'll use yesterday's closing block hash as the seed"), then share the generated link so anyone can independently re-run the draw.
- Running a multi-round raffle? Draw once, then use "Remove winner & draw again" for each subsequent place — the pool shrinks automatically and the history keeps your audit trail.
- Prefer weighted syntax (Alice:3) over pasting an entry three times — it keeps the list readable, and the Total Weight counter tells you the real odds at a glance.
- Use the live statistics row to spot duplicates before you shuffle — surprise duplicates often mean a CSV import problem (e.g. an extra trailing column).
- Random Picker draws without replacement — once an item is picked it cannot be picked again in the same draw. For draws with replacement (e.g. five dice rolls from {1..6}), run five single-item picks.
- Turn "Include list in link" off when the list contains names or email addresses — the seed-only link still reproduces the draw for anyone who already has the list.
- Team Splitter balances group sizes automatically: 10 people in "groups of 3" become 3 / 3 / 2 / 2 rather than 3 / 3 / 3 / 1, so nobody ends up in a group of one.
Share This Tool
Found this tool helpful? Share it with others who might benefit from it!
💡 Help others discover useful tools! Sharing helps us keep these tools free and accessible to everyone.