Provably fair is a cryptographic method that lets you re-check a game result after the round and confirm the operator did not swap the outcome once your bet was in. It rests on three published values (1): a hashed server seed shown before you play, a client seed you control, and a nonce that counts each bet. Re-run the math, match the hash, and the round proves itself. On Rainbet I rotated my seed after five Dice rounds and re-hashed the revealed server seed in a browser console; the fingerprint matched in well under a minute.
That is the whole promise, and it is narrower than most players assume. Let me walk it through generically first, then show how Rainbet actually implements it, and finally where the mechanism stops helping.
What provably fair really means
It means one thing: a specific result was locked in before you bet and cannot have been altered after. Nothing more.
It does not prove a game has a fair house edge. It does not prove a slot’s advertised return to player is genuine. It does not promise your withdrawal gets paid. A Dice game can be flawlessly provably fair and still keep a 1% cut of every wager - the math being honest and the value being good are two separate questions, and I have watched people confuse them. Treat provably fair as a tamper-evidence seal on a single round, not a stamp of overall trust.
The reason it exists is that ordinary online slots run on a server-side random number generator you can never inspect. In-house crypto games flip that: they hand you the ingredients to audit each round yourself, no support ticket required.
The three values that drive a round
Three pieces of data feed the result, and each one has a distinct job. This is the split Rainbet’s Originals use, and it is standard across seed-based provably-fair systems.
| Value | Who sets it | Shown to you | Its job |
|---|---|---|---|
| Server seed | The operator | Hashed before the bet; plaintext revealed on rotation | The secret ingredient, committed in advance so it cannot change |
| Client seed | You (editable) | Yes, in full | Stops the operator picking a server seed to line up against a value it already knew |
| Nonce | Automatic | Counts from 0, +1 per bet | Keeps every round in a session distinct from the same two seeds |
Combine the three, hash them together with SHA-256 (2), and a deterministic function converts that hash into a game result: a Crash multiplier, a Dice roll, a Mines layout. Same three inputs, same output, every single time. That determinism is the point - you can reproduce the result, so the operator can’t lie about it.
Why the client seed matters most to you
The client seed is your lever. Because you can edit it, the operator cannot have hand-picked a server seed that pairs badly with a client seed it controlled. If a site locks the client seed or buries the rotation button, that is a small red flag worth noting before you deposit much. Rainbet lets you set your own client seed and rotate freely, which is what you want.
How the commit-and-reveal cycle works
The sequence is a sealed-envelope trick. Before you bet, the operator shows you only the hashed server seed - the answer is inside the envelope, you just can’t read it yet.
You then set or accept a client seed and start playing, the nonce climbing by one with each round. When you want to audit, you rotate the server seed. At that moment the operator reveals the old plaintext seed and immediately commits a fresh hash for the next batch. Now you hold everything you need: the revealed server seed, your client seed, and the nonce range you played.
Verification is two checks. First, hash the revealed server seed yourself and confirm it equals the fingerprint you were shown up front. Second, feed all three inputs through the game’s published algorithm and confirm the output matches what landed on screen. Both pass, the round was clean.
How Rainbet implements provably fair
Rainbet ships this on its in-house Originals - Plinko, Limbo, Wheel, Tower, Mines, Keno, Dice, Crash and the rest - and publishes the exact algorithm on each game page. Each result is built from your client seed, the hashed server seed, and the per-bet nonce, exactly as above.
In my own test I opened Dice, left the client seed at its default for two bets, then edited it to a phrase of my own and placed three more. After the fifth round I rotated the server seed, copied the revealed plaintext, and ran SHA-256 on it in the browser console. The result matched the pre-bet fingerprint character for character. I then pushed server seed, client seed and nonce 2 through the documented Dice formula and reproduced the roll that had busted my third bet. Two matches, and I never had to trust Rainbet’s own verifier to get them.
One honest caveat: most players never do this. The feature only protects you if you actually exercise it, and the overwhelming majority of rounds go unchecked. It is a right, not an automatic shield.
Verifying a past bet, step by step
Here is the exact routine I follow. It takes about a minute once the seeds are rotated.
| Step | What you do | What proves out |
|---|---|---|
| 1 | Before playing, copy the hashed server seed shown in the fairness panel | The outcome is committed in advance |
| 2 | Set your own client seed (or note the default) and play your rounds | Nonce increments 0, 1, 2… per bet |
| 3 | Rotate the server seed to reveal its plaintext | Old seed is unhashed; a new hash is committed |
| 4 | Run SHA-256 on the revealed seed and compare to step 1’s hash | The seed was never swapped mid-session |
| 5 | Feed seed + client seed + the bet’s nonce through the published algorithm | Output equals the result you saw on screen |
You don’t have to use the operator’s built-in verifier for steps 4 and 5, and arguably you shouldn’t. Paste the values into an independent third-party verifier, or run the hash yourself. When both strings line up, no mid-session tampering is possible.
Provably fair versus certified RNG
Rainbet’s third-party slots and live-dealer tables - the Pragmatic Play, Evolution, Hacksaw and NoLimit City content - do not expose seeds. They can’t, really; the game logic lives on the studio’s servers. Instead they rely on a certified random number generator audited by an independent testing lab (3). That is a different trust model, and both matter.
Provably fair gives you per-round proof you run yourself. Certified RNG gives you a lab’s periodic word that the generator and RTP hold up across millions of spins. One is real-time and self-served; the other is statistical and outsourced to auditors. A crypto casino that offers both - auditable Originals plus lab-checked studio games - covers more ground than either alone.
| Property | Provably fair (Originals) | Certified RNG (third-party slots) | EOS blocks (multiplayer) |
|---|---|---|---|
| What it proves | This round wasn’t altered after your bet | Generator and RTP hold over millions of rounds | Randomness came from a public external event |
| Who verifies | You, per round | An independent testing lab | Anyone, via the public ledger |
| How often | Real time, if you bother | Periodic audit | Real time, per round |
| Covers studio slots? | No | Yes | No |
| Source of randomness | Seeds you help set | Server-side RNG | EOS blockchain block hash |
Blockchain randomness for multiplayer games
Seed-based provably fair has one structural limit in a multiplayer game: if the operator generates the server seed, a suspicious player can always ask whether it was chosen to favour the house. Rainbet’s shared games - Case Battles and EOS Roulette - sidestep that by taking their randomness from the EOS blockchain instead (4).
Here’s the idea. EOS produces new blocks on a fixed cadence, and each block carries a hash that nobody can predict or rewrite once it’s confirmed. When a Case Battle needs a result, the outcome is derived from an upcoming block’s hash - a value the operator does not create and cannot alter. Because that block is public and permanent, every participant can look it up on any EOS explorer and confirm the game used it honestly.
That is arguably a stronger guarantee than a self-generated server seed, because the entropy comes from outside the casino entirely. No seed to rotate, no fingerprint to trust - just a public ledger entry that all players in the battle can read the same way. It’s the closest thing online gambling has to rolling dice in the open air.
What provably fair does not cover
Verification only helps if you read its limits correctly. A few worth stating plainly.
- House edge is untouched. A provably-fair game can pay 1.98x on a 50/50 bet instead of 2.00x. The math is honest; the value carries a cut. Check the RTP or house edge separately.
- It only covers games that offer it. Rainbet’s studio slots don’t expose seeds, so on those you’re back to trusting the certified RNG and its lab audit.
- A clean hash is not a payout guarantee. Honest round math says nothing about whether a large withdrawal clears promptly. That is a licensing and cashier question, which I dig into in the full Rainbet assessment.
- Most rounds go unverified. The tooling protects only the bets you actually check.
None of this makes provably fair weak - it makes it specific. Used right, it removes one very real worry (a rigged result) and leaves the others where they belong.
Frequently asked questions
Can a provably-fair game still be rigged against me?
No, not on any round you verify, because you can re-compute the result from the seeds and catch tampering. But the proof only covers games that expose seeds, and it says nothing about the house edge or whether withdrawals get paid.
Do I need coding skills to check a bet?
No. Most operators publish the algorithm and a built-in verifier where you paste the revealed server seed, client seed and nonce. For independence you can run the same SHA-256 hash in any browser console. It’s copy-paste, about a minute.
Why should I change my client seed?
Because it’s the value you control. Setting your own client seed removes any chance the operator paired the server seed against a client seed it already knew. If a site won’t let you edit it, treat that as a caution before depositing much.
Does provably fair mean the odds are good?
No, and this is the common trap. It confirms the result was honest, not that the payout is generous. A Dice game with a 1% edge and one with a 10% edge can both be fully provably fair, so read the RTP separately.
How is EOS-block randomness different from seeds?
Seed randomness is generated by the operator; EOS-block randomness comes from a public blockchain block the operator can’t create or rewrite. For multiplayer games like Case Battles that external source is generally a stronger, harder-to-question guarantee.
Which Rainbet games are provably fair?
The in-house Originals - Plinko, Limbo, Dice, Crash, Mines, Wheel, Tower, Keno and others - use client-seed, server-seed and nonce verification. Third-party slots and live tables instead use certified, lab-audited RNG.
Can I verify a bet after I’ve already played it?
Yes, as long as you rotate the server seed to reveal its plaintext. Rotation unhashes the old seed and commits a new one, so you keep the ability to audit every round played under the previous seed.
How did we verify the fairness system?
I played five Dice rounds on Rainbet, edited the client seed partway through, rotated the server seed, then re-hashed the revealed seed in a browser console and re-ran the published formula. Both the hash and the roll matched.