HOW TO VERIFY PROVABLY FAIR HI-LO

Updated Jul 20268 min read

In Hi-Lo you guess whether the next card is higher or lower than the one shown. A provably fair Hi-Lo game lets you prove that the card you were dealt was locked in before you placed your bet — not swapped afterwards to beat you. This guide shows the exact algorithm that turns an HMAC-SHA256 hash into a specific playing card, walks through a real worked example you can reproduce, and links you to our free Provably Fair Verifier tool so you can check any Hi-Lo bet in seconds.

The Three Seeds and What Hi-Lo Verification Proves

Every provably fair Hi-Lo bet is built from three inputs. The server seed is a random string the casino generates and keeps secret during play — but it commits to it in advance by publishing its SHA-256 hash, like a sealed envelope. The client seed is yours; you can set it to any value, which guarantees the casino cannot have pre-computed a deck just for you. The nonce is a counter that increases by one with every bet on that seed pair.

For Hi-Lo specifically, verification proves one thing precisely: the card you were dealt was fixed before you bet higher or lower, and could not have been swapped afterwards. Because the server seed hash was published before the round, and you chose the client seed, neither side can change which card appears once the bet is locked. After you rotate (retire) the seed pair, the casino reveals the unhashed server seed and you can recompute every card. For the general mechanics across all games, see our complete guide to verifying provably fair results.

How the Hash Becomes a Card: The Real Algorithm

Hi-Lo on Stake — the operator that popularised this method and publishes the algorithm openly — derives each card directly from the bytes of an HMAC-SHA256 hash. The same logic is implemented in the widely used open-source reference verifier lucasholder/fair, which is explicitly built to match Stake's output. Here is the full chain, step by step:

• 1
  Build the HMAC. The server seed is the HMAC key; the message is the string clientSeed:nonce:cursor. Computing HMAC_SHA256(serverSeed, "clientSeed:nonce:cursor") produces a 32-byte hash (64 hex characters). The cursor starts at 0.
• 2
  Take 4 bytes, make a float. Each card uses 4 bytes. Those bytes are turned into a decimal between 0 and 1 with the formula byte₀/256¹ + byte₁/256² + byte₂/256³ + byte₃/256⁴. A 32-byte hash therefore yields 8 cards; if more are needed the cursor increments to 1, 2, … for a fresh hash.
• 3
  Scale the float to a card index. Multiply the float by 52 and round down: index = floor(float × 52). This gives a whole number from 0 to 51 — one slot for every card in a standard deck.
• 4
  Map the index to a rank and suit. On Stake's ordering, the rank is index ÷ 4 (integer division) and the suit is index % 4. Ranks run 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A (Ace high) and suits run Diamonds, Hearts, Spades, Clubs. So index 0 = 2♦, index 1 = 2♥, index 2 = 2♠, index 3 = 2♣, index 4 = 3♦, and so on up to index 51 = A♣.

One important detail unique to Hi-Lo: each card is drawn independently from a full 52-card deck, as if from an infinite shoe. Stake assigns a cursor of 13 to Hi-Lo so it can generate up to 52 cards per bet when needed, but every individual draw is still a fresh 1-in-52 pick — which is why the same card can legitimately appear twice in a row (a tie).

Worked Example You Can Reproduce

Let us derive a real card from real inputs. These are genuine values computed with HMAC-SHA256 — paste them into any HMAC tool (or our verifier) and you will get the identical hash.

Input	Value
Server seed	serverSeed123
Client seed	clientSeed456
Nonce	3
Cursor	0

• 1
  Compute the HMAC. HMAC_SHA256("serverSeed123", "clientSeed456:3:0") =
  daeed0d0ff5ea59c83572c351983da4718595f610eb00c416f068d282f1faecf
• 2
  Read the first 4 bytes. The leading hex pairs are da ee d0 d0, i.e. the decimal bytes 218, 238, 208, 208.
• 2
  Convert to a float. 218÷256 + 238÷256² + 208÷256³ + 208÷256⁴ = 0.85520654.
• 3
  Scale to a card index. floor(0.85520654 × 52) = floor(44.47) = 44.
• 4
  Map to a card. Rank = 44 ÷ 4 = 11 → the 12th rank in the list (0-indexed) = King. Suit = 44 % 4 = 0 → Diamonds. The dealt card is the King of Diamonds.

Where to Find Your Hi-Lo Seeds

Before you can verify, you need the unhashed server seed, which the casino only reveals once you rotate (retire) the seed pair. Here is where to look on the main provably fair platforms:

Casino	How to Find Your Seeds
Stake	Profile icon → Settings → Fairness. Note your active client seed and the next server seed hash, then click Rotate / New Seed to reveal the previous unhashed server seed. The Hi-Lo bet detail shows the nonce.
BC.Game	Avatar → Profile → Fairness. View the current seed pair, then rotate to unhash the old server seed. Open Game History for the per-bet nonce.
Roobet & others	Open Game History, click the Hi-Lo bet, then Fairness / Reveal Seeds. The server seed is shown after the pair is rotated, alongside the client seed and nonce.

What This Proves — and What It Does Not

Provably fair verification is powerful, but it is precise about what it guarantees. Be clear on both sides:

• ✓It proves the card was not altered after your bet. The outcome was committed by the server seed hash before you chose higher or lower, so the casino could not change it to make you lose.
• ✓It proves the casino used the seeds it claimed. A matching result confirms the published server seed really does hash to the committed value and produces the card you saw.
• ✗It does NOT remove the house edge. Hi-Lo's payouts are set slightly below true odds. A fair card and a long-term mathematical edge for the casino coexist — verification confirms fairness, not profitability.
• ✗It does NOT guarantee you get paid. Provably fair maths says nothing about whether a casino will process your withdrawal or treat you fairly elsewhere. For that, choose a licensed, reputable operator — see our best provably fair casinos.

Frequently Asked Questions