Provably fair is a way to check that a casino result follows previously committed inputs and a published calculation. In a common design, the casino publishes a hash of a secret server seed before play, combines that seed with player input and a round counter, then reveals the secret later so you can reproduce the result.
A successful check establishes consistency with that recorded process. It does not, by itself, establish that the inputs were chosen without bias, that the payout is favourable or that the casino will honour a withdrawal. Those are separate questions.
How does provably fair verification work?
Provably fair verification connects a commitment made before play with information disclosed afterward. The commitment is usually a cryptographic hash: a fixed-length output calculated from an input such as a secret seed.
A seed is a value used to generate results. A hash lets the casino publish a commitment to its server seed without publishing the seed itself. After the seed is revealed, anyone can calculate its hash and compare it with the earlier commitment.
NIST’s Secure Hash Standard specifies hash functions including SHA-256. Their security properties are designed to make recovering an unknown input from its hash, or finding a different input that matches a given hash, computationally impractical. That protection assumes an appropriate implementation and a sufficiently unpredictable secret.
There are two distinct checks:
- Hash the revealed seed and compare it with the commitment recorded before play.
- Run the disclosed inputs through the game’s published algorithm and compare the calculated result with the recorded outcome.
| Verification check | What a match supports | What it does not establish |
|---|---|---|
| Revealed seed matches its earlier hash | The revealed seed is consistent with the recorded commitment | The seed was selected without searching for favourable outcomes |
| Published formula reproduces the round | The recorded outcome follows those inputs and that formula | The formula offers favourable payouts |
| Calculated payout matches the rules | Settlement follows the stated paytable for that outcome | The account balance will be withdrawable |
These checks address different parts of a round. A complete record needs the commitment, calculation inputs, result and applicable rules.
“Provably” therefore refers to a checkable claim with defined assumptions. It should not be read as a certification of every activity at the casino. A useful fairness page identifies precisely what can be checked and supplies enough information to repeat the calculation independently.
What do server seeds, client seeds and nonces do?
A common design combines a secret server seed, a client seed and a nonce, but the exact inputs depend on the game. The nonce is a counter or identifier that distinguishes rounds using the same seed pair.
The server seed remains secret while it is active. The client seed is player-side input; depending on the interface, it may be generated automatically or editable. Its protective role depends on how and when it is chosen, not merely on its name.
| Input | Function | Detail to preserve |
|---|---|---|
| Server-seed commitment | Commits the casino to a secret before play | Exact hash and when it was supplied |
| Revealed server seed | Allows the commitment and results to be checked | Exact characters and required encoding |
| Client seed | Adds player-side input to the result calculation | Value used for the specific round |
| Nonce | Distinguishes rounds under a seed pair | Recorded value, including whether counting starts at zero |
| Cursor or additional counter | Selects further output when a game needs it | Position and increment rules |
| Game configuration | Determines how generated values become outcomes and payouts | Relevant settings and algorithm version |
The order matters. Suppose a casino knows a fixed client seed before choosing its server seed. It could calculate outcomes for many candidate server seeds and select one. Publishing the chosen seed’s hash afterward would not reveal that selection process.
A fresh, unpredictable client seed chosen after the server commitment can restrict that particular opportunity. It does not stop the casino from calculating results once it knows all the inputs, and it does not prevent every form of misconduct.
A memorable phrase can function as input, but it should not be treated as strong randomness merely because you typed it yourself. Likewise, changing seeds after a losing sequence does not make the next outcome more likely to win.
For the seed pair you intend to use, check:
- Whether the server commitment appears before you choose or confirm your client seed.
- Whether changing the client seed also changes the server commitment.
- Whether the platform records the actual nonce for each bet.
- Whether the old server seed becomes available after rotation.
How do you verify a provably fair bet?
Verify a bet by preserving its pre-bet commitment, obtaining the later seed reveal and reproducing the result with the correct algorithm. You may be able to practise using a published sample round without placing a new wager.
- Find the game-specific documentation. Identify the commitment hash, result-generation function, required inputs and payout rules. A platform-wide fairness badge is insufficient if it does not explain the game being checked.
- Save the commitment before play. Keep the full server-seed hash and enough context to associate it with the correct seed pair. A hash obtained only after the result is weaker evidence of a prior commitment.
- Record the player-side inputs. Save the client seed and relevant settings. If you change the seed, confirm which rounds use the replacement.
- Save the round record. Preserve the bet identifier, nonce, stake, outcome and payout. Games with multiple actions may need additional inputs.
- Wait for the reveal or rotate the seed. Follow the documented process. Rotation commonly retires a seed pair so the old server seed can be disclosed.
- Check the commitment. Hash the revealed seed using the specified algorithm and encoding. Compare the entire output with your saved commitment.
- Reproduce the result. Apply the published result formula, including byte selection, counters and conversion into the game outcome.
- Check settlement separately. Compare the recorded payout with the applicable paytable and rounding rules.
An operator’s verifier can make these steps accessible. An independent implementation adds a useful check because the operator’s page is itself software that could contain an error. Independence is meaningful only if the second implementation follows the same published specification.
You do not need to write code to inspect a record. A verifier should make its inputs and calculated output visible rather than returning only a green confirmation icon.
Useful records include:
- The original commitment and the subsequently revealed seed.
- The round’s client seed, nonce and game settings.
- The algorithm version and the full calculated result.
- The original outcome and settlement amount.
How do hashes become dice rolls or game outcomes?
The game’s algorithm converts cryptographic output into an outcome using explicit rules. Hashing alone does not define a dice result, mine layout or crash multiplier.
Some designs use HMAC, a construction that combines a secret key with a message through a hash function. RFC 2104 defines HMAC. A game specification must still say which hash it uses, what serves as the key and exactly how it constructs the message.
An illustrative design might use:
commitment = SHA256(server_seed) message = client_seed + ":" + nonce output = HMAC_SHA256(key = server_seed, message = message) result = game_specific_conversion(output)
This is a schematic example, not a formula for a named casino. It cannot verify a real bet unless that game uses precisely these operations.
The final conversion deserves attention. A hexadecimal digest is a representation of bytes, not a casino result. The algorithm must say which bytes to read, how to interpret them and how to map the resulting number into the game’s allowed outcomes.
A small arithmetic example shows why the mapping matters. Assume a toy generator produces each integer from 0 through 255 with equal probability. Mapping those integers to ten outcomes by taking the remainder after division by ten produces:
| Final outcome | Number of original values mapping to it | Probability |
|---|---|---|
| Each outcome from 0 through 5 | 26 | 26 ÷ 256 = 10.15625% |
| Each outcome from 6 through 9 | 25 | 25 ÷ 256 = 9.765625% |
OddsGuru derivation for an illustrative uniform 256-value generator; these are not figures for an actual casino game.
The mapping is reproducible, but its outcomes are unequal. One possible correction is to reject values from 250 through 255 and draw again under a defined procedure. The remaining 250 values divide evenly into ten groups.
This is why a verification specification needs more than a hash-function name:
- Input encoding and separators affect the generated output.
- Byte order and selected positions affect the number being read.
- Rejection, rounding and range rules affect the final distribution.
Does provably fair mean a game has fair odds?
No. Provably fair verification concerns the generation of results; mathematically fair payouts concern the relationship between probabilities and money returned.
In probability terms, a financially fair wager has an expected net return of zero under its assumptions. Expected return is the probability-weighted average of the possible returns. It is not a prediction of what will happen during a particular session.
Consider a hypothetical wager with a 50% win probability. A winning $1 stake returns $1.98 in total, including the original stake, while a losing stake returns nothing.
The expected total return is:
- (0.50 × $1.98) + (0.50 × $0) = $0.99
For this simple win-or-lose wager:
- House edge = 1 − (win probability × total-return multiplier)
The same wager could produce correctly verified results on every round and still have that edge. Nothing in the seed commitment changes the paytable.
Keep these distinctions separate:
- Win probability describes how often the selected outcome occurs under the model.
- Payout describes the return when it occurs.
- House edge describes the average loss relative to the amount wagered.
- Variance describes how widely individual results can differ from that average.
The crypto dice mathematics guide examines the relationship between selected win chance and payout. The casino betting guide explains how house edge and variation affect gambling budgets.
Neither a verified round nor a favourable-looking sequence establishes a profitable strategy. Betting more to recover losses increases the money exposed to the game’s existing probabilities.
Do crash, mines, Plinko and slots use the same proof?
No. Games may share cryptographic components while using different rules to generate outcomes and settle bets.
A verifier must match the specific implementation. Entering a seed pair into an unrelated dice verifier cannot establish whether a mines layout or crash round was correct.
| Game type | Outcome the calculation may reproduce | Additional detail to inspect |
|---|---|---|
| Dice | Numeric result | Range, rounding and winning threshold |
| Mines | Mine positions | Layout generation, duplicate handling and tile numbering |
| Plinko | Direction sequence or final position | Row count, conversion method and applicable paytable |
| Crash | Crash point | Commitment scheme, multiplier formula and cashout rules |
| Card game | Card sequence or shuffle | Deck composition, shuffle method and draw order |
These are verification targets, not a claim that every game bearing those names offers player-verifiable results. The documentation must establish what is available.
In mines, a checker needs to reproduce the relevant layout and interpret positions in the same order as the game interface. Verifying a layout still leaves the payout schedule to be checked. Our mines probability guide separates safe-pick probabilities from cashout returns.
For Plinko, a calculated position and its payout are different pieces of information. The same position can have different payouts under different settings. The Plinko odds guide examines how rows and paytables affect the result.
Some crash designs use hash chains: a sequence linked by repeated hashing, with a commitment anchoring later verification. The direction of disclosure and any additional public input depend on the design. A verified crash point does not, by itself, establish when a cashout request reached the server. The crash game mathematics guide covers the separate payout questions.
For slots or other third-party titles, the relevant questions are:
- Does this particular game publish a player-verification protocol?
- Are the necessary inputs disclosed?
- Can the result be independently reproduced?
- Is a separate testing or certification claim being confused with that proof?
Can a provably fair casino still cheat or withhold money?
Yes. Result verification does not prevent every form of game manipulation or establish that the operator will pay customers.
A correctly recorded commitment makes changing the committed secret detectable under the cryptographic assumptions. It does not automatically reveal biased seed selection before commitment, undisclosed inputs, missing rounds or selective refusal to complete a process.
The threat depends on the design. For example, if an operator can calculate an outcome and then decide whether to accept the wager, reproducing an accepted round does not explain how rejected wagers were handled.
There are also risks outside result generation:
- Withdrawal delays, disputes and account restrictions.
- Differences between advertised terms and applied settlement rules.
- Account-security failures or misleading balance displays.
- Missing records that prevent a promised verification.
Licensing checks and technical verification answer different questions. A licence concerns the operator and its regulatory obligations. A game test can examine implementation or statistical behaviour. Player verification lets someone reproduce a disclosed result. These protections can coexist.
A fairness badge is not a withdrawal guarantee. Assess the operator’s identity, licence claims, withdrawal conditions and dispute route separately. The online casino selection guide sets out those checks.
A successful verification also does not reduce the financial risk of continued play. The game’s paytable remains relevant, and losses can accumulate despite every outcome being reproducible. The responsible gambling guide covers limits and support options.
What should you do if a provably fair check fails?
A failed check means the available inputs and calculation did not reproduce the expected value. It warrants investigation, but a copied character, incorrect nonce or incompatible verifier can also cause a mismatch.
First identify which stage failed. A server-seed hash mismatch is different from a matching commitment followed by an incorrect game result. A correct result with an incorrect payout is a settlement issue.
- Compare the full saved commitment with the calculated hash.
- Confirm that the revealed seed belongs to the recorded seed pair.
- Check capitalisation, spaces, text encoding and accidental line breaks.
- Confirm the client seed and nonce from the round record.
- Check any cursor, additional counter or game setting.
- Match the algorithm version and conversion rules.
- Repeat the calculation with another implementation if available.
Text that looks like hexadecimal may need to be processed as literal text or decoded into bytes. Those are different inputs. The specification must identify which interpretation applies.
Similarly, a nonce beginning at zero should not be changed to one merely because it was the first bet shown in a session. Use the recorded value rather than reconstructing it from memory.
Preserve:
- The original commitment, seed reveal and round identifier.
- The inputs entered into each verifier.
- The calculated output and recorded outcome.
- The documentation and correspondence relevant to the mismatch.
A refusal to disclose a promised retired seed leaves the result unverified. A confirmed mismatch between an independently reproduced result and the recorded round provides more specific evidence. Keep that distinction clear when using the operator’s complaints process or the relevant dispute route.
Compare current betting odds