What Is Provably Fair Gaming?
Provably fair gaming is a system where every game outcome is generated from public cryptographic math — so you can independently verify that the result wasn't manipulated. No trust required in the operator. The proof is the math.
1. The trust problem in online games
When you play a game online, the server decides the outcome. A coin flip, a dice roll, a raffle winner — the operator runs the math and tells you what happened. You don't see the dice. You see the result.
That works if you trust the operator. But how do you know the coin wasn't flipped after the server saw your guess? How do you know the raffle draw wasn't tilted toward an internal account? In most online games, the answer is: you don't. You trust.
Provably fair gaming removes the trust assumption. The operator still generates the outcome — but in a way that's mathematically impossible to manipulate after the fact, and independently checkable by anyone with a calculator and ten minutes.
2. The provably fair solution
Provably fair systems use three inputs, a cryptographic hash function, and a commitment scheme. Here's the core idea in plain English:
- The operator commits first. Before you play, the server generates a secret random number (the server seed), then publishes its hash — a fingerprint that proves the seed existed but doesn't reveal its value.
- You contribute randomness. You provide a client seed — any string you choose. This guarantees the operator can't pre-pick a seed designed to give a specific outcome, because it doesn't know your seed yet.
- Every game has a counter. A nonce starts at zero and increments with each bet, so every outcome is unique even with the same two seeds.
- The outcome is derived deterministically. The server combines (server seed, client seed, nonce) through HMAC-SHA256 and extracts the game result from the resulting bytes. There's no randomness at play time — just math.
- Later, the server reveals the seed. You can hash the revealed seed and check it matches the fingerprint published before you played. If it matches, the seed was locked in before your bet — no post-hoc manipulation possible.
The result: a game outcome you can recompute, verify, and audit — using only public information and a standard cryptographic library any developer has access to.
3. The algorithm, step by step
FairWin uses the standard provably fair construction, identical to the algorithm documented by every serious transparent-odds operator. Here it is in one block:
Every FairWin game uses exactly this skeleton. Only the extract step differs — dice reads the first four bytes modulo 100, coinflip reads modulo 2, keno does a Fisher-Yates shuffle, and so on. The core derivation is identical, and it's deterministic: the same three inputs always produce the same HMAC.
4. How each game uses the algorithm
The HMAC is the same 32 bytes for every game. What changes is which bytes each game reads and how it maps them to an outcome.
Read the first four bytes as a 32-bit integer, take modulo 2. Exactly 50/50.
Uniform roll between 1 and 100. You win by rolling over or under your chosen target.
Read four bytes as a float 0-1, invert with a small house factor. Lower floats mean higher crash points.
Modulo 10 selects one of ten equally probable segments. Each segment maps to a multiplier defined by the risk level.
European single-zero roulette. Each of the 37 pockets is equally likely.
The index maps to a predefined payout table — determines which symbols appear and the multiplier.
A 40-number pool is shuffled using bytes from a chained HMAC. The first ten after shuffle are the draw. Every permutation is equally likely.
One byte per row; the least-significant bit decides left (0) or right (1). The ball's final bucket is the sum of its path.
Extended HMAC bytes shuffle the grid. Mines are placed at the first N positions of the shuffle — uniformly random across all possible configurations.
Want to recompute any of these? Use our verification tool — paste in the three inputs and it runs the same math your browser or a Python script would.
5. Seed rotation and why it matters
There's one subtlety: while the current server seed is in use, its actual value stays secret. The server reveals only the hash. That prevents you from precomputing outcomes and cherry-picking bets — but it also means you can't verify your bets until later.
This is solved by seed rotation. When you rotate your server seed (anytime you want from your account), three things happen:
- The old server seed is revealed to you in full.
- A fresh server seed is generated and its new hash is published.
- The nonce counter resets to zero.
With the old seed revealed, you can now verify every bet you made while it was active. Hash the revealed seed — if it matches the hash published before your first bet, you've confirmed the server committed to that seed before you played. Then replay each bet by running HMAC-SHA256 over (old_seed, your_client_seed, nonce) for each nonce you used. Every outcome you saw during play should match.
Rotate often if you want frequent audits. Rotate rarely if you want fewer steps. The math works either way.
6. How to verify a result yourself
Two ways to verify a FairWin outcome:
Fastest. Paste your (revealed server seed, client seed, nonce) into the verification tool and it shows the HMAC + the derived outcome for the game you pick. If it matches what you saw during play, the result was fair.
Open the verification tool →Don't trust our tool either? Here's Python that recomputes any outcome. Swap the extract function for the game you're verifying (see section 4).
Run it in Python, Node, Go, Rust — any language with SHA-256 works. The output must match what the game showed. If it ever doesn't, you have proof of manipulation. That's the whole point.
7. What provably fair does — and doesn't — guarantee
Being honest matters. Provably fair is powerful, but it has a specific scope.
- The server seed was committed before your bet — no post-hoc manipulation.
- Every outcome is a deterministic function of three public-enough inputs — you can recompute any past result.
- The server cannot pre-pick a seed that favors any specific client seed, because it doesn't know yours yet.
- Every game shares the same core derivation — the math is simple enough to audit in a weekend.
- That you'll win. Games still have built-in odds. The math is fair; it's not free money. Transparent odds ≠ favorable odds.
- That the operator will pay out. Fairness verifies the math, not the solvency. Always check an operator's payout history and reputation separately.
- That the front-end is honest. Provably fair verifies the game outcome, not the entry amount shown on your screen. Check your wallet balance against transaction history to confirm amounts.
- That your account is safe. Fairness is a game-level property, not a security guarantee. Use strong OAuth (Google), rotate seeds periodically, and verify withdrawal addresses.
Provably fair is a necessary condition for an honest game, but not a sufficient one. It's a foundation — a claim that's easy to audit. Combined with transparent payout history and open community channels, it's how a gaming operator earns long-term trust without asking for it on faith.
Try it yourself
Open the verification tool and recompute any FairWin outcome. Or browse the games and know, before your first bet, that you can audit every result.