How to Verify a Provably Fair Hash Yourself

Checking a provably fair crash round takes a few minutes and requires no special software, only a modern browser and a willingness to copy-paste two hex strings. This article walks through the general steps for the server seed, client seed and nonce design, and shows how to confirm that a commitment was honored.

What will I need to verify a round?

Three things:

1. A modern web browser: Chrome, Firefox, Edge, or Safari. You will use the browser's built-in developer console.
2. Your provably fair seeds, the server seed (revealed after rotation), your client seed, and the nonce of the round you want to verify. These are available in the platform's fairness settings.
3. A few minutes, the first time.

No special software. No downloads. No command-line tools. Everything you need is built into your browser.

If you want to understand what you are verifying and why it matters before you start, read Provably Fair, Explained first. This article assumes you understand the concept and want the hands-on walkthrough.

Where do I find the server seed, client seed, and nonce?

The location varies by game and by site, so check the game's own fairness or provably fair page. In a per-player design you will usually find:

• The server seed hash: the SHA-256 commitment to the seed currently in use.
• Your client seed: often editable.
• The nonce: a counter that rises with each bet.
• A way to retire the seed, often called rotating or changing the seed, which reveals the old server seed and starts a new one.

Shared-round games built on a hash chain instead publish the end of the chain before play and reveal each round's hash afterwards.

Before you retire a seed: write down your current client seed and the nonce of the round you want to check. After the change, the old values may no longer be displayed.

How do I compute the SHA-256 of the revealed seed?

After rotating, you will see the actual server seed, a long hex string. Your first step is to confirm that the SHA-256 hash of this seed matches the hash that was displayed before the rotation.

Method 1: Browser console:

Open your browser's developer console (F12, then click "Console") and paste:

async function sha256(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  const hash = await crypto.subtle.digest('SHA-256', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// Replace with your actual revealed server seed:
sha256('your_revealed_server_seed_here').then(console.log);

The output is a 64-character hex string. Compare it character by character to the server seed hash that was displayed before the rotation.

Method 2: our hash commitment check.

Open the hash commitment check, paste the revealed server seed and the hash shown before the rotation, and choose SHA-256. It runs with your browser's Web Crypto and sends nothing to us. It confirms the commitment; it does not recompute the round.

If they match: The operator committed to this seed before any rounds were played. Proceed to the next step.

If they do not match: The operator changed the seed after committing its hash. This is a critical failure. Document everything and report it.

How do I recompute the round's hash?

Now you know the server seed is authentic. Next, recompute the keyed hash (HMAC-SHA256) behind a specific bet. Paste this into the browser console:

async function hmacSha256(key, message) {
  const encoder = new TextEncoder();
  const cryptoKey = await crypto.subtle.importKey(
    'raw', encoder.encode(key), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
  );
  const sig = await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
  return Array.from(new Uint8Array(sig))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// Replace with your actual values. The message format (here "client:nonce")
// is set by the game's documentation; check it before you compare.
hmacSha256('your_revealed_server_seed', 'your_client_seed:42').then(console.log);

Turning the hash into a multiplier. Each game documents its own formula for this last step, and formulas differ: how much of the hash is read, how the house edge is applied, how results are rounded. Use the formula from the game's fairness page. We do not publish one here, because a formula copied from one game will give wrong answers for another and look like a failed check.

Important caveats:

• The message format, the formula and the rounding all come from the game's documentation.
• The nonce usually counts bets, not rounds. If you skipped rounds, your nonce did not move for them.
• Rounding can make the last decimal differ by 0.01. A gap of one hundredth is rounding; a gap like 2.47 against 3.12 is a mismatch.

What do I do if my verification doesn't match?

First, rule out user error:

1. Check your client seed. Are you using the client seed that was active during the round you are verifying? If you changed it, you need the old one.
2. Check the nonce. The nonce is per-bet. If the platform counts nonces differently than you expect, the mismatch may be a nonce offset.
3. Check the formula. Different games use different derivation formulas. Confirm you are using the one the game documents.
4. Check the server seed. Are you using the revealed server seed from the correct rotation? If you have rotated multiple times, make sure the seed corresponds to the rotation that was active during the round.

If you have ruled out user error and the verification still fails:

1. Screenshot everything. The revealed server seed, the committed hash, your client seed, the nonce, the displayed crash point, and your computed crash point.
2. Try additional rounds. Verify 3-5 more rounds from the same rotation. If they all fail, the issue is systematic. If only one fails, it may be a data display error.
3. Report to the platform. Most platforms have a support channel for provably fair disputes.
4. Keep the evidence. A documented, repeatable mismatch on a correctly run check is serious, and it is evidence anyone can re-run.

A single verification failure in a correctly implemented system should never occur. The cryptographic operations are deterministic, the same inputs always produce the same output. If the output does not match, either the inputs were wrong (user error) or the system is not operating as described (platform issue).

How do I verify many rounds at once?

For spot-checking, a handful of rounds is enough. For many rounds, loop the same function over a range of nonces and compare each result with the game's history:

async function hashesForRange(serverSeed, clientSeed, startNonce, endNonce) {
  const rows = [];
  for (let nonce = startNonce; nonce <= endNonce; nonce++) {
    rows.push({ nonce, hash: await hmacSha256(serverSeed, clientSeed + ':' + nonce) });
  }
  return rows;
}

hashesForRange('your_revealed_server_seed', 'your_client_seed', 1, 100).then(console.table);

Apply the game's documented formula to each hash, then compare with the displayed result for that nonce.

What does a passing check not tell you?

A passing check proves the round was fixed before bets and not changed afterwards. It does not prove the game's overall return matches its stated RTP; that needs a large count of rounds, published with an interval, which the lab does game by game once a game passes its minimum sample. See Understanding RTP.

It also tells you nothing about the next round. A seed is revealed only after the rounds it produced, so verification always looks backwards. History describes behaviour. It does not predict the next round. Apps that claim to read the next result from a hash cannot see the secret seed; see the predictor bots check.

Which games can be checked this way?

Only provably fair games, such as Aviator, Mines and Stake Crash, let you recompute a round from its seeds. Each game uses its own formula; for Aviator, our Aviator provably fair calculator recomputes the multiplier from a round's seeds. Hash-committed games such as JetX let you check the commitment but publish no formula from hash to result. Certified-RNG games such as Spaceman cannot be checked round by round at all. Each game page carries a fairness badge that says which applies.

The value of checking, whether five rounds or fifty, is the same: it turns "trust the operator" from an act of faith into a claim anyone can test.