How to Verify Provably Fair Results: A Technical Tutorial

Provably fair is a cryptographic system that lets players independently verify that every game result was determined fairly and was not manipulated by the casino. It is one of the most important innovations in online gambling because it replaces "trust us" with "verify it yourself." This guide explains exactly how it works and how to check results on your own.

The Core Concept

Traditional online casinos ask you to trust that their random number generator (RNG) is fair, usually backed by a third-party audit certificate. Provably fair eliminates the need for trust entirely. The system works by committing to a result before you place your bet, then revealing the proof after the round so you can verify it.

The underlying principle is cryptographic commitment: the casino commits to a secret value (via a hash) before the game, and the player can later verify that the commitment was not changed.

The Building Blocks

SHA-256 Hashing

SHA-256 (Secure Hash Algorithm, 256-bit) is the foundation of provably fair systems. It is the same algorithm that secures Bitcoin. Key properties:

• Deterministic: The same input always produces the same output
• One-way: It is computationally infeasible to reverse a hash back to its input
• Collision-resistant: It is nearly impossible to find two different inputs that produce the same hash
• Avalanche effect: Changing a single bit in the input completely changes the output

Example:

Input:  "hello"
SHA-256: 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Input:  "Hello" (capital H)
SHA-256: 185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969

Notice how a single character change produces a completely different hash. This property ensures that the casino cannot tweak the input to change the result without the hash being different.

Server Seed

The server seed is a secret random string generated by the casino for each game round (or series of rounds). Before the game begins, the casino publishes the hash of the server seed, not the seed itself. This is the commitment.

Client Seed

The client seed is a random string provided by the player. This can be auto-generated by the platform or set manually by the player. The client seed ensures the casino cannot predetermine the outcome for a specific player because the final result depends on input the casino cannot control.

Nonce

A nonce (number used once) is an incrementing counter that changes with each bet. Combined with the server seed and client seed, it ensures every bet produces a unique result, even if the seeds stay the same across multiple rounds.

How the System Works: Step by Step

Server Seed: "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4" (secret)
Server Seed Hash: SHA-256("a1b2c3d4...") = "7f83b1657ff1fc53..." (public)

Client Seed: "myRandomSeed123" (chosen by player)

combined = HMAC-SHA256(serverSeed, clientSeed + ":" + nonce)
result   = convertToGameResult(combined)

How to Verify: Practical Tutorial

Method 1: Using a Web-Based SHA-256 Tool

1. Go to any SHA-256 calculator (search "SHA-256 online" or use a tool like sha256.dev)
2. Paste the revealed server seed into the input
3. Click "Hash" or "Calculate"
4. Compare the output to the server seed hash that was shown to you before the game
5. If they match, the server seed was not changed after you placed your bet

Method 2: Using the Command Line

# On macOS or Linux:
echo -n "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4" | shasum -a 256

# On Windows (PowerShell):
[System.BitConverter]::ToString(
  (New-Object System.Security.Cryptography.SHA256Managed).ComputeHash(
    [System.Text.Encoding]::UTF8.GetBytes("a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4")
  )
).Replace("-","").ToLower()

Method 3: Using JavaScript

// In your browser console (F12 > Console):
async function verifySeed(serverSeed, expectedHash) {
  const encoder = new TextEncoder();
  const data = encoder.encode(serverSeed);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');

  console.log('Computed hash:', hashHex);
  console.log('Expected hash:', expectedHash);
  console.log('Match:', hashHex === expectedHash);
  return hashHex === expectedHash;
}

// Example usage:
verifySeed(
  'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4',
  '7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069'
);

Method 4: Verifying the Full Game Result

Verifying the hash only proves the server seed was not changed. To verify the actual game result, you need to reproduce the full calculation:

// Full provably fair verification (JavaScript):
async function verifyGameResult(serverSeed, clientSeed, nonce) {
  const encoder = new TextEncoder();
  const key = await crypto.subtle.importKey(
    'raw', encoder.encode(serverSeed),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
  );

  const message = encoder.encode(clientSeed + ':' + nonce);
  const signature = await crypto.subtle.sign('HMAC', key, message);
  const hashArray = Array.from(new Uint8Array(signature));
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');

  // Convert first 8 hex characters to a game result
  const decimalValue = parseInt(hashHex.substring(0, 8), 16);

  // For dice (0-99.99):
  const diceResult = (decimalValue % 10000) / 100;

  // For crash (with 1% house edge):
  const h = decimalValue / Math.pow(2, 32);
  const crashResult = Math.max(1, Math.floor(99 / (1 - h)) / 100);

  console.log('Hash:', hashHex);
  console.log('Dice result:', diceResult);
  console.log('Crash result:', crashResult + 'x');

  return { hash: hashHex, diceResult, crashResult };
}

// Example:
verifyGameResult('serverSeed123', 'clientSeed456', 1);

What Makes a System Truly Provably Fair?

Red Flags: When "Provably Fair" Is Not

Not every platform claiming provably fair is actually implementing it correctly. Watch for:

• No server seed hash shown before the game: If you cannot see the commitment before betting, the system is not provably fair
• No ability to set your own client seed: If the platform controls both seeds, they can precompute and select favorable outcomes
• Custom or proprietary algorithms: If the algorithm is not documented or uses non-standard cryptography, it cannot be independently verified
• No way to verify past results: A truly provably fair system lets you verify every historical bet
• Server seed never revealed: If you can never see the actual server seed, you can never complete verification

FAQ

Can I predict future results?

No. You can see the server seed hash, but SHA-256 is a one-way function. You cannot reverse the hash to determine the server seed, which means you cannot predict the result. This is the same mathematical guarantee that secures Bitcoin.

Can the casino cheat even with provably fair?

If implemented correctly, no. The combination of a committed server seed and a player-chosen client seed makes it mathematically impossible for the casino to manipulate results. The only way to cheat would be to break SHA-256, which would also break Bitcoin and most of the internet's security infrastructure.

Should I change my client seed often?

It is good practice to rotate your client seed periodically. Every time you change it, you trigger a server seed rotation, which reveals the old server seed for verification. This lets you verify results more frequently.

What if my verification does not match?

If the server seed hash you compute does not match the hash shown before the game, the casino may have changed the server seed after your bet. This would be evidence of manipulation. Document everything and report it publicly.