Kaia Thompson
Crypto & Payments Writer · Reviewed 2026-08-11
Kaia writes about crypto casinos, no-KYC play and NZ payment rails. She has held crypto since 2017 and verifies withdrawal times and provably-fair tooling hands-on.
What "provably fair" actually means
A provably fair game is one where you can mathematically prove, after the fact, that the result was decided before you bet and wasn't tampered with. In a traditional online casino you simply trust that the random number generator is honest and that an auditor checked it. Provably fair replaces that trust with proof: the casino commits to a hidden random value before your bet, and once the round is over you can reveal that value and confirm the outcome was generated from it — not chosen afterwards to make you lose. It only works with cryptography, which is why you find it at crypto casinos and essentially nowhere else.
Provably fair vs a normal RNG
The difference is who you have to trust. A conventional casino uses a certified RNG (random number generator) that a testing lab audits to be statistically random overall. That's a real check — but it's a check on the system, done by a third party, that you can't repeat yourself. Provably fair is a check on the individual result, that you can repeat, every single bet. Both have their place: RNG certification covers third-party pokies where the maths is too complex to expose; provably fair covers the simple in-house games where each outcome comes from one random draw.
Server seed, client seed and nonce
Three ingredients produce every provably fair result:
- Server seed — a long random string the casino generates and keeps secret during play. Before you bet, the casino shows you a hash of it (a SHA-256 fingerprint). You can't reverse the hash to learn the seed, but the casino also can't change the seed later without the hash no longer matching — that's the commitment.
- Client seed — a string that comes from you (your browser generates one, and you can usually edit it). Because the outcome depends on your input, the casino can't have pre-computed a losing result: it doesn't know your client seed when it commits the server-seed hash.
- Nonce — a counter that increases by one with each bet (0, 1, 2, …), so the same pair of seeds produces a different result on every round without needing a new server seed each time. Some platforms add a cursor — a byte offset into the output — for games that need more than one random draw per round.
The maths: HMAC-SHA256 and the commit–reveal model
Here's what actually happens under the hood, stated accurately. Modern provably-fair games use
HMAC-SHA256, a keyed hash. The raw server seed is the key, and your client seed, the
nonce and (where used) the cursor are the message, joined in a fixed format — typically
HMAC_SHA256(server_seed, "client_seed:nonce:cursor"). That produces a 256-bit digest, a stream
of bytes. The game converts those bytes into an outcome: successive bytes are read as a base-256 fraction to
make a number in the range [0,1), and rejection sampling or modulo is used to map it fairly onto the game
(a dice roll, a crash multiplier, a shuffled deck).
The security comes from the commit–reveal ordering. Before you bet, the casino publishes only the SHA-256 hash of the server seed — that's the commitment. It can't change the seed afterwards, because the revealed seed would no longer hash to the value it already showed you. And it can't have rigged the result in advance, because your client seed (which it didn't know at commit time) feeds into every outcome. Older or simpler explainers describe plain concatenation and a single SHA-256 hash instead of HMAC; HMAC is the accurate current standard, but the verification logic is the same either way.
How to verify a bet result, step by step
Here's the actual check. It takes a couple of minutes and needs no special software:
- Before you play, open the game's "Fairness" or "Provably Fair" panel and copy the hashed server seed the casino shows you. Save it — if you don't keep this pre-bet hash, you can't later prove the seed was committed in advance. Note your client seed too (change it to something of your own if you want extra assurance).
- Play your rounds. The nonce ticks up by one each bet — note the nonce of the bet you want to check, plus any game settings (mine count, Plinko rows and risk, and so on).
- Rotate/reveal the seed. When you're done with that seed pair, click "rotate seed" (or similar). The casino now reveals the unhashed server seed it committed to earlier, and issues a fresh committed seed for future bets.
- Confirm the commitment. Paste the revealed server seed into any SHA-256 hashing tool and check the output equals the hash you copied in step 1. If it matches, the casino could not have changed the seed after you bet.
- Reproduce the outcome. Feed the revealed server seed, your client seed and the nonce into the casino's own verifier or an independent third-party verifier — or run the HMAC yourself — and confirm it reproduces the exact result you got. Match confirmed: the bet was fair.
The key insight is the ordering. The casino commits to the server seed (via its hash) before seeing your bet, and your client seed feeds into the result, so neither side can rig an individual round after the fact.
Tools you can use to verify
- The casino's own verifier — every provably-fair site provides one, pre-filled with your seeds and nonce. Convenient, but it's the same party you're checking, so it's the weaker proof.
- An independent browser verifier — third-party tools reproduce the commitment check and the HMAC for standard dice/crash/mines logic. Stronger evidence because it's not the operator's code.
- The command line — for the technically inclined, a one-liner reproduces the HMAC:
printf '%s' 'client_seed:nonce' | openssl dgst -sha256 -hmac 'server_seed'. A SHA-256 tool then confirms the commitment.
How specific games derive the result
The seeds and HMAC are the same; what differs is how each game turns the byte stream into an outcome:
| Game | How the outcome is derived |
|---|---|
| Dice | Bytes → a bounded number, e.g. 0.00–99.99, compared to your target |
| Crash / Limbo | A ~52-bit value → a multiplier, with an edge factor and instant-bust logic |
| Mines | A deterministic Fisher–Yates shuffle of tiles driven by the byte stream and cursor |
| Plinko | A sequence of left/right decisions (needs the rows and risk settings) |
| Blackjack / video poker | Deterministic reconstruction of the shuffled deck or shoe |
This is why you must record the game settings, not just the seeds — feed a Plinko verifier the wrong row count and it won't reproduce your result even though nothing was rigged.
Why a verification check sometimes fails
If your check doesn't match, the cause is almost always your inputs, not a dishonest casino. The usual culprits:
- Using the hashed server seed as the HMAC key instead of the raw revealed seed.
- Off-by-one on the nonce (0-indexed vs 1-indexed).
- Text-vs-hex encoding confusion, or the wrong separator between fields.
- Missing or wrong game settings (mine count, rows, risk).
- Display rounding — the shown result is rounded, the raw value isn't.
Work through those before concluding anything. A genuine mismatch on a correctly reproduced round would be extraordinary — and grounds to stop playing there immediately.
Which games support it
Provably fair suits games where a single random draw decides the result: dice, crash, plinko, mines, limbo and coin flip are the classic in-house provably fair titles. Standard third-party pokies from studios like Pragmatic or NetEnt generally are not provably fair — they use certified RNGs audited by labs like eCOGRA instead. Slots are hard to make provably fair because their mechanics are complex, and sports betting can't be (the outcomes are real-world events, not RNG). So a crypto casino typically offers a mix: verifiable in-house "originals" plus conventional certified pokies.
What provably fair does NOT prove
Provably fair vs RNG and RTP
These answer different questions, so don't conflate them. Provably fair proves a specific result wasn't tampered with. A certified RNG is audited to be statistically random overall, but you can't check any individual spin yourself — you trust the auditor. RTP (return to player) is a long-run average payout percentage; it says nothing about whether one result was honest. Provably fair is the only one of the three you can verify personally, bet by bet — which is exactly why it matters.
Best provably-fair crypto casinos NZ
The crypto casinos we rank for New Zealand players all offer provably fair originals with an on-site verifier. Compare them on the crypto casinos pillar, or start with our Bitcoin casinos and no-KYC picks. To fund an account, see how to buy Bitcoin in NZ.
Provably fair FAQ
What does provably fair mean?
It's a cryptographic system that lets you prove a bet's result was decided before you bet and wasn't tampered with, using a server seed, your client seed and a nonce combined with HMAC-SHA256.
Is provably fair the same as RNG?
No. A certified RNG is audited by a lab and you trust that audit. Provably fair lets you verify each individual result yourself, bet by bet.
How do I verify a provably fair bet?
Copy the hashed server seed before playing, note the nonce and game settings, then rotate the seed to reveal it. Hash the revealed seed to confirm it matches, and feed the seeds and nonce into a verifier to reproduce the result.
What is a server seed and client seed?
The server seed is a secret random string the casino commits to via a hash before you bet. The client seed comes from you, so the casino can't pre-compute a losing outcome.
What is a nonce?
A counter that increases by one each bet, so the same pair of seeds produces a fresh result every round without needing a new server seed each time.
Why doesn't my verification check match?
Almost always an input error: using the hashed seed instead of the raw seed as the HMAC key, an off-by-one nonce, text/hex confusion, wrong game settings, or display rounding — not a rigged casino.
Can provably fair results be predicted?
No. You can't reverse the server-seed hash to learn the seed, and the result also depends on your client seed and the nonce.
Does provably fair mean the game has no house edge?
No — that's the biggest misconception. It proves one result was fair, not that the RTP is 100%. The house edge is baked into the game's payout maths, and provably fair doesn't remove it.
Are pokies provably fair?
Usually not. In-house games like dice, crash and plinko are provably fair; third-party pokies use certified RNGs audited by labs like eCOGRA instead.
Is provably fair the same as RTP?
No. RTP is a long-run average payout percentage. Provably fair proves a specific result wasn't tampered with — it's the only one you can verify yourself.