Seeds, hashes, one check

Plinko provably fair checker: seeds, hashes and one drop

A provably fair board commits to its secret before you drop a ball and reveals it afterwards, so anyone can recompute the result. Follow the scheme step by step, then see exactly what the check proves and what it leaves open.

Plinko provably fair games let you confirm, after the fact, that the bin your ball reached was fixed before you pressed the button and was not changed afterwards. The method is a commit-and-reveal scheme built from ordinary cryptographic hashing. This page walks through it one step at a time, follows a single drop through a check, and then draws a clear line between what a passing check proves and what it cannot.

The problem the scheme solves

In an online game the result is produced in software you cannot see. Without some extra mechanism, you would have to take on trust that the outcome was not chosen after your stake was known. A commit-and-reveal scheme replaces that trust with arithmetic you can repeat. That trust problem sits inside a single game; picking which casino to trust with an account in the first place is what the plinko gambling sites ranking is for.

The idea is older than computers. Imagine someone writes a number on a card, seals it in an envelope and hands you the envelope before you make your choice. After you choose, they open it. They could not have changed the number, because you held the envelope throughout. A hash plays the part of the sealed envelope.

The three ingredients

Server seed

A long random string produced by the game's server. It stays secret while you play. Before the first drop, the game shows you its hash: the output of a one-way function such as SHA-256. A hash is easy to compute from the seed but, in practice, impossible to reverse, and changing a single character of the seed produces a completely different hash.

Client seed

A string on your side. Many games fill it in automatically and let you replace it with your own text. Because it enters the calculation too, the server cannot know the final result when it commits to its seed, unless it also controls your seed.

Nonce

A counter that starts at zero or one and goes up by one with every drop made under the same pair of seeds. It makes each drop's input different, so one pair of seeds can produce thousands of separate results.

How a plinko provably fair drop is produced, step by step

The game creates its secret server seed and puts the hash of it on screen. Write the hash down or copy it somewhere outside the game.
You set or accept a client seed. Changing it after seeing the hash is a sensible habit, because then the server's commitment was made before your input existed.
You drop a ball. The game combines the server seed, the client seed and the current nonce, runs them through a hash function, and reads the output as a stream of numbers.
For a board of n rows, the game turns that stream into n left-or-right decisions, one per row. The count of rights is the bin. The exact recipe is published on the game's fairness page, and a check only works with that recipe.
The nonce goes up by one and the next drop repeats step 3 with the new counter.
When you ask to rotate the seed pair, the game reveals the old server seed in full and commits to a new one by showing its hash.

The drop's animation is drawn to match the bin already determined in step 4. It carries no information that the check needs.

Checking one drop yourself

Once a server seed has been revealed, every drop made under it can be recomputed. The check has two parts.

Part 1: the seal was intact

Hash the revealed server seed with the function the game names. Compare the result with the hash you copied before playing. If the two match character for character, the server seed you now hold is the one the game committed to. If they differ in any way, the commitment was broken.

Part 2: the result follows from the inputs

Pick the drop you want to test, for example nonce 42, and gather its three inputs: the now-public server seed, the client seed in force at the time and that nonce. Run them through the recipe from the game's fairness page, using any independent tool that implements the same hash function. Convert the output into left-or-right decisions exactly as the recipe says, count the rights and compare the bin number with the one in your bet history.

If both parts pass, drop 42 landed where the committed inputs said it must. You can repeat Part 2 for every nonce under that seed pair.

What a plinko provably fair check proves

A passing check establishes two things, and they are worth stating precisely.

Verification step for provably fair play: the revealed server seed is run through the published hash function and the output is compared character by character with the hash shown before play; equal means the seed was not swapped — Verification is one recomputation. If the hash of the revealed seed equals the hash you saw before playing, the seed behind your drops was fixed in advance.

The result was fixed before the drop. The server seed was committed by its hash before you played, and your client seed and the nonce were known inputs. The bin follows from those alone.
The result was not changed afterwards. Any change to the server seed would have produced a different hash, and any change to the result would fail the recomputation.

Those two facts rule out a game that picks the outcome after seeing your stake or your settings. That is valuable, and it is more than a bare result screen can show.

What the check does not prove

A passing check says nothing about several things that matter just as much.

The paytable's return. The check confirms which bin the ball reached, not what that bin pays. The long-run return is set by the printed multipliers, and you calculate it from the paytable, as the multiplier page explains. A board can be perfectly verifiable and still return less than another.
Whether the recipe splits evenly. The check confirms that the published recipe was followed. Whether that recipe gives each peg an even split is a separate question, which you can test by recomputing many drops and comparing the spread of bins with the route counts on the probability tables page.
The server seed's randomness. The check proves the seed was not changed, not that it was chosen well. Setting your own client seed after the hash is shown is what stops a known seed pair from being lined up in advance.
The operator's account rules. Identity checks, deposit minimums, withdrawal caps and the rest of the terms sit outside the game entirely. Those are covered on the page about ID checks in casino terms.

Common misreadings

Seeing the hash of the next server seed does not let anyone predict drops, because the hash cannot be reversed into the seed. Anything that claims to read upcoming bins from a displayed hash is false; no tool can do it, and apps sold on that promise are scams.

Likewise, recomputing past drops tells you nothing about future ones. Each new nonce produces an unrelated output, so a verified run of results carries no pattern to follow.

A short routine for checking

Before the first drop, copy the server seed hash outside the game.
Replace the client seed with your own text.
Play, noting the nonce of any drop you want to check.
Rotate the seed pair to reveal the old server seed.
Hash the revealed seed and compare; then recompute the chosen drops with the published recipe.

Gambling is for adults aged 18 and over. A verified result is an honest result, not a reason to stake more than planned.

Questions people type about the board

Does a plinko provably fair game have a better return than one without seeds?

Not necessarily. The seed scheme proves that each result was fixed before the drop and not altered, but the return comes from the multipliers printed under the bins. Two boards can both pass every check and still return different amounts over a long run. Compare the published return figure and the paytable for your chosen rows and risk level separately.

Why should I change the client seed?

Because it closes the one gap the scheme leaves open. If the server knew your client seed before committing to its own, it could in principle choose a server seed with that pairing in mind. When you set your own client seed after the server's hash is on screen, its commitment was made before your input existed, so neither side could steer the combined result.

Can I check a drop while the current server seed is still secret?

Only partly. While the seed is hidden you can record the hash, your client seed and the nonce of each drop, but you cannot recompute results until the server seed is revealed. Rotating the seed pair reveals it. After that, every drop made under the old pair can be checked, in any order, as many times as you like.