{benefit_1_title}
{benefit_1_text}
{article_author} {article_updated} {article_read_time}
{hero_eyebrow}
{hero_title}
{hero_subtitle}
- {hero_stat_1_value} {hero_stat_1_label}
- {hero_stat_2_value} {hero_stat_2_label}
- {hero_stat_3_value} {hero_stat_3_label}
{hero_badge_1_title} {hero_badge_1_text}
{hero_badge_2_title} {hero_badge_2_text}
{benefits_title}
{benefits_subtitle}
{benefit_2_title}
{benefit_2_text}
{benefit_3_title}
{benefit_3_text}
{benefit_4_title}
{benefit_4_text}
{benefit_5_title}
{benefit_5_text}
{benefit_6_title}
{benefit_6_text}
{comparison_title}
{comparison_subtitle}
| {comparison_col_feature} | {comparison_best_tag}{comparison_col_1} | {comparison_col_2} | {comparison_col_3} |
|---|---|---|---|
| {comparison_row_1_label} | {comparison_row_1_col_1} | {comparison_row_1_col_2} | {comparison_row_1_col_3} |
| {comparison_row_2_label} | {comparison_row_2_col_1} | {comparison_row_2_col_2} | {comparison_row_2_col_3} |
| {comparison_row_3_label} | {comparison_row_3_col_1} | {comparison_row_3_col_2} | {comparison_row_3_col_3} |
| {comparison_row_4_label} | {comparison_row_4_col_1} | {comparison_row_4_col_2} | {comparison_row_4_col_3} |
| {comparison_row_5_label} | {comparison_row_5_col_1} | {comparison_row_5_col_2} | {comparison_row_5_col_3} |
| {comparison_row_6_label} | {comparison_row_6_col_1} | {comparison_row_6_col_2} | {comparison_row_6_col_3} |
| {comparison_footer_label} | {comparison_col_1_cta} | {comparison_col_2_cta} | {comparison_col_3_cta} |
{comparison_note}
{faq_title}
{faq_subtitle}
{faq_help_title}{faq_help_link}
{faq_1_question}
{faq_1_answer}
{faq_2_question}
{faq_2_answer}
{faq_3_question}
{faq_3_answer}
{faq_4_question}
{faq_4_answer}
{faq_5_question}
{faq_5_answer}
{faq_6_question}
{faq_6_answer}
{faq_7_question}
{faq_7_answer}
What to collect before verifying
Server seed, hash, client seed and nonce
Where each value sits in bet history
Verification stalls for one reason most of the time: a missing input. Before you open the verifier you need four values plus the round identifier, and all five are already stored on your account. Collect them the moment a bet settles, because the server seed becomes readable only after the seed pair rotates and the nonce increments with every wager you place.
- Server seed - the secret key, hidden while the seed pair is active; it is revealed after rotation, so only past rounds can be checked.
- Server seed hash - a SHA-256 fingerprint published before the first bet of the pair; it is what binds the operator to the seed.
- Client seed - the public half you control; change it whenever you like, and the change applies from the next bet onward.
- Nonce - a counter that starts at 1 for each new seed pair and rises by one per bet.
- Round ID - the label that ties these four values to one specific wager.
| Value | Where to find it | Stored as |
|---|---|---|
| Server seed | Bet history, expanded row, Seed column | 64-character hexadecimal string |
| Server seed hash | Same row plus the pre-commit notice on /provably-fair | SHA-256 hash of the server seed |
| Client seed | Account, Fairness, Client seed | Text or digits you choose |
| Nonce | Bet history row, next to the stake | Whole number, 1 upward |
| Round ID | Bet history row and the cashier ledger | UUID-style string |
Method one: the built-in verifier
Opening the verifier
Reading the confirmation output
The built-in verifier on /provably-fair runs entirely in your browser and does the arithmetic for you. No seed value is sent to the server, so once the page has loaded it keeps working after you disconnect. It takes the four values, rebuilds the round hash with HMAC-SHA256 and compares the result with the outcome the game actually produced.
- Open /provably-fair and pick the coin and game the round belongs to.
- Paste the server seed from the rotated seed pair into the first field.
- Paste the client seed exactly as it stood at the time of the bet; a later edit will not reproduce the round.
- Enter the nonce as a whole number, then the round ID for your own reference.
- Press Verify: the tool builds the message string, hashes it and converts the digest into the game's outcome range.
- Compare the shown outcome and hash against the same wager in your bet history.
| Input state | What the verifier shows |
|---|---|
| Correct seed pair, unused nonce | Green Verified badge, matching round hash, outcome identical to bet history |
| Client seed edited after the bet | Amber warning: hash mismatch, with the fields to re-check listed |
| Server seed hash pasted instead of the seed | Red error: value looks like a hash, not a seed |
| Nonce with a decimal point or trailing space | Red error, no hash produced |
Does the tool send my server seed anywhere?
No. The hash is computed locally, so you can disconnect before pasting if you prefer.
Which rounds can I verify?
Any round whose seed pair has already rotated, since the server seed is only revealed at rotation.
Method two: manual verification
Creating the message string from client seed and nonce
Computing HMAC-SHA256 with the server seed as key
Manual verification needs nothing beyond a hash function you trust. The steps below are tool-agnostic: any HMAC-SHA256 implementation returns the same bytes provided the key and the message stay in the same order. Work in hexadecimal throughout, and never paste a server seed into a site you do not recognise.
- Set the key: the server seed as a UTF-8 string or raw hex bytes. Decide once and stay consistent.
- Build the message string: client seed, a colon, then the nonce, for example MySeed42:17.
- Run HMAC-SHA256 over that message with the server seed as the key.
- Read the 64-character hex digest. This is the round hash you compare with the game.
- Take the first eight hex characters and convert them to an integer between 0 and 4,294,967,295.
- Divide that integer by 4,294,967,296 to get a float between 0 and 1.
- Multiply the float by the game's outcome range (100 for a 0-99 roll) and round down.
- Map the result onto the paytable published on the game page.
| Step | Value | Example |
|---|---|---|
| Message string | client seed + ':' + nonce | MySeed42:17 |
| HMAC key | rotated server seed | a3f1c8... (64 hex chars) |
| Digest to integer | first 8 hex chars, base 16 | 0x2b7f19ac = 729355692 |
| Float 0-1 | 729355692 / 4294967296 | 0.1698 |
| Dice outcome | floor(0.1698 x 100) | 16 |
Matching the result to the round outcome
Slots and card games derive differently
Worked mapping example
The final step turns a hexadecimal hash into an integer and then into a game outcome. Nothing in this step is discretionary: the conversion is fixed by the published rules, so the same seed pair and nonce always produce the same number. What changes between games is only the range and the way that number is read — a card, a reel position or a crash multiplier.
- Slots and card games derive differently: take the first 8 hex characters of the round hash and convert them from base 16 to a decimal integer.
- Divide that integer by 4,294,967,296 to get a float between 0 and 1.
- Multiply by the game's range and round down, then apply the game's mapping table.
- Re-hash the server seed with the client seed and nonce, and confirm the fingerprint matches the published server seed hash.
| Game | Value used | Mapping to outcome |
|---|---|---|
| Dice | Float in [0,1), 4 decimals | Outcome 0.00–99.99 equals float × 100, rounded down |
| Slots | First 8 hex characters per reel | Each 8-character block picks a stop on that reel's strip |
| Crash | Float in [0,1) folded twice | Crash point = 99 ÷ (1 − float), capped at the maximum multiplier |
| Card games | Integer modulo the remaining deck | The remainder selects the card, which is then removed from the deck |
Worked mapping example: a dice float of 0.4193 becomes 41.93, which settles an under-50.50 bet as a win. The identical float on a crash round gives 99 ÷ (1 − 0.4193) = 170.4, cut to the maximum multiplier. The number is the same; only the rule reading it differs, which is why the mapping table is checked rather than assumed.
When verification does not match
Common input errors
Escalating a genuine mismatch
Most mismatches are input errors, not operator misconduct. A mistyped nonce, a client seed changed after the round, or a hash copied from the wrong row of the history table all produce a different result. Before escalating, re-run the verifier with the exact server seed, client seed and nonce shown on the settled round, then confirm the revealed server seed matches the hash published before the round.
- Nonce off by one — the counter resets per seed pair, not per session.
- Client seed edited after the bet was placed; only the value active at settlement counts.
- Hashed server seed compared against the seed hash instead of the raw revealed seed.
- Trailing whitespace or a capital letter pasted into the client seed field.
- Verifier run on the wrong game rules, for example a dice range of 0–100 instead of 0.00–99.99.
| Step | What to send | Expected handling |
|---|---|---|
| 1. Re-check inputs | Server seed, client seed, nonce, round ID | Self-service, immediate |
| 2. Attach proof | Screenshot of verifier output, round ID, timestamp, bet amount | Support replies within 48 hours |
| 3. Formal complaint | Round ID plus your own hash calculation and the operator's | Reviewed as a fairness dispute |
Does a mismatch always mean the round was manipulated?
No. Most cases trace back to a wrong nonce or an edited client seed. A confirmed mismatch on a settled round would be a serious finding and is reported through the complaints route with the round ID.
What if the revealed server seed does not match its published hash?
That cannot be explained by input error. Save the round ID, both hashes and the timestamp, and escalate immediately.