Inputs for this example

Use the exact strings below: letter case, spaces and leading zeroes matter.

FieldValue
Secret hash0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
Secret salteditorial-salt
Client seedreader-seed
Nonce7
Public hash to comparefb77e8d8fb1e42f3f496012e75695207dea65308c04da765878526185bae17f3
Roll to compare80732

For an actual opening, collect all fields from the same record and its seed sequence. Also save the opening ID, time, case name, resulting item and the range table valid at that time. The account's current seed cannot replace the old seed used for that result.

Save Public hash before opening if you want independent evidence of a prior commitment. Obtaining every field only afterward allows a consistency check, but does not independently prove that the commitment was published beforehand. Our invented example has no actual commitment from the service.

Step 1: compare Public hash

The reviewed algorithm applies SHA-256 to the direct concatenation of the Secret hash and Secret salt text strings. Add no hyphen, colon or newline between them.

Our inputs produce:

fb77e8d8fb1e42f3f496012e75695207dea65308c04da765878526185bae17f3

A match binds the revealed pair to that control value. It does not yet calculate the roll or select a skin.

Step 2: calculate the roll

The HMAC message is Client seed, a hyphen and Nonce: exactly reader-seed-7 here.

Use HMAC-SHA-512 with Secret hash as UTF-8 text for the key, not bytes decoded from its hexadecimal representation. Convert the first seven hexadecimal characters of the digest to an integer, take the remainder modulo 100,000 and add 1.

The first seven characters are e663abb, or 241580731 in decimal. The remainder is 80731, giving roll 80732 after adding 1. That last step matters: this scale runs from 1 through 100,000. The intermediate 80,731 is not the final roll.

Complete code and expected output

Save this as verify_opening.py and run python3 verify_opening.py with Python 3. No additional packages are needed. It runs locally, sends nothing over the network and does not contact Steam.

import hashlib
import hmac

secret_hash = "0123456789abcdef" * 4
secret_salt = "editorial-salt"
client_seed = "reader-seed"
nonce = "7"
expected_public_hash = (
    "fb77e8d8fb1e42f3f496012e75695207dea"
    "65308c04da765878526185bae17f3"
)
expected_roll = 80732

public_hash = hashlib.sha256(
    (secret_hash + secret_salt).encode("utf-8")
).hexdigest()
message = client_seed + "-" + nonce
digest = hmac.new(
    secret_hash.encode("utf-8"),
    message.encode("utf-8"),
    hashlib.sha512,
).hexdigest()
prefix = digest[:7]
number = int(prefix, 16)
roll = number % 100000 + 1

print("Public hash:", public_hash)
print("Public hash match:", public_hash == expected_public_hash)
print("Message:", message)
print("HMAC prefix:", prefix)
print("Integer:", number)
print("Roll:", roll)
print("Roll match:", roll == expected_roll)

# Fictional ranges, NOT a real case's odds.
ranges = [("A", 1, 50000), ("B", 50001, 99000), ("C", 99001, 100000)]
items = [name for name, low, high in ranges if low <= roll <= high]
print("Toy item:", items[0] if len(items) == 1 else "RANGE ERROR")

Expected output:

Public hash: fb77e8d8fb1e42f3f496012e75695207dea65308c04da765878526185bae17f3
Public hash match: True
Message: reader-seed-7
HMAC prefix: e663abb
Integer: 241580731
Roll: 80732
Roll match: True
Toy item: B

Check both match lines separately. The script can print a number even when Public hash does not match. A numeric result alone does not validate the inputs.

Step 3: select the item by its range

The last code line uses a fictional table. A, B and C refer to the teaching items below, not the odds of a real DatDrop case.

Teaching itemInclusive roll range
A1–50,000
B50,001–99,000
C99,001–100,000

80,732 falls in B. The boundary 99,000 still selects B; 99,001 selects C. If the record assigned C to roll 80,732, item selection would fail verification even with a matching hash and roll.

For your opening, replace the entire fictional table with the historical ranges of that case. A table after the contents changed does not automatically validate an earlier result. Without the correct version, you can reproduce the number but cannot finish checking the skin selection.

Troubleshooting mismatches

ProblemCheck first
Public hash differsSecret hash and salt from the same sequence; concatenation order; stray spaces or newlines
Hash matches, roll differsClient seed, exact nonce, message hyphen, UTF-8 text key, first seven hex characters and the final +1
Roll matches, item differsHistorical case version, inclusive boundaries and the correct opening record
Secret inputs are missingWhether the used sequence has been revealed and its fields saved; a full recalculation remains incomplete without them

Change only salt to see the stages differ: Public hash changes but the roll stays the same, because salt is absent from this roll calculation. Changing nonce requires recalculating the roll; Public hash stays the same. Different inputs need not produce different rolls: only 100,000 outcomes exist.

DatDrop describes Reveal Server Hash as revealing the current sequence's Secret hash and salt and creating a new sequence for future openings. Keep the revealed old values for the old record. You do not need to change your account's seed to run this example.

If a mismatch persists, save the opening ID, input fields, failing stage and both results. Ask a specific question, such as “expected roll 80732, different roll recorded.” Missing data leaves verification unfinished; it establishes neither successful verification nor a proven substitution.

What we verified

DatDrop's published single-opening code was read on 9 November 2026. The teaching calculation was independently reproduced in Python and Node.js. No paid opening or item withdrawal was performed.

Agreement at all stages validates the selected record's calculation for those inputs, algorithm and table. It does not verify Steam delivery, market value or the whole service. A finished battle additionally requires its modes and winner-selection data; this single-opening algorithm cannot replace them.