Poker hand odds
A flush that is not a straight shows up in 5108 of the 2598960 possible five-card hands, odds of 648463 to 1277 against. Pick a hand such as pair, full house or four of a kind and get its exact count and probability. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hand
- flush
- Total
- 2,598,960
- Hand name
- Flush
- Quantity
- 5,108
- Probability
- 0.0019654015
Five-card poker is one of the cleanest combinatorics demos in everyday life: every unordered five-card deal from a standard fifty-two-card deck is equally likely, and the classic hand rankings partition that space into a handful of well-known categories. When someone asks how rare a flush is, or what chance a random deal is exactly one pair, the answer is not a simulation estimate — it is a ratio of two exact integers. This capability accepts a standard hand name such as pair, flush, full house, or four of a kind, then returns the exact favorable count, the total of two million five hundred ninety-eight thousand nine hundred sixty five-card hands, the probability as a fraction of one, a percent, simplified odds against, and a short combinatorial formula. Unknown hand names are rejected with a clear validation error instead of a silent zero.
How five-card poker hand probabilities are counted
A standard deck has fifty-two distinct cards: thirteen ranks in each of four suits. A five-card poker hand is an unordered selection of five cards, so the sample space size is the binomial coefficient C(52, 5), which equals two million five hundred ninety-eight thousand nine hundred sixty equally likely outcomes. Each classic ranking is defined by a mutually exclusive pattern of ranks and suits.
A royal flush is the specific A-K-Q-J-10 sequence in one suit, so there are exactly four such hands. A straight flush that is not royal has nine remaining contiguous sequences per suit, for thirty-six hands. Four of a kind chooses the quad rank in thirteen ways and the kicker from the forty-eight remaining cards, giving six hundred twenty-four.
A full house multiplies choices of the three-of-a-kind rank and the pair rank with their suit combinations to three thousand seven hundred forty-four. A flush that is not a straight chooses one suit and five ranks that do not form a straight sequence, yielding five thousand one hundred eight. A non-flush straight has ten rank sequences and four suit choices per card minus pure flushes, for ten thousand two hundred.
Lower categories — three of a kind, two pair, one pair, and high card — follow the same style of rank selection with suit factors and exclusion of stronger patterns so the ten categories sum exactly to C(52, 5). This implementation stores those textbook counts and divides by the fixed total; it never shuffles, never samples, and never consults a network clock.
Edge cases such as treating royal flush as separate from straight flush match the ranking used in almost every casino chart and probability table you will find in discrete-math courses.
Where poker hand odds show up in real work
Introductory probability and discrete mathematics courses constantly ask students for the chance of a flush, a full house, or exactly one pair in a random five-card deal, and instructors need a deterministic answer key rather than a random Monte Carlo run that changes between grading sessions. Game designers and tabletop publishers embed the classic percentages in rulebooks, loading screens, and tutorial tooltips so players understand how rare premium hands really are.
Casino training material and responsible-gaming explainers compare the rarity of royal flushes against everyday one-pair deals using the same fixed ratios. Data journalists and educators building interactive charts need a single authoritative source that agrees with every standard poker probability table. If you later need Texas Hold'em equity given hole cards and a board, seven-card stud combinations, multiway pot odds, or random hand generation for stress tests, treat those as separate search intents rather than overloading this landing.
What you can do with it
Statistics and discrete-math homework
Look up exact five-card poker probabilities for flush, full house, pair, and other rankings when building answer keys or checking combinatorics exercises.
Game design and teaching tools
Embed classic poker hand rarity into tutorials, loading screens, and probability demos without Monte Carlo variance or offline spreadsheet tables.
FAQ
Which poker hands are supported?
The ten standard five-card categories: royal flush, straight flush, four of a kind, full house, flush, straight, three of a kind, two pair, one pair, and high card.
Is the probability exact?
Yes. Favorable counts are the classic combinatorial integers and the total is always C(52,5)=2,598,960. Probability is count/total; count and total are returned as integers for exact checks.
Does this cover Texas Hold'em equity?
No. This computes unconditional five-card draw frequencies from a full deck, not multi-street Hold'em equity with hole cards and community boards.
What does it cost?
The browser tool is free and runs locally.
How rare is a full house compared with a flush?
A full house appears in 3744 of the 2598960 possible hands and a flush that is not a straight in 5108, so the flush is somewhat more common. Four of a kind is rarer still, with only 624 hands.
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/prob/poker-odds \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hand":"flush"}'const res = await fetch("https://api.kit.forhosting.com/prob/poker-odds", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hand": "flush"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/prob/poker-odds",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hand": "flush"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/prob/poker-odds", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hand":"flush"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hand":"flush"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/prob/poker-odds", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"hand": "flush"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "prob.poker_odds",
"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.
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
What you send and what you get back
Validation failures are not charged. Provide a required string field hand (aliases hand_type, type, category, or hand_name) naming the category you care about. Names are case-insensitive and accept spaces, hyphens, or underscores: flush, full house, full_house, one_pair, pair, four_of_a_kind, quads, three_of_a_kind, trips, two_pair, high_card, royal_flush, and straight_flush are all recognized. Missing hand, empty strings, non-string values, and any label that is not a standard five-card category fail with invalid_input; the error message includes Unknown poker hand and lists the known keys so clients can correct the request without guessing. On success the response always includes hand as the canonical snake_case key; hand_name as a human label; count as the exact favorable integer; total as two million five hundred ninety-eight thousand nine hundred sixty; probability as count divided by total; percent as probability times one hundred; odds_against as a reduced a:b string meaning a against to b for; formula as a short combinatorial display string; and deck describing the model as a fifty-two-card five-card draw where order is irrelevant. Example checks: hand equals flush yields count five thousand one hundred eight and probability about zero point zero zero one nine six five; hand equals full house yields three thousand seven hundred forty-four favorable hands; hand equals pair maps to one_pair with over one million favorable deals; hand equals not_a_hand yields invalid_input. Pricing for successful API calls is the published base of $0.002 per item.
Where poker hand odds show up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance. Keep requests to a single named category so the response stays a simple, cacheable JSON object, and remember that floating-point probability is ideal for display while the integer count and total remain exact for combinatorial proofs and automated assertions.
Integration use cases
Simulator and ranking-engine fixtures
Assert that a deal simulator or hand classifier approaches textbook frequencies (count over 2,598,960) for each mutually exclusive category.
Technical questions
What happens if I send an unknown hand name?
The request fails with invalid_input and a message that starts with Unknown poker hand, listing the known categories. Invalid input is not charged.