Skip to content
Pickerify

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. 1Readthe public comments and replies on the post you paste.
  2. 2Filterthem by your rules, so only qualifying entries remain.
  3. 3Drawthe winners with a new random seed, after the list is locked.
  4. 4Publisha results page with the seed and a fingerprint of the list.

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.

ReasonWhat happened
Not enough tagsFewer different @mentions than your tag-a-friend minimum
Missing keywordThe comment doesn't contain your required word, hashtag or emoji
DuplicateThe person already has an entry and one entry per person is on
Excluded accountThe account is on your exclusion list, such as your own
Outside the entry windowPosted before the start or after the deadline
Reply ignoredReplies 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.

  1. 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.
  2. 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.
  3. 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 showsWhy it matters
Winners and backups, in orderWho won and who's next if a winner doesn't reply
The post and the hostWhich giveaway the draw belongs to
Every rule that was appliedEntrants can see what counted
The random seedThe input that decided the shuffle
The SHA-256 fingerprint of the entry listProof the list wasn't changed after the draw
Earlier draws, if there was a redrawNo hidden redraws
/r/{code}/verify.jsonReruns 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. 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. 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. 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. 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. 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
Picking from a list instead of a post? Use the random comment picker. Wondering what it costs? See pricing.