DEV Community: CasinoKit

Building an odds converter in JavaScript: decimal, fractional, American and the hidden margin

CasinoKit — Wed, 28 Oct 2026 10:07:02 +0000

An odds converter looks like a weekend exercise: three formulas and an input field. When we built one for our project, the formulas took ten minutes. The edge cases took the rest of the day: fractions that come out as 9091/10000, American odds between -100 and +100 that do not exist, and floating point turning a clean -110 into something nobody would ever print on a betting slip.

This post walks through the conversions, the traps, and one number every converter user should understand: the bookmaker's margin.

Note: this is about probability and code, not advice to bet. Gambling is 18+, and the bookmaker's margin means the odds are always slightly against you.

Four ways to write the same price

Format	Example	Read it as
Decimal	2.75	total return per 1 staked (stake included)
Fractional	7/4	profit / stake
American	+175	profit on a 100 stake (or, if negative, stake needed to win 100)
Implied probability	36.36%	the chance the price suggests

All four describe the same thing, so the clean way to build a converter is to pick one internal format and convert everything through it. Decimal is the natural choice: it is a single positive number, and every other format maps to it with one line.

Everything into decimal

function toDecimal(format, value) {
  switch (format) {
    case 'decimal': {
      const d = parseFloat(value);
      return d > 1 ? d : null;               // 1.00 would mean "win nothing"
    }
    case 'fractional': {
      const [num, den] = String(value).split('/').map(Number);
      if (!den || !(num / den > 0)) return null;
      return num / den + 1;                  // 7/4 -> 2.75
    }
    case 'american': {
      const a = parseFloat(value);
      if (Math.abs(a) < 100) return null;    // -99..+99 is not a valid American price
      return a > 0 ? a / 100 + 1 : 100 / Math.abs(a) + 1;  // +175 -> 2.75, -110 -> 1.909
    }
    case 'probability': {
      const p = parseFloat(value);
      if (!(p > 0 && p < 100)) return null;
      return 100 / p;                        // 36.36% -> 2.75
    }
  }
  return null;
}

Two validation rules are easy to miss:

Decimal odds must be above 1. At exactly 1.00 you get your stake back and nothing else, so the price is meaningless.
American odds never sit between -100 and +100. Positive prices start at +100 (evens), negative ones at -100. A value like +50 is not "short odds", it is an input error, and the converter should say so instead of producing a number.

And back out again

function fromDecimal(format, d) {
  if (!(d > 1)) return '';
  switch (format) {
    case 'decimal':
      return d.toFixed(2);
    case 'american':
      return d >= 2
        ? `+${Math.round((d - 1) * 100)}`    // 2.75 -> +175
        : `${Math.round(-100 / (d - 1))}`;   // 1.909 -> -110
    case 'probability':
      return `${(100 / d).toFixed(2)}%`;
    case 'fractional':
      return toFraction(d - 1);              // the interesting one
  }
}

The American branch switches at exactly 2.0 (evens). Above it you show the profit on 100, below it the stake needed to win 100, with a minus sign.

The fraction problem

The obvious way to turn 0.75 into a fraction is to scale and simplify:

const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
const simplify = (n, d) => { const g = gcd(n, d); return `${n / g}/${d / g}`; };

simplify(Math.round(0.75 * 10000), 10000);   // "3/4"  fine

It works for 0.75, but try American -110. That is decimal 1.90909..., so the fractional part is 0.90909... Scaling by 10,000 gives 9091/10000, which is technically correct and completely useless. Every bookmaker prints that price as 10/11.

The fix is to look for a small denominator that reproduces the value exactly before falling back to rounding:

function toFraction(x) {
  for (let den = 1; den <= 1000; den++) {
    const num = Math.round(x * den);
    if (num > 0 && Math.abs(num / den - x) < 1e-9) return simplify(num, den);
  }
  return simplify(Math.round(x * 10000), 10000);   // fallback for odd decimals
}

toFraction(100 / 110);  // "10/11"
toFraction(0.75);       // "3/4"
toFraction(0.91);       // "91/100"  (decimal 1.91 really has no prettier fraction)

The loop runs at most a thousand cheap iterations, which is nothing for a UI that converts on every keystroke, and the tolerance of 1e-9 absorbs the floating point noise from the American conversion.

The number the converter does not show you: the margin

Implied probability is where odds stop being a formatting problem. Take a football match priced at:

Outcome	Decimal	Implied probability
Home	2.10	47.62%
Draw	3.40	29.41%
Away	3.60	27.78%
Total		104.81%

The three outcomes cover every possibility, so the true probabilities must add up to exactly 100%. The extra 4.81% is the bookmaker's margin (also called the overround or vig). It is built into every price on the market.

const margin = (odds) => odds.reduce((s, o) => s + 1 / o, 0) - 1;

margin([2.10, 3.40, 3.60]);   // 0.0481 -> 4.81%
margin([1.91, 1.91]);         // 0.0471 -> 4.71% on a classic -110 / -110 line

To estimate the "fair" price without the margin, scale the implied probabilities back to 100%:

const fair = (odds) => {
  const total = odds.reduce((s, o) => s + 1 / o, 0);
  return odds.map(o => +(total * o).toFixed(2));
};

fair([2.10, 3.40, 3.60]);   // [2.2, 3.56, 3.77]

This proportional method is the simplest of several and assumes the margin is spread evenly across outcomes. In practice it tends to be loaded more on long shots, but as a first approximation it shows clearly how much each price has been shaded.

Takeaways

Convert everything through one internal format. Decimal keeps the logic to two small functions.
Validate the impossible ranges. Decimal at or below 1 and American between -100 and +100 are errors, not edge cases to round.
Search small denominators before rounding. It is the difference between 10/11 and 9091/10000.
Sum the implied probabilities. Anything above 100% is the margin you pay on that market.

If you want to try the conversions without writing any code, the odds converter on CasinoKit uses exactly this logic: type a price in any of the four formats and the other three update as you type.

I analysed the bonus terms of 200 online casinos. Only 8 clear the 25x break-even line

CasinoKit — Wed, 28 Oct 2026 09:45:53 +0000

In my previous post I showed that a casino bonus has a simple break-even point: at an average RTP of 96%, a wagering requirement of 25x on the bonus costs exactly as much as the bonus is worth. Below that the bonus has a positive expected value, above it a negative one.

That raised an obvious question: how many real offers are actually below that line? Our project keeps the terms of every casino it lists as structured data, so I ran the numbers across all 200 of them.

Note: this is a data and probability post, not advice to gamble. Gambling is 18+, and the house always keeps an edge.

The dataset

Each casino is one JavaScript object, filled from a first-hand check of its terms page and cashier (October 2026). The fields that matter here look like this:

{
  bonus: {
    welcome: {
      match: 100,                 // %
      maxAmount: 500,             // EUR
      wageringRequirement: 35,    // x, null when not published
      wagerAppliesTo: 'bonus',    // or 'deposit+bonus'
      maxBet: 5,                  // EUR per spin while wagering
      timeLimit: 10               // days
    },
    cashback: { rate: 10, wageringRequirement: 0, maxAmount: 1000 }
  },
  licenseAuthority: 'Curacao Gaming Authority (CGA)'
}

One rule made the analysis much easier: unpublished values are stored as null, never 0. A 0 in a wagering field would mean "no wagering", which is a very different claim. Every number below only counts the casinos that actually publish that value.

How many casinos offer a welcome bonus at all?

	Casinos
With a welcome bonus	191
Without one (cashback or VIP only)	9
Wagering requirement published	185

The typical headline offer is a 100% match (the median of 190 offers with a match figure).

The wagering distribution

const wr = brands
  .map(b => b.bonus?.welcome?.wageringRequirement)
  .filter(x => typeof x === 'number');

const bucket = (lo, hi) => wr.filter(x => x >= lo && x <= hi).length;

Wagering	Casinos	Share
25x or lower	8	4%
26x to 35x	112	61%
36x to 40x	57	31%
above 40x	8	4%

The median is 35x, the lowest is 10x and the highest is 60x. So only 8 of 185 published offers sit at or below the 25x break-even line, and they are the only ones where the bonus is not negative on average before any other rule kicks in.

The word that doubles the cost

The multiplier is only half the story. What it multiplies matters just as much:

Wagering applies to	Casinos	Median wagering
Bonus only	104	40x
Deposit + bonus	83	35x
Deposit only	2

At first glance the deposit + bonus offers look friendlier (35x instead of 40x). Run the expected value on a €100 deposit with a 100% match and 96% RTP and it flips:

const ev = ({ deposit, bonus, wagering, appliesTo, rtp = 96 }) => {
  const base = appliesTo === 'deposit+bonus' ? deposit + bonus : bonus;
  return bonus - base * wagering * (1 - rtp / 100);
};

ev({ deposit: 100, bonus: 100, wagering: 40, appliesTo: 'bonus' });          // -60
ev({ deposit: 100, bonus: 100, wagering: 35, appliesTo: 'deposit+bonus' });  // -180

The "lower" 35x on deposit + bonus means €7,000 of betting instead of €4,000, so the expected cost is €280 instead of €160. 43% of the offers in the dataset use the deposit + bonus base.

The rules around the bonus

Two smaller fields shape how a bonus can be played:

Maximum bet while wagering: €5 is close to a standard. 155 of the 185 casinos that publish a cap use exactly €5.
Time limit: 10 days (69 casinos) and 7 days (58) dominate, with 30 days at 28 casinos.

With a €5 cap, clearing 35x on deposit + bonus for a €100 deposit takes at least 1,400 spins inside those 7 to 10 days.

Cashback looks very different

Cashback is the quiet counterpart to the welcome bonus. 181 of the 200 casinos offer some form of it, and the wagering picture is the opposite:

Cashback wagering	Casinos
None (paid as cash)	78
1x	81
3x to 30x	10
40x	9

For 159 casinos (88%) cashback carries no wagering or 1x. Mathematically that makes a modest cashback worth more than most welcome bonuses, because almost none of it is eaten by required betting.

Licences

Licence shown on the site	Casinos
Anjouan	73
Curacao	28
Tobique Gaming Commission	9
Malta (MGA)	6
Kahnawake	3
Other	13
No licence displayed on the site	68

Offshore licences (Anjouan, Curacao) cover most of the list, and about a third of the casinos do not display a licence on their site at all. Players who care most about regulation usually look for an MGA or UK Gambling Commission licence, which only a handful of these brands hold.

Takeaways

Only 4% of welcome offers clear the 25x line. The median offer (35x) has a negative expected value before max-bet and time rules.
Read what the multiplier applies to. Deposit + bonus can nearly double the betting needed even when the number looks lower.
Cashback is the better deal on paper. 88% of the cashback offers have no wagering or 1x.
Store "unknown" as null. It sounds like a detail, but it is what keeps a dataset like this honest: 6 of the 191 offers do not publish a wagering figure, and counting them as 0x would have almost doubled the "good" bucket.

If you want to look at the underlying data per casino (match, wagering, max bet, cashback and licence side by side), the full list is on CasinoKit. The calculators from the previous post use the same objects, so you can plug any offer in and see its expected value.

The math behind a casino bonus wagering calculator (and why most "100% bonuses" are worth less than zero)

CasinoKit — Tue, 20 Oct 2026 06:14:01 +0000

A "100% welcome bonus up to €500" sounds like free money. In practice the value depends on four numbers hidden in the terms: the match, the cap, the wagering requirement and the RTP of the games you play. When we built a small bonus calculator for our project, the most interesting part was not the UI. It was how a few lines of arithmetic turn marketing into an expected value you can actually reason about.

This post walks through that math and a tiny JavaScript implementation you can reuse.

Note: this is about probability and expected value, not a recommendation to gamble. Gambling is 18+ and the house always has an edge.

The inputs

Input	Meaning	Example
`deposit`	what you put in	100
`match`	bonus percentage	100 (%)
`maxBonus`	cap on the bonus	500
`wagering`	how many times you must bet the amount	35 (x)
`appliesTo`	wagering on bonus only, or deposit + bonus	bonus
`rtp`	average return-to-player of the games	96 (%)
`maxBet`	largest allowed bet while wagering	5

Step 1: the bonus you actually get

The match is capped, so the bonus is the smaller of the two:

const bonus = Math.min(deposit * (match / 100), maxBonus);
// 100 * 1.00 = 100, cap 500 -> bonus = 100

Step 2: how much you must bet

The wagering requirement multiplies either the bonus alone or the deposit plus the bonus. That one word in the terms doubles the work:

const base = appliesTo === 'both' ? deposit + bonus : bonus;
const totalWager = base * wagering;
// bonus only:        100 * 35 = 3,500
// deposit + bonus:   200 * 35 = 7,000

Step 3: what that betting costs on average

Every unit you bet returns rtp on average, so you lose 1 - rtp of everything you wager:

const expectedLoss = totalWager * (1 - rtp / 100);
// 3,500 * 0.04 = 140

Step 4: the real value

const realValue = bonus - expectedLoss;     // 100 - 140 = -40
const valueRating = (realValue / bonus) * 100; // -40%
const roundsNeeded = Math.ceil(totalWager / maxBet); // 700 spins at €5

So with these (very common) terms, the "free" €100 has an expected value of -€40. With wagering on deposit + bonus it gets worse: 7,000 wagered, 280 expected loss, -€180.

What actually moves the number

Because expectedLoss = base * wagering * (1 - rtp), the wagering multiplier dominates everything:

Wagering	Total wager	Expected loss (96% RTP)	Real value of €100 bonus
10x bonus	1,000	40	+60
20x bonus	2,000	80	+20
25x bonus	2,500	100	0 (break-even)
35x bonus	3,500	140	-40
35x deposit + bonus	7,000	280	-180

Break-even is simply wagering = 1 / (1 - rtp), which at 96% RTP is 25x on the bonus. Anything above that is negative on average, before you even look at max-bet rules, excluded games or win caps.

The whole function

export function bonusValue({ deposit, match, maxBonus, wagering, appliesTo, rtp, maxBet }) {
  const bonus = Math.min(deposit * (match / 100), maxBonus);
  const base = appliesTo === 'both' ? deposit + bonus : bonus;
  const totalWager = base * wagering;
  const expectedLoss = totalWager * (1 - rtp / 100);
  const realValue = bonus - expectedLoss;
  return {
    bonus,
    totalWager,
    expectedLoss,
    realValue,
    valueRating: bonus > 0 ? (realValue / bonus) * 100 : 0,
    roundsNeeded: Math.ceil(totalWager / maxBet),
  };
}

It is deliberately simple: expected value only, no variance. A natural next step is a Monte Carlo simulation to estimate the chance of finishing the wagering with anything left, which is a fun exercise in its own right.

If you want to play with the numbers without writing code, we published the same logic as a free bonus wagering calculator that runs in the browser in 12 languages.

Questions about the math or ideas for the variance model are welcome in the comments.