Stake Engine verifier
in your browser Stake Engine slots · the roll is computed on your device- 3,179 games
- 919 studios
- 61,804 published outcome tables
- HMAC-SHA256 runs locally
A Stake Engine game does not calculate your result from the hash the way a Stake Original does. Before it goes live, every game mode publishes a fixed table of every outcome it can ever produce, each with a probability weight. The hash only picks a row.
-
1
Hash the seeds
HMAC_SHA256(key = serverSeed, message = clientSeed + ":" + nonce)32 bytes of entropy. Deterministic — the same three inputs always give the same bytes.
-
2
Read a 128-bit number
rand128 = uint128_big_endian(entropy[0..16])Only the first 16 of the 32 bytes are used, read most-significant byte first.
-
3
Land on a published row
roll = rand128 % weightSum → event = search(weightTable, roll) → payoutEach row owns a slice of the weight range in proportion to its probability. Whichever slice the roll falls in is the spin you got.
Game
- Published RTP
- —
- Outcomes in the table
- —
- weightSum (the modulus)
- —
The game list loads when you start typing.
Seeds and nonce
SHA-256 of exactly what you paste appears here — compare it with the commitment hash the casino showed you before the rotation.
The hash is computed here. Nothing you type is sent anywhere unless you press a cross-check or the range replay.
The spin
nothing verified yet- Message hashed — client seed, a colon, then the nonce
- HMAC-SHA256 digest — 32 bytes; the highlighted first 16 are the ones used
- rand128 — those 16 bytes as one big-endian unsigned integer
- weightSum — total of every weight in this mode's published table
- roll = rand128 mod weightSum — everything to here was computed on your device
- Row the roll lands in — found in Stake's published table
- Published payout — cents per unit staked, as Stake publishes it
Sends this seed pair and nonce to Stake's public fairness API and compares their answer with the one worked out above. Optional — the numbers above stand without it.
- Stake's roll
- —
- Stake's payout
- —
Replay a run of spins
Stake returns the roll and payout for every nonce in the range; this page then re-derives each of those rolls from your seeds and reports how many agreed. A replay is evidence about bets that already happened — it says nothing about the next one.
Running balance in units, one unit staked per spin at this mode's cost. The scale is written above rather than drawn, because the line is stretched to the full width.
| Nonce | Roll | Payout | Cents | Balance | Reproduced here |
|---|
The published outcome table
This is the thing that makes the game checkable: a fixed list of every result the mode can produce, each holding a slice of the weight range. It is fixed when the version is published, so the same row numbers mean the same payouts for everybody.
| Row | Weight range start | Weight range end | Chance | Payout |
|---|---|---|---|---|
| Pick a game and mode to read its table. | ||||
Questions worth asking
What is different about verifying a Stake Engine game?
Stake Originals such as Dice or Limbo turn the hash into a number with arithmetic — a float, a roll, a multiplier. Stake Engine games do not: every game mode publishes a fixed table of every possible outcome, each with a probability weight, before the game goes live. The hash only chooses a row. So verifying a spin means reproducing the roll and then looking it up in that published table.
Where do the server seed and client seed come from?
From your own casino account. The client seed is yours and visible at any time. The server seed is only revealed once you rotate the seed pair — until then you get a commitment hash instead. Rotate first, then every bet made under the old pair can be checked. Stake Engine writes both seeds as base64url: 8 characters for the client seed, 43 for the server seed.
Do my seeds leave this page?
Not for the roll. The HMAC-SHA256, the 128-bit conversion and the modulo all run in your browser through the Web Crypto API. Looking the roll up needs the game's published outcome table, so the page requests a few rows of it from Stake's public fairness API by row number — that request carries the row numbers, never your seeds. Only the two buttons labelled as cross-checks and the range replay send seeds to Stake, and they say so before you press them.
Why is the payout shown in cents?
That is how Stake publishes it. The outcome table stores each payout as an integer number of cents per unit staked, so 100 means 1.00× your bet and 0 means the spin lost. This page shows both the raw published integer and the multiplier it works out to.
Can this predict a future spin?
No. It can only replay bets whose server seed has already been revealed. While a seed pair is live its server seed is secret, and without it the next nonce is unguessable. A verified history is evidence about bets that already happened, not a forecast of the ones that have not.
What does the published RTP mean here?
It is the exact expected return of the outcome table for that game mode — the weighted average of every payout in it, which Stake can state precisely because the whole table is known in advance. A short replay will not land near it; that is variance, not a broken game.
Method.
The roll on this page is computed in your browser with the Web Crypto API: HMAC-SHA256 keyed on the server seed string over the message "clientSeed:nonce", the first 16 bytes of the digest read as a big-endian 128-bit integer, then reduced modulo the mode's published weightSum. Nothing about that step is taken on trust from us or from Stake — it is the arithmetic described on Stake Engine's own fairness page, and you can redo it in a few lines of any language. Mapping the roll to a payout needs the game's outcome table, which only Stake publishes, so this page reads it from their public fairness API by row number. Payouts are shown exactly as published — integer cents per unit staked — alongside the multiplier they work out to.
Limits.
A spin can only be checked after its server seed has been revealed, so rotate your seed pair first. A verified run describes the bets in it and nothing else — no sample of spins forecasts the next one, and a return far from the published RTP over a few hundred spins is ordinary variance. This page does not check whether the casino used the seed pair it said it did; it checks that the results follow from the seeds and the table that were published.
Sources.
The pipeline and the four endpoints are documented by Stake Engine itself — stake-engine.com/fair
and /fair/api. Everything this page shows can be reproduced against those endpoints directly. Game catalogue snapshot taken 2026-08-19T17:20:13Z; the Refresh button re-pulls it live. Related: Originals verifier,
Stake seed simulator,
slot catalogue.