To verify a provably fair Plinko round, hash the revealed server seed and compare it with the commitment saved before play. Then reproduce the ball’s left/right decisions from the recorded client seed and nonce, count the right turns to find the pocket, and check that pocket against the saved payout table. We use Stake Originals’ published HMAC-SHA256 method here, with a complete calculated example and scripts you can run without placing a bet.
What a provably fair check establishes
A provably fair game still uses a random-number generator. Its extra feature is a receipt you can examine: a commitment published before play, inputs revealed afterwards and a documented calculation. Checking that receipt has three parts: the committed seed, the generated result and the settlement. A hash calculator alone completes only the first part.
Certification and round verification answer different questions. Testing can examine a game’s implementation and statistical behaviour; replaying a round checks its particular inputs. For evidence beyond the calculation, our guide to assessing Plinko rigging claims explains how to distinguish a losing streak from a result mismatch.
Server seed, client seed, nonce and cursor
The server seed and its commitment
Stake describes its server seed as a random 64-character hexadecimal string. The secret stays hidden while active; its SHA-256 digest is shown first. After rotation reveals the seed, recomputing that digest lets you detect substitution against your saved commitment. A hash is one-way: a verifier does not decrypt it to recover the seed.
The client seed and the order of commitment
The client seed is the player’s contribution. Save the server commitment first, then choose a fresh client seed before the rounds being checked. This order matters: if an operator knows a fixed client seed before committing, it could search candidate server seeds for a favourable sequence. Changing your client seed after the round cannot change that round’s inputs. Nor can a client seed predict outcomes while the server seed remains secret.
The nonce identifies the bet
The nonce changes the HMAC message between bets using the same seeds. Copy the value from the individual bet record rather than counting animations or assuming a starting number. Different nonces can produce the same pocket, or even the same L/R path: a 16-row board has only 65,536 possible paths.
The cursor identifies bytes within a bet
For a path starting at byte cursor 0, one SHA-256 HMAC block supplies 32 bytes, enough for eight four-byte decisions. Rows 9–16 use the next block. The suffix in clientSeed:nonce:block is therefore 0 for the first eight decisions and 1 for the next eight; it is separate from the bet’s nonce. An eight-row board uses one block, while 9–16 rows require two.
How to verify a saved round
- Preserve the commitment before play. Save the active server seed hash and the client seed, with a timestamp or screenshot. Check that setting your client seed has not also replaced the server commitment.
- Export the round record. Keep the bet ID, game/provider, seed-pair identifier, nonce, row count, risk setting, stake, pocket and credited payout. Save the multiplier strip for that configuration. A bet ID is a useful reference for support, but is not the nonce used in the formula.
- Reveal the old seed. In Stake’s fairness interface, rotate the seed pair to retire the active server seed. Retrieve the revealed seed for the pair used by your saved bet.
- Compare the commitment. Calculate SHA-256 of the exact revealed seed text. Its 64-character hexadecimal digest must match your original record.
- Replay and reconcile. Use the published game algorithm to reproduce the path and pocket. Compare that pocket with the bet record, then apply the saved multiplier and compare the credited amount, allowing for the game’s documented rounding.
We recommend saving the payout strip alongside the seeds because the seed calculation supplies a position; it does not supply the price attached to that position. Our Plinko payout table guide covers row settings and total returns.
The exact Stake calculation: bytes to bounces
The key is the server seed’s UTF-8 text. Do not decode its hexadecimal-looking characters into raw bytes. For each block, the message is the exact text clientSeed:nonce:block, including the two colons. SHA-256 of the server seed is the commitment; HMAC-SHA256 with that seed as a key produces the game bytes. These are two different calculations.
Read each consecutive group of four bytes as an unsigned big-endian integer and divide by 2^32 = 4,294,967,296. Equivalently, for bytes b0–b3, calculate b0/256 + b1/65,536 + b2/16,777,216 + b3/4,294,967,296. The resulting float is at least 0 and less than 1. Values below 0.5 mean L; values at least 0.5 mean R. Pocket numbering starts at 0 on the left edge, so the pocket index equals the count of R decisions.
This method applies to Stake Originals Plinko. A third-party game inside the same casino can use a different system. We keep this guide’s scripts and checker limited to that named implementation; they are not BGaming or Spribe verifiers. The Stake Plinko mechanics guide covers the board settings separately.
Worked example: all 16 bounces, pocket and payout
We calculated this test vector using the following fixed inputs. It includes a supplied payout strip so the calculation can run through to settlement. It is a teaching example, rather than a casino bet receipt; the strip defines the example and does not claim to be a current live paytable.
| Input | Exact value |
|---|---|
| Revealed server seed | d4e3a89c1b72e50f34a9128c70123456789abcdef0123456789abcdef0123456 |
| Client seed | melbourne-punters-2026 |
| Nonce | 42 |
| SHA-256 commitment | c3549b8ea5a0dc3f6fbb70b8bb58b26b280e4439341ee08efb4c7ddb7acfd88a |
| Rows / initial byte cursor | 16 / 0 |
| Example payout strip, pockets 0–16 | 1000, 130, 26, 9, 4, 2, 0.2, 0.2, 0.2, 0.2, 0.2, 2, 4, 9, 26, 130, 1000 |
The server seed hashes to the commitment in the table. The two HMAC messages and their full outputs are:
melbourne-punters-2026:42:0
edd3f249625f916257b640981e9726ef8e9d885cc175a7f03c77cca2246a0bc7
melbourne-punters-2026:42:1
fd863cc15d63ded6b3a45c0cd2a909ddeb2ef29cb83ac35d485326bc4462f24d
For the first bounce, ed d3 f2 49 represents 3,990,090,313. Dividing by 4,294,967,296 gives approximately 0.9290152958, so the first direction is R. The next four bytes give 0.3842707505 and therefore L. Continue in four-byte groups, switching to block 1 at bounce 9.
| Bounce | Block | Four bytes (hex) | Float | Direction |
|---|---|---|---|---|
| 1 | 0 | edd3f249 | 0.9290152958 | R |
| 2 | 0 | 625f9162 | 0.3842707505 | L |
| 3 | 0 | 57b64098 | 0.3426246997 | L |
| 4 | 0 | 1e9726ef | 0.1194938978 | L |
| 5 | 0 | 8e9d885c | 0.5570912575 | R |
| 6 | 0 | c175a7f0 | 0.7557015382 | R |
| 7 | 0 | 3c77cca2 | 0.2362029930 | L |
| 8 | 0 | 246a0bc7 | 0.1422431336 | L |
| 9 | 1 | fd863cc1 | 0.9903295489 | R |
| 10 | 1 | 5d63ded6 | 0.3648051522 | L |
| 11 | 1 | b3a45c0c | 0.7017266778 | R |
| 12 | 1 | d2a909dd | 0.8228918232 | R |
| 13 | 1 | eb2ef29c | 0.9186851149 | R |
| 14 | 1 | b83ac35d | 0.7196466543 | R |
| 15 | 1 | 485326bc | 0.2825187882 | L |
| 16 | 1 | 4462f24d | 0.2671348036 | L |
The complete path is R-L-L-L-R-R-L-L-R-L-R-R-R-R-L-L. Eight right turns put the ball in pocket 8, the ninth pocket from the left and the centre of a 17-pocket board. The supplied payout strip assigns pocket 8 0.2×. On an illustrative A$1 stake, that returns A$0.20 in total, a net loss of A$0.80. Replace the strip with the actual bet’s table when auditing a recorded round.
Eight right turns can occur in C(16,8) = 12,870 paths, so this pocket’s probability under independent 50/50 decisions is 12,870/65,536 ≈ 19.6381%. This exact L/R sequence is one of the 65,536 paths. Repeated central landings therefore do not imply repeated seed inputs. The checker’s probability explorer lets you compare other pockets without changing the example’s payout assumptions.
Python and JavaScript verification scripts
Both versions implement the published Stake path calculation from byte cursor 0 and use the worked example’s inputs. For another round, replace the seeds, commitment and nonce; set the recorded rows and use its payout table with exactly rows + 1 entries. The table is deliberately separate from the cryptographic function.
Python 3: run locally without extra packages
Save as verify_plinko.py and run python3 verify_plinko.py. Python’s standard library supplies SHA-256 and HMAC.
import hashlib
import hmac
SERVER = "d4e3a89c1b72e50f34a9128c70123456789abcdef0123456789abcdef0123456"
CLIENT = "melbourne-punters-2026"
COMMITMENT = "c3549b8ea5a0dc3f6fbb70b8bb58b26b280e4439341ee08efb4c7ddb7acfd88a"
# Payout input for this teaching example, indexed from the left edge.
EXAMPLE_PAYTABLE = [1000, 130, 26, 9, 4, 2, .2, .2, .2, .2, .2, 2, 4, 9, 26, 130, 1000]
def plinko_path(server_seed, client_seed, nonce, rows=16):
if not isinstance(nonce, int) or nonce < 0 or not isinstance(rows, int) or not 8 <= rows <= 16:
raise ValueError("Use a non-negative integer nonce and 8–16 rows")
path = []
for block in range((rows + 7) // 8):
message = f"{client_seed}:{nonce}:{block}".encode("utf-8")
digest = hmac.new(server_seed.encode("utf-8"), message, hashlib.sha256).digest()
for offset in range(0, min(8, rows - len(path)) * 4, 4):
value = int.from_bytes(digest[offset:offset + 4], "big") / 2**32
path.append("R" if value >= 0.5 else "L")
return path, path.count("R")
if __name__ == "__main__":
print("Commitment matches:", hashlib.sha256(SERVER.encode()).hexdigest() == COMMITMENT)
path, pocket = plinko_path(SERVER, CLIENT, 42)
print("Path:", "-".join(path))
print("Pocket:", pocket)
print("Example multiplier:", EXAMPLE_PAYTABLE[pocket])
JavaScript: Web Crypto in a browser console
Open developer tools on this HTTPS guide and run the snippet in the Console. Read it before pasting: it uses the browser’s Web Crypto API, writes results to the console and makes no network requests.
const serverSeed = "d4e3a89c1b72e50f34a9128c70123456789abcdef0123456789abcdef0123456";
const clientSeed = "melbourne-punters-2026";
const commitment = "c3549b8ea5a0dc3f6fbb70b8bb58b26b280e4439341ee08efb4c7ddb7acfd88a";
const nonce = 42, rows = 16;
// Payout input for this teaching example; replace with the recorded table.
const examplePaytable = [1000, 130, 26, 9, 4, 2, .2, .2, .2, .2, .2, 2, 4, 9, 26, 130, 1000];
const enc = new TextEncoder();
const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", enc.encode(serverSeed)));
const hex = Array.from(digest, b => b.toString(16).padStart(2, "0")).join("");
console.log("Commitment matches:", hex === commitment);
const key = await crypto.subtle.importKey(
"raw", enc.encode(serverSeed), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]
);
const path = [];
for (let block = 0; path.length < rows; block++) {
const message = `${clientSeed}:${nonce}:${block}`;
const bytes = await crypto.subtle.sign("HMAC", key, enc.encode(message));
const view = new DataView(bytes);
for (let offset = 0; offset < 32 && path.length < rows; offset += 4) {
const value = view.getUint32(offset, false) / 2 ** 32;
path.push(value >= 0.5 ? "R" : "L");
}
}
const pocket = path.filter(d => d === "R").length;
console.log("Path:", path.join("-"));
console.log("Pocket:", pocket);
console.log("Example multiplier:", examplePaytable[pocket]);
Each script prints a matching commitment, the 16-direction path shown above, pocket 8 and example multiplier 0.2. The interactive checker follows the same path algorithm and adds bucket probabilities; it leaves the payout comparison to your saved record.
Diagnosing a failed check
| What differs? | Check first | Evidence to retain |
|---|---|---|
| Server seed hash | Correct retired seed pair; seed letter case; leading/trailing whitespace; UTF-8 text rather than decoded hex bytes. Do not silently trim or alter the seed to force a match. | Original commitment and the exact revealed seed. |
| Path or pocket, with a matching hash | Round’s client seed and nonce; correct game; all required HMAC blocks. Reusing block 0 for bounces 9–16 gives an incorrect path. | Bet ID, inputs, both digests and reproduced path. |
| Pocket matches but payout differs | Saved rows and risk setting; pocket numbering from 0 versus 1; total return versus net profit; currency precision and documented rounding. | Payout strip, stake, credited amount and game rules. |
Typing an old seed into a verifier is legitimate: it replays history. Changing an active client seed is a separate action affecting later bets. If a mismatch persists after these checks, keep the original records, stop adding funds and ask support to explain that specific discrepancy. Our withdrawal dispute guide explains how to organise evidence when the issue is payment.
Limits of verification and the Australian context
A matching commitment and result establish consistency with the disclosed calculation. They do not audit the server’s entropy generation, establish the payout table’s expected return or prove the operator can pay withdrawals. For expected-return calculations, use the complete table and probabilities in our RTP and volatility guide.
The Interactive Gambling Act 2001 prohibits providers from offering online casino services to people in Australia. A provably fair label does not change that status. ACMA reports complaints about illegal operators accepting deposits and then withholding winnings, and warns that Australian regulators cannot recover those winnings for customers. Our Australian Plinko legality guide covers the local rules; responsible gambling support covers limits and help. You can practise the calculation here without opening an account or depositing money.