What Is Provably Fair in CS2? How to Verify Case Openings and Rolls
Updated October 2026 · MyCS2Guru crew
"Provably fair" gets thrown around on every CS2 site, bro, but most people have no idea what it means or how to check it. This guide explains what provably fair is in CS2, how the server seed, client seed and nonce fit together, how to verify a case opening step by step, what it does and doesn't prove, and the red flags that tell you a "fair" system isn't really fair.
18+ only. Fair doesn't mean you'll win. Every game still has a house edge. Responsible gambling.
Provably fair in one paragraph
Before you play, the site picks a secret server seed and shows you its hash (a fingerprint that can't be reversed). You provide a client seed. Each roll combines the server seed, your client seed and a nonce (a counter) to produce a number, and that number decides the result. When you rotate seeds, the site reveals the old server seed. You hash it to confirm it matches the fingerprint shown earlier, then recompute your results. If everything matches, the site couldn't have changed the outcome after you bet.
The ingredients
| Ingredient | What it is | Who controls it | When you see it |
|---|---|---|---|
| Server seed | A long random secret | The site | Hashed before play, revealed after rotation |
| Server seed hash | SHA-256 fingerprint of the server seed | The site | Before play |
| Client seed | A string you can set | You | Any time |
| Nonce | A counter that goes up each roll | Automatic | Shown with each result |
| Public seed (some games) | Shared randomness, e.g. from a third party | Outside source | After it's generated |
How a result is generated
Sites document their own formula, but most follow a similar pattern:
- Combine the inputs, e.g. *client_seed:nonce*, and run HMAC-SHA256 with the server seed as the key.
- Take part of the output (for example the first 8 hexadecimal characters).
- Convert it to a number and divide to get a value between 0 and 1 (or 0 and 100, or a ticket number).
- Map that value onto the game, for example onto a case's odds table.
Example mapping for a case: if a case has items with chances of 70%, 25%, 4.5% and 0.5%, a roll of 0.00-69.99 gives item A, 70.00-94.99 item B, 95.00-99.49 item C and 99.50-99.99 item D. The roll is fixed by the seeds, so the item is too.
Why hashing makes it "provable"
A hash function like SHA-256 turns any input into a fixed-length fingerprint. Two important properties:
- You can't work backwards from the hash to the seed, so showing the hash doesn't reveal the secret.
- You can't find a different seed with the same hash, so the site can't swap seeds later.
That's what lets a site commit to a seed in advance without giving it away.
Step-by-step: verifying a case opening
- Open the fairness page on the site before playing. Copy the server seed hash and note your client seed.
- Optional but smart: set your own client seed, any random string you like.
- Play. Note the nonce for the opening you want to check.
- Rotate seeds. This reveals the old server seed and starts a new pair.
- Check the hash. Run SHA-256 on the revealed server seed (any online SHA-256 tool or the site's verifier). It must exactly match the hash from step 1.
- Recompute the roll using the site's published formula or an independent verifier, with the server seed, client seed and nonce.
- Map the roll to the odds table for that case and confirm you got the right item.
If any step fails, screenshot everything and contact support. On a properly run site, it will match.
What provably fair proves
| Proves | Doesn't prove |
|---|---|
| The result was fixed before you played | That the odds are good |
| The site didn't change the outcome afterwards | That there's no house edge |
| Your client seed was used | That the published odds table is generous |
| Results follow the published formula | That the site will pay out withdrawals |
Provably fair is about integrity, not value. A case with terrible odds can be perfectly provably fair.
Provably fair vs in-game CS2 cases
| In-game CS2 cases | Provably fair site cases | |
|---|---|---|
| Odds published | Rarity odds (Valve) | Per-item odds table |
| Can you verify a result? | No | Yes |
| Who generates the result | Valve's servers | Seeds you can check |
| House edge | Key cost and market | Built into case pricing |
In-game cases use Valve's published odds, and there's no reason to think they're rigged, but you can't verify an individual unboxing the way you can on a provably fair site.
Provably fair in different games
| Game | How the roll is used |
|---|---|
| Case opening | Roll maps to the odds table |
| Upgrader | Roll compared with your win chance |
| Roulette | Roll maps to a wheel slot |
| Crash | Seeds generate the crash point |
| Plinko | Seeds decide left or right at each row |
| Coinflip | Roll decides the side |
| Case battles | Shared seeds for all players, often with outside randomness |
| Jackpot | Roll picks the winning ticket |
Case battles: why shared randomness matters
In a battle, several players need to trust one result. If one player's client seed decided everything, others could feel cheated. Good battle systems use a public seed generated after everyone has joined, often from a third-party source, combined with the server seed. Clash.gg reportedly uses a third-party randomness source for battles, so nobody, including the site, knows the outcome when the lobby fills.
How our two picks handle it
Clash.gg
Clash.gg documents provably fair for its PvE games: hashed server seed before play, your client seed and a nonce, with seed rotation revealing old seeds. Independent analysts have reproduced its case results from the published method. For battles, it reportedly uses a shared seed from a third-party randomness source. Deep dive: Clash.gg provably fair explained.
CSGOEmpire
CSGOEmpire uses a provably fair system across its games and is unusually open about house edges, listing them in its help centre (6.66% on roulette colour bets, for example). Check its fairness page for the exact method. Note its restricted countries, which include the US, UK, Australia, France, Germany, Spain and the Netherlands.
| Site | Bonus with FREECASES4U | Games | Payments | |
|---|---|---|---|---|
| Clash.gg (Top pick) | 3 Free Cases + 5% deposit bonus | Case battles, cases, upgrader, crash, roulette, plinko, mines, keno, esports | CS2 skins, crypto | Claim |
| CSGOEmpire | Free case up to $1.4k | Roulette, case battles, cases, coinflip, esports | CS2 skins, crypto | Claim |
Red flags: fake "provably fair"
| Red flag | Why it matters |
|---|---|
| No server seed hash shown before play | Nothing is committed in advance |
| You can't set a client seed | The site controls all inputs |
| Seeds never get revealed | You can't check anything |
| No published formula | You can't recompute results |
| Verifier only on the site, with no method | You're trusting their tool |
| Old seeds "unavailable" | Possible tampering |
| Hashes change after you bet | Big problem |
Common misunderstandings
"Provably fair means 50/50." No, it means the result followed the published odds.
"If I lose a lot, it's not fair." Losing streaks are normal. Verify a few results, and if they check out, it's variance plus the house edge.
"I can predict results if I know the hash." No. The hash doesn't reveal the seed, and that's the whole point.
"Changing my client seed changes my luck." It changes the outcomes, but not the odds. Each new combination is just as random.
A simple verification habit
You don't need to verify every roll. A good habit:
- Set your own client seed when you join a site.
- Verify one or two results after your first session.
- Verify any big or suspicious result.
- Rotate seeds occasionally so you can check past results.
Glossary
| Term | Meaning |
|---|---|
| Hash | A one-way fingerprint of data |
| SHA-256 | A widely used hash function |
| HMAC | A way of hashing with a secret key |
| Server seed | The site's secret random input |
| Client seed | Your input |
| Nonce | A counter for each roll |
| Seed rotation | Swapping to a new seed pair and revealing the old server seed |
| Public seed | Outside randomness used in shared games |
| Verifier | A tool that recomputes results |
Bottom line
Provably fair is one of the best things to happen to CS2 gambling. It means you don't have to take a site's word for it. Learn how to check one result, set your own client seed and remember that fair doesn't mean favourable. Both of our picks, Clash.gg and CSGOEmpire, use it. Start with free cases via FREECASES4U.
A worked example (made-up numbers)
Let's walk through a pretend case opening so the steps feel real. These values are illustrative, not from any real site.
- Before playing, the fairness page shows a server seed hash, a long string of 64 hexadecimal characters such as *9f2c...e71a*. You copy it into a notes file.
- You set your client seed to *bro-luck-2026*.
- You open a case. The result page shows nonce 1.
- The site computes HMAC-SHA256 with the server seed as key and *bro-luck-2026:1* as the message. The output is another 64-character hex string, say *3b7a91c4...*.
- It takes the first 8 characters, *3b7a91c4*, which as a number is 997,888,452.
- It divides by 2^32 (4,294,967,296), giving about 0.2323, or a roll of 23.23 out of 100.
- It maps 23.23 onto the odds table. If item A covers 0.00-69.99, you get item A.
- Later you rotate seeds. The site reveals the old server seed. You hash it with SHA-256 and get exactly *9f2c...e71a*, matching what you saved.
- You recompute steps 4-7 with a verifier and get the same roll and item. Verified.
Different sites use slightly different steps, such as more characters, a different divisor or a different message format, which is why you always use the site's published method.
How crash games use hash chains
Crash games often use a different design: a hash chain. The site generates a long chain of hashes where each round's seed is the hash of the next one. It publishes the final hash in the chain up front. Each round, it reveals the previous link, and you can hash it to confirm it leads to the one before. Because each value depends on the next, the site can't change future rounds without breaking the chain. Some sites also mix in a public value, like a future blockchain block hash, so even the site can't pick the chain to suit itself.
Sources of outside randomness
| Source | How it's used | Why it helps |
|---|---|---|
| Third-party random services | Generate a value after a lobby fills | Nobody knows it in advance |
| Future blockchain block hashes | Used as a public seed once the block exists | Can't be predicted or controlled by the site |
| Combined seeds from all players | Each player's input mixed together | No single party controls the result |
Verifying without being a programmer
You don't need to code to check a result:
- Use the site's verifier to recompute rolls, and compare with the result you saw.
- Use an independent SHA-256 tool to hash the revealed server seed and compare with the hash you saved. This step doesn't depend on trusting the site's tool.
- Use an independent verifier that supports the site's published method, if one exists.
- Keep screenshots of the hash, client seed and results before you rotate.
If you can code, recreating the formula from the site's documentation in a few lines of Python or JavaScript is the gold standard.
A brief history of provably fair
Provably fair systems came out of early Bitcoin gambling sites, which wanted a way to show players they couldn't cheat without needing a regulator to vouch for them. Skin gambling sites adopted the same idea after a run of scandals in the CS:GO scene, when players had no way to check whether a jackpot or coinflip had been rigged. Today, a working provably fair system is a basic requirement for any CS2 site we'd consider.
Provably fair checklist for any site
- [ ] Server seed hash shown before I play
- [ ] I can set my own client seed
- [ ] Nonce shown for each result
- [ ] Old server seeds revealed on rotation
- [ ] Published formula or documentation
- [ ] Results I've checked actually match
- [ ] Shared games (battles, crash, jackpot) use outside or combined randomness
How provably fair and house edge fit together
Think of it like this: the odds table or payout rules decide how generous a game is, and that's where the house edge lives. Provably fair guarantees the site actually followed those rules for your roll. You want both: a fair process (provably fair) and published odds or edges so you know the price you're paying. CSGOEmpire's help centre publishing edges like 6.66% on roulette colours is a good example of the second part.
More provably fair questions
Can a site still cheat with provably fair? It's much harder. The main risks are a site misrepresenting the odds table, delaying seed reveals or changing rules without telling anyone. That's why reputation and published odds matter too.
Why do I have to rotate seeds to verify? Revealing the current server seed would let you predict future rolls. The site only reveals it once you've moved to a new seed.
Does the nonce matter? Yes. It makes each roll different even though the seeds stay the same. Always note the nonce of the roll you're checking.
Is a longer client seed better? Length doesn't change the odds. What matters is that you chose it.
What if the site's verifier and my own check disagree? Trust the independent check, document everything and contact support. If it isn't resolved, stop using the site.
Are case battles verified per player? Usually the whole battle uses shared seeds so every player's drops come from the same verifiable source. Check the battle's fairness panel.
Provably fair vs licensing and audits
| Trust signal | What it tells you |
|---|---|
| Provably fair | Individual results weren't changed |
| Published odds / edges | How generous the games are |
| Licence | A regulator has some oversight |
| Independent audits | A third party has tested systems |
| Track record | The site has paid players over time |
No single signal is enough. The best sites stack several. When you're choosing where to play, look at all of them together.
Why this matters for you
The scene has a history of rigged games and scams. Provably fair takes away one big risk: that the site changes a result after the fact. Spend ten minutes learning to verify once, and you'll be able to check any site that claims to be fair, and spot the ones that only pretend to be.
Auditing a case: provably fair plus the odds table
Verifying a roll tells you the result was honest. To judge whether a case is worth opening, add one more step: check its expected value from the odds table.
- List every item with its chance and value.
- Multiply each chance by its value.
- Add them up. That's the case's expected value.
- Compare with the case price.
| Item | Chance | Value | Chance x value |
|---|---|---|---|
| A | 70% | $0.50 | $0.35 |
| B | 25% | $1.50 | $0.375 |
| C | 4.5% | $6.00 | $0.27 |
| D | 0.5% | $60.00 | $0.30 |
| Total EV | $1.295 |
If this made-up case cost $1.45, its EV of about $1.30 means an average return of roughly 89%, so about an 11% edge. Provably fair guarantees your roll was honest, while the odds table tells you the price. Together, they give you the full picture.
Walkthrough: finding the fairness page
On Clash.gg: look for the fairness or provably fair link in the site footer or your account settings. There you'll see your current server seed hash, your client seed (which you can change) and options to rotate seeds and view previous ones. Battles have their own fairness details.
On CSGOEmpire: look for the provably fair or fairness section, usually linked from the footer or help centre. It explains how each game's results are generated and how to check them. The help centre also lists game house edges.
Interfaces change, so if you can't find it, ask live chat: "Where can I verify provably fair results?" A legit site will point you straight to it.
Teaching a friend in 30 seconds
"The site locks in a secret before you play and shows you its fingerprint. You add your own random word. Each roll mixes the secret, your word and a counter. Afterwards, the site reveals the secret, you check it matches the fingerprint, and you can redo the maths yourself. If it matches, they couldn't have cheated that roll. It still doesn't mean you'll win, because the odds are still the odds."
Provably fair dos and don'ts
| Do | Don't |
|---|---|
| Save the server seed hash before you play | Rotate seeds before saving your results |
| Set your own client seed | Assume a "verified" badge means anything without checking |
| Verify big or unusual results | Trust "predictor" tools that claim to read seeds |
| Use an independent SHA-256 tool for the hash check | Share your account with anyone offering to "verify" for you |
| Read the site's published method | Forget that the house edge still applies |
Final checklist before you trust a "fair" site
If a site shows a server seed hash before play, lets you set a client seed, reveals old seeds, publishes its formula and its results check out when you verify them, it passes the provably fair test. Then look at its odds, edges, track record and withdrawals. Our two picks clear that bar, and you can test them yourself with the free cases from FREECASES4U.
One last tip: keep a simple text file with each site's current server seed hash and client seed whenever you start a session. It takes ten seconds and means you can always verify later, even if you forget to screenshot before rotating seeds. Future you will thank you.