How it works
How Pickerify picks a winner you can check
Every Pickerify draw goes through the same four stages, and each one leaves a record. Nothing happens out of sight, and anyone can check the result afterwards with the published data.
1. Reading the public comments
When you paste a link, Pickerify first shows the post and the price. Once you confirm, it reads the comments page by page.
- Replies are included. Pickerify opens reply threads too, so a tag or keyword in a reply counts like any other comment.
- Only public data. Pickerify reads what a logged-out visitor can see. It never asks for your password and has no access to your account.
- A set reading time. Each draw reads comments for a set time; paid plans read longer. Deleted, hidden, restricted and spam-filtered comments aren’t public, so no tool can read them.
- Lists skip this stage. If you paste a list instead of a link, your list is the starting point.
2. Turning comments into eligible entries
Your rules turn a pile of comments into a list of eligible entries. A comment that doesn't make it onto the list is left out for one of these reasons.
| Reason | What happened |
|---|---|
| Not enough tags | Fewer different @mentions than your tag-a-friend minimum |
| Missing keyword | The comment doesn't contain your required word, hashtag or emoji |
| Duplicate | The person already has an entry and one entry per person is on |
| Excluded account | The account is on your exclusion list, such as your own |
| Outside the entry window | Posted before the start or after the deadline |
| Reply ignored | Replies don't count in this draw |
The rules you set are printed on the results page exactly as applied, so entrants can see what counted.
3. The draw: lock, seed, shuffle
When you press Pick winners, three things happen in a fixed order, so nobody can influence the result once it's known.
- The entry list is locked. The eligible entries are put in a fixed order and fingerprinted with SHA-256. From now on, any change to the list would change the fingerprint.
- A new seed is created. Pickerify generates a 256-bit random seed from the server’s cryptographically secure random number generator. The seed is created only after the list is locked.
- The list is shuffled. The seed drives a Fisher–Yates shuffle over the locked list. The first entries in the shuffled list are the winners, the next ones are the backups, in order.
Every entry has exactly the same chance. Random numbers are drawn with rejection sampling, which removes the small bias that simpler methods introduce when a list size doesn’t divide evenly.
If you redraw: a redraw gets a new seed and is labelled as a redraw on the results page, with the earlier winners still listed. A host can’t quietly redraw until a favourite wins.
4. A results page anyone can open
Every draw gets its own page at pickerify.com/r/{code}. Share the link with your audience, and anyone can see how the winner was chosen.
| The results page shows | Why it matters |
|---|---|
| Winners and backups, in order | Who won and who's next if a winner doesn't reply |
| The post and the host | Which giveaway the draw belongs to |
| Every rule that was applied | Entrants can see what counted |
| The random seed | The input that decided the shuffle |
| The SHA-256 fingerprint of the entry list | Proof the list wasn't changed after the draw |
| Earlier draws, if there was a redraw | No hidden redraws |
/r/{code}/verify.json | Reruns the draw and reports whether the winners match |
The host also gets a winner image sized for Stories and can download the locked entry list to share with anyone who wants to check the draw on their own.
Verify a draw yourself
You don’t have to trust Pickerify. With the data from a draw, anyone can rerun it and check that it gives the same winners.
The quick way
Open pickerify.com/r/{code}/verify.json. Pickerify reruns the draw from the published seed and the locked entry list and reports whether the winners and backups match.
The independent way
- 1
Get the entry list. Ask the host for the entry list they downloaded from the draw. Each line is one eligible entry: a username in lowercase without the @, or a line from a pasted list.
- 2
Check the fingerprint. Sort the lines in UTF-8 byte order (plain alphabetical order for usernames), join them with a line break, and compute the SHA-256 hash of the text. It must match the entry list fingerprint on the results page.
- 3
Build the random numbers. For each counter value 0, 1, 2 and so on, compute HMAC-SHA256 with the seed as the key and the counter as an 8-byte big-endian number as the message. Read each 32-byte result as eight 4-byte big-endian unsigned numbers, in order.
- 4
Shuffle. Run a Fisher–Yates shuffle on the sorted list, from the last position down to the second. For each position i, take the next random number; discard it if it is at or above the largest multiple of i + 1 below 2³², otherwise use its remainder after dividing by i + 1 as the position to swap with.
- 5
Read off the winners. Walk the shuffled list from the start, skipping any entry already picked, so a person with several tickets wins once. The first picks are the winners, the next ones the backups, in order.
If your result differs from the results page, email hello@pickerify.com with the draw code.
Reference code
// Reference verifier. Runs in any modern browser console or Node 20+.
async function rerun(entries, seedHex, winners, backups) {
const enc = new TextEncoder();
const cmp = (a, b) => {
const x = enc.encode(a), y = enc.encode(b);
for (let i = 0; i < Math.min(x.length, y.length); i++) if (x[i] !== y[i]) return x[i] - y[i];
return x.length - y.length;
};
const list = [...entries].sort(cmp);
const hash = await crypto.subtle.digest("SHA-256", enc.encode(list.join("\n")));
const fingerprint = [...new Uint8Array(hash)].map((b) => b.toString(16).padStart(2, "0")).join("");
const seed = Uint8Array.from(seedHex.match(/../g), (h) => parseInt(h, 16));
const key = await crypto.subtle.importKey("raw", seed, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
let counter = 0n, block = null, offset = 32;
const next = async () => {
if (offset >= 32) {
const msg = new ArrayBuffer(8);
new DataView(msg).setBigUint64(0, counter++);
block = new DataView(await crypto.subtle.sign("HMAC", key, msg));
offset = 0;
}
const v = block.getUint32(offset); offset += 4; return v;
};
for (let i = list.length - 1; i >= 1; i--) {
const bound = i + 1, limit = Math.floor(2 ** 32 / bound) * bound;
let r = await next();
while (r >= limit) r = await next();
const j = r % bound;
[list[i], list[j]] = [list[j], list[i]];
}
const picked = [];
for (const e of list) {
if (!picked.includes(e)) picked.push(e);
if (picked.length === winners + backups) break;
}
return { fingerprint, winners: picked.slice(0, winners), backups: picked.slice(winners) };
}What Pickerify deliberately doesn't do
Some limits are there on purpose, because they protect your account, your entrants or the fairness of the draw.
- It never logs in to your account. No passwords, no app permissions, so Pickerify can’t post, comment, like, follow or message on your behalf.
- It doesn’t pretend to check follows, likes, shares or subscriptions. Those lists aren’t reliably public, so Pickerify says so instead of guessing.
- It doesn’t hide redraws. Every redraw is labelled and the earlier winners stay visible on the results page.
- It doesn’t run your giveaway. Pickerify picks the winner fairly; the prize, the rules and contacting the winner stay with you. The giveaway rules generator helps with the rules.
How it works: common questions
How is the winner chosen?
At random from the eligible entries. Pickerify locks the list, creates a new 256-bit seed and uses it to shuffle the list with Fisher–Yates; the first entries in the shuffled list win.
Can the host pick a specific winner?
No. The seed is created only after the list is locked, and every redraw is labelled on the results page, so a host can't choose the outcome or hide a redraw.
Why publish the seed?
Because it makes the draw checkable. With the seed and the entry list, anyone can rerun the shuffle and get the same winners.
Is a published seed a security risk?
No. The seed is created after entries close and is used for that one draw only, so knowing it afterwards can't change or predict anything.
What does the entry list fingerprint prove?
That the list used in the draw is the one the host shares. Adding or removing even one entry would change the SHA-256 fingerprint completely.
Why are some comments not counted?
A comment is left out when it misses a rule, such as a missing tag, a missing keyword, a duplicate or a time outside the entry window. Comments that were deleted or hidden on the platform can't be read at all, and each draw reads comments for a set time.
See it work on your own giveaway
Paste a post link or a list, set your rules and get a winner with a results page anyone can check.
Pick a winner