List Randomizer & Picker
Randomize lists and pick random items. Shuffle list items in random order or select random items from your list with customizable options — all in your browser, with no data sent anywhere.
Input
Tip: You can also load a list from a text file (.txt, .csv) 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 shuffles a list into a random order or selects N items at random from any list. It supports four input formats (one-per-line, comma, semicolon, or space-separated), reads from .txt and .csv files, and offers an "extra-fair" mode that uses your operating system's cryptographic random number generator — the same one banks use — for raffle-grade fairness. 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 groups, randomise A/B-test cohorts, or break ties in any decision where fairness matters.
Who is it for?
Built for educators picking students at random, marketers running giveaways and contests, researchers needing unbiased random samples, event organisers assigning seats or teams, content creators randomising playlists or presentation order, developers seeding test fixtures, and anyone who needs a fair coin-flip-equivalent for a decision. The optional Advanced settings (custom seed for reproducible shuffles, JSON export with original positions) make it equally useful for QA engineers and data-science workflows.
How to use the tool
Choose Randomize List (shuffle the entire list) or Random Picker (select N items from the list)
Type or paste your list into the text area, or click "Load Sample" for a quick example, or "Load from File" for a .txt / .csv
Pick the input format that matches your data (one-per-line, comma, semicolon, or space)
For Random Picker, enter how many items you want to select
Choose an output format (one-per-line is standard; JSON is useful for code fixtures)
Optionally enable "Remove duplicates" to dedupe before shuffling
For raffles or any draw where fairness matters, tick "Extra-fair shuffle" — it uses your operating system's cryptographic RNG instead of the standard one
Click Randomize or Pick Random — the results appear on the right with Copy and Download buttons
Key Features
Two modes — shuffle or pick
Randomize List reorders every item; Random Picker selects N items at random without replacement. Switch between modes with a single click; all settings persist.
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.
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.
Multiple input & output formats
Read lists from one-per-line, comma, semicolon, or space-separated text — and emit results in any of those formats, plus JSON arrays for code fixtures.
File import
Drop in a .txt or .csv file (up to 10 MB) — the tool parses it locally and never uploads it.
Live list statistics
See total, unique, and duplicate counts update in real time as you type or paste — useful for spotting CSV-import issues before you shuffle.
Advanced settings (for power users)
A collapsible Advanced panel exposes a custom random seed (for reproducible shuffles you can verify later) and an "Include original positions" toggle (each output item gets a #N prefix or originalIndex field for auditable picks).
100% client-side
Both shuffling and picking run entirely in your browser. No list data — names, emails, ticket IDs — is ever transmitted, logged, or persisted. Verifiable in your DevTools network tab.
Common Use Cases
Raffle / giveaway winner draw
Scenario: You've collected a list of entries (Twitter handles, email addresses, ticket numbers) and need to pick a winner publicly and fairly.
✓ Enable Extra-fair shuffle, optionally set a published seed before the draw (so anyone can re-run the draw and verify the same winner came out), then pick — fully reproducible, fully transparent, no server involved.
Classroom random selection
Scenario: You need to pick students for a question, assign them to project groups, or randomise the speaking order without showing favouritism.
✓ Paste the class roster, click Pick Random for the day's volunteer or Randomize for a presentation order — done in seconds, no spreadsheet formulas.
Survey / experiment randomisation
Scenario: You're 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 (Advanced) 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 in Advanced settings, export as JSON — your fixture is reproducible across runs and CI environments without committing a static random ordering by hand.
Team / pair assignment
Scenario: You're forming hackathon teams, sprint pairings, or 1:1 buddy assignments and need an unbiased way to pair people up.
✓ Shuffle the roster, then split the result into pairs — guaranteed no implicit bias toward who got assigned with whom.
Fisher–Yates shuffle, optional cryptographic-grade randomness
100% client-side — your list never leaves your device
Static site — no backend dependency
Frequently Asked Questions
What does "Extra-fair shuffle" do?
Standard JavaScript randomness (Math.random) is fine for casual use but is not designed for situations where the outcome must be unguessable or audit-quality. Extra-fair shuffle switches to your operating system's cryptographic random source — the same one used by banks, password generators, and TLS — making the result indistinguishable from physically drawing slips of paper out of a hat. Recommended for any draw where there's money, prizes, or trust on the line.
Is the random result the same every time?
No, by default each run produces a fresh random order. If you do want a reproducible shuffle (e.g. so others can verify your draw), open Advanced settings and enter a custom seed — the same seed always produces the same shuffle of the same input.
Does this tool send my list anywhere?
No. All shuffling and picking runs entirely in your browser. There are no API calls and no analytics events with your list data. You can verify in your browser's DevTools network tab — running the tool produces zero requests. This is important for raffle entries, member rosters, or any list with personal data.
Why use Fisher–Yates instead of just sort(() => Math.random())?
A common but broken approach is to call array.sort with a random comparator — it produces measurably biased results because most sort algorithms aren't designed for non-deterministic comparators. Fisher–Yates is provably uniform: every permutation has exactly the same probability of being generated. This tool uses Fisher–Yates for both Randomize and Pick modes.
Can I publicly verify a draw I ran with a custom seed?
Yes — that's exactly what custom seeds are for. Before the draw, publish the seed (e.g. the closing block hash of the day, or any public string). Run the draw with the announced seed. Anyone with the same input list and the same seed will get the same result, which they can verify by re-running the tool. This is a lightweight way to make small public draws auditable without a notary.
What's the maximum list size?
There's no hard cap on the number of items — Fisher–Yates is linear, so even 100,000 items shuffle in milliseconds. The only limits are your browser's memory and the 10 MB file-import cap. For practical purposes, anything up to a few hundred thousand items works fine.
How does "Remove duplicates" interact with shuffling?
Duplicates are removed first, then the deduplicated list is shuffled or picked from. So if your list has [Alice, Bob, Alice, Carol], turning on Remove duplicates means the shuffle/pick operates on [Alice, Bob, Carol] only.
What does "Include original positions" do?
When enabled (in Advanced settings), each output item gets a marker showing its position in the original list — e.g. "[#17] Alice" in text formats, or {"value": "Alice", "originalIndex": 17} in JSON. Useful for auditable picks (you can show "we drew item #17 from the entry list") and for QA fixtures where you need to know which original record each picked item came from.
Technical Specifications
Supported Formats
- ✓Input formats: one-per-line, comma-separated, semicolon-separated, space-separated
- ✓Output formats: one-per-line, comma-separated, semicolon-separated, space-separated, JSON array
- ✓File import: .txt, .csv (any text/* MIME type), up to 10 MB
- ✓Standard randomness: Math.random (≈ 2⁵³ bits of state, fast)
- ✓Extra-fair randomness: crypto.getRandomValues (cryptographic-grade, OS-provided)
- ✓Reproducible randomness: mulberry32 PRNG seeded from any text seed (Advanced)
- ✓Shuffle algorithm: Fisher–Yates, O(n) time, O(1) extra space
- ✓Includes-original-position output: text "#N item" prefix or JSON originalIndex field
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 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 Bitcoin block hash as the seed"), then anyone can independently re-run the draw with the same input and confirm the result.
- For very long lists, paste in one-per-line format — it's the least ambiguous, and CSV files exported from spreadsheets often round-trip best as one-per-line.
- If you're generating test fixtures for a code project, choose JSON output and consider using a fixed custom seed — your tests stay deterministic across CI runs.
- 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 can't be picked again in the same draw. If you need draws with replacement (e.g. picking 5 dice rolls from {1..6}), pick 1 item five times and run it five times.
- For raffle entries with weighted chances (e.g. "premium members get 2 entries"), expand the entries beforehand: list each premium member twice in the input. Fisher–Yates then handles the weighting fairly.
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.