What makes Aviator's algorithm 'provably fair'?

Provably fair means the crash point for each round is cryptographically committed to before the round begins (via the published server seed hash). After the round, the server reveals the original seed, and you can verify that it matches the pre-committed hash. If it matches, the result was not manipulated.

What is the exact crash point formula in Aviator?

In the reference construction used in this guide: crash_point = floor((1 − 0.03) × 2^32 / (2^32 − h)) / 100, where h is a 32-bit integer derived from the first 8 hexadecimal characters of the round hash, and h mod 33 = 0 crashes the round instantly at 1.00×. Spribe's own implementation hashes the server seed with three client seeds using SHA-512 and does not publish its exact arithmetic.

Can the server manipulate results after a round starts?

No. The hash of the server seed is published before the round is played. Changing the server seed after commitment would produce a different hash, which players could immediately detect. The cryptographic commitment makes post-hoc manipulation mathematically infeasible.

How does the 3% house edge appear in the algorithm?

The house edge appears in two places: (1) the 0.97 factor in the crash formula reduces all crash points proportionally, and (2) when h mod 33 = 0 (probability ≈ 3.03%), the round crashes instantly at 1.00×. Together, these produce exactly P(crash ≥ x) = 0.97/x.

How do I verify a specific Aviator round was fair?

Use the AviatorStats Provably Fair Checker: enter the server seed (revealed post-session), server seed hash, client seed, and round nonce. The tool recomputes HMAC-SHA256, derives the crash point using the formula, and compares with the stated result. A match confirms fairness.

Aviator Algorithm Explained: Provably Fair SHA-512 Deep Dive

Aviator Algorithm Explained: A Complete Technical Guide

One of Aviator's most important features is its provably fair algorithm — a cryptographic system that allows any player to independently verify that the crash point for any round was determined fairly and not manipulated. This guide explains how it works, the mathematics behind it, and how to verify results yourself.

What Is "Provably Fair"?

Traditional casino games require you to trust that the operator has not manipulated outcomes. Provably fair systems remove this trust requirement by using cryptographic hash functions that make it mathematically impossible to alter an outcome after it is committed to.

The core principle:

Before a round, the server commits to an outcome by publishing its hash
After the round, the server reveals the pre-image (the seed used to generate the hash)
You can verify that the committed hash matches the revealed seed
If they match, the outcome was not manipulated

The SHA-512 Hash Function

SHA-512 (Secure Hash Algorithm 512-bit) is a cryptographic hash function with two critical properties for provably fair gaming:

Property 1: Determinism

The same input always produces the same output:

Input: "hello" → Output: 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043

Property 2: Pre-image Resistance

Given a hash output, it is computationally infeasible to reverse-engineer the input. Even with all the world's computing power, finding the input to a given SHA-512 hash would take longer than the age of the universe.

This means: if the server publishes a hash before a round, it cannot change the underlying seed after the fact without producing a completely different hash — which you would immediately detect.

The Inputs: Server Seed and Three Client Seeds

Aviator's crash points are generated from four inputs:

Server Seed

A random string generated by the server before the round. The server publishes the SHA-256 hash of this seed before bets are taken and reveals the seed itself once the round ends.

Client Seeds

The client seeds of the first three players who placed a bet in the round are collected and shown in the round details. Because these values come from independent players, the operator cannot know the combined input in advance.

Combining the Inputs

The server seed and the three client seeds are concatenated and hashed with SHA-512. The resulting 128-character hexadecimal string determines the crash point.

How the Crash Point Is Calculated

Spribe does not publish the exact arithmetic that turns the SHA-512 hash into a multiplier. The walkthrough below uses the open reference construction popularised by Bustabit (an HMAC-SHA256 round hash with a nonce) to show how a hash becomes a multiplier whose distribution satisfies P(crash ≥ x) = 0.97/x. Aviator's SHA-512 pipeline follows the same principle: take leading bits of the hash, map them to a multiplier, apply the house edge.

In the reference construction the crash point is derived through a deterministic process:

Step 1: Generate the Round Hash

round_hash = HMAC-SHA256(server_seed, client_seed + ":" + nonce)

This produces a 64-character hexadecimal string, for example:

a7b3c8d2e9f14056789012345678901234567890abcdef1234567890abcdef12

Step 2: Extract a Number from the Hash

Take the first 8 characters (32 bits) of the hash and convert from hexadecimal to decimal:

h = parseInt(hash.substring(0, 8), 16)
// Example: "a7b3c8d2" → 2,813,000,914

The maximum possible value of h is 2^32 − 1 = 4,294,967,295.

Step 3: Apply the Crash Point Formula

crash_point = floor((1 − houseEdge) × 2^32 / (2^32 − h)) / 100

Where houseEdge = 0.03 (3%).

Simplified:

crash_point = floor(0.97 × 4,294,967,296 / (4,294,967,296 − h)) / 100

Special Case: Instant Crash

A separate condition handles the house edge directly. If:

h mod 33 === 0

...the round crashes instantly at 1.00× regardless of the formula result. This occurs with probability 1/33 ≈ 3.03%, enforcing the house edge.

Walking Through a Concrete Example

Suppose the first 8 hex characters of a round hash are 4f2a1b3c:

h = 0x4f2a1b3c = 1,328,284,988
2^32 = 4,294,967,296

Check: Is 1,328,284,988 mod 33 === 0? No → proceed to formula.

crash_point = floor(0.97 × 4,294,967,296 / (4,294,967,296 − 1,328,284,988)) / 100
= floor(4,166,117,577 / 2,966,682,308) / 100
= floor(1.4043...) / 100
= 140 / 100
= 1.40×

This round's crash point would be 1.40×.

Why This Formula Produces the Right Distribution

The formula P(crash ≥ x) = 0.97 / x emerges mathematically from this construction:

For a crash point to be at least x, the hash-derived value h must satisfy:

0.97 × 2^32 / (2^32 − h) ≥ x
→ 2^32 − h ≤ 0.97 × 2^32 / x
→ h ≥ 2^32 × (1 − 0.97/x)

The probability that a uniformly random h satisfies this is:

P(h ≥ 2^32 × (1 − 0.97/x)) = 1 − (1 − 0.97/x) = 0.97/x

Which gives exactly P(crash ≥ x) = 0.97/x — the house edge formula is mathematically baked into the crash point derivation.

How to Verify Results Yourself

Step 1: Record the Round Data

After any round, note:

Server seed hash (shown before the round)
Server seed (revealed after the round)
Client seeds of the first three bettors

Step 2: Verify the Hash Commitment

Compute SHA-256(server_seed) and confirm it matches the pre-committed hash. If it matches, the server seed was not changed after commitment.

Step 3: Recompute the Crash Point

Using the formula above, recompute the crash point from the seeds. If it matches the stated crash point, the round was fair.

Using the AviatorStats Provably Fair Checker

Our Provably Fair Checker tool at AviatorStats.com automates this entire process:

Enter the revealed server seed and the three client seeds shown in the round details
The tool computes the SHA-512 combination, extracts h, applies the crash formula, and displays the expected crash point
Compare with the game's stated result — they should match exactly

This gives you cryptographic certainty about round fairness without manual computation.

What Provably Fair Does and Does Not Guarantee

It Guarantees:

Crash points were not altered after commitment
Results are mathematically determined by the seeds
The house edge is exactly 3% as specified
Anyone can verify any historical round independently

It Does Not Guarantee:

That you will win any particular round
That the sequence of results is "fair" to any individual player
That strategies can overcome the built-in house edge
That past results predict future outcomes (they do not)

The provably fair system is a transparency mechanism, not a winning tool. It ensures the game operates as advertised — which is itself valuable, but separate from the mathematics of long-run expected value.

Use Our Aviator Analytics Tools

Analyze Aviator data with our live statistics, distribution analysis, trend charts, and provably fair verifier. All tools are free and require no registration.

Related Guides

Game Guides:

Strategy & Analysis:

Scam Warnings:

Platform Guides:

Disclaimer: This technical explanation is for educational purposes. Understanding the algorithm does not provide any advantage in predicting outcomes. Aviator results are cryptographically unpredictable before each round. Always gamble responsibly.