How to Verify a Provably Fair Crash Round, Step by Step

🏆 No.1 Crash Games Casino

Crashino

★★★★★ 4.3 / 5

100% up to $1,000 + 200 Free Spins

• ✓ 30+ provably fair crash games: Aviator, JetX, Spaceman & more
• ✓ 10% weekly cashback for every player, paid automatically
• ✓ Crypto only: BTC, ETH, USDT and 9 more coins accepted
• ✓ Extra value: 2x monthly bonus and up to 125 Friday Fun Spins

Claim $1,000 + 200 Free Spins →

18+ | New players only | T&Cs apply | Availability may vary by location | Play responsibly

⚡ Verify an Aviator round

Aviator verification is two hash checks: confirm the revealed server seed matches its pre-round commitment, then confirm the combined SHA-512 hash of all four seeds matches the one shown in the round panel. Before each round the operator generates a 16-character server seed and publishes its hash. When the round starts, that seed is combined with the client seeds of the first three players to bet and hashed with SHA-512 to drive the result.

That three-player design is unique among the big crash titles: the house cannot pick the outcome alone, and neither can any player. The game itself, its features and its maths are covered in our Aviator guide. Here is the verification routine.

Reproducing the multiplier itself is the loose end. The widely used method takes the first 13 hex characters of the combined hash, divides by 2 to the power of 52 to get a number x between 0 and 1, then computes 0.97 / (1 − x). That output matches Aviator’s fixed 97% RTP, including the roughly 3 in 100 rounds the algorithm forces to end at 1.00x.

Try it yourself: check a practice round in the demo below before you verify a real one.

🛡️ A check proves two things: the result was fixed first and really used

Verifying a provably fair round means proving two things: the result was locked in before you bet, and the multiplier on your screen really came from that locked-in value. Every provably fair crash game runs on a commit-reveal scheme. The casino publishes a hash of its secret server seed before the round, then reveals the seed afterwards so anyone can check it. We ran this check on 20 sampled Rollbit X-Crash rounds, and all 20 passed.

The cryptography behind that promise is covered in our provably fair explainer. This page is the hands-on companion: where to click, what to copy, and what the numbers must equal. You need three things: your bet history, the platform’s fairness panel, and a free in-browser hash calculator, ideally one that runs entirely client-side through the Web Crypto API so your seeds never leave your device.

🏆 Aviator, Stake and BC.Game at a glance

All three platforms commit to the result before bets close; they differ in how the seeds combine and whether the exact formula is public. The differences matter when you check by hand, because the right method on one platform produces a false mismatch on another.

Aviator’s three-player design means no single party, Spribe included, knows the result until three independent client seeds are committed. Stake is the easiest to verify rigorously, because every step of its algorithm is public and every past bet stays verifiable indefinitely. BC.Game’s chain design means every crash number in its history already existed before the first round was ever played.

⚙️ Verify a Stake Crash round

Stake Crash does not use your client seed. Stake’s seeding post on BitcoinTalk sets out the method: a chain of 10 million SHA-256 hashes, played in reverse, salted with the hash of Bitcoin block 584,500. That block had not been mined when Stake posted the chain, so Stake could not pick it. Each round’s crash point comes from HMAC-SHA256 with the round’s hash as the key and the block hash as the message. Stake’s client seed and nonce system is only for its single-player games such as Dice and Limbo. The game itself is covered in our Stake Crash guide.

houseEdge = 0.99
floatPoint = (1e8 / (float * 1e8)) * houseEdge
crashPoint = floor(floatPoint * 100) / 100
result = max(crashPoint, 1)

The float comes from the first 4 bytes of the HMAC output, each divided by 256 to the power of its position and summed, which is the same as reading the first 8 hex characters as a 32-bit integer. The whole calculation is algebraically identical to the simpler form crashPoint = max(1, (2^32 / (int + 1)) * 0.99), which is the version most independent verifiers implement.

For the independent cross-check, provablyfair.me, Spindex, Dyutam and Stake Analyzer all reimplement Stake’s published algorithm in the browser and run client-side, so seeds never leave your device. Stake’s own help centre points players to external verification, and the casino is a verified operator with the Crypto Gambling Foundation. Use the external tool as the deciding vote, not the in-house calculator.

🔢 Verify a BC.Game Crash round

BC.Game Crash is checked with a round hash and a Bitcoin block hash, not with your own client seed. BC.Game pre-generates a chain of SHA-256 hashes and plays it in reverse order, so every crash number existed before the first bet. Each round uses one hash, and hashing a round’s value with SHA-256 gives the previous round’s hash. BC.Game’s own site lists Bitcoin block 967,100 as the salt for its current Crash results. We could not find a published commitment hash or chain length for this chain, so you can check single rounds but not the whole chain back to its start.

Every round hash is then run through HMAC-SHA256 with a salt: the hash of a Bitcoin block that had not been mined when BC.Game published the chain. For the current chain, BC.Game’s own site lists Bitcoin block 967,100, hash 000000000000000000010283162e089cc99f643ee5043141412e839945afe2f9. The salt is the same for every player, which is why everyone in a round sees the same crash point. BC.Game could not pick the block hash in advance, so it could not pick results. The game itself is covered in our BC.Game Crash guide; here is the white paper’s own worked example of how a hash becomes a multiplier.

hash = 6b5124897c3c48d0...
first 13 hex = 6b5124897c3c4 = 1,887,939,992,208,324
X = 1,887,939,992,208,324 / 4,503,599,627,370,496 = 0.419206...
raw = 99 / (1 − X) = 170.45...
crash point = floor(170.45) / 100 = 1.70x

The 13 hex characters carry 52 bits, and the divisor is the largest 13-character hex value, which normalises X to between 0 and 1. Any raw value below 100 is set to 100, which is the roughly 1-in-100 instant bust at 1.00x that carries the house edge.

BC.Game publishes an open-source chain verifier on GitHub, hosted at game-verify.github.io. Because its crash variant differs from the generic Stake-style method, test any third-party tool against a round you have already verified with the official one before relying on it.

⚠️ Eight mistakes that break a verification

Almost every failed provably fair check is an input error, not proof of rigging. The most common is hashing the pre-round hash instead of the revealed server seed. Others are checking before you rotate the seed, using the wrong nonce, swapping the HMAC inputs, or using another platform’s formula. Stake’s 32-bit method, BC.Game’s 13 hex chain and Aviator’s three seed SHA-512 are not interchangeable. Work through all eight mistakes below before you blame the casino. If a word here is new to you, check our A to Z of crash game terms.

🎯 Picking an independent verifier

A trustworthy verifier runs entirely in your browser, shows its source, and produces the same answer as the casino’s tool from the same inputs. Open-source options include the verifier apps hosted by the provably-fair GitHub organisation and BC.Game’s own chain checker, while the four browser tools named in the Stake section reimplement Stake’s published algorithm.

To confirm a tool really is client-side, open your browser’s developer tools with F12, watch the Network tab and run a check: there should be zero outbound requests. Then run the same seeds, client seed and nonce through both the casino’s verifier and the independent one. Identical results from two unrelated code bases is the strongest practical assurance you can get.

🔍 What a matching hash proves, and what it does not

A passed verification proves the result was sealed before your bet and untouched afterwards; it says nothing about the price of playing. Be precise about what each side of that line means before you draw any conclusions from a check.

What it does not prove: that the game is beatable, or that the return is generous. A game can verify perfectly and still run at 94%, because the edge is written into the very formula you reproduced, the 0.97 in Aviator’s method and the 0.99 in Stake’s and BC.Game’s. It also says nothing about deposits, withdrawals or whether the platform can pay you. Honest and cheap are different claims, and verification only ever speaks to the first.

Run the routine once and watch the hashes line up, and the anxiety behind our is Aviator rigged deep dive answers itself. The maths is honest, the result was sealed before you bet, and the cost of playing is exactly the advertised edge, collected on every round wherever you cash out.

One last filter before you deposit anywhere new.

Get more from CrashEdge on GooglePick CrashEdge as a preferred source and Google will show you more of our pages when you search.Add to Preferred Sources on Google

❓ Frequently asked questions

Quick answers to the questions players ask most about running these checks.

How do I check if a crash game is provably fair?

Look for three things before betting: a server seed hash published before the round, an editable client seed, and a way to reveal past server seeds. If all three exist, run the four-step check at the top of this guide on a real round. If any is missing, the game is not verifiably fair, whatever the marketing says.

Can I verify Aviator rounds?

Yes. The round’s fairness panel exposes the server seed, the three client seeds and the combined SHA-512 hash, and both hash checks can be reproduced exactly in any independent calculator. Only the final multiplier formula is unofficial, so treat that last step as an approximation rather than proof.

What tools can I use to verify provably fair rounds?

Any client-side SHA-256, SHA-512 or HMAC calculator covers the hash checks. For Stake, provablyfair.me, Spindex, Dyutam and Stake Analyzer reimplement the full algorithm in the browser, and BC.Game publishes an open-source chain verifier. Confirm a tool sends no network requests before trusting it with your seeds.

Why do I need to rotate my seed before verifying?

Rotation is what reveals the previous server seed; until then you only ever see its hash. That design stops anyone, you included, from reading future results in advance. After rotating, the nonce resets to 0 and a fresh hidden seed takes over.

Does provably fair mean I will win?

No. It proves the results were generated honestly and were not altered after your bet. The house edge sits inside the verified formula itself, so a perfectly fair game still costs you its edge over time.