A client seed is your own input into a provably fair result: a short string tied to your account that you can see and change whenever you want. Because the site cannot read your mind, it has to fold your value into every pull alongside its own hidden secret. That is what stops either side from steering the outcome on its own, and it is the one piece of the whole system that you personally control.
The dice you bring to the table
The easiest way to picture a client seed is a set of dice you bring to a game. The site already has its own hidden number sealed away, but if it rolled entirely on its own you would just have to trust the roll. So the site lets you add dice of your choosing to the cup. Every result now depends on both throws at once: the site's sealed number and the dice you brought. Neither side can call the outcome alone, because neither side fully controls what the other one adds.
In a provably fair pull, your dice are the client seed. It is usually a short text string, and on most sites you can either accept the one it hands you or type your own. What matters is that your value is visible to you the whole time and locked into the calculation, so the result was never something the site could compute by itself.
What a client seed actually is
A client seed is a plain string, often letters and numbers, that represents the player's contribution to a provably fair outcome. It sits next to two other ingredients: the server seed, which is the site's secret, and the nonce, a counter that ticks up with every pull. The three are combined and run through a keyed hash function to produce the number that decides your item.
The defining trait of a client seed is that it is yours and it is open. Unlike the server seed, which stays hidden behind a fingerprint until after you play, the client seed is shown to you from the start and can be edited at will. That openness is deliberate. If your input were secret too, you would have no way of knowing it had not been quietly swapped. Because it is public and under your control, you can prove exactly which value went into any given result.
How your client seed shapes a pull
Your outcome does not come from the client seed by itself. It comes from three inputs run together:
- The server seed, the site's secret, committed in advance as a hashed fingerprint.
- The client seed, your visible input, changeable whenever you choose.
- The nonce, a play count that increases by one each pull, so two pulls in a row never land the same way.
Those get fed through HMAC, a standard keyed hash function, and the resulting hex string is turned into a number that maps to an item. The important thing is how tightly the three are bound together. Change a single character in your client seed and the entire output changes into something unrelated. There is no partial nudge and no near miss. A different client seed does not shift the odds in your favour, it simply produces a completely different, equally unpredictable chain of results.
A worked example you can follow
Here is one real published scheme so you can see there is nothing hidden in the middle. The client seed is one of three inputs, and it is the one you set:
server seed (revealed after): 8f2a1c9e4b7d0a63f5e8c2b1a4d7906e3c8b5f2a1e9d4c7b0a6f3e2d1c8b5a49
client seed (your input): player-chosen-seed
nonce (play count): 42
HMAC-SHA256(key = server seed, message = "player-chosen-seed:42")
= 7f7c47d46f21aa75eebcad01075ecec0f30e7e3b093969e75ca4a1e0b6aa286d
take the first 8 hex characters: 7f7c47d4
read them as a number: 2,138,851,284
scale into a 0 to 100 roll: 49.7990
Now swap only the client seed, from player-chosen-seed to something like my-lucky-string, and leave the server seed and nonce exactly as they are. The HMAC output changes entirely, the first eight characters become different digits, and the roll lands somewhere else on the 0 to 100 scale. That single substitution is the whole reason a client seed exists: your value is stitched into every result, so the site cannot have worked out your outcome ahead of time. Different sites use different exact recipes, but the shape holds everywhere: three inputs, a hash, a number, an item.
Why setting your own client seed matters
Most sites will happily generate a client seed for you, and the result is still provably fair if you leave it alone. But typing your own is the stronger move, and the reason is about timing. The site publishes the hashed fingerprint of its server seed before it knows what client seed you will use. If you then choose a fresh value it could not have guessed, there is no possibility that the committed server seed was picked to produce a bad result for your particular input. You closed the only door.
This is also why fairness guides tell you to change your client seed when you first arrive and again whenever the server seed rotates. A new client seed starts a clean chain of outcomes that the site had no chance to precompute. It costs nothing, takes one click or one line of text, and it turns fairness from something you accepted into something you helped build. It is worth stressing that this is verification, not prediction. Setting a clever client seed cannot make good pulls more likely, because the outcome is still bound to the hidden server seed. Anything that claims to predict results from a client seed is a scam.
Client seed versus server seed
People mix these two up constantly, so it is worth stating plainly. The server seed is the site's input, secret until it is revealed. The client seed is your input, visible and editable throughout. They exist as a pair precisely so that neither party owns the result.
If only the site had an input, you would be trusting it completely. If only you had one, you could rig your own outcomes. Two independent inputs, with the site's committed in advance behind a fingerprint and yours public and chosen freely, is what makes a pull something both sides are bound to and neither can fake. The nonce then keeps each individual pull in that chain distinct, so the same seed pair can produce a long run of different results.
How to check it yourself
You never have to take any of this on faith. Once the server seed is revealed, you can recompute the exact result on your own device using the same three inputs, including the client seed you can see in your account. The verifier below does that math for you, and nothing you paste into it leaves your browser.
- Note the client seed shown in your account for the pull you care about.
- Copy the hashed server seed the site committed before you played.
- Record the play count, or nonce, for that pull.
- After you rotate seeds, copy the revealed server seed and paste everything in.
If the numbers line up and the revealed seed matches the fingerprint you saved, the result was built from the exact inputs on record, your client seed included, and nothing was altered after the fact. For the full picture of how the pieces fit together, the what is provably fair guide walks through the entire flow.
Step 1Where did you play?
Using Ripster box / upgrade: HMAC-SHA256 over clientSeed:noncedetails
HMAC-SHA256 keyed with the server seed over clientSeed:nonce. The first 8 hex characters become a 32-bit integer, divided by 2^32 and multiplied by 100 for a roll in [0, 100). Items are sorted by item ID and selected by cumulative probability: the first item whose cumulative probability is at least the roll wins.
Where to find your numbers on Ripster.gg:
- Before rolling, copy the Server Seed Hash from the Provably Fair modal (also recorded per roll in Account History).
- After the roll, open the Provably Fair modal to copy the Server Seed, Client Seed and Nonce.
- Change your Client Seed anytime in Account Settings; doing so reveals the current Server Seed so all past rolls become verifiable.
Source: Ripster.gg's own fairness page
Step 2Paste your numbers
Runs entirely on your device via your browser's built-in cryptography. Don't take our word for it: open DevTools → Network, click the button, and watch: zero requests.
Runs entirely in your browser. Nothing you paste is sent anywhere.
The short version
A client seed is your visible, changeable half of a provably fair pull, mixed with the site's secret server seed and a play count to produce a result neither side can steer alone. Because the site commits to its server seed before it knows your value, choosing your own client seed shuts the last door on any pre-arranged outcome. Understanding it is most of what you need to check a provably fair result with real confidence.