How Provably Fair Crash Games Work (Explained Simply)
Published 29 May 2026 · 6 min read
"Provably fair" is the phrase every crash game waves around. Most players nod and move on. This guide explains exactly what's happening under the hood — server seeds, client seeds, SHA hashing — in plain English, so you can decide for yourself whether to trust a result.
What "provably fair" actually means
A game is provably fair if, after a round ends, you can independently verify that the result wasn't manipulated using only publicly available information. You don't have to trust the operator. You don't have to trust a regulator. The math is the proof.
For crash games, this works by committing to a future random number before the round runs, then revealing the inputs after — so the operator can't change anything without getting caught.
The three pieces
1. The server seed
Before a round begins, the operator generates a long random string — usually 40 to 64 characters — called the server seed. They don't show it to you yet. Instead, they publish the SHA-256 (or SHA-512) hash of that seed. A hash is a one-way fingerprint: given the seed you can compute the hash, but you cannot reverse the hash to find the seed.
This is the commitment. Once the hash is published, the operator can't change the seed without breaking it.
2. The client seed(s)
Now the players contribute randomness. In Goemon, the first three players to wager in a round each provide a client seed (their browser generates a random string when they place a bet). Mixing player-supplied randomness into the calculation means even if the operator wanted to cheat, they'd need to know every client seed in advance — which is impossible.
3. The hash
After the round ends, the operator combines the server seed and the three client seeds into a single SHA-512 hash. That hash is then converted into a number, and the number is mapped to a multiplier using a public formula.
Step by step: how a round is generated
- Pre-round. Operator picks a random server seed. Publishes
SHA256(serverSeed)in the round info. - Bets open. The first three wagering players each contribute a client seed.
- Round runs. Multiplier climbs. Players cash out when they want. Round ends at a crash point that nobody knows yet.
- Post-round. Operator reveals the server seed. The crash point is computed as a function of
SHA512(serverSeed + clientSeed1 + clientSeed2 + clientSeed3). - Verification. Any player can re-hash the inputs and confirm the crash point matches. They can also re-hash the revealed server seed and confirm it matches the pre-round commitment.
If any step fails — the hash doesn't match, the crash point doesn't reproduce — the operator has been caught.
Why this is stronger than "RNG certified"
Most slots are RNG certified. A third-party lab (eGaming Labs, iTech Labs, GLI) tested the random number generator at some point and signed off. You trust the lab. You trust the operator hasn't modified the code since. You can't verify any individual spin.
Provably fair flips that around. You verify every round, in real time, by re-computing the hash yourself. No lab. No "trust me." Just math.
Common misconceptions
"Provably fair means I can predict the outcome." No. The outputs are still random. You can only verify them after the round, not predict them before.
"Provably fair means the game has high RTP." Unrelated. Fairness and RTP are independent. A provably fair game can have an RTP of 80% or 99% — both are honest, just at different rates. Always check the published RTP separately. More on RTP here.
"All crypto casinos are provably fair." Many are, but not automatically. Look for the actual seed/hash mechanics in the game info panel before assuming.
Ready to verify a round yourself?
The next guide walks through the exact procedure: How to verify provably fair results. It includes the SHA-512 step and the multiplier-mapping formula so you can spot-check Goemon (or any provably fair crash game) on your own.