Server seed, client seed, nonce

The practical steps to verify a mines round yourself

To verify a mines round, you recompute the hash of a revealed server seed and compare it to the hash the operator showed you before the round started.

Provably fair verification isn't a concept you have to take on faith — it's a specific, repeatable process. To verify a mines round, you use numbers an operator publishes before and after play, and this page walks through what to look for and what each step actually confirms.

1
Grid size — usually a 5×5 board of 25 covered tiles, set by the studio, not the player.
2
Mine count — chosen before the first click; more mines shrink every safe-tile chance that follows.
3
Safe-tile counter — how many uncovered tiles have not been a mine so far in this round.
4
Multiplier ladder — the number printed against the current safe-tile count, read off the paytable, not guessed.
5
Cash-out step — the moment a player takes what the ladder currently shows, before the next click.

The same five parts on every Mines round this site describes: the grid, the mine count the player sets before the first click, the safe-tile counter, the multiplier ladder under it, and the cash-out step. Data status: operator terms read 24 August–12 September 2026, licence registers checked 8–13 September 2026; Mines-in-the-lobby facts read from the operators’ own published pages, latest capture 16 September 2026.

Where the panel usually sits

Most operators that publish provably fair details put a panel for it somewhere near the account or fairness settings, sometimes directly in the game's own interface — often labeled “fairness,” “provably fair,” or something close to it. That panel is typically where you'll find the current server seed hash, your client seed (editable on most builds), and the current nonce, along with a history of previous rounds once their seeds have rotated and been revealed.

If you can't find a fairness panel for a specific operator at all, that's worth noting on its own — a genuine provably fair system depends on this information being published somewhere accessible, not buried or absent.

What the three values look like before a round

Mine count set
Chosen once, before the first tile; it fixes every odds figure for the rest of that round.
A tile is clicked
One of the remaining covered tiles is revealed; the round either continues or ends there.
The ladder updates
Each safe click moves the multiplier to the next printed step — the same step for every player who reaches it.
Cash out, or click again
The only two choices at any point: take the current ladder value, or risk it against the next tile.

Four moments in one Mines round where a number on the paytable, not a hunch about the grid, is the thing actually deciding what happens next.

Before a round starts, three pieces of information matter. The server seed hash is a fixed string — typically a long hexadecimal value — generated from a server seed the operator holds but hasn't shown you yet; the hash is a one-way function of that seed, so it can be shown safely without revealing the seed itself. The client seed is a value you can usually set yourself, sometimes with a default value provided, and it feeds into the same calculation as the server seed. The nonce is a counter, incrementing with each round you play under the current server seed, so the same server seed produces a different, unpredictable result for round one versus round two.

Together, these three values are combined — through a defined hashing process the operator's documentation should describe — to fix the mine positions for a given round, before your first click on the grid. The hash you're shown beforehand is your evidence that the server seed used in that calculation existed and was fixed ahead of time, without you having to trust the operator's word alone.

How to verify a mines round after a seed rotation

To verify a mines round, you need the operator to reveal the server seed — this typically happens when you rotate to a new server seed, which most interfaces let you trigger manually, or automatically after a set number of rounds. Once revealed, take the original server seed and run it through the same hashing function the operator used (commonly SHA-256, though the operator's documentation should confirm the exact method) — you can do this with an independent, third-party hash calculator rather than anything the operator provides, which is the point of the exercise.

Compare the hash you just computed to the hash you were shown before the round. If they match, that confirms the revealed server seed is the same one the operator committed to before play — nothing was substituted after the fact. From there, combining that confirmed server seed with your client seed and the round's nonce, using the operator's documented method, should reproduce the exact mine positions that appeared in that round, letting you check the outcome itself, not just the seed's authenticity.

What a match confirms, and what a mismatch would mean

A match confirms one specific thing clearly: the round's mine positions were fixed before your first click, using a server seed the operator had already committed to via the hash shown beforehand. That's a real, checkable guarantee about that round's mechanics — it is not a broader claim about an operator's account handling, its identity-check process, or anything about a withdrawal, all of which are separate matters this verification doesn't touch.

A mismatch — a recomputed hash that doesn't equal the hash you were shown before the round — would mean the revealed seed doesn't correspond to what was committed to beforehand. That's a signal worth taking seriously and worth raising directly with the operator, since it indicates the commitment the hash was supposed to represent didn't hold up under an independent check.

How the mine positions connect to the mechanic

Once a server seed, client seed, and nonce are combined, the result determines where the mines sit on the mines gambling game grid before you ever click a tile — on a typical 5x5 layout of 25 tiles, with whichever mine count was set for that round. More mines set before the first click shrink every later safe-tile chance, and the same probability arithmetic applies regardless of whether you've verified the round or not: with n tiles and m mines, the first click is safe with probability (n-m)/n. Verification doesn't change that arithmetic — it confirms that the specific positions used in a given round came from a seed fixed ahead of time, rather than anything adjusted afterward based on how you played.

That's worth restating because it's easy to conflate “the odds are what they are” with “the round was rigged” when a run of unlucky clicks happens. The arithmetic of shrinking odds is expected behavior, built into the mine count you or the interface set before the first click. Verification addresses a different question entirely — whether that arithmetic was applied to positions fixed in advance, not whether the outcome of any single round felt favorable.

A worked example, using placeholder values

To make the steps concrete, here's an illustrative walkthrough using made-up example values rather than any operator's real data. Suppose an interface shows a server seed hash before a round begins — a long hexadecimal string — alongside a client seed you've set and a nonce reading, say, 47. You play several rounds, and later trigger a seed rotation. The interface now reveals the original server seed in plain text. You take that revealed seed, run it through the hashing method the operator's documentation specifies, and compare the result to the hash you were shown before the rotation. If the two strings match character for character, the seed is confirmed authentic; if even one character differs, something about the commitment failed.

From there, an independent implementation of the operator's documented combination method — again, something the operator's own documentation should specify, since methods can differ — lets you reproduce the mine positions for a specific round using the confirmed server seed, your client seed, and that round's nonce. Comparing the reproduced positions to what actually appeared in that round is the final check: a match confirms the round played out exactly as the pre-committed seed determined it would.

Reading the underlying mechanism first

If the commit-reveal idea itself isn't fully clear yet — why a hash can prove a seed existed without revealing it, or why a nonce matters at all — provably fair mines covers the underlying method in more depth before you attempt the practical steps here. And if any of the terms used on this page (mine count, safe-tile counter, multiplier ladder, nonce) aren't familiar, the mines glossary defines each one individually.

Why this matters more than trusting a claim

Provably fair documentation, where it exists, is independently checkable in a way a general claim of fairness never is. Running the hash recomputation yourself, on an operator that actually publishes the necessary seeds, is a more direct answer than any assurance a page could offer without you doing the check — and the mines gambling sites ranked on the home page are a reasonable place to start looking for one that does.

Do I need special software for this process?

No special software is required, though a third-party hash calculator makes the process faster. You need the revealed server seed, the hash you were shown before the round, and a way to compute a cryptographic hash (commonly SHA-256) independently of the operator, to confirm the two values match.

What if I can't find the fairness panel on a specific site?

That's worth treating as meaningful on its own. A genuine provably fair system depends on the server seed hash, client seed, and nonce being published somewhere accessible before and after play — if that information isn't published anywhere you can find, the steps described here can't be carried out for that operator.

How often should I verify a mines round?

There's no fixed schedule, but checking after a seed rotation — when the server seed is finally revealed — is the natural point to do it, since that's when you have both the hash you were shown earlier and the seed needed to recompute it. Checking occasionally is enough to confirm the mechanism is functioning as documented.

Does verifying a mines round tell me anything about withdrawal speed?

No. Verification confirms that a round's mine positions were fixed before your first click, using a committed server seed — it says nothing about an operator's withdrawal handling, identity-check timing, or account rules, all of which are separate matters governed by that operator's own terms.