ForHosting KIT · Math

Lottery jackpot odds calculator

See how unlikely the top prize really is: a 6-from-49 game has 13,983,816 possible tickets, so matching every number is 1 in 13,983,816, or about 13,983,815 to 1 against. Enter only the pool size and the count drawn. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Pool: 49
Drawn: 6

You get

Probability: 0.0000000715
Favorable combinations: 1
Total combinations: 13,983,816
Odds against: 13,983,815.000000002

The lottery jackpot odds calculator answers one clear combinatorial question: if a game draws a fixed count of numbers from a larger pool, and your ticket holds the same count, what is the probability that you match every number and win the top prize? That is the pure n-choose-k jackpot model used by classic six-from-forty-nine games, classroom exercises, and prize-ladder sketches that only care about the full-match tier. You supply the pool size and how many numbers are drawn; the engine returns the exact jackpot probability as one over the binomial coefficient C of pool choose drawn, the total number of equally likely tickets, the single favorable combination, odds against expressed as one minus p over p, and a one-in-N reading of the same figure. All arithmetic is deterministic—multiplicative binomial coefficients, no random sampling, no network, no clock—so the same inputs always produce the same outputs.

What jackpot odds mean and what you get

A jackpot in an n-choose-k lottery is the event that every number on your ticket also appears in the draw. When the ticket and the draw both contain exactly drawn distinct values from a pool of size pool, every unordered combination of that size is equally likely. There are C of pool choose drawn such combinations, and exactly one of them matches a given ticket completely.

Therefore the jackpot probability is simply one divided by that binomial coefficient. Required inputs are pool and drawn.

What you can do with it

Homework and exam preparation

Look up exact jackpot probabilities for textbook n-choose-k exercises, including odds against and one-in-N combination counts.

Jackpot marketing and prize sketches

Convert pool and draw size into a clear one-in-N jackpot figure for product copy, prize ladders, or explainers without secondary match tiers.

FAQ

What does the lottery jackpot odds calculator cost?

It is free in your browser on this page.

What formula is used for matching all numbers?

P(jackpot) = 1 / C(pool, drawn). Every unordered ticket of size drawn from the pool is equally likely, and exactly one is a full match.

What happens if drawn is greater than pool?

You cannot draw more numbers than exist in the pool; drawn must be less than or equal to pool.

Does this compute partial matches like three of six?

No. This tool is jackpot-only: the probability of matching every number. For exact m-of-k match tiers, use a multi-match hypergeometric lottery calculator.

Is this a jackpot payout or expected-value calculator?

No. It returns combinatorial full-match probability and odds against only. It does not model prize amounts, taxes, ticket cost, or expected monetary value.

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

POSThttps://api.kit.forhosting.com/stat/lottery-odds

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/lottery-odds \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"pool":49,"drawn":6}'

const res = await fetch("https://api.kit.forhosting.com/stat/lottery-odds", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "pool": 49,
    "drawn": 6
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/stat/lottery-odds",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "pool": 49,
    "drawn": 6
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/lottery-odds", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"pool":49,"drawn":6}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"pool":49,"drawn":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/lottery-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

{
  "pool": 49,
  "drawn": 6
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "stat.lottery_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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_pool 10000

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 jackpot odds mean and what the response contains

The calculator returns that probability as a floating-point number in the closed unit interval, the favorable combination count which is always one for a full match, the total combination count C of pool choose drawn, odds against defined as one minus p over p so that a probability of one in thirteen million nine hundred eighty-three thousand eight hundred sixteen appears as roughly thirteen million nine hundred eighty-three thousand eight hundred fifteen to one, and odds_one_in which echoes the total combination count as the familiar one-in-N figure players and journalists quote. The engine rejects drawn greater than pool with invalid_input, because you cannot draw more numbers than exist in the pool; that is the hard combinatorial constraint the product page emphasizes. The response also echoes normalized parameters, attaches a short formula string for learners who want to cross-check by hand, and publishes max_pool so clients can validate before they send work. This page is not a multi-tier match calculator, a bonus-ball joint model, a jackpot payout estimator, a tax calculator, or a Monte Carlo simulator of many tickets. It is the exact combinatorial jackpot odds tool for matching all numbers in an n-choose-k draw, free to run in the browser and priced consistently through the API at $0.002 per successful request when you integrate it into scripts.

How pool and drawn are read and how C(pool, drawn) is computed

Optional leading plus signs on integers are allowed; embedded spaces, hex prefixes, negatives where forbidden, and scientific notation on integer fields are rejected so a bad cell does not become a wrong jackpot figure. The total combination count uses a multiplicative product that builds C of pool choose drawn without computing full factorials, then rounds to the nearest representable integer when the result stays finite. Edge cases are intentional and stable: when drawn equals pool there is only one possible ticket and the jackpot probability is one with odds against zero; when drawn is one the total combinations equal the pool size and the jackpot is simply one over pool. The preferred fields are pool for the size of the main number pool and drawn for how many numbers are selected on each ticket and in each draw. Aliases are accepted so spreadsheets and scripts can keep familiar names: for pool the aliases are n, pool_size, balls, and total; for drawn they are k, r, draw, picks, numbers, and ticket_size. The rule drawn must not exceed pool is checked after both values are parsed and surfaces a clear invalid_input message that names the fields and states that drawn exceeds pool. Both fields must be positive integers within the supported range up to max_pool of ten thousand; values outside that range fail validation rather than silently overflowing. Probability is the reciprocal of that count when the count is positive and finite; odds against follows one minus p over p; odds_one_in mirrors the total combination count so callers can print phrases such as one in thirteen million without re-deriving the binomial coefficient. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing binomial coefficients yourself.

Where jackpot odds fit in study, product design, and code

Students meet jackpot odds when a textbook asks for the chance of matching all six numbers in a six-from-forty-nine game, when a worksheet wants odds against a full house of main balls, or when they verify that one over C of n choose k matches the definition built from combinations. Teachers can pre-generate answer keys for modest pools without trusting opaque calculator apps that round intermediate coefficients or hide the jackpot-only definition. Journalists and curious players use the same contract to translate slogans such as one in fourteen million into an explicit combinatorial statement before writing explainers. Contest practice often needs a fast offline source of jackpot values so solutions can be checked without embedding large static tables by hand. Game designers and product managers sketch top-tier prizes: fix pool and drawn from the rules, read probability and odds_one_in, and decide whether the advertised jackpot is rare enough for marketing without inventing secondary match tiers on this page. Developers call the endpoint from scripts to seed deterministic test vectors, to illustrate binomial coefficient tricks, or to satisfy programming-challenge statements that demand the probability of a full match for given pool and drawn. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with multi-match hypergeometric tools when you need the probability of exactly m hits rather than a full jackpot, with combinatorial counters when you need only C of n choose k, and with other math endpoints when you are building a small lab of free, deterministic probability helpers for education and product work focused on the top prize alone.

Integration use cases

Deterministic test fixtures

Generate reproducible probability, combinations, and odds fields for unit tests and CI without hand-rolled binomial coefficients.

Read the full KIT documentation →

Run — free