HOW TO VERIFY PROVABLY FAIR PLINKO

The Three Inputs Behind Every Plinko Drop

Every provably fair Plinko drop is a deterministic function of three values, all of which exist before the ball touches the first peg.

The casino's contribution is the server seed, which stays secret during play — what you see up front is its SHA-256 hash, a fingerprint the casino publishes and can never wriggle out of. Your contribution is the client seed (editable at any time), and the nonce is simply the drop counter on the current seed pair: 0, 1, 2 and so on. When you bet, HMAC-SHA256 mixes all three, and the resulting bytes dictate every bounce.

The trap for the casino is that its seed was fingerprinted before your seed entered the mix — so a rigged bounce would require a different server seed, and a different server seed would no longer hash to the fingerprint you were shown. The background theory is covered in our complete guide to provably fair gambling and the general how-to-verify walkthrough.

How the Hash Becomes a Path Down the Pegs

Plinko is the most intuitive provably fair game to understand because the hash maps onto the board almost directly. A standard Stake-style board has 16 rows of pegs, and every row is a single yes/no decision: does the ball bounce left or right? Sixteen decisions in a row determine which of the 17 buckets (indexed 0 to 16) the ball lands in.

Here is the exact derivation used by Stake-style implementations and mirrored by our verifier:

• 1
  Compute the HMAC. The casino calculates HMAC_SHA256(key = serverSeed, message = clientSeed:nonce:0). The output is 32 bytes (64 hex characters).
• 2
  Turn bytes into numbers in [0,1). The 32 bytes are read in groups of four. Each group becomes a fraction using the published formula byte1/256 + byte2/256² + byte3/256³ + byte4/256⁴. One 32-byte digest yields 8 such numbers; for a 16-row board the casino simply continues the byte stream (appending :1, :2… to the message) until it has 16 numbers.
• 3
  Each number is one peg. If the number is below 0.5 the ball goes left; 0.5 or above it goes right. (Equivalently, you can read one bit per row — the principle is identical.)
• 4
  Count the right moves. The number of times the ball went right is the bucket index, from 0 (all left, far-left bucket) to 16 (all right, far-right bucket). That index maps to the payout multiplier shown on the board for your chosen risk level.

The edge buckets (0 and 16) need all 16 moves to agree, which is why they are rare and pay the most; the centre buckets are reached by many different left/right combinations, so they are common and pay the least. That distribution is just the maths of 16 coin flips — and it is fully reproducible.

Worked Example You Can Reproduce

The first digest is HMAC_SHA256("server-seed-demo-2026", "player-007:7:0"):

Reading the bytes four at a time gives the per-row numbers. The first byte pair shows how it works: the first four bytes are a2 c3 57 f1 = 162, 195, 87, 241, so the first number is 162/256 + 195/256² + 87/256³ + 241/256⁴ = 0.6358 — that is ≥ 0.5, so peg 1 goes right.

That is the whole game. The ball was always going to trace RLLLRLLLRLLRLLLR into bucket 5 the instant the server seed was committed — the animation is just theatre over a result that was already locked in.

Where to Find Your Plinko Seeds

One rule trips up almost everyone: a casino never shows the raw server seed while it is still in use, because live drops would become predictable. Rotate the seed pair first; retiring a seed is what unlocks it, and once revealed it lets you audit every drop that pair produced.

What This Proves — and What It Does Not

Verification answers one question — "was this drop decided fairly?" — and only that question. Here is the boundary, stated plainly.

Honesty and generosity are different properties. A verified bucket 5 means the cryptography always pointed at bucket 5 — it never means the payout table was kind, and no amount of transparency turns a 0.5× bucket into a 2× one. Nor does clean game maths vouch for the business behind it: a casino can run textbook Plinko and be slow, evasive or unlicensed at the cashier, which is exactly why licensing and payout history carry weight in our provably fair casino reviews. We unpack these limits fully in is provably fair actually fair?

Verify Other Games Too

Learn Plinko and you have effectively learned them all: the HMAC front end is identical across originals, and each game just interprets the byte stream differently. Where Plinko reads 16 left/right bits, its siblings read the bytes as:

• •Limbo — one float, converted into a crash-style target multiplier (house edge included).
• •Keno — a sequence of distinct drawn numbers.
• •Dice, Crash & Mines — walked through in the how to verify provably fair results guide.

Frequently Asked Questions