
Provably fair, explained: how to verify a Stake bet yourself
Provably fair is the one casino promise you can test yourself. We read all six of Stake’s fairness pages, took the published code apart and ran one Dice bet through Stake’s own calculator with seeds you can copy. What the proof covers, what it leaves out, and how to check a bet in five minutes.
What provably fair means
A commitment scheme, in one paragraph
A provably fair casino does not ask you to trust its random number generator; it lets you recompute each result. Stake’s overview page puts it in one line: fair result = operator’s input (hashed) + player’s input. Before you bet, Stake generates a secret server seed and shows you its SHA-256 hash, which commits Stake to the seed without revealing it. You supply a client seed. A nonce counts your bets, so each bet is a different input to the same pair. When Stake later reveals the server seed, you check that it hashes to the fingerprint and recompute any bet. Cryptographers call this a commitment scheme; the hash is the sealed envelope.
Why it is narrower than it sounds
The provably fair meaning is precise: each outcome was fixed by the seeds and the nonce before you bet, with your input included, and was not altered afterwards. It says nothing about the paytable, about whether the operator pays, or about third-party slots. Stake lists a community verifier (provablyfair.me) on the overview page and is a verified operator on the Crypto Gambling Foundation network; both re-run the same arithmetic, which we walk through below with one bet verified in Stake’s own calculator.
The provably fair algorithm Stake publishes
From seeds to bytes: HMAC-SHA256
Stake’s implementation page gives the function in full. Four inputs go in: the server seed (a random 64-character hex string), the client seed, the nonce and a cursor. The function computes HMAC-SHA256 with the server seed as the key and the text client seed:nonce:cursor as the message, producing 32 bytes. Each result uses 4 bytes, so one round supplies eight; the cursor rises only when a game needs more (Plinko and Keno two rounds, Mines and Chicken three, Video Poker seven, Blackjack and Hilo as many as the hand requires).
From bytes to a float, then to a game event
The conversions page turns four bytes into a number between 0 and 1: byte one divided by 256, plus byte two divided by 256², plus byte three divided by 256³, plus byte four divided by 256⁴. The float is multiplied by the number of possible outcomes and read as the event. Where outcomes cannot repeat (Keno, Mines, Pump, Chicken, Video Poker) the pool shrinks by one per draw, a Fisher–Yates shuffle. The game-events page gives each rule; the edge is visible in it (Limbo’s code multiplies by 0.99).
| Original | Floats per bet | Rule on stake.com/provably-fair/game-events |
|---|---|---|
| Dice | 1 | float × 10,001 / 100, a roll 00.00–100.00 |
| Limbo | 1 | 0.99 / float, floored to two decimals, minimum 1.00× |
| Plinko | 8–16 | floor(float × 2): 0 left, 1 right, one per row |
| Mines | up to 24 | float × tiles remaining, grid read left to right |
| Keno | 10 | floor(float × 40), then 39, 38… no repeats |
| Roulette | 1 | floor(float × 37): European wheel, 0–36 |
| Blackjack, Hilo, Baccarat | per card | floor(float × 52), ♦2 to ♣A |
| Chicken | up to 20 | float × rounds remaining, Fisher–Yates |
| Crash, Slide | chain | Separate salted hash chain (see limits) |
How to verify provably fair bets on Stake, step by step
In the Stake fairness panel
Every Original has a Fairness control beside the bet panel; the modal has three tabs, Overview, Seeds and Verify.
- Set your client seed first. Seeds tab: type a seed of your own before the first bet. Your browser generated one at registration; Stake’s implementation page “highly recommends” replacing it with an input the operator did not choose.
- Copy the hashed server seed. Same tab: the hash of the active server seed is the commitment. Save it with the client seed and the nonce.
- Play and note the nonce. Each bet adds one; the bet details in your history show it.
- Rotate the seed pair. In Seeds, enter a new client seed and rotate. Stake reveals the previous server seed in plain text and starts a new pair; rotation is the only way to see a server seed.
- Check the commitment. Run SHA-256 on the revealed seed in any hashing tool; the output must equal the hash from step 2.
- Recompute the bet. Verify tab or stake.com/provably-fair/calculation: choose the game, paste client seed, server seed and nonce. The result must match your bet history. One rotation covers every bet since the previous one.
Doing it without Stake’s tools
The Stake provably fair pages publish the code, so a ten-line Python or Node script reproduces the calculator: HMAC-SHA256, four bytes to a float, the float through the game rule. Third-party verifiers do the same; the maths is not Stake’s to run.
Claim the deal with code PACTBONUS
A worked example: one Dice roll, verified
The inputs
We generated our own 64-character hex server seed, used the client seed pactbonus and nonce 1, and put the three into Stake’s calculator with Dice selected.
| Input | Value |
|---|---|
| Server seed | 5796333f82905801e4389af02d9e9b9b96fb5e4beb51174a8d77707bd073362a |
| SHA-256 of the server seed (the hash shown before betting) | 9498260da15d2ef542131cff2006c16b25564f69b44ef145ac391436cc6254eb |
| Client seed | pactbonus |
| Nonce | 1 (cursor 0: Dice uses one round) |
The arithmetic, as the calculator shows it
HMAC-SHA256 with the server seed as key and pactbonus:1:0 as message starts 61 82 a0 81 in hex: 97, 130, 160, 129 in decimal. The float is 97/256 + 130/65,536 + 160/16,777,216 + 129/4,294,967,296 = 0.380899459356. Times 10,001 that is 3,809.375; the calculator shows the whole number 3,809 on a 0 to 10,000 scale and the final result 38.09. The game-events page writes the rule as float × 10,001 / 100; the calculator makes the floor explicit. A bet on under 50.00 (win chance 50%, payout 99 / 50 = 1.98×) wins with this roll.
The same float gives 2.59× in Limbo and a first bounce left in Plinko. Nonce 1 went through Stake’s calculator, nonces 2 to 5 through our own script with the published code.
| Nonce | First four bytes | Float | Dice roll |
|---|---|---|---|
| 1 | 97, 130, 160, 129 | 0.38089946 | 38.09 (Stake calculator) |
| 2 | 240, 234, 112, 224 | 0.94107728 | 94.11 |
| 3 | 150, 87, 93, 244 | 0.58727061 | 58.73 |
| 4 | 22, 140, 254, 137 | 0.08808890 | 8.80 |
| 5 | 86, 106, 60, 231 | 0.33755856 | 33.75 |
What provably fair proves, and what it does not
Three things it proves
The outcome was fixed before you bet: the server seed was committed by its hash, and SHA-256 cannot be run backwards or steered to a chosen output. Your input counted: change one character of the client seed and every result in the pair changes. Nothing was altered afterwards: a result that does not recompute from the revealed seed, your seed and the nonce is proof of tampering.
Three things it does not
It does not prove the RTP. The return is a parameter inside the game rule, the 0.99 in Limbo’s code or the 99 / chance payout in Dice, confirmed by reading the rule and over many bets. It does not prove you will be paid: that depends on the licence, the terms and the KYC process, covered in is Stake safe and Stake verification. And it stops at the Originals: a Pragmatic Play slot or an Evolution table on Stake runs on the studio’s own RNG. See the games and Originals review.
Limitations and the attack surface
Where the scheme can be weakened
The commitment protects you only if the order is right: hash first, your client seed second, bets third. If you never set a client seed, the operator knows both inputs when the pair is created and could in theory try server seeds until one suits it before committing. Setting your own seed after the hash is shown closes that door: no seed can be chosen against an input that does not exist yet. Likewise, a server seed hash that appears after the bet, or a nonce that jumps, is a red flag.
Games outside the model
Crash and Slide do not use the seed pair. The game-events page points to a BitcoinTalk seeding thread for their salted hash chain: hashes generated in advance, each round’s hash the SHA-256 of the next, with a public salt chosen after publication mixed in to produce the multiplier. You verify a round from its hash and the salt; our Crash guide goes through it. Third-party slots and live tables are not provably fair in any sense; their RNGs are tested by independent laboratories (eCOGRA, a UK lab founded in 2003, lists RNG and RTP testing among its services; GLI, iTech Labs and BMM do the same).
Implementation is the spec
A provably fair system is only as fair as its published code, which is why independent verifiers reimplement it. Read the rule for the game you play: Plinko is a chain of coin flips, Chicken a shuffle of 20 positions, and the paytable, not the proof, decides what each costs.
Stake RTP by game: what the proof leaves to arithmetic
Published returns on the Originals
Stake RTP figures sit in each game’s information panel. The proof fixes the result; the paytable fixes the return.
| Game | Published RTP | Where the edge sits |
|---|---|---|
| Dice | 99% | Payout = 99 / win chance, not 100 |
| Limbo | 99% | The 0.99 factor in the formula |
| Plinko | 99% | Multiplier rows summing to 99% |
| Mines | 99% | Cash-out multipliers 1% under true odds |
| Crash | 99% | 1% edge in the crash-point formula |
| Chicken | 98% | Every multiplier = 0.98 / survival probability |
| Blackjack (Original) | Higher with basic strategy | Your decisions set the edge |
| Third-party slots | The studio’s figure | Check the game info |
What the code changes and what it does not
Nothing about fairness changes with a bonus code. Register with PACTBONUS and the deal adds 200% to a first deposit of $50 or more, up to $1,000, plus rakeback of 3.5% of the house edge on every casino bet for life: $100 of Dice turnover carries $1 of edge, so the rakeback is 3.5 cents (VIP and rakeback). Seeds, hash and the 99% are identical with or without the code.
The provably fair calculator: inputs and outputs
Stake’s calculator page
stake.com/provably-fair/calculation takes four inputs and, until all are filled, says the result needs more inputs. It accepts any seeds, which is how we produced the example above.
| Field | What to enter | Where it comes from |
|---|---|---|
| Game | One of about thirty Originals, Baccarat to Zoo | The game you played |
| Client seed | The seed active during the bet | Seeds tab, or your saved copy |
| Server seed | The revealed, unhashed seed | Seeds tab after rotation, or the unhash page |
| Nonce | The bet’s counter, with a stepper | Bet details in your history |
The page then shows the final result (a Dice roll such as 38.09, a Plinko path), the HMAC-SHA256 call with all 32 bytes in hex and decimal, and the bytes-to-number arithmetic. The companion unhash page has one field: paste a hashed server seed and, once that seed has been rotated, it returns the plain seed.
Fair does not mean beatable
Verifying a bet confirms the roll was honest; it does not change the next one. Every roll is independent, and no client seed, rotation habit or betting pattern moves a 99% game above 100%. Set deposit and loss limits in Stake Smart before you play, and stop if play stops being play. Stake does not serve Ontario and is an offshore operator elsewhere in Canada. 18+. Help and limits: responsible gambling.
Common questions
What does provably fair mean?
That you can recompute a casino result yourself. The operator commits to a secret server seed by publishing its SHA-256 hash before you bet, you add a client seed, a nonce counts your bets, and HMAC-SHA256 of those inputs produces the outcome. After the server seed is revealed you check the hash and redo the arithmetic.
Is Stake provably fair?
Stake Originals are: Dice, Limbo, Plinko, Mines, Keno, Chicken, the table Originals and the rest of the in-house catalogue use the published seed-pair algorithm, and Crash and Slide use a published hash chain. Third-party slots and live tables on Stake are not provably fair; they run on the studio’s certified RNG.
Is provably fair really fair?
It is honest in a narrow, testable sense: the result was fixed before your bet and not changed after. It is not generous. The house edge is written into the game rule, 1% on Dice and Limbo for example, and the proof shows you exactly where it sits rather than removing it.
How do I verify a Stake bet?
Set your own client seed, copy the hashed server seed and the nonce, play, then rotate the seed pair so Stake reveals the server seed. Check that SHA-256 of the revealed seed equals the hash, then enter game, client seed, server seed and nonce in the Verify tab or at stake.com/provably-fair/calculation and compare the result with your bet history.
Does provably fair prove the RTP?
No. RTP is a parameter in the game rule and the paytable, published by Stake (99% on Dice, Limbo, Plinko, Mines and Crash, 98% on Chicken). Verification proves a single result was not manipulated; the return you check by reading the rule and over many bets.
Are Stake slots provably fair?
No. Slots from Pragmatic Play, Hacksaw or any other studio, and Evolution’s live tables, use the studio’s random number generator, tested by laboratories such as eCOGRA, GLI, iTech Labs or BMM. Only Stake Originals can be verified from seeds.
Can I use the seeds to predict the next result?
No. The server seed stays secret until you rotate it, and rotating it starts a new pair, so the seed you can see never produces a result you have not already bet on. Predictor apps that claim otherwise are random-number toys or phishing. 18+; if play stops being play, our responsible gambling page lists limits and help lines.
Sources: stake.com/provably-fair/overview, /implementation, /conversions, /game-events, /calculation and /server-seed-unhash (read 2026-10-05; the calculator run with our test seeds, Dice, nonce 1, result 38.09; nonces 2 to 5 from our own script using the published code); ecogra.org (RNG and RTP testing services, 2026-10-05); Stake game information panels for the published RTPs (2026-10-05).
