
What each operator actually publishes
One row per operator: the scheme it documents, the games the scheme covers, the games it leaves out, whether a third party could reproduce a result from the documentation alone, and the URL we read with the date we read it.
14 operators11 publish5 reproducible0 cover every gameread 2026-09-22
| Operator | Publishes | Scheme | Reproducible | Verifier | Runs on your machine | Games named | Documentation |
|---|---|---|---|---|---|---|---|
| BC.GAME | Yes | sha256 hash chain for crash, sha256 over serverSeed:clientSeed:nonce for classic dice | Yes | Yes | Not stated | 2 titles | source read 2026-09-22 |
| Shuffle | Yes | hmac-sha256 | Yes | Yes | Not stated | 17 titles | source read 2026-09-22 |
| Sportsbet.io | Yes | hmac-sha256 into chacha20, with sha256 commitments | Yes | Yes | Yes | 6 titles | source read 2026-09-22 |
| Stake | Yes | hmac-sha256 | Yes | Yes | Not stated | 26 titles | source read 2026-09-22 |
| Thunderpick | Yes | sha256 over salt concatenated with the winning number | Yes | No | Not stated | Roulette | source read 2026-09-22 |
| BetFury | Yes | sha256 over a per-round random seed | No | Yes | Not stated | BetFury in-house games | source read 2026-09-22 |
| Cloudbet | Yes | sha3-256 round signature into shake256 | No | Yes | Not stated | Mines | source read 2026-09-22 |
| Flush | Yes | not named | Not established | Yes | Not stated | 7 titles | source read 2026-09-22 |
| Gamdom | Yes | sha256 hash chain played in reverse | Not established | Yes | Yes | 15 titles | source read 2026-09-22 |
| Roobet | Yes | not named | Not established | Not established | Not stated | 14 titles | source read 2026-09-22 |
| Wild.io | Yes | not named | No | Yes | Not stated | 20 titles | source read 2026-09-22 |
| Rakebit | No | not named | No | Not established | Not stated | 15 titles | source read 2026-09-22 |
| Winz.io | No | not named | Not established | Not established | Not stated | none named | source read 2026-09-22 |
| Jackbit | Not retrieved | not named | Not established | Not established | Not stated | none named | none found read 2026-09-22 |
Reproducible: Someone with no account could recompute a result from the documentation alone. Runs on your machine: The verification runs on the player's own machine. A verifier that posts the seeds to the operator and receives a verdict verifies nothing, because the party being checked is doing the checking.
The two rows worth reading twice
Sportsbet.io publishes the best fairness documentation on the register
It is not the operator most players would name, and it is one of only two on the register, with Gamdom, that publishes a verifier we could confirm runs on the player’s own machine. The help centre article gives the whole chain rather than a summary of it: the commitment as SHA256 of the server seed published before the round, HMAC-SHA256 keyed by the server seed over clientSeed:nonce, SHA-256 of that HMAC used as a ChaCha20 key, the first twelve bytes of the HMAC as the 96 bit nonce, rejection sampling for bounded draws, Fisher-Yates for decks, and a second commitment for card games as SHA256 of the initial shuffle concatenated with the server seed. It then prints working source and states The verifier below is standalone, it depends only on the Node.js crypto module and reproduces the random draws exactly.
The detail that gives it away is the warning: the page flags the ChaCha20 initialisation vector convention that would otherwise make an independent implementation silently disagree. That sentence is written by someone who expects a reader to actually build the thing. Six games are in scope and the rest of the casino is not, which is the same limit everybody else has, stated more plainly.
Wild.io shows what a verifier that proves nothing looks like
Wild.io claims coverage of 20 Originals, second only to Stake on this register, and publishes one of the thinnest specifications against it. No hash function is named anywhere on the page. The mechanism is described only as two seeds, one hashed before play and revealed afterwards, which is the shape of the scheme without any of the content, so nobody outside the company can recompute a result. There is no dedicated fairness page at all: this is a games category page.
The instruction it gives the player is the exact failure: Go to Fairness, then Verify and input: Client Seed, Original Server Seed, Round ID. The tool instantly confirms the outcome.
An instant confirmation from the party being checked verifies nothing. The player learns that the operator says the operator was honest, which is what they had before they opened the tool. The same doubt applies more weakly to Stake and Shuffle, whose calculators are good but whose pages never say where the arithmetic happens, and it is cheap to fix: one sentence.
The operators that cannot be verified, and why
- Winz.io. Publishes nothing. The URL that looks like documentation is a game lobby listing titles, and the operator’s own support answer confirms it: asked whether it provides provably fair games it replies
Yes, you can find the list of Provably fair games in the relevant section
and points back at the lobby. A list of game titles is a claim about which games qualify, not a system anyone can check. - Rakebit. Publishes nothing. The home page says
Fairness is verifiable, not promised. Every Rakebit Original runs on provably fair algorithms, so any player can independently confirm that a result was not manipulated after the bet was placed
, and no fairness page exists behind it. Six candidate paths and the sitemap were tried. The sentence promising that fairness is not a promise is, on the evidence, a promise. - Wild.io, Cloudbet and BetFury. Publish a system that cannot be recomputed from. Cloudbet names SHA3-256 and SHAKE256 and stops before the message construction. BetFury names SHA256 and never says what goes into it. Wild.io names no primitive at all.
- Flush. Explains the commitment carefully in plain English and calls the primitive
a mathematical function called a hash function
. It also claims to publish its code so a reader can build their own tool. We could not render that code block, so reproducibility is recorded as not established rather than credited. - Thunderpick. Reproducible, and narrow on purpose. One equation,
SHA256(Salt + Random) = Hash
, with a worked example, covering Roulette and nothing else, not even its own Originals suite. It provides no verifier of its own and tells the player to use any SHA256 calculator, which is the honest answer when the scheme is that simple.
Where a scheme cannot be checked with our verifier
The schemes are not interchangeable, and several operators would fail a Stake-style verifier while being entirely honest. BC.GAME Classic Dice is plain SHA-256 over server_seed:client_seed:nonce, not an HMAC. BC.GAME Crash and Gamdom both run reverse SHA-256 hash chains committed in advance, with no client seed at all. Thunderpick hashes a salt against the winning number. Cloudbet is on SHA-3. Even among the HMAC-SHA256 operators the conversions differ, so Stake and Shuffle give different limbo multipliers from the same seeds. Any tool that reports a mismatch without first establishing which scheme the operator documents is manufacturing an accusation out of an assumption. Ours says so on its own page.
Coverage, operator by operator
| Operator | Covered | Not covered |
|---|---|---|
| BC.GAME | Crash, Classic Dice | Third party publisher slots, Live dealer, All other BC.GAME originals, which the fairness documentation does not describe |
| Shuffle | Dice, Limbo, Roulette, Plinko, Keno, Mines, Wheel, Tower, Chicken, Blackjack, Hilo, Baccarat, Blitz, Coinflip, Floor is Lava, Crash, Slide | Third party publisher slots, Live casino, Sportsbook |
| Sportsbet.io | Dice, Roulette, Plinko, Baccarat, Blackjack, Hi-Lo | Third party publisher slots, Live casino, Sportsbook, Esports |
| Stake | Dice, Limbo, Wheel, Baccarat, Roulette, Diamonds, Cases, Darts, Primedice, Packs, Tarot, Drill, Hilo, Keno, Mines, Pump, Chicken, Plinko, Blackjack, Video Poker, Snakes, Slots (Stake Originals), Flip, Rock Paper Scissors, Bars, Moles | Third party publisher slots, Live casino, Sportsbook, Racing, Crash (named on the game events page but deferred to an external BitcoinTalk seeding thread rather than specified) |
| Thunderpick | Roulette | Thunderpick Originals including Mines and Dice, Third party publisher slots, Live casino, Sportsbook, Esports |
| BetFury | BetFury in-house games | Third party publisher slots, Live casino, Sportsbook |
| Cloudbet | Mines | The rest of Cloudbet Originals, Third party publisher slots, Live casino, Sportsbook |
| Flush | Crash, Dice, Mines, Plinko, Keno, Wheel, Video Poker | Third party publisher slots, Live casino, Sportsbook |
| Gamdom | Crash, Dice, Hilo, Roulette, Plinko, Mines, Keno, Pocket Dice, Limbo, Blackjack, Twist, Towers, Chicken, Slots Arena, Raffle draws | Third party publisher slots, Live casino, Sportsbook |
| Roobet | Roulette, Crash, Dice, Mines, Towers, Coinflip, Plinko, Mission Uncrossable, Keno, Blackjack, Slide, Limbo, Striker, Wheel | Third party publisher slots, Live casino |
| Wild.io | Blackjack, Chick N Run, Crash, Dice, Diamonds, Indyz Gold, Keno, Limbo, Coin Flip, Mines, Pachinko, Plinko, Pump, Ra Ra Riches, Roulette, Slot (Originals), Tower, Wheel, Croc Snap, Darts | Third party publisher slots, Live casino, Game shows, Table games that are not Originals |
What we could not retrieve
- Jackbit: nothing at all, from eight candidate paths and the sitemap. Excluded from every denominator rather than counted as publishing nothing.
- Roobet: the fairness page renders and names fourteen games, but the algorithm, commitment, rotation and verifier sit behind per-game JavaScript tabs that would not open. Six fields are empty as a result.
- Gamdom: the prose could not be extracted. The verifier fields come from the page’s own configuration payload; the commitment fields are not recorded.
- Flush: the published code block could not be rendered, so the reproducibility claim is recorded and not credited.
Two of those, Jackbit and Roobet, are the same two documents that resist retrieval elsewhere on this site. Each is a gap on one date, not a finding, and each should be closed by hand.
Notes on every row
| Operator | What we found |
|---|---|
| BC.GAME | Two different schemes under one heading, and only two games documented. Crash runs on a pre-generated chain: 'We have generated a total of 10 million hashes (the generation chain is verifiable), and each hash corresponds to a Crash multiplier. We release these 10 million numbers in reverse order.' There is no seed pair and no rotation for Crash, because the commitment is the chain itself. Classic Dice is a per-bet seed pair and is documented separately at https://blog.bc.game/how-is-provably-fair-used-in-classic-dice: combine server_seed, client_seed and nonce separated by colons, SHA-256 the string, take the first eight characters, convert them to an int32 two characters at a time, divide by 0x100000000, multiply by 10001 and divide by 100. That is plain SHA-256, not HMAC, so a Stake style verifier will not reproduce a BC.GAME dice roll. The page states 'You have to change your seed pair before seeing the server seed used on previous games'. A verifier is linked at game-verify.github.io, hosted outside BC.GAME's own estate; we did not confirm where its computation runs, so that field is null. |
| Shuffle | A five article set that mirrors Stake's structure and is in places more explicit about per-game conversion. The implementation article gives `const hmac = crypto.createHmac('sha256', serverSeed); hmac.update(`${clientSeed}:${nonce}:${currentRound}`);`. The game events article at https://help.shuffle.com/en/articles/9286069-provably-fair-game-events gives a conversion for each game, including `Math.floor(floats * 10001) / 100` for dice, `(rtp * MAX_VALUE) / (MAX_VALUE * float + 1)` for limbo, `Math.floor(val * 37)` for roulette and `Math.floor(val * 2)` per row for plinko. Note that the limbo expression carries a plus one that Stake's does not, so the two operators' limbo results are not interchangeable. Crash and Slide are stated to run off a Bitcoin block hash rather than the per-bet HMAC. The verification article at https://help.shuffle.com/en/articles/9182950-provably-fair-how-to-verify-bets confirms the commitment is hashed and that the seed is unhashed and revealed after rotation, and directs the player to 'Open Shuffle's provably fair verification tab to enter your bet details and verify the outcome onsite'. Onsite does not establish in-browser, so verifier_runs_client_side is null. |
| Sportsbet.io | The only operator of the fourteen that publishes a verifier the player runs on their own machine. The page states 'The verifier below is standalone, it depends only on the Node.js crypto module and reproduces the random draws exactly', and then prints the source. The scheme is not the Stake one: HMAC-SHA256 keyed by the server seed over `${clientSeed}:${nonce}` produces a 32 byte value, SHA-256 of that value is the ChaCha20 key, the first twelve bytes of the HMAC are the 96 bit ChaCha20 nonce, and the keystream supplies the draws, with rejection sampling for bounded ranges and Fisher-Yates for card games. The commitment is stated as `serverSeedHash = SHA256 (serverSeed)` published before the round, with `SHA256 (serverSeed) == serverSeedHash` checked after. Card games carry a second commitment, `initialShuffleHash = SHA256 (initialShuffle + serverSeed)`. The server seed is revealed when the round resolves rather than only on rotation, which is stronger than rotation. The page even flags the Node ChaCha20 IV convention that would otherwise make a third party implementation disagree. Six games only: the rest of the casino is out of scope. Retrieved twice, the second time with a rendering browser, because the help centre body is client rendered and a plain fetch returns an empty shell. |
| Stake | The most completely specified of the fourteen. byteGenerator is given as source: HMAC-SHA256 keyed by the server seed over `${clientSeed}:${nonce}:${currentRound}`, where currentRound is the cursor divided by thirty-two and floored. The conversions page gives the four-byte float, and the game events page gives per-game conversions, including `const roll = (float * 10001) / 100` for dice, `1e8 / (float * 1e8) * houseEdge` with houseEdge 0.99 for limbo, `POCKETS[Math.floor(float * 37)]` for roulette and `Math.floor(float * 2)` per row for plinko. We reproduced dice, limbo, roulette and plinko from these pages and the results match independently published vectors. A calculator is offered at https://stake.com/provably-fair/calculation, but nothing on that page states whether the calculation happens in the browser or on Stake's servers, so that field is null rather than a guess. Crash is the one gap: the game events page points at a forum thread instead of specifying the scheme. |
| Thunderpick | Honest and narrow. One equation, 'You can prove a round is fair yourself by simply checking that the following equation is true: SHA256(Salt + Random) = Hash', with a worked example. Reproducible, because that is the whole scheme. But it covers a single game, there is no client seed and therefore no seed pair to rotate, and the page provides no verifier of its own: it tells the player to 'test it using any SHA256 hash calculator' and links to the third party xorbin tool. Thunderpick's Originals suite is not covered by this page and no other fairness documentation for it was found on the operator's own estate. |
| BetFury | Names the primitive and stops: 'The provably fair principle is based on SHA256 technology the same as Bitcoin.' The concatenation that actually goes into the hash is never stated, which is the difference between a scheme a reader can check and a scheme a reader can only admire. What the page does establish is the commitment, 'Before placing a bet you may check the hash of the next round number in the Fairness pop-up', and a check the player performs afterwards: 'Click Check. Then in the opened window paste Random Seed you've copied. The issued hash below must match that fixed on BetFury.' That check is per round rather than per seed pair, so there is no rotation mechanic. The user-facing mirror is betfury.ac/fairness; betfury.com redirects to bf1.io. Individual game coverage is not enumerated. |
| Cloudbet | The only operator here not using the SHA-2 family. The calculator page states that the inputs are 'combined using SHA3-256 to create a unique Round Signature. This signature is then fed into SHAKE256.' It names the primitives and nothing else: no message construction, no byte to result conversion, so the primitives alone do not let an outsider recompute a Mines board. Coverage is one game and the page says so: 'Right now, we're rolling it out with Mines, but it will be part of all Cloudbet Originals moving forward.' The tool takes a server seed, client seed and nonce, but the page does not say where it computes. The academy article at https://www.cloudbet.com/en/academy/crypto-betting-basics/provably-fair-gaming/ is generic education about provably fair in the abstract and says nothing specific about Cloudbet's own implementation, so it is not used as a source for any field here. |
| Flush | A fairness page that explains the commitment in plain English and never names the primitive. It describes 'performing a mathematical function called a hash function on our seed' without saying which function, so the prose alone does not let anyone recompute anything. It is clear on the commitment and the reveal: 'Until you play the game we can only show you the hashed server seed', and 'After you play we can provide you with the unhashed server seed and then use a new server seed for the following games.' It also claims to publish its code: 'we have provided the tools on our site for you to check the result yourself. And for those that do not trust our tools, we show our code here so you can build your own tool, and check it yourself.' We could not render that code block, so reproducible_by_third_party is null: the claim is made but we have not seen the thing it refers to. |
| Gamdom | The page exists and its own summary states the scheme: 'By checking that the SHA256 hash of that game's hash is the game's hash of the previous game you can make sure that we were not able to modify the result.' That is a reverse hash chain. The rendered body text could not be extracted; what a rendering browser returned was the page's configuration payload rather than its prose, so the fields that depend on the prose are null rather than inferred. That payload is itself evidence for two fields. It carries a distinct gameVerifier URL for each of the fifteen games listed above, and every one of them is a codesandbox.io preview embed, which executes in the viewer's own browser. So a verifier is provided for each game and it is client side, but it is not hosted by Gamdom, and the per-game conversion exists only inside those sandboxes rather than in prose anyone can read. The same payload publishes a current provablyFairGameHash and a chain length of one million rounds for crash, hilo and roulette. Gamdom's front page advertises over three thousand slots and live games; none of them are in the fifteen. |
| Roobet | The page exists and names fourteen games as verifiable, and states the principle: 'Provably fair means you do not need to trust us to be fair; it means you can prove our fairness', and 'Each bet made on Roobet can be verified so that you know with certainty the house could have in no way chosen the outcome.' Everything past that sits behind per-game JavaScript tabs. The page's own text says to click them to 'see how we generate our bet results', and neither a plain fetch nor a rendering retrieval could open them: a rendered attempt returned 'You've Encountered An Unexpected Error'. So the algorithm, the commitment, the rotation and the verifier are all recorded as null. This is not the same as recording that they are absent, and it is not inferred from any other operator. It is a gap in what we could retrieve on 22 September 2026, and it should be closed by hand. |
| Wild.io | The widest claimed coverage of the fourteen and one of the thinnest specifications. Twenty Originals are named as provably fair. The mechanism is described only as two seeds: the server seed is 'created by Wild.io and shown as a hashed value before you play', and 'After the round, the original Server Seed is revealed.' No hash function is named anywhere on the page, and no conversion is given, so nobody outside the company can recompute a result. A tool exists inside the product, 'Go to Fairness, then Verify and input: Client Seed, Original Server Seed, Round ID. The tool instantly confirms the outcome', but the page does not say where that confirmation is computed, and an instant confirmation from the operator is exactly the shape of verification that proves nothing. There is no dedicated fairness page: this is a games category page. |
| Rakebit | Asserts the property and documents nothing. The home page says 'Fairness is verifiable, not promised. Every Rakebit Original runs on provably fair algorithms, so any player can independently confirm that a result was not manipulated after the bet was placed', and names the fifteen Originals listed here. No fairness or provably fair page exists behind it: /provably-fair, /fairness, /fair, /originals/provably-fair, /casino/rakebit_original and the sitemap were all tried and all returned nothing. The sentence promising that fairness is not a promise is, on the evidence available on 22 September 2026, a promise. publishes is false because the claim is marketing copy and not documentation of a system. |
| Winz.io | The URL that looks like documentation is a game lobby. It lists titles filed under a provably fair category and explains nothing: no seeds, no hash function, no commitment, no verifier. The operator's own FAQ confirms that this is all there is. Asked 'Do you provide any Provably fair games?' it answers 'Yes, you can find the list of Provably fair games in the relevant section' and points at the same lobby. A list of games is a claim about which games qualify, not a fairness system anyone can check, so publishes is false. |
| Jackbit | Nothing could be retrieved. /provably-fair, /fairness, /en/provably-fair, /en/fairness, /originals/provably-fair, /originals, /help/provably-fair, /en/casino/originals/provably-fair and the sitemap all returned empty, duplicate or dead responses, and a site-restricted search surfaced only promotional and login pages. We are not recording that Jackbit publishes nothing, because we did not establish that; we are recording that we could not retrieve anything, which is a different statement. Jackbit is excluded from every denominator in the findings. |