Provably Fair Gaming at Our Casino

Online gambling always comes with one key question: can the results be trusted? Our provably fair system is built to let you answer that yourself. Instead of asking you to trust us simply, we give you the tools to check every Stake Originals game round and prove that it was not manipulated.

The idea is simple: each result is generated from two ingredients – our hidden server data and your own input – then locked in with cryptographic hashing. Once the round is over, you can verify that:

fair result = our server seed + your client seed + nonce

Nothing in that process can be changed after the fact without you noticing, which is the whole point of provable fairness.

Independent Checks and 3rd-Party Verification

You do not have to rely only on our word or our own tools. All Stake Originals can be checked:

  • Directly in your account through our built-in provably fair tools;
  • On independent verification sites such as provablyfair.me;
  • Through resources from the Crypto Gambling Foundation, where our casino is listed as a verified operator.

The Crypto Gambling Foundation focuses on high standards for provably fair systems. By working within that framework, we align our games with clear, open rules rather than closed, black-box logic. If you want to go deeper, you can take any round from your history, plug the seeds and nonce into a third-party verifier, and compare the result with what you saw on screen.

Seeds, Nonce, and Your Role in Randomness

Our provably fair model rests on three main values:

Server seed: Our system generates a random 64-character hex string and stores it as the server seed. Before you place any bets, you see only a hashed version of that seed. The hash proves that the seed already exists, but does not reveal it. That way:

  • We cannot change the seed mid-way without changing the hash;
  • You cannot predict future outcomes from it.

When you rotate the server seed, the old one is revealed, and a new one is created. You can check that the revealed seed matches the hash you saw earlier.

Client seed: The client seed belongs to you. It gives you direct influence over the random results, so the outcome is not based on our server seed alone.

  • A default client seed is created in your browser during registration so you can start playing immediately;
  • You can change your client seed at any time in the fairness settings to start a fresh chain of outcomes.

Think of it like cutting the deck in a land-based casino: the cards are shuffled by the house, but you still have a hand in the final order.

Nonce: The nonce is a simple counter: it starts at zero and increases by 1 with every bet you place using a given server-seed / client-seed pair. Each unique combination of server seed, client seed, and nonce produces a new random output through SHA-256.

You do not need to manage the nonce manually. It just ensures that every round is unique without constantly regenerating new seeds.

Cursor and Incremental Numbers in Complex Games

Some games need more than one random number per round. For example, Blackjack uses multiple cards, Mines needs several bomb positions, and Keno requires numerous hits on a board. In those cases, we use a cursor on top of the nonce.

  • The cursor starts at zero and steps through the 32 bytes produced by the HMAC_SHA256 function;
  • Each 4-byte chunk becomes one random number (a “float”) used to drive a game event;
  • If a game needs more than eight numbers (because 32 bytes / 4 bytes = 8), the cursor increases, and another set of 32 bytes is generated.

Games like Hilo, Keno, Mines, Pump, Chicken, Plinko, Blackjack, Video Poker, Snakes, Flip, Rock Paper Scissors, and Bars can use several increments per round, depending on how many events they must generate. Simpler games such as Dice, Limbo, Wheel, Baccarat, Roulette, Diamonds, Cases, Darts, Primedice, Packs, Tarot typically use only one incremental number per round.

You do not see the cursor in the interface, but it is part of the verification logic, and it ensures that every card, tile, or step in a round comes from a traceable position in the random stream.

From Raw Numbers to Actual Game Results

The cryptographic side produces random numbers between 0 and 1 (floats). Each game then converts these floats into familiar results:

  • In card games like Blackjack, Baccarat, Hilo, and Video Poker, the float is multiplied by the number of possible cards (usually 52). The result is mapped to a specific card in a fixed index of the deck;
  • In Dice and Primedice, the float is mapped onto a range from 0.00 to 100.00, using 10,001 possible outcomes;
  • In roulette, the float is multiplied by 37 and corresponds to one of the wheel pockets from 0 to 36;
  • In Mines, Keno, Pump, Chicken, and similar games, floats are used with a Fisher–Yates shuffle so that each bomb, tile, or hit position is unique and cannot be repeated in the same round.

Every game has its own translation rules, but they all follow the same pattern:

  1. Start with a fair cryptographic output from server seed, client seed, and nonce.
  2. Convert that output to floats.
  3. Map floats to game-specific events using clear, deterministic formulas.

Because the formulas are public, anyone can rebuild the process and check that a given chain of seeds and nonce values leads to exactly the same sequence of results that appeared in the game.

How You Can Verify Your Own Bets

We want you to check any round that matters to you. The basic verification flow looks like this:

  1. Open your game history and select a specific round.
  2. Reveal the server seed once you rotate it, and note your client seed and nonce for that round.
  3. Enter these values into our internal verification tool or a trusted third-party checker like provablyfair.me.
  4. Run the calculation and compare the reconstructed result with what you saw in the game.

If the numbers match, you know that:

  • The server seed was committed in advance (via the hash);
  • Your client seed and nonce contributed properly;
  • No one altered the outcome after the bet was placed.

You can repeat this process for as many rounds as you like, and you can change your client seed whenever you want extra peace of mind.

Our Commitment to Transparent Randomness

Provably fair systems are not just a technical feature for us; they are part of how we think about trust. By combining hashed server seeds, your own client seeds, deterministic algorithms, and third-party verification, we create a setup where:

  • You can independently prove that outcomes are fair;
  • We cannot secretly adjust results without breaking the cryptographic trail;
  • Complex games still follow clear, published rules.

We will continue refining our provably fair tools, documentation, and community resources so that every Stake Originals game remains fully verifiable, not just claimed to be fair.

Updated: