Round-robin matches calculator
Plan a league where everyone meets once: 8 teams need 28 games over 7 rounds with 4 games per round, while 5 teams need 10 games over 5 rounds. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 8
- Teams
- 8
- Games
- 28
- Matches
- 28
- Rounds
- 7
A single round-robin tournament is the fairest classic format: every team plays every other team exactly once. Organizers still need two numbers before they book courts, referees, or broadcast slots — how many games will be played in total, and how many rounds the schedule will take if each team plays at most once per round. The total is always the binomial coefficient n choose two, written n times n minus one over two. The number of rounds depends on parity: when n is even the field pairs completely every round and finishes in n minus one rounds; when n is odd one team sits out each round and the tournament needs n rounds so every side still meets n minus one opponents. This capability accepts an integer team count n of at least two and returns games, matches, rounds, games per round, and short formula strings computed with pure integer arithmetic. Values below two are rejected with a clear validation error.
How round-robin games and rounds are counted
In a single round-robin every unordered pair of teams meets exactly once, so the game total is the combination formula C(n,2) equals n times n minus one, all over two. Two teams produce one game, four teams produce six, five produce ten, and eight produce twenty-eight. That count does not depend on how you order the schedule; it only depends on the complete set of pairs.
Scheduling length is a different question. Each team must play n minus one opponents and can play at most one opponent in a given round, so each side needs n minus one rounds of activity. When n is even, every team can be paired every round and the tournament finishes after n minus one rounds with n over two simultaneous games each round.
When n is odd, exactly one team has a bye in every round, so you need n rounds for each team to accumulate n minus one games, and each round holds n minus one over two matches. The circle method and related constructive algorithms implement those bounds; this capability returns the bounds themselves without listing pairings. Related but different formats include double round-robins where home and away both count, Swiss systems that pair by standing, and single-elimination brackets whose game counts grow differently.
Declared bounds keep n from two through one hundred thousand inclusive, which is more than enough for school leagues, pro seasons, and esports ladders while keeping free-tier latency trivial.
Where round-robin sizing shows up in real work
Sports clubs and school athletic directors use these numbers to book fields for a full season of mutual opponents. Esports tournament operators size groups inside larger events so each pool finishes in a known number of rounds before playoffs. Conference and league secretaries compare single round-robin cost against double schedules when travel budgets tighten.
Broadcast and streaming planners estimate match volume for rights deals; refereeing associations staff crews from games-per-round peaks. Teachers and coaches explain fairness by showing that every team plays the same number of games, then ask students to compute C(n,2) by hand before checking the tool. Software engineers building tournament management products need a single reliable closed form instead of ad-hoc loops that double-count pairs or forget byes on odd fields.
If you later need an explicit pairing table, home-and-away doubles, Swiss pairing rounds, or knockout bracket math, treat those as separate search intents rather than overloading this landing. Keep n inside the documented bound so free-tier latency stays predictable, and remember that rounds here assume one game per team per round with byes when the field is odd — not multi-game days or rest-day calendars.
What you can do with it
League and school season planning
Size total matches and schedule rounds for a single round-robin of n clubs before booking venues and referees.
Esports group-stage design
Compare pool sizes so every team plays every other once and the group finishes in a known number of rounds.
Classroom combinatorics demos
Show C(n,2) as real tournament matches and check even versus odd round rules against hand calculations.
FAQ
How many games are in a round-robin of n teams?
Exactly C(n,2) = n×(n−1)/2 games: every pair meets once. For example eight teams play twenty-eight games.
How many rounds does a single round-robin need?
If n is even, n−1 rounds with n/2 games each. If n is odd, n rounds with (n−1)/2 games each and one bye per round.
What happens if n is below 2?
A round-robin needs at least two teams; n below 2 is rejected and not charged.
Is this a double round-robin?
No. This calculator counts a single round-robin only. Home-and-away doubles would roughly double the games and are a separate format.
What does it cost?
The browser tool is free and runs locally.
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/combo/round-robin \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":8}'const res = await fetch("https://api.kit.forhosting.com/combo/round-robin", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/combo/round-robin",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/combo/round-robin", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/combo/round-robin", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"n": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "combo.round_robin",
"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
min_n | 2 |
max_n | 100000 |
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
The free browser tool and the paid API share one pure function, so league planners and automated pipelines never disagree on the same n.
How round-robin games and rounds are counted
The path is fully deterministic — no random seeds, no clocks, no network, and no model drift — so the same n always yields the same JSON.
What you send and what you get back
The integer n must lie from two through one hundred thousand inclusive. Error messages name the offending field and the rule that failed so form clients and scripts can correct the input without guessing. Provide a required integer n under the field n (aliases teams, number, or N). Missing fields, non-integers, decimals, and any n below two are rejected with invalid_input and are not charged. On success the response always includes the normalized n and teams, games and matches as the same C(n,2) total, rounds for a standard single-round schedule, games_per_round for that parity, and formula_games plus formula_rounds strings for display. Example checks: n equals eight yields twenty-eight games and seven rounds with four games per round; n equals five yields ten games and five rounds with two games per round; n equals two yields one game and one round; n equals four yields six games and three rounds; n equals one or zero yields invalid_input because a tournament needs at least two teams; a decimal or non-numeric string also yields invalid_input. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where round-robin sizing shows 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.