What this tool does: Paste the game hash from a completed round to independently recalculate the crash point. Implements the exact published algorithms of Stake Crash (232 formula, salted hash chain) and Bustabit (52-bit formula, current and previous chains). All calculations run in your browser — no data is sent to any server.
This is an independent verification tool. Never trust a casino’s built-in verifier alone — always cross-check with an independent tool like this one. If the calculated crash point matches what you saw in the game, the round was not tampered with. Both algorithms below were checked against their primary sources — the operators’ own published code — on August 20, 2026.
Enter Round Data
Test Vectors
Use these examples to confirm the verifier is working correctly on your device. The first row of each pair uses a publicly known value from the operator’s own seeding event; the second uses a synthetic hash generated for this page.
| Mode | Game Hash | Salt | Expected Result |
|---|---|---|---|
| Stake Crash | 78a9757d3be42b74a3f70239078ad9317125fe9ee630d5bdada46de963e56752(terminating hash published in Stake’s seeding thread — a worked example, not a played round) | Default (block 584,500 hash) | 1.18x |
| Stake Crash | 0576bbc6cdde4619a1e2533fd8a58f356094739b9794f6a06102b23e3d30c5e7(synthetic) | Default (block 584,500 hash) | 7.53x |
| Bustabit | 567a98370fb7545137ddb53687723cf0b8a1f5e93b1f76f4a1da29416930fa59(terminating hash of the current chain — a worked example, not a played round) | Current chain | 1.02x |
| Bustabit | 274a58277eaf8bfdf9132f801027ac3e117d882ccd03829e7b81c58809612bbb(synthetic) | Current chain | 2.25x |
| Manual SHA-256 | Input: test | 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08 | |
Determinism test: Enter any values, note the result, reload the page, enter the same values — the result must be identical. If it changes, something is wrong with your browser’s crypto implementation (extremely rare).
Supported Platforms
| Platform | Mode to Use | Method | Where to Find the Game Hash |
|---|---|---|---|
| Stake Crash | Stake Crash | HMAC-SHA256(key = game hash, message = salt), first 8 hex chars, 232 formula, 1% edge | Crash → round history → round details |
| Bustabit | Bustabit | HMAC-SHA256(key = salt, message = game hash bytes), first 13 hex chars, 99 ÷ (1 − X) formula | Game history → Verify link |
| Any platform | Manual SHA-256 | Plain SHA-256 of a UTF-8 text input | Varies — check platform docs |
How This Verifier Works
Stake Crash Mode (232 formula)
Implemented exactly as published in Stake’s Crash seeding event, which their provably fair documentation points to. Results come from a pre-committed chain of 10,000,000 SHA-256 hashes. For each round: hash = HMAC-SHA256(key = gameHash, message = salt), where the salt is the hash of Bitcoin block 584,500 (mined after the chain was committed, so neither side could pick it). The first 8 hex characters become a 32-bit integer, and: crashPoint = max(1, (2^32 / (int + 1)) × (1 − 0.01)). The result is shown truncated to two decimals.
Bustabit Mode (52-bit formula)
Implemented exactly as in Bustabit’s official open-source verifier: hash = HMAC-SHA256(key = salt, message = gameHash bytes), the first 13 hex characters (52 bits) become r, then X = r / 2^52, X = 99 / (1 − X), and the result is max(1.00, floor(X) / 100). There is no separate instant-crash rule in the current implementation — rounds at exactly 1.00x arise from the formula itself, about 2% of the time. Note the two chains use different salts (both preset above), and the argument order is the opposite of Stake’s. One scope limit: rounds between games 10,000,001 and 12,279,450 were produced during Bustabit’s third-party co-signing period and can only be checked with Bustabit’s own verifier.
Manual SHA-256
For commitment checks on any platform. Enter any string — the verifier computes the SHA-256 of its UTF-8 text. If you also paste the hash the platform published before the round into the Expected SHA-256 field, the tool compares them automatically: green for match (data wasn’t altered), red for mismatch (double-check your input before concluding manipulation). This mode also reproduces chain links for chains that hash the hex text of the previous hash (Stake’s chain and Bustabit’s previous chain work this way; Bustabit’s current chain hashes raw bytes, so its links can’t be checked with a text hasher).
→ For the full mathematical breakdown, see our Crash Game Algorithm Guide.
→ For step-by-step verification per platform, see our Provably Fair Verification Guide.
→ To understand what RTP and house edge cost you, see our RTP & House Edge Guide.
Frequently Asked Questions
Is this verifier independent from the casinos?
Yes. This tool runs entirely in your browser using the Web Crypto API (crypto.subtle). No data is sent to any server — not ours, not the casino’s. You can verify this by opening your browser’s DevTools (F12 → Network tab) and confirming zero outbound requests when you click “Verify Round.”
Why doesn’t my result match the game?
The most common reasons: (1) wrong mode — Stake Crash and Bustabit use different formulas and opposite HMAC argument orders; (2) wrong chain or salt — Bustabit rounds up to game 10,000,000 belong to the previous chain; (3) pasting a value that is not the round’s game hash (for example, a bet ID or a hashed commitment); (4) a Bustabit round from the co-signing window (games 10,000,001–12,279,450), which this tool cannot reproduce. A mismatch usually means incorrect inputs, not manipulation.
Can I verify BC.Game rounds with this tool?
Possibly, but with caution. BC.Game’s white paper describes a 52-bit implementation close to Bustabit mode, but the salt and argument order may differ. Before relying on results, test with a round where you already know the correct crash point from BC.Game’s own verifier. If the results match for your test round, the mode works for your BC.Game version.
Can I verify Aviator rounds with this tool?
No. Aviator uses SHA-512 (not SHA-256) and derives the client seed from the first three players who bet in each round. This tool does not implement that algorithm. For Aviator, use Spribe’s official verifier alongside an independent SHA-512 calculator.
Is my data safe?
Yes. All calculations happen locally in your browser using crypto.subtle. You can disconnect from the internet after loading this page and the verifier will still work.
What does “instant crash” mean in the result?
A round that resolves at exactly 1.00x. Neither implementation uses a separate trigger for it: on Stake Crash it happens when the derived integer is large enough that the formula lands at or below 1 (about 1% of rounds), and on Bustabit it happens whenever the 52-bit value falls in the bottom ≈2% of its range. Older Bustabit code (v1) did use an explicit divisible-by-101 rule — that rule is not part of the current implementation. An instant crash is a normal outcome of the math, not a sign of manipulation.