On this page

Provably Fair Plinko: How Cryptographic Verification Works

Source code displayed on a computer screen
The worked example exposes both HMAC blocks so each bounce can be checked against the code.

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

  1. 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.
  2. 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.
  3. 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.
  4. Compare the commitment. Calculate SHA-256 of the exact revealed seed text. Its 64-character hexadecimal digest must match your original record.
  5. 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.

Inputs for the worked example
InputExact value
Revealed server seedd4e3a89c1b72e50f34a9128c70123456789abcdef0123456789abcdef0123456
Client seedmelbourne-punters-2026
Nonce42
SHA-256 commitmentc3549b8ea5a0dc3f6fbb70b8bb58b26b280e4439341ee08efb4c7ddb7acfd88a
Rows / initial byte cursor16 / 0
Example payout strip, pockets 0–161000, 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.

Computed decisions; floats rounded for display only
BounceBlockFour bytes (hex)FloatDirection
10edd3f2490.9290152958R
20625f91620.3842707505L
3057b640980.3426246997L
401e9726ef0.1194938978L
508e9d885c0.5570912575R
60c175a7f00.7557015382R
703c77cca20.2362029930L
80246a0bc70.1422431336L
91fd863cc10.9903295489R
1015d63ded60.3648051522L
111b3a45c0c0.7017266778R
121d2a909dd0.8228918232R
131eb2ef29c0.9186851149R
141b83ac35d0.7196466543R
151485326bc0.2825187882L
1614462f24d0.2671348036L

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 firstEvidence to retain
Server seed hashCorrect 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 hashRound’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 differsSaved 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.

Stake-method Plinko hash and path checker

Reproduce a recorded drop using a revealed server seed, its original commitment, the round's client seed, nonce and rows. The calculation runs in your browser. It checks the hash and landing path; compare the payout with the multiplier row saved for that bet.

Sample seed text is prefilled. Supply a recorded commitment to check a real round.

Calculated server seed hash
—
Commitment comparison
—
Path (L = left, R = right)
—
Bucket index (0 = left edge)
—
Probability of this bucket
—
HMAC blocks used
—

A hash match checks the saved commitment. You still need to compare the reproduced bucket with the recorded result. No data is sent to Stake.

Bucket probabilities

Landing probabilities depend on rows. Difficulty changes the payouts assigned to these positions.

BucketProbabilityApproximate frequency

Frequently asked questions

Can I check an old round if I did not save its pre-bet hash?

You can reproduce the result from revealed seeds and the nonce, but a hash supplied only afterwards cannot establish what was committed before play. An independently preserved pre-bet record is needed for that comparison.

Does changing from AUD to cryptocurrency change the seed calculation?

The published Stake HMAC message contains the client seed, nonce and block number; currency is not part of that message. Currency still matters when you reconcile the stake, credited payout and rounding in the bet record.

Can I use this checker on a phone?

Yes, in a browser that supports Web Crypto over HTTPS. Use the form rather than the console snippet. If Web Crypto is unavailable, the checker shows an error instead of calculating a result.

Are SHA-256 and SHA-512 interchangeable in a verifier?

No. SHA-256 outputs 32 bytes and SHA-512 outputs 64 bytes. HMAC also needs the specified key and message format. Substituting a different hash, changing delimiters or switching between text and decoded bytes changes the output; a longer digest does not make an incompatible verifier valid.

Do you need my login details to verify a round?

No. Our checker uses the seeds, commitment, nonce and rows entered in the form. Its calculation runs locally and does not request your casino password, wallet recovery phrase or payment details. Keep account identifiers out of any records you share publicly.