For the DeFi casino guide (on-chain smart contract gambling and DeFi casino mechanics), see DeFi casino guide.
For the Crash game strategy guide (auto-cashout, bankroll, and provably fair Crash), see Crash game strategy guide.
For the full provably fair games guide (how crash, dice, limbo, mines, plinko verification works), see provably fair games guide. For the multiplier games guide (crash, plinko, limbo, wheel — RTP comparison), see multiplier games guide.
Provably fair is a cryptographic system used by crypto casinos for certain game types — crash, dice, plinko, limbo, and other in-house games — that allows players to independently verify that a game outcome was determined fairly before bets were placed. Unlike traditional casino RNG (where you trust a third-party audit), provably fair lets you verify outcomes yourself using publicly available cryptographic tools. This guide explains how the system works, how to verify a result, what it proves, and its limitations.
How Provably Fair Works — The Hash Chain Explained
The core problem it solves: In a traditional casino, you trust that the RNG produces fair outcomes because a testing lab (eCOGRA, iTechLabs) audited the software. You cannot verify individual game results. A dishonest operator could deploy a modified RNG after the audit. Provably fair uses cryptography to make this tampering impossible to hide — the outcome is committed to by the operator before bets are placed, and revealed in a verifiable way after the round ends.
Server seed: Before a game session starts, the operator generates a random server seed — a long string of random characters. The operator does not reveal this seed to the player until after all related rounds are complete. Instead, the operator publishes the cryptographic hash of the server seed (a one-way function: hash = SHA-256(server seed)). Because hash functions are one-way, knowing the hash does not let you calculate the server seed — but you can verify that the seed matches the hash after it is revealed.
Client seed: The player (or the browser, automatically) generates a client seed. This seed is known to the player before the round starts. Both the server seed hash and the client seed are combined to determine the game outcome. The player can change their client seed at any time — changing it rotates the server seed (the old server seed is revealed, a new one is generated and its hash published).
Nonce: Each round uses a nonce (a sequential number incremented with each round). The outcome of round N is determined by: HMAC-SHA256(server_seed, client_seed + ":" + nonce). Because the nonce increments, each round produces a different outcome even with the same seeds.
Why this proves fairness: The server seed was committed to (via hash) before the player's bet was placed. The player sees the hash before betting. The operator cannot know the client seed when generating the server seed (generated before the session). Therefore: the operator cannot manipulate the outcome for a specific round — the outcome is already determined by the server seed at the time the hash is published, and the operator cannot retroactively change the server seed without the mismatch being detected via the hash.
How to Verify a Provably Fair Result — Step by Step
Step 1 — Find the verification data: In your game history or bet history on the casino, find the specific round you want to verify. The casino should provide: server seed (revealed after the round), client seed, nonce, and the hash of the server seed from before the round. Some casinos provide a verification tool in-platform; others require you to verify externally.
Step 2 — Verify the server seed hash: Confirm that SHA-256(server_seed) = the hash that was published before the round. Use any SHA-256 tool (online or command line: echo -n "server_seed" | sha256sum). If the hash matches: the server seed is authentic — it was set before the round started.
Step 3 — Calculate the outcome: Compute HMAC-SHA256(server_seed, client_seed + ":" + nonce). The result is a hex string. Convert specific bytes of this hex to a number and apply the game's outcome formula. For crash games: the formula is documented in the casino's provably fair documentation — typically involves the hex value modulo a range to determine the crash multiplier. Each casino publishes its specific formula in its provably fair documentation.
Step 4 — Compare to the actual result: If your calculated outcome matches the actual round result: the round was provably fair. If it doesn't match: either the seeds provided are incorrect, or the outcome was manipulated. In practice, mismatches are extremely rare at established operators — the system makes manipulation detectable by any player.
Tools available: Most major crypto casinos (BC.Game, Stake, Duelbits) provide an in-platform verification tool where you enter the seeds and nonce and it calculates the expected result automatically. Third-party tools: dicesites.com/verify, csfair.net. Command-line: openssl or Python hashlib for HMAC-SHA256 if you prefer to verify independently without any web tool.
What Provably Fair Proves and What It Does Not
What it proves: (1) The outcome was determined before bets were placed (the hash commitment proves this). (2) The outcome was not changed after bets were placed (any change to the server seed would produce a different hash — detectable immediately). (3) The stated game formula was applied to the seeds to produce the result. These three things are proven cryptographically — no trust in the operator is required for this specific claim.
What it does NOT prove: (1) That the house edge is what the operator claims — a crash game could be provably fair with a 5% house edge while claiming 1%. Provably fair proves outcome integrity, not house edge calibration. Verify house edge via the formula documentation: the crash multiplier distribution should produce the claimed long-run RTP. (2) That the server seed generation is truly random — if the operator generates server seeds predictably (not cryptographically random), an insider could predict outcomes. In practice this requires the operator to be actively malicious. (3) That game types outside the provably fair system (slots, live dealer) are fair — provably fair only applies to the specific in-house games that use it, not to third-party slot content.
Game types with provably fair support: Crash, dice, plinko, limbo, mines, hilo, keno (in-house versions), roulette (in-house RNG only — not live dealer). Third-party slots, live dealer games (blackjack, baccarat, roulette via Evolution): these use provider RNG or physical randomness — not provably fair. See the crash game guide and dice game guide for the specific provably fair implementations at major operators.
Practical implication for high-limit players: For large-stakes play on crash, dice, or plinko: provably fair verification is meaningful — you can audit any outcome independently. For slots and live dealer at high stakes: you rely on provider reputation and operator trust score. This is why the crash vs slots comparison and Trust Score are relevant for high-limit game selection decisions.
Our Current #1 for High Rollers
CocoBet — Trust Score 9.6/10.
500 free spins advertised for qualifying new players; current bonus terms should be checked before depositing.
Read the full CocoBet review or
visit CocoBet.
Frequently Asked Questions
What does provably fair mean at a crypto casino?
Provably fair is a cryptographic system that allows players to verify that a game outcome was determined before bets were placed and was not manipulated. The operator commits to a server seed via a cryptographic hash before the round; after the round, the server seed is revealed and players can verify the hash matches (proving it wasn't changed). The outcome formula is then applied to the server seed, client seed, and nonce to independently reproduce the result. Any player can verify any round — no trust in the operator is required for this specific claim.
How do I verify a provably fair result?
Find the round in your game history (server seed, client seed, nonce, and pre-round server seed hash). Verify SHA-256(server_seed) = published hash. Then compute HMAC-SHA256(server_seed, client_seed + ':' + nonce) using the casino's published formula and compare to the actual result. Most major casinos provide an in-platform verification tool. Third-party tools: dicesites.com/verify, or command-line OpenSSL/Python. If the calculated result matches the actual result: the round was provably fair.
Do all games at crypto casinos have provably fair?
No — provably fair applies to in-house game types: crash, dice, plinko, limbo, mines, hilo. Third-party slot games (Pragmatic Play, Hacksaw, NetEnt) use provider-certified RNG — not provably fair. Live dealer games (blackjack, baccarat, roulette via Evolution Gaming) use physical randomness (real wheel, real cards) — also not provably fair. Provably fair is specifically for in-house RNG-based crypto-native games.