How We Test: Simulations, Exact Math and Their Limits

We test casino-style games with code, not with luck. Our scripts either calculate the exact odds of a game from its rules, or simulate millions of rounds and count the results. Every script records the game, its parameters, the number of rounds, the random seed and the date it ran, and that record travels with the data into every article that uses it.

Exact math vs Monte Carlo simulation

We use two methods, and each page says which one a figure comes from.

Exact calculation works out probabilities directly from the rules using combinatorics: counting the ways something can happen and dividing by all possible outcomes. Mines, keno, baccarat, craps, roulette bet tables and plinko landing odds can all be solved this way. Exact figures have no sampling error.

Monte Carlo simulation plays a game many times with a random number generator and counts what happens. We use it for two jobs:

1. Checking exact formulas. If 1,000,000 simulated plinko balls land where the binomial formula says they should, the formula and the code agree.
2. Answering questions formulas handle badly. How often does a 100 USDT bankroll double before it busts? What does a Martingale player's session usually look like? Those depend on long chains of bets, stop rules and table limits, and simulation handles them well.

A simulated figure is an estimate. With enough rounds the estimate is very close to the true value, but it is never exact, so where precision matters we report the standard error alongside it.

The scripts

All scripts are written in Python and live in a data-scripts/ folder alongside the site. They use NumPy for random numbers and arrays, except the blackjack script, which uses Python's built-in random module. The random seed is 20261004 throughout (blackjack derives a separate seed for each worker process from it). The current outputs were generated on 2026-10-04.

A shared helper, common.py, writes each result as a JSON file (used by our tables and charts) and a CSV file (for download), and stamps both with the parameters, seed, date and script name.

Dice

Dice multipliers come straight from the formula: multiplier = 0.99 ÷ win chance, at a 1% house edge. We then rolled 1,000,000 times at targets of 10, 25, 49.5, 75 and 90 to confirm the observed return matched 99%. For bankroll survival, each of 20,000 simulated sessions starts with 100 USDT and bets 1 USDT a time until the player busts, reaches 200 USDT, or hits a cap of 10,000 bets.

Plinko

A plinko ball bounces left or right at each row with equal chance, so its landing slot follows the binomial distribution, as a Galton board does. We calculate that distribution exactly for 8 to 16 rows and drop 1,000,000 simulated balls per setting as a check. We publish landing odds only, not RTP, because payout tables differ from game to game.

Crash

We generated 10,000,000 crash points with the formula "crash point = max(1, 2^32/(int+1) x 0.99), truncated to 2 decimals", which one operator published for its provably fair crash game. We then counted how often each target multiplier was reached, how often the round busted instantly at 1.00x, and how 100 bets at six fixed auto-cashout levels turned out across 50,000 sessions.

Mines

Mines on a 5×5 grid is a hypergeometric problem: drawing tiles without replacement. The chance of picking k safe tiles with m mines on the board is C(25 − m, k) ÷ C(25, k). The script calculates it for every valid combination. No randomness is involved, so there's no seed.

Roulette

The bet table is exact: win chance and edge for every standard bet on 37-, 38- and 39-pocket wheels. The simulations cover three questions:

• 1,000 spins on red: 100,000 simulated players per wheel, 1 USDT a spin.
• Betting systems: flat betting, Martingale, D'Alembert and Fibonacci on red, European wheel. Rules: bankroll 100 USDT, base 1, table max 100, stop at 150 or when next bet unaffordable, max 1000 spins, betting red.
• Stop rules: five stop-loss/stop-win combinations, betting 5 USDT on red for up to 200 spins.

Blackjack

The script builds basic strategy charts following the Wizard of Odds 4–8 deck strategy, for four rule sets (dealer stands or hits soft 17, with or without double after split). It then plays 10,000,000 hands per rule set under these rules: 6 decks, 75% penetration, dealer peeks, double any two, one split, split aces one card, no surrender. Each hand is scored twice, once with blackjack paying 3:2 and once at 6:5, so the cost of 6:5 is measured on identical cards.

Blackjack results are Monte Carlo estimates. The standard error is about 0.036 percentage points per rule set, which means the true edge for our simplified rules is very likely within roughly ±0.07 points of the published figure.

Baccarat, keno and craps

Baccarat is solved exactly by walking through every possible sequence of card ranks, removing each card from the shoe as it's dealt and applying the standard drawing rules. Keno uses the hypergeometric formula for 20 numbers drawn from 80. Craps pass and don't pass edges are calculated as exact fractions, and 1,000,000 simulated rolls confirm the dice-total probabilities.

How we cross-check the numbers

We compare our output with published figures before anything goes live. Here is how some of our results line up with the Wizard of Odds, a long-standing reference for casino game math.

For blackjack we compare rule changes rather than the overall edge, because our simulation's rules are simplified. The Wizard of Odds rule-variations table gives the effect of each rule against an 8-deck baseline; ours is measured on 6 decks.

The 6:5 figure is close because both payouts are scored on the same hands. The soft-17 and double-after-split differences come from separate runs, each with a standard error of about 0.036 points, so a difference between two runs carries roughly 0.05 points of uncertainty. Both land within about two of those units of the published values. The double-after-split gap is the larger of the two, and our one-split limit is a likely contributor.

Simulated figures are also checked against their own formulas. In our crash run, the chance of reaching 2x was 49.4711% against a theoretical 49.5%, and the dice return checks all landed within a tenth of a percentage point of 99%.

Re-running the scripts yourself

Each script runs on its own with Python 3 and NumPy, for example python3 data-scripts/crash_sim.py. The blackjack script takes the number of hands as an argument; our published run used python3 data-scripts/blackjack_ev.py 10000000, which takes a long time on an ordinary computer. Results are written to an out/ folder as JSON and CSV.

With the same seed and the same library versions, the scripts reproduce our numbers. The date field will show the day you ran it. The script source is linked from our data downloads page; if you have questions about a script, email us.

You don't need the scripts to check most figures. The exact results follow from formulas shown on each page, and you can recompute them with a calculator or spreadsheet.

Download the data

All outputs are free to download as CSV files. Each file's first row records the parameters, seed, date and script. The full list is on our data downloads page:

• blackjack.csv: house edge per rule set at 3:2 and 6:5, with standard error
• crash.csv: theoretical vs simulated chance of reaching each multiplier
• dice.csv: win chance and multiplier for every target
• mines.csv: probability and multipliers for every mines/picks combination
• plinko.csv: exact vs simulated landing odds for every slot, 8–16 rows
• roulette.csv: betting-system results against a 100 USDT bankroll
• table_games.csv: baccarat probabilities and edges by deck count
• keno.csv: hit probabilities for 1–10 spots

Limitations

No model is the real thing. These are the main limits to keep in mind:

• Blackjack rules are simplified. The simulation allows one split per hand (no resplitting), gives split aces one card each, and has no surrender. It uses 6 decks only and reshuffles at 75% penetration. Real tables vary, so treat our edges as close estimates for these rules, and use exact calculators for other rule sets.
• Crash uses one operator's formula. Our crash figures come from a formula one operator published for its game, with a 1% edge. Other crash games may use a different formula or a different edge, and then the numbers change.
• Plinko payouts vary. We publish where the ball lands, which is the same everywhere for a given row count. What each slot pays, and therefore the RTP, depends on the payout table of the game you play.
• House edges are assumptions. Our dice, crash and mines tables use a 1% edge as an example. A game with a higher edge costs more, and the same formulas show how much.
• Simulations have sampling error. Monte Carlo results are estimates. We use large samples and report standard errors where precision matters, but the last decimal place can move between runs with different seeds.
• No first-hand payment tests yet. We haven't published deposit or withdrawal tests at any operator. When we do, each test will include the date, network, amount and transaction hash, so you can check it on a blockchain explorer.

Spotted a number that looks wrong? Please report it. Our editorial policy explains how figures are checked before publishing.