Provably Fair CS2 Gaming
Every game outcome is cryptographically verifiable. Neither players nor the house can manipulate results — you can prove it yourself.
How It Works
Commit
Before you play, we generate a random server seed and show you its SHA-256 hash. This locks our commitment — we cannot change it.
SHA256(server_seed) → a3f8c1d…Play
Your client seed and an incrementing nonce combine with the server seed to produce the game outcome via HMAC-SHA256.
HMAC(server, client:nonce:0) → resultVerify
When you rotate seeds, the previous server seed is revealed. Verify it hashes to the original commitment, then reproduce the outcome yourself.
✓ Hash matches → outcome is authenticGame Verification
Each case open uses HMAC-SHA256 to derive a random float from the server seed (key) and a message of .
The float is mapped to a ticket between 1 and 100,000. Each item in the case owns a contiguous ticket range — all ranges sum to exactly 100,000. The item whose range contains your ticket is the outcome.
1const crypto = require('crypto');
2
3function verifyCaseRoll(serverSeed, clientSeed, nonce) {
4 const hmac = crypto.createHmac('sha256', serverSeed);
5 hmac.update(`${clientSeed}:${nonce}:0`);
6 const buf = hmac.digest();
7
8 const float =
9 buf[0] / 256 +
10 buf[1] / 65536 +
11 buf[2] / 16777216 +
12 buf[3] / 4294967296;
13
14 const ticket = Math.floor(float * 100000) + 1;
15 return { ticket, float };
16}
17
18// Verify the server seed commitment
19function verifyHash(serverSeed, expectedHash) {
20 const hash = crypto.createHash('sha256')
21 .update(serverSeed).digest('hex');
22 return hash === expectedHash;
23}
24
25// Each case item owns a ticket range.
26// All ranges sum to 100,000.
27// The item whose range contains your ticket wins.
Verify a Case Roll
Your Seeds
View your active seed pair, change your client seed, or rotate to reveal the current server seed.
Seed History
Past seed pairs with revealed server seeds. Use these to verify any previous game.
About this page
Can the house manipulate outcomes?
No. Before any round we publish a SHA-256 hash of the active server seed. The actual seed stays secret while you play, but the hash is fixed — if we ever swapped the seed to engineer a different outcome, the new seed would produce a different hash and you would catch it the moment you rotated. Combined with your own client seed and the per-game nonce, this means every roll is committed in advance and reproducible after the fact, with no room for the server to "rerun" a result it did not like.
What is a server seed, a client seed, and a nonce?
The server seed is a long random value picked by our backend and kept secret while in use; only its SHA-256 hash is shown publicly. The client seed is your random value — generated for you by default, or one you pick yourself in Settings. The nonce is a counter that increments by one for each game played on the active seed pair. The three together feed an HMAC-SHA256 function: same inputs always produce the same outcome, so any spin can be reproduced byte-for-byte.
Why do I need to rotate seeds to verify?
Verification requires the server seed in plaintext, but revealing it during play would let anyone predict the next outcomes — defeating the whole point. Rotation solves this: when you rotate, the current server seed is retired and revealed to you, a new one (with a new hash) is committed for future play, and the nonce resets. From that moment you can verify every game played on the retired seed, and the next games are committed under the new one.
Can I set my own client seed, and should I?
Yes. Open Settings → Provably Fair (or scroll to "Your Seeds" on this page), type any client seed you want — a word, a number, anything — and hit Rotate. From that moment every outcome is mixed with your seed, so the house cannot have predicted it in advance. Leave the field blank and we will generate a strong random one for you. Either is provably fair; setting a custom seed mainly gives you extra peace of mind and a nicer audit story when explaining results to friends.
How do I rotate my seeds?
Go to Settings → Provably Fair (or the "Your Seeds" panel on this page) and click "Rotate seeds". Rotation immediately reveals the current server seed so you can verify every past game played on it, generates a new server seed and publishes its hash, applies the client seed you chose (or a fresh random one if blank), and resets the nonce to zero for the next round. There is no cooldown — you can rotate as often as you like, including right before a session you want to audit cleanly.
What is the nonce and why does it matter?
The nonce is a per-game counter that ticks by one for each round played on the current server-seed/client-seed pair. It is what makes consecutive games unique even though the seed pair is the same — every nonce produces a different HMAC output and therefore a different outcome. When you verify a round you need to provide the exact nonce that was used, otherwise the verifier will reproduce a different (and wrong) result.
How is fairness handled differently in Case Battles?
Case Battles share a single committed server seed across every seat in the lobby, but each seat needs an independent roll on the same shared case. To make that work without a personal client seed per seat, the HMAC input mixes the shared server seed, the round nonce, and the player's user ID. Each seat's rolls are unique and verifiable, and the shared server seed is revealed when the battle ends so anyone can replay any spin in the battle.
How do I verify a roulette, mines, blackjack, or case round?
Open the verifier on this page and pick the matching game. Each verifier needs the revealed server seed (rotate first if needed), your client seed at the time of the round, and the round nonce — plus a game-specific input such as the mine count for Mines, the case ID for Cases, or the seat's user ID for Battles. The verifier reproduces the exact outcome the server generated. If the result differs from what the game showed on screen, save your seeds and contact support immediately.
What if I lose my client seed or do not save my nonces?
Your active seed pair and the nonce of every settled round are stored in your account so you can retrieve them later from Settings → Provably Fair and from your in-game history (case openings, hand history, mines history, etc.). If you rotate seeds without writing the values down it does not matter — the previous seed pair stays available for 14 days after rotation. Detailed game history is retained for 14 days, or 3 days for Poker. Save the verification details if you need them later.
Is provably fair the same thing as a regulator audit?
No, and that is important. Provably fair guarantees that each individual round was generated from inputs the server committed to in advance, so the house cannot pick outcomes after the fact. It does not, on its own, certify the long-run house edge of every game, the integrity of payouts, or compliance with a particular jurisdiction. CSRAGE pairs provably fair with internal controls and, where required, third-party scrutiny — but you should treat the two as complementary, not interchangeable.
Can I script my own verifier instead of using yours?
Yes. The exact algorithm for every game is documented on this page in plain JavaScript. The cryptographic primitives (SHA-256 for the commitment hash, HMAC-SHA256 for the per-round draw) are standard library functions in any major language, so you can port the snippets to Python, Go, Rust, or anything else. Independent verifiers help the whole community: if your script ever disagrees with our on-screen outcome, save the inputs and reach out so we can compare reference implementations.
Does playing more change the odds in my favour or against me?
No. Each round's outcome depends only on the seed pair and that round's nonce; nothing about your history, your level, your win streak, or your balance feeds into the RNG. Long sessions feel different because variance smooths out over many rounds, not because the underlying probabilities change. The verifier proves it: you can replay a single round in isolation, and the result will not depend on anything outside that round's inputs.