Clash.gg is not a hash-slice system
Clash.gg breaks the pattern the rest of this site's platforms follow. Almost every other one works the same way underneath: hash some seeds, take a slice of the digest, convert it to a number. Clash.gg does something different, and that difference is the single most important thing to understand before trying to check a result.
Clash.gg seeds a pseudo-random number generator with your seeds and reads the first number it produces.
seedrandom( "serverSeed:clientSeed:round" ) seedrandom v3.0.5, colons
|
v
the generator's first output, a value between 0 and 1
|
v
( value x 100,000 ) rounded down = ticket, 0 to 99,999
The consequence is unusual. With a hash-based system, anyone who knows the algorithm can reimplement it from scratch in any language, because SHA-256 is SHA-256 everywhere. With a seeded generator, the result depends on the precise internal behaviour of one specific piece of software. Reproduce it with a different generator, or even a different version of the same generator, and you get a different number that is no less "random" and completely wrong.
Clash.gg pins seedrandom version 3.0.5, loaded from a fixed source in its published code. Pinning it is what makes the method reproducible at all, and it deserves credit: a page that said only "we use seedrandom" would not be a specification.
The commitment is a plain SHA-256 of the server seed, which is the ordinary construction and behaves the way you would expect.
Why the version number matters
To be blunt about it: this is a genuine structural difference between Clash.gg and a hash-based platform.
A hash-based algorithm is self-describing. Publish the formula and anyone can implement it correctly from the specification alone. A generator-based algorithm is not: the specification is the library's source code, and "we use seedrandom" is only a complete description once the version is pinned as well.
This is not a criticism of Clash.gg's fairness. The commitment still works, the seeds are still published, the result is still checkable. It does mean the check carries a dependency that a hash-based check does not, and that a verifier which quietly upgrades its library could start producing wrong answers without anything visibly breaking. We pin the version deliberately.
The version change nobody dated
Here is the problem with checking an older Clash.gg round, and it is a real one.
The code embedded on Clash.gg's fairness page today is titled v2. An earlier validator, for the same platform, is still publicly hosted on the same account and is a materially different algorithm:
| Current (v2) | The earlier version | |
|---|---|---|
| What gets fed in | The server seed and client seed | The hashes of those seeds |
| Extra step | None | An additional SHA-256 over the combined string |
| Multiplier | 100,000 | 1,000 |
| Ticket range | 0 to 99,999 | 0 to 999 |
Those are not variants of one method. They are two different calculations producing numbers on two different scales.
Clash.gg publishes no date, no round ID and no nonce marking where one ended and the other began. The battle validator carries a "New / Old" dropdown with no date attached either. So for a round played some time ago, both algorithms can be run and there is no published fact that says which one applied.
That is the practical limit of what this page can offer. A recent round checks cleanly. An older one produces two plausible answers and no way to choose between them, which is not a verification.
What the alternative looks like
This is not a hard problem to solve, which is the frustrating part. CSGORoll publishes dated legacy code for nearly every mode, with boundaries given down to the play ID and, in several cases, the exact timestamp. A reader there can tell which algorithm governed their round and check it against the right one.
Clash.gg's older validator still being reachable is not the issue. Keeping old code public is the right instinct, and plenty of platforms simply delete it. The missing piece is the one line saying when it stopped applying.
Clash.gg publishes no test values
One more thing to be straight about, because this page used to say otherwise.
Both of Clash.gg's published validators ship with empty input fields and no worked example. There is no set of seeds with a stated expected output anywhere in its fairness material. So when this page cites ticket 18,875 from the seeds clash-server-seed and clash-client-seed at round 1, that is a figure computed by running Clash.gg's own published code, not a number Clash.gg states.
The distinction matters for what "verified" means here. Running an operator's code correctly proves our implementation matches theirs. It does not independently confirm that the code they publish is the code their site runs, which is what a published input-and-output pair would do. JemLit publishes one. CSGORoll publishes one. Clash.gg does not, and the honest status is code-level agreement rather than an end-to-end confirmation.
The battle side is stronger: thirteen of thirteen values cross-check against Clash.gg's own hosted verifier, including the tie-break value, so that mode was confirmed against the operator's own tool rather than only against its source.
Battles use Random.org
For case battles the shared input cannot come from any single player. Clash.gg draws it from Random.org, a third-party service that produces randomness from atmospheric noise, after every player has joined.
seedrandom( "battleSeed:round+1:slot" )
|
v
( value x 100,000 ) rounded down = ticket for that slot in that round
The battle's Random.org seed takes the place of the server seed, the round number is offset by one, and the slot identifies which position in the battle the ticket belongs to. Slot counts follow the format: two for a 1v1, three for a three-way, four for a 2v2 and six for a 3v3. Ties are broken with a fresh draw from the bare battle seed, which splits the tied players into equal proportional ranges.
Tickets and items
A ticket is a number from 0 to 99,999, which makes the arithmetic unusually easy to follow. Each item holds a contiguous block of tickets sized to its stated chance, so an item listed at 1% holds exactly 1,000 of them and an item at 0.1% holds 100. Clash.gg states that rule on its fairness page.
What it does not put there are the per-item tables themselves. The rule tells you how many tickets an item should hold; it does not tell you which numbers belong to which skin in a given case. Whether those tables are visible inside a logged-in account is not something we have tested, so treat the roll as the part you can confirm from public material and the item mapping as open.
Where to find your seeds
Three values decide a case check, and one only appears after you act.
- The hashed server seed, shown before you play. Save it; this is the commitment.
- Your client seed, editable in your account.
- The round, which is the index of the roll inside your bet rather than a running total.
The unhashed server seed appears once you rotate, which is what makes past rounds checkable. A server seed still in use cannot be published, because anyone holding it could compute every remaining outcome in advance. For battles you need the Random.org seed instead, drawn after the last player joins, plus the round and your slot.
Sister sites share this engine
Clash.gg is not the only site running this code. RustClash and DotaClash use the same engine against different item pools, and the published validators are titled for all three brands together.
| Site | Item pool | Fairness material | Engine |
|---|---|---|---|
| Clash.gg | CS2 skins | Its own page | seedrandom 3.0.5 |
| RustClash | Rust skins | Word-for-word identical, same embedded code | Identical |
| DotaClash | Dota 2 items | Named in the validator titles | Identical |
This is not an inference from similar-looking pages. Both Clash.gg and RustClash name the same operating company in their own terms, at the same registered address, with terms last updated on the same date. If you have verified a result on one, the same method works on the others unchanged, and the ticket range is the same 0 to 99,999 on all three. The undated version change applies to all three equally.
Clash.gg also runs modes we do not implement, including a Champion mode added recently, so a result from one of those is outside what the verifier above covers.
What 851 reviews describe
On Trustpilot, Clash.gg holds 3.0 out of 5 across 851 reviews, on a profile claimed since August 2023. The distribution is the most polarised of any platform we cover: 60% five-star and 34% one-star, with almost nothing in between.
Two observations about that profile, both checkable rather than interpretive. Trustpilot notes the company has not recently invited customers to review, so the sample is unprompted in both directions. And while the profile reports a 44% reply rate on negative reviews as a historical figure, the operator had replied to none of the twenty most recent one-star reviews at the time this page was checked. For comparison, CSGORoll had replied to eighteen of twenty over a similar window.
Sorted by subject, those twenty split as eight about odds or a belief results are steered, six about account restrictions, most of them tied to a withdrawal or an identity check, two about technical faults affecting withdrawals, and the remainder about deposits, promotions and support. A September 2026 reviewer describes winning, then finding withdrawals blocked behind repeated additional verification requests. A July 2026 reviewer reports an account blocked after submitting verification documents.
Those are individual accounts rather than findings, and a platform will generally frame account actions as ordinary policy enforcement. They belong here because account access is the thing a fairness check cannot speak to, and because the complaint that dominates the pile, that results are steered, is the one thing on this page that can be settled rather than argued.
What a passing check settles
A match proves the round you are checking came from values committed before you played, and that Clash.gg did not alter it afterwards, provided the round is recent enough for the current algorithm to be the right one.
It proves nothing about anything else: not whether a withdrawal completes, not how support responds, and on a skins platform not what the item is worth, since wear tier and float do the pricing rather than the name. Those are separate questions with separate evidence, and we keep what verification cannot prove as a standing page precisely because the distinction gets blurred so often.