Board game playtime calculator
A game that takes 60 minutes with 2 players comes to 96 minutes with 5, if each extra player adds 12. Enter your reference time, the table size and the game's minimum to plan the night or book a table. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Base playtime minutes
- 60
- Base player count
- 2
- Actual player count
- 5
- Minimum player count
- 2
- Minutes per extra player
- 12
- Extra player count
- 3
- Added playtime minutes
- 36
- Estimated total minutes
- 96
A box estimate rarely tells you exactly how long tonight's session will take, especially when your group is larger than the player count behind that estimate. This board game playtime calculator starts with a known duration at a known player count, then adds a fixed number of minutes for every extra participant. It also checks the game's minimum player requirement before calculating, giving organizers a quick, repeatable estimate for scheduling a game night, reserving a table, or choosing a title that fits the time available.
Start with a comparable base session
Choose a base playtime that represents the game and group as closely as possible. The printed range on a box is useful, but a duration from one of your own recent sessions may be better because it reflects setup familiarity, teaching style, and how quickly your group takes turns. Enter the player count associated with that duration as the base player count.
For example, if a game usually takes about an hour with two people, use sixty minutes and two players even when planning for a larger table. The calculator treats that pair as the anchor for the estimate. Also enter the official minimum player count.
Both the base count and the planned actual count must meet that minimum, because a duration estimate is not meaningful for a group size the game does not support. This separation between the reference count, actual count, and minimum avoids silently treating an invalid session as a normal one.
Apply one clear rule for extra players
Set the number of minutes that each participant above the base count is expected to add. The calculation subtracts the base player count from the actual player count, never allowing the difference to fall below zero, and multiplies that extra-player count by the chosen increment. It then adds those minutes to the base playtime.
Suppose the base is sixty minutes for two players, the planned table has five players, and each extra participant is expected to add twelve minutes. There are three extra players, so thirty-six minutes are added and the estimate becomes ninety-six minutes. If the actual count is equal to or lower than the base count while remaining legal for the game, no time is subtracted: this tool models added turn load, not faster play at smaller counts.
That conservative rule is simple to explain, easy to reproduce, and avoids suggesting unsupported precision from sparse information.
Use the estimate as a planning baseline
Treat the result as a scheduling estimate rather than a guarantee. A fixed increment captures the common effect of more turns, more discussion, and longer rounds, but it cannot know whether someone needs a rules explanation, whether analysis paralysis is common, or whether the game ends after a fixed number of rounds. For a relaxed event, add a separate buffer for setup, teaching, breaks, scoring, and packing away.
For repeated sessions, compare the estimate with the observed finish time and adjust the minutes-per-extra-player value until it fits your group. The response includes the extra-player count and the exact number of added minutes, so the reasoning stays visible instead of appearing as a mysterious total. That makes the estimate suitable for invitations, venue bookings, convention schedules, and automated game-night planning.
What you can do with it
Plan a game-night schedule
Compare estimated session lengths for the confirmed group before choosing which games fit the evening.
Reserve a table or room
Turn a box-time estimate into a more realistic booking duration for a larger group.
Build a board game catalog
Calculate consistent playtime estimates for different player counts in a collection or event-planning tool.
FAQ
What formula does the calculator use?
It adds the base playtime to the number of players above the base count multiplied by the minutes-per-extra-player value.
What happens when the actual group is smaller than the base count?
No time is subtracted. The estimate stays at the base playtime as long as the group still meets the game's minimum.
Why does a player count below the minimum return an error?
The game does not support that group size, so applying a playtime scaling rule would produce a misleading result.
Does the estimate include setup and teaching time?
Only if those activities are already included in your base playtime. Add a separate planning buffer when they are not.
Where should the base playtime come from?
From the box or, better, from one of your own recent sessions, because it reflects how quickly your group teaches and takes turns. Enter the player count that went with that time as the base count.
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/game/board-game-playtime-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"base_playtime_minutes":60,"base_player_count":2,"actual_player_count":5,"minimum_player_count":2,"minutes_per_extra_player":12}'const res = await fetch("https://api.kit.forhosting.com/game/board-game-playtime-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"base_playtime_minutes": 60,
"base_player_count": 2,
"actual_player_count": 5,
"minimum_player_count": 2,
"minutes_per_extra_player": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/game/board-game-playtime-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"base_playtime_minutes": 60,
"base_player_count": 2,
"actual_player_count": 5,
"minimum_player_count": 2,
"minutes_per_extra_player": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/game/board-game-playtime-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"base_playtime_minutes":60,"base_player_count":2,"actual_player_count":5,"minimum_player_count":2,"minutes_per_extra_player":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"base_playtime_minutes":60,"base_player_count":2,"actual_player_count":5,"minimum_player_count":2,"minutes_per_extra_player":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/game/board-game-playtime-estimate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"base_playtime_minutes": 60,
"base_player_count": 2,
"actual_player_count": 5,
"minimum_player_count": 2,
"minutes_per_extra_player": 12
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "game.board_game_playtime_estimate",
"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
Use the estimate as a planning baseline
Run it in the browser for quick checks or use the API for $0.002 per request when a calendar or catalog workflow needs consistent calculations.
Technical questions
How much does the API request cost?
Each API request costs $0.002. The same deterministic calculation can also run in the browser.