Short answer: provably fair means the site commits to a secret before the round, and you can check afterwards that the result came from that secret. It proves the round was not changed. It does not prove the house edge is low, that you will be paid, or that play is profitable.
The idea in four moves
- Commit. Before play, the site publishes a hash of a secret server seed. A hash is a one-way fingerprint: it identifies the seed without revealing it.
- Mix. Your client seed and a counter called a nonce (one per round) are combined with the server seed to produce a random number.
- Play. That number sets the crash point.
- Reveal and recompute. Later the site reveals the server seed. You hash it, compare with the commitment, and recompute the crash point yourself.
If the revealed seed does not match the earlier hash, the site changed it. If the recomputed crash point differs from the one you saw, the site did not follow its own formula.
Schemes differ by site
Not every crash site works exactly like the four moves above. As the operators describe them:
| Operator | Scheme as the site describes it | Player seed or nonce |
|---|---|---|
| CSGO500 | A chain of 10 million hashes generated in advance, used in reverse, with a validation table | Not described |
| Gamdom | A chain of 10 million SHA256 hashes per game, each game’s hash published after it ends | Not described |
| CSGORoll | Hashed server seed plus a future EOS block hash as outside randomness | Seeded games only |
| PLG.BET | A new secret each day, shown as a hash and revealed later | Not described |
A hash chain works in reverse: the last hash in the chain was published first, and each earlier round’s hash, when hashed, must equal the next one. That lets the site commit to millions of rounds at once. All four rows are the operators’ own descriptions.
A worked recomputation
Below is a generic pattern, not any site’s formula. It uses the standard HMAC-SHA256 function available in most languages. Always use the exact formula on your site’s fairness page.
import crypto from 'node:crypto';
const serverSeed = '3f1c9a7e5b2d48c0a6e1f7d92b84c35a'; // revealed after the round
const clientSeed = 'crashlog-demo-seed'; // chosen by the player
const edge = 0.01; // site's stated house edge
// 1) Commitment check: hash of the revealed seed must equal what was published earlier
const commitment = crypto.createHash('sha256').update(serverSeed).digest('hex');
// 2) Recompute one round
function crashPoint(nonce) {
const h = crypto.createHmac('sha256', serverSeed).update(`${clientSeed}:${nonce}`).digest('hex');
const r = parseInt(h.slice(0, 13), 16) / 2 ** 52; // 52 bits -> number in [0, 1)
return Math.max(1, Math.floor(100 * (1 - edge) / (1 - r)) / 100);
}Running it with these demo values gives:
| Nonce | First 16 hex characters of the HMAC | Random number | Crash point |
|---|---|---|---|
| 1 | a99309172fde0dbf | 0.6624 | 2.93x |
| 2 | 540ef8d621a6dc16 | 0.3284 | 1.47x |
| 3 | cfeeb237da39422a | 0.8122 | 5.27x |
The demo seed hashes to 9ee504cd355875f95bf6142cc96e04d881d3af9907d5bbd49afd484aef189713, which would be the commitment the site published. These values are for illustration only. They are not from any real round or site.
How to verify a real round
- Save the commitment (the server-seed hash) before you play, and note your client seed.
- Play and note the nonce or round ID of the round you want to check.
- After the seed is revealed, hash it and confirm it equals the saved commitment.
- Recompute the crash point with the formula from the fairness page, or use the operator’s own verifier.
- Compare with the multiplier you saw. They should match exactly.
- Cross-check with a second tool if you can. A verifier hosted by the same site is convenient, but an independent script is stronger.
Where a site has no per-player seed (for example a daily secret or a pre-made hash chain), the check is different: confirm that each revealed hash links to the next, and recompute the crash from the published formula.
What it proves
- The result was fixed before you bet. The site cannot choose it after seeing your stake.
- The result follows the published formula.
- You can check any past round yourself, not just one.
What it does not prove
- That the edge is low. The edge is a number in the formula. A site can be perfectly provable and still take 4%.
- That you will be paid. Fairness covers the round, not withdrawals. See how to spot a scam crash site for payout checks.
- That the seed was random. A provable round can still use a biased seed if the site picked it badly. Outside randomness, such as a future block hash, reduces that risk.
- That play is profitable. The edge guarantees the opposite on average. See how CS2 crash works.
Red flags on a fairness page
- No commitment published before play.
- A verifier that only runs on the operator’s own server and shows no formula.
- Marketing wording that says “100% fair” in place of a method. A method can be checked, wording cannot.
- Stale text: for example an instruction dated in the past, which suggests nobody maintains the page.
- A change of scheme with no explanation of how earlier rounds were verified.
Where our reviewed sites stand
The CSGO500 review covers a round-validation table, the Gamdom review a hash chain published after each game, and the CSGORoll review an outside-randomness scheme. Our methodology gives fairness transparency the largest weight, 25%, and every fairness fact carries a date.
Key points
- Commit, mix, play, reveal and recompute: the order is what makes it provable.
- Schemes differ, so use the exact formula on the site’s fairness page.
- Provable fairness checks the round, not the edge, the payout or the profit.