Meet the Kettlecorn editorial team Read our editorial policy
In plain English
A matching hash checks the values you supply. Full game verification needs the earlier record and the game's exact result calculation.

- Record
Save the commitment before the result.
- Reveal
Obtain the input for that same session.
- Compare
Hash the exact documented input; check the rest of the calculation separately.
The precise meaning
Provably fair describes a way to check a game's disclosed calculation against recorded inputs. Start by understanding what was committed before the result and what was revealed afterwards.
In this guide: contents & sources
Provably fair systems let you check whether a disclosed game calculation is consistent with recorded inputs and an earlier cryptographic commitment. In a server-seed scheme, you save the seed's hash before the result, then hash the revealed seed and compare the two.
That comparison is one part of verification. A matching hash does not establish the full result, a fair payout policy or a profitable game. This guide includes a local SHA-256 commitment checker so you can inspect that specific step without opening a casino account or placing a bet.
Commit first, reveal later
A commitment is a fingerprint of data that is initially hidden. For a SHA-256 server-seed commitment, the operator publishes the hash and later discloses the seed. Your earlier record matters: a newly supplied seed and hash can always agree with each other without showing what was published before the result.
A cryptographic hash is not an encrypted seed that you decrypt. To perform this comparison, you need the actual revealed input. The calculator below does not recover an unrevealed seed or predict a future game.
Record the commitment
Save the hash and the relevant game or session identifier before the result. Keep the time and provenance of that record separate from the later reveal.
Obtain the disclosed input
Follow that game's reveal procedure. Use the seed for the same recorded session and check how its documentation encodes it.
Recompute and compare
Apply the documented hash calculation. A hash match checks the commitment; reproducing the outcome still requires the rest of the game's calculation.
Try a local SHA-256 commitment check
This utility hashes the seed text in the input field as UTF-8 and compares the result with the 64-character hexadecimal commitment you enter. Browser text fields normalize pasted line endings to LF. It supports only schemes in which that text alone is the SHA-256 commitment input. Raw-byte inputs or a scheme that depends on CRLF line endings need their own verifier. It does not implement a casino's complete verifier.
Compare a revealed seed with its recorded hash
For schemes that commit to SHA-256 of the server seed as UTF-8 text. This checks one commitment, not the game outcome.
Use a game seed that has already been revealed. Never enter a wallet seed phrase, password or private key. Inputs stay in this checker; it sends no requests and saves no values.
UTF-8 text as entered in this field. Spaces count; browser text fields normalize line breaks to LF. Hex-looking seed text is hashed as text, not decoded into bytes. Raw-byte or CRLF-dependent schemes need their own verifier.
64 hexadecimal characters. Letter case and surrounding hash whitespace are ignored.
Enter both values, or load the educational example.
Calculated SHA-256
What a match does and does not establish
A match shows that the supplied text produces the supplied hash. This checker cannot establish when you recorded it. It does not recalculate a bet, validate randomness, certify a casino or predict a result.
Demo only: abc hashes to ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad. It is a public test string, not a secure random game seed.
A reproducible example: abc, abc with a space, and a missing record
The public test string abc produces the SHA-256 digest displayed in the checker's example above. Load that educational example and compare. Then add a space after abc and compare again: the input bytes changed, so the original commitment no longer matches. The checker preserves spaces rather than silently correcting them.
Now consider provenance. If someone gives you abc and its hash today, the two match. That does not show that this hash existed before yesterday's game. The missing evidence is the earlier commitment record, not another hash calculation.
The three-letter example is intentionally easy to reproduce. It is not a secure random server seed. A real system also needs appropriate seed generation and an implementation whose exact rules you can inspect.
| Input or record | What this checker can tell you | What remains unresolved |
|---|---|---|
| abc with the demo hash | The supplied text hashes to the supplied commitment | When that commitment was published; the outcome calculation |
| abc followed by a space with the same hash | Those exact bytes do not match that commitment | Whether the copied input or the scheme is wrong |
| Matching seed and hash, no earlier record | The two current values agree | Whether there was a pre-result commitment at all |
Why one site's inputs do not verify another site's game
Stake's implementation documents a server seed, client seed, nonce and cursor. Its published HMAC-SHA256 byte generation uses the server seed as the key and a message containing the client seed, nonce and round. The commitment comparison is separate from those generated bytes and their conversion into game events.
BGaming documents a different commitment based on result-and-secret data. Reproducing that scheme requires its specified data structure and game-specific steps. Pasting only a server seed into this guide's checker would test a different input.
Use the exact game's original documentation. Check whether a hex-looking seed is text or decoded bytes, how fields are joined, which hash or HMAC is used, and how random bytes become the displayed result. A nonce or cursor from another round cannot establish your round's result.
What you need to reproduce an actual result
Follow the verification process for that particular game. If the documentation or required inputs are missing, leave the outcome unverified. A commitment match cannot fill those gaps. A cryptocurrency payment or blockchain transaction does not by itself establish how a game result was calculated.
- The earlier commitment and a record tying it to the correct game or session.
- The revealed inputs and their exact encoding, including the client seed where used.
- The applicable nonce, round or cursor values and the game's documented algorithm version.
- The result-conversion rules, including ranges, rounding or selection rules.
- The recorded result to compare with your independently reproduced calculation.
A verifiable calculation can still cost you money
Result verification and payout economics answer different questions. A reproducible result can coexist with a house edge, fees or losses. For an illustrative C$100 of total stakes at a stated 97% theoretical return to player, the long-run average loss implied by that assumption is C$3. That is an expectation under the stated model, not a forecast for a C$100 session or proof that a game's advertised percentage is accurate.
This checker does not assess account restrictions, withdrawal handling, operator reliability or whether you should gamble. Those decisions require separate evidence. You can use the explanation and example here without making a commercial choice.
If your next question is which casino makes verification records available, NEXT LEVEL’s separate comparison describes casino verification evidence and its limits. It covers provider choices rather than the calculation taught here. Gambling can cause financial loss; a verifiable result does not remove that risk.
A few loose ends
Common questions
What does provably fair mean?
It describes a disclosed verification process for checking a game's calculation against recorded inputs and a prior commitment. The useful question is which calculation you can reproduce and which evidence is available for your specific result.
Can this checker verify a complete casino round?
No. It compares SHA-256 of a revealed seed's exact UTF-8 text with a supplied commitment. It does not apply client seeds, nonces, cursors or game-result conversion rules.
Why does a space change the result?
SHA-256 hashes bytes. A trailing space, different capital letter or line break changes those bytes. The checker does not trim the seed or interpret hexadecimal-looking text as binary data.
Does a hash mismatch prove cheating?
No. It could reflect the wrong session, copied text, a different encoding or a different commitment scheme. Check the original records and implementation before drawing a conclusion.
Do I need a wallet or a deposit for the example?
No. The public abc example and local hash comparison work without a wallet connection, casino account or payment.
Check the original
Sources & checks
Reviewed October 1, 2026. Availability, fees and platform rules can change. Confirm the relevant details at the source before acting.