How to verify a case or dice roll step by step (HMAC-SHA256)

To verify a roll you need four things: the revealed server seed, the hash of it you were shown before playing, your client seed and the nonce. You hash the server seed and compare it with the commitment, then compute HMAC-SHA256 of client_seed:nonce keyed with the server seed, convert the start of the result into a number, scale it to a roll, and check it against the outcome you were given. This guide walks through each step with real computed values.

The method below is one common convention. Sites differ in the details, so always compare it with the documentation of the game you're checking. All seeds are examples made up for this guide.

What you need before you start

If any of these are missing, you can't complete the check. A site that hides one of them is on our red-flags checklist.

Step 1: Check the commitment

Hash the revealed server seed with SHA-256 and compare the result, character by character, with the commitment you saved.

sha256("9f2c4e1a7b3d8e6f0a5c2b9d4e7f1a3c")
= a5e39de9361cb47dd6ccdf84bb0cbeff1e402575f217b91bb2e560cfe1ac582d
commitment
= a5e39de9361cb47dd6ccdf84bb0cbeff1e402575f217b91bb2e560cfe1ac582d   ✓ match

This is the most important step. If it fails, the seed you've been given isn't the one that was committed, and nothing that follows can be trusted.

Be exact about the input. Hashing the same seed with a trailing newline (what you get from some copy-paste or echo commands) gives 2fe7323ff3e99f18…, a completely different hash. If you get a mismatch, check for stray whitespace before drawing conclusions.

Step 2: Build the message

In this method, the message is the client seed, a colon and the nonce:

message = "lab-reader-01:0"

Other methods use different separators, put the nonce first, or add a round counter. The message must match the site's format exactly.

Step 3: Compute HMAC-SHA256

HMAC-SHA256 is a keyed hash. Here the key is the server seed and the data is the message.

HMAC-SHA256(key = "9f2c4e1a7b3d8e6f0a5c2b9d4e7f1a3c", data = "lab-reader-01:0")
= c6b1e6abfb75912f63fb7d8e96d037910dd26cd81e57d5e70c7fc855c3fdb59e

The result is 64 hex characters, or 32 bytes. Its first four bytes are c6, b1, e6, ab — in decimal, 198, 177, 230 and 171.

Step 4: Turn hex into a number

Take the first 8 hex characters (those four bytes) and read them as one unsigned 32-bit integer:

0xc6b1e6ab = 3,333,547,691

The largest possible value is 2³² − 1 = 4,294,967,295, so this number sits about 77.6% of the way through the range.

Step 5: Scale to a roll

Multiply by 10,000, divide by 2³² (rounding down), then divide by 100:

floor(3,333,547,691 × 10,000 ÷ 4,294,967,296) ÷ 100
= floor(7761.55…) ÷ 100
= 77.61

That gives a roll between 0.00 and 99.99. The game showed 77.61, so the roll is verified.

Step 6: Map the roll to an outcome

The roll itself isn't the prize. The game turns it into an outcome with a rule, and that rule is something you check by reading, not by hashing.

Dice example. A fictional dice bet "roll under 49.50" wins on rolls 0.00–49.49. A roll of 77.61 loses. On nonce 1 the same seeds give 18.35, which would win.

Case example. A fictional case publishes this range table:

Roll 77.61 falls in 0.00–79.99, so the outcome is Common. Two separate checks have happened here: the cryptography confirmed the roll, and the table confirmed what the roll should have paid. The ranges also add up to 100% and their widths match the stated shares — worth checking on any real table, because the proof can't do it for you.

Do the whole thing in Python

import hmac, hashlib

server_seed = "9f2c4e1a7b3d8e6f0a5c2b9d4e7f1a3c"
commitment  = "a5e39de9361cb47dd6ccdf84bb0cbeff1e402575f217b91bb2e560cfe1ac582d"
client_seed, nonce = "lab-reader-01", 0

assert hashlib.sha256(server_seed.encode()).hexdigest() == commitment
h = hmac.new(server_seed.encode(), f"{client_seed}:{nonce}".encode(), hashlib.sha256).hexdigest()
n = int(h[:8], 16)
roll = (n * 10000 >> 32) / 100
print(h)     # c6b1e6abfb75912f63fb7d8e96d037910dd26cd81e57d5e70c7fc855c3fdb59e
print(n)     # 3333547691
print(roll)  # 77.61

Or skip the code and paste the same values into our browser verifier, which uses WebCrypto and gives identical output.

When it doesn't match: a troubleshooting table

What you've proved

A successful check shows the roll was produced from a seed fixed before your bet, using your client seed, by the stated formula. It doesn't show the odds are good, that the payout table is generous, or that the site will honour withdrawals; for that distinction, see what provably fair means and what it doesn't prove. The roll is checked; the house edge is still there.