There are exactly two models that promise players a fair game online. One hands you a certificate from a lab you've never heard of. The other hands you a hash and says "check it yourself." Both claim to guarantee fairness — but they guarantee very different things, and both have gaps they'd rather you didn't think about. After building the provably-fair mechanics in ZimBet and reading through RNG certification standards for comparison, here's an honest look at what each model actually does and where each one breaks down.
How RNG certification works
Traditional online casinos rely on a pseudorandom number generator — a deterministic algorithm seeded with entropy — to decide every outcome. Players never see this RNG or its output directly. Instead, an independent testing lab audits it and issues a certificate saying "we checked; it's fair."
The big labs — eCOGRA, GLI (Gaming Laboratories International), iTech Labs, BMM Testlabs — follow a standard process:
- Source code review. Engineers inspect the RNG implementation to confirm it uses a sound algorithm (typically a well-known CSPRNG like Fortuna or a Mersenne Twister variant), is properly seeded from real entropy, and hasn't been tampered with.
- Statistical testing. The lab runs the RNG's output through batteries of randomness tests, often based on NIST SP 800-22 — a suite of 15 tests (frequency, runs, serial, approximate entropy, etc.) designed to catch patterns, correlations, or biases in a bitstream.
- Payout verification. The lab checks that the game's theoretical return-to-player (RTP) matches what the code actually calculates — i.e. the game pays out at the advertised rate, not less.
- Periodic re-audit. Certification isn't permanent. Labs typically re-test annually, and some jurisdictions require ongoing monitoring of live payout data against declared RTPs.
The result is a stamp — "eCOGRA Certified" or similar — that appears in a casino's footer. Players are trusting the lab's competence, independence, and the fact that the production system matches the one that was audited.
How provably-fair works
Provably fair flips the trust model. Instead of an outside lab verifying the system behind closed doors, the game gives you enough information to verify each round yourself, using a cryptographic commit-and-reveal pattern:
- Before the round, the server generates a server seed and publishes its SHA-256 hash — a one-way fingerprint. This commits the server to that seed without revealing it.
- The player provides (or has previously set) a client seed, and the system tracks a nonce that increments each round.
- The outcome is computed deterministically:
HMAC-SHA256(server_seed, client_seed + nonce)→ hex → game result. - After the round, the server reveals the actual server seed. The player can hash it to confirm it matches the pre-round commitment, then re-run the HMAC to confirm the result wasn't altered.
No lab, no certificate, no trust required — you verify it with the same maths the server used. I covered the specific mechanics for crash games in how Aviator's crash point works and for Plinko in how Plinko's RNG maps hash bits to bounces.
What each model actually guarantees
They sound like they're doing the same job, but they're answering different questions entirely:
- RNG certification answers: "Is the system's random number generator statistically sound, and does the game pay out at the declared rate?" It checks the system as a whole — algorithm quality, entropy, payout tables — at the time of audit.
- Provably fair answers: "Was this specific round determined by the committed inputs, and can I reproduce the result?" It guarantees per-round integrity, not system-wide properties.
Notice the gap. RNG certification doesn't let you verify any individual round — you're trusting the lab's stamp. Provably fair doesn't tell you whether the payout percentages are honest or whether the RNG has good entropy — it only proves the commit-reveal chain wasn't broken.
Where RNG certification falls short
The obvious weakness is opacity. You can't check anything yourself. You're trusting:
- That the lab was thorough and independent (labs are paid by the operator).
- That the production build matches the one the lab tested (the audit covers a snapshot in time).
- That nothing was changed between certification cycles (re-audits are typically annual, not continuous).
Most reputable labs do solid work, and regulated jurisdictions impose real consequences for cheating. But the player has no way to independently confirm any of it. You either trust the logo in the footer, or you don't.
Where provably fair falls short
This is the part that rarely makes it into the marketing. Provably fair has a known structural weakness that's worth understanding:
After you set your client seed, the server already knows every future outcome for that seed pair. It controls the server seed. Nonces are sequential. So it can compute round 2, 3, 4, … before they happen. A dishonest operator could theoretically cycle through server seeds before committing, searching for one whose sequence favours the house across your session. No individual round's verification would fail — every hash would still check out — but the selection of the seed pair wouldn't have been random.
The only round that's truly immune to this is the very first one after you change your client seed — because the server commits to its server seed hash before knowing your new client seed. From round two onward, the server has enough information to compute future outcomes.
This doesn't mean every provably-fair casino is cheating. It means provably fair, on its own, is not the complete guarantee some people assume it is. It proves the commit-reveal chain worked. It doesn't prove the seed was chosen honestly.
What each model misses
Here's the practical summary:
- RNG certification checks but doesn't let you verify. The lab inspects payout rates, entropy quality, and the algorithm — things you can't see — but you have no way to confirm any specific round was fair.
- Provably fair lets you verify but doesn't check. You can re-derive any round's result, but nobody's auditing the payout table, the actual house edge, server-side seed selection, or whether the implementation has bugs.
The strongest setup is both: lab certification for system-level assurance (the maths is sound, the RTP is honest, the entropy is real) plus provably fair for per-round transparency (this specific outcome wasn't swapped after you bet). Neither alone covers everything.
Which one matters more to players?
It depends entirely on the player. Someone in a regulated market like the UK or Malta probably cares more about the licensing body and lab certification, because those come with legal teeth — complaints, fines, licence revocation. A crypto-native player on a Curaçao-licensed site might care more about provably fair, because the licensing in some offshore jurisdictions is lighter and the ability to verify rounds yourself provides a tangible check.
If you're building a casino, the pragmatic answer is straightforward: implement provably fair if your game's mechanics support it (crash, dice, Plinko, mines — single-outcome games where the hash-to-result mapping is clean). Get RNG certification if you operate in any regulated jurisdiction, because regulators generally don't accept provably fair as a substitute. Ideally, do both.
What building both sides taught me
Implementing the provably-fair flow in ZimBet gave me a deep appreciation for how elegant the commit-reveal pattern is — and also for its limits. The cryptography is genuinely beautiful: you can hand someone a hash and later prove you weren't lying, without revealing anything in advance. But elegant cryptography doesn't automatically mean the whole system is trustworthy. The payout table, the seed selection process, the server-side implementation — those live outside what the hash can prove.
That's why I think the most honest thing you can do as a developer is be transparent about both what your system guarantees and what it doesn't. Provably fair is a powerful tool, not a magic seal. RNG certification is a necessary check, not a blank cheque. The real answer to "what makes a game fair" isn't either model alone — it's the combination of verifiable mechanics, honest payout design, and independent oversight.