Roulette payout calculator
25 chips on red with 7 as the winning number pay 25 and bring 50 chips back to you. Name the bet, the stake and the pocket that landed on a single-zero wheel, and see the payout, the odds and whether the bet won. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bet type
- Red
- Amount
- 25
- Winning number
- 7
- Odds
- 1
- Payout
- 25
- Total return
- 50
- Color
- red
A European roulette table pays a fixed multiple of the stake when the winning pocket sits on the numbers covered by the wager, and pays nothing when it does not. This roulette payout calculator takes a recognized bet type, a positive stake, and the winning number from 0 through 36, then returns the net payout, the chips the dealer would push back, the published odds, and whether the wager won. Red, black, even, odd, low, high, the three dozens, and the three columns are complete from those three fields. A straight-up chip also needs the pocket you actually covered. Zero is green: it loses every even-money, dozen, and column bet.
How European roulette pays a recognized bet
European single-zero roulette uses thirty-seven pockets labelled 0 through 36. Eighteen of those numbered pockets are red, eighteen are black, and the single 0 is green. A recognized outside bet covers a published set of pockets and pays even money, which is 1 to 1, or two to one for a dozen or a column.
Red covers the eighteen red pockets. Black covers the eighteen black pockets. Even covers 2, 4, 6, through 36.
Odd covers 1, 3, 5, through 35. Low covers 1 through 18. High covers 19 through 36.
The first dozen covers 1 through 12, the second 13 through 24, and the third 25 through 36. Column one is 1, 4, 7, through 34. Column two is 2, 5, 8, through 35.
Column three is 3, 6, 9, through 36. A straight-up chip on one pocket pays 35 to 1. The house edge lives in the green 0: when 0 lands, every even-money, dozen, and column wager loses, because 0 is neither red nor black, neither even nor odd in table rules, and sits in no dozen and no column.
This calculator applies those table rules exactly. If the winning number is among the pockets the bet covers, the net payout is the stake times the odds. Otherwise the payout is zero and the stake is lost.
There is no random draw here. You already know the winning number and you want the money that number produces for that wager.
Who uses a roulette payout calculator
Dealer schools and table-games trainers use a roulette payout calculator so a student can name a bet, a stake, and a pocket and see the chips that should come back without flipping a paper odds card. Probability and gambling-math courses treat the same identity as a homework oracle: students compute expected value by hand from the published odds and the thirty-seven pockets, then check the cash result of one realized spin against a deterministic machine.
Game designers and casino-software authors need a tiny parse service that will not invent a 35 to 1 payout for an unknown bet type, because a silent default is how a prototype ships the wrong house edge. Failed validation does not consume balance. Keep the stake inside the published ceiling, pin the integer examples in tests, and you get reproducible winnings for a training desk, an LMS plugin, or an edge worker without standing up a full table-games engine.
This page prices one already-known winning number. It does not spin a wheel, simulate a session, or compute expected value over many trials.
What you can do with it
Dealer training and table checks
Name a recognized bet, a stake, and the pocket that landed, then confirm the net payout and the chips the dealer should push back.
Classroom gambling-math drills
Let students check the cash result of one European spin against published 1:1, 2:1, and 35:1 odds without a felt diagram.
Game-design and grading scripts
Reject unknown bet types in a prototype or auto-grader instead of silently paying a default multiple that invents the house edge.
FAQ
How is the roulette payout computed?
If the winning number sits on a pocket the bet covers, payout is stake times the published odds (1 for even money, 2 for a dozen or column, 35 for a straight).
Which roulette bet types are recognized?
A straight bet also needs selection, the pocket the chip sits on.
Why does 0 lose even-money, dozen, and column bets?
On a European wheel 0 is green. Table rules treat it as neither red nor black, neither even nor odd, and outside every dozen and column. Only a straight bet on 0 itself wins when 0 lands.
Does it work for American double-zero roulette?
No. It follows the European single-zero wheel with pockets numbered 0 to 36, and a winning number of 00 is not accepted, because that pocket does not exist on this wheel.
What is the difference between the payout and the chips returned?
The payout is the net win, the stake times the odds. The chips returned add your original stake back: 25 chips on red that win pay 25 and return 50. After a loss both are zero.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/stat/roulette-payout \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bet_type":"red","amount":25,"winning_number":7}'const res = await fetch("https://api.kit.forhosting.com/stat/roulette-payout", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bet_type": "red",
"amount": 25,
"winning_number": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/roulette-payout",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bet_type": "red",
"amount": 25,
"winning_number": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/roulette-payout", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bet_type":"red","amount":25,"winning_number":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bet_type":"red","amount":25,"winning_number":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/roulette-payout", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"bet_type": "red",
"amount": 25,
"winning_number": 7
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.roulette_payout",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_amount | 1000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Unrecognized bet types fail with invalid_input instead of inventing house odds. The same pure function powers the free browser form and the prepaid API path, so a training desk and a grading script never disagree. Successful API calls cost $0.002; failed validation is not billed.
How European roulette pays a recognized bet
The returned total_return is the chips the dealer pushes back on a win, which is the original stake plus the net payout, and zero on a loss.
Input contract, response shape, and error behaviour
Send three required fields. bet_type is a recognized European wager: straight, red, black, even, odd, low, high, dozen_1, dozen_2, dozen_3, column_1, column_2, or column_3. amount is a finite positive stake, also accepted as bet_amount, stake, or wager. winning_number is the pocket that landed, an integer from 0 through 36, also accepted as winning, result, or number. A straight bet also needs selection, the pocket the chip sits on, also accepted as bet_number, chosen, or on. Missing fields, empty strings, booleans, non-numeric stakes, non-integer pockets, pockets outside 0 through 36, and the American double-zero token 00 fail with invalid_input naming the culprit. If bet_type is not on the recognized list the task fails with a message that the bet type is not a recognized roulette bet, which is the contract for invented wagers such as a neighbor stack or a call bet this endpoint does not price. Those failures are not billed. On success the body echoes the cleaned bet_type, amount, and winning_number, reports won as a boolean, odds as the published ratio, payout as the net house payment, and total_return as the chips pushed back. color is the color of the winning pocket: red, black, or green. covered is the sorted list of pockets the wager actually covers, and covered_count is its length. formula restates the table identity that was used, for example even-money 1:1 (red) or straight-up 35:1. selection is present only for a straight bet. Pair the JSON with your own layout drawing if you need a felt diagram; this endpoint computes money, not a wheel animation.
Technical questions
What happens if the bet type is not recognized?
The task fails with invalid_input and a message that bet_type is not a recognized roulette bet. Invented wagers are not priced and the call is not billed.
What does the roulette payout calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.