Bingo card combinations calculator
Classic 75-ball bingo with an open center square allows 552,446,474,061,128,648,601,600,000 different cards. Enter each column's number range and filled cells to size a deck or prove every card can be unique. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Pools
- 15, 15, 15, 15, 15
- Cells
- 5, 5, 4, 5, 5
- Columns
- 5
- Column counts
- 360,360, 360,360, 32,760, 360,360, 360,360
- Total cards
- 552446474061128648601600000
Bingo card combinations answer a deceptively simple question: given how many numbers sit in each column’s pool and how many cells that column must fill, how many physically distinct cards exist? Event organizers, app developers, and teachers use that count to size decks, prove uniqueness guarantees, and compare free-center five-by-five layouts against custom grids. This bingo card combinations calculator multiplies independent column choices—ordered row placements P(n,k) by default, or unordered sets C(n,k) when only the number set matters—and returns an exact total as a safe integer or full decimal string when the product overflows JavaScript’s safe range. Classic United States seventy-five-ball bingo is the ready example: five columns of fifteen numbers each, five rows, free center on N so that column needs four numbers, and order inside every column matters, which yields the famous astronomical card count.
How column pools turn into a card total
A bingo card is a grid whose columns draw from disjoint number ranges. In standard seventy-five-ball play the B column may only show numbers from one through fifteen, I from sixteen through thirty, N from thirty-one through forty-five, G from forty-six through sixty, and O from sixty-one through seventy-five.
Each of those ranges is a pool of size fifteen; a five-row card without a free space would place five numbers from each pool, while the ubiquitous free-center house rule leaves the middle N cell blank and therefore places only four numbers in that column. Because the rows of a printed card are ordered, two cards that share the same five B numbers but in a different vertical order are different cards. Columns are independent, so the total number of cards is the product of those column contributions.
When you only care which numbers appear and not their row order, set ordered to false and each column instead contributes the binomial coefficient C(n,k).
Where bingo card combinatorics earns its keep
Hall operators and charity fundraisers use a bingo card combinations calculator before printing runs so they know whether a requested deck size is a tiny fraction of the theoretical space or dangerously close to collision risk under naive random generation. Mobile bingo and party-game apps seed decks offline by sampling without replacement from the combinatorial space and need an oracle that matches classroom combinatorics notes, not an approximate Monte Carlo estimate.
Educators teaching permutations versus combinations contrast ordered column fillings with unordered set selection on the same pools array, toggling ordered to show how free-center and full-grid layouts change the product. Custom party variants—three-by-three kids’ boards, ninety-ball British strip layouts reduced to column pools, or themed decks with uneven ranges—map cleanly onto arbitrary pools and cells arrays without hard-coding the seventy-five-ball legend.
What you can do with it
Print-run and deck sizing
Before ordering physical cards, compute the theoretical total for your pool and free-center layout so the printed deck stays a safe subset of distinct cards.
Bingo app deck generation
Seed mobile or browser bingo decks with an exact upper bound on unique cards; compare ordered versus unordered modes when UI shuffles column rows.
Classroom combinatorics demos
Show P(n,k) versus C(n,k) on the same five-column bingo pools so students see how free center and row order change the product.
FAQ
How many distinct US 75-ball bingo cards are there?
With pools [15,15,15,15,15], cells [5,5,4,5,5] (free center), and ordered true, the total is P(15,5)^4 × P(15,4) = 552446474061128648601600000 distinct cards.
What do pools and cells mean?
pools[i] is how many numbers column i may draw from; cells[i] is how many cells that column fills. Lengths must match. Classic free-center N uses cells 4 on the middle column.
When should ordered be false?
Set ordered false when two cards that share the same numbers in a column but in different row order should count as one. That multiplies binomial C(n,k) instead of permutations P(n,k).
What if cells exceeds pool for a column?
You cannot place more filled cells than the pool has distinct numbers. Invalid input is not billed.
Why does the open center square change the number of bingo cards?
The N column fills only 4 cells instead of 5, so it can be arranged in 11 times fewer ways than each of the other columns, and the total number of cards shrinks by that same factor.
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/hobby/game-bingo-combinations \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pools":[15,15,15,15,15],"cells":[5,5,4,5,5]}'const res = await fetch("https://api.kit.forhosting.com/hobby/game-bingo-combinations", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pools": [
15,
15,
15,
15,
15
],
"cells": [
5,
5,
4,
5,
5
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/game-bingo-combinations",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pools": [
15,
15,
15,
15,
15
],
"cells": [
5,
5,
4,
5,
5
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/game-bingo-combinations", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pools":[15,15,15,15,15],"cells":[5,5,4,5,5]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pools":[15,15,15,15,15],"cells":[5,5,4,5,5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/game-bingo-combinations", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"pools": [
15,
15,
15,
15,
15
],
"cells": [
5,
5,
4,
5,
5
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.game_bingo_combinations",
"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
How column pools turn into a card total
That is why the default mode multiplies permutations: for a column with pool n and k filled cells the contribution is P(n,k) equals n factorial over (n minus k) factorial, computed as the falling product n times (n minus one) times down to (n minus k plus one). Either way the endpoint returns the per-column counts and the grand product so you can audit intermediate factors against a spreadsheet or textbook identity.
Input contract, response fields, and validation
Classic free-center United States bingo is pools equal to fifteen fifteen fifteen fifteen fifteen and cells equal to five five four five five. Optional ordered defaults to true; pass false when combinations rather than permutations should be multiplied. POST a JSON body with two required arrays of equal length: pools, the size of the number set available to each column from left to right, and cells, how many cells that column actually fills. Arrays may be sent under common aliases such as column_pools, ranges, column_cells, or picks. Each entry must be a non-negative whole integer within the published column and pool limits; empty arrays, mismatched lengths, fractional values, and any column where cells exceeds pool fail with invalid_input and are not billed. On success the body echoes pools, cells, and ordered; reports columns as the shared length; lists column_counts as the individual P or C values (numbers when they fit safely, otherwise decimal strings); gives total_cards as the product in the same number-or-string form; and includes a formula string that concatenates P(n,k) or C(n,k) factors with multiplication signs for display. Large products such as the full seventy-five-ball free-center total exceed fifty-three bits of mantissa, so clients must treat total_cards as either a number or a string and never force it through unsafe floating-point conversion if they need an exact value for inventory math.
Technical questions
What does the bingo card combinations calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; validation failures are not billed.