Dice notation min and max calculator
2d6+3 can never land below 5 or above 15, and that gives 11 possible totals. Paste a damage line, an attack roll or a homework expression and see its full reachable range at once. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Notation
- 2d6+3
- Normalized
- 2d6+3
- Min total
- 5
- Max total
- 15
- Range
- 10
This dice notation min and max calculator reads a standard dice expression and returns the lowest and highest totals the expression can produce when every die shows a face from one through its number of sides. Tabletop RPG damage lines, board-game attack charts, virtual tabletop macros, and homework problems all write rolls as compact strings such as 2d6, 3d8+2, 1d20+1d4−1, or d%. Designers and players need the full reachable band before they debate probabilities or average damage: if the floor is too low or the ceiling too high, the table feels wrong long before anyone cares about the mode. The engine tokenizes NdS dice terms and signed constants, applies the fair-die face model one through sides, and adds each term’s contribution to a global minimum and maximum—no Monte Carlo sampling, no network calls, and no date-dependent shortcuts. Classic checks include 2d6 from two through twelve, 3d6+2 from five through twenty, and a bare d20 from one through twenty.
What the lowest and highest totals tell you
Standard dice notation answers a discrete range question: each die shows an integer from one through its number of sides, every face is equally possible for the extremes, rolls are independent, and modifiers shift the total by fixed integers. The sample space of intermediate sums is not required here; only the envelope matters. For a positive term with count N and sides S the contribution is at least N (all ones) and at most N times S (all faces maxed).
For a negative dice term the extremes flip because subtracting a high roll hurts more than subtracting a one, so the contribution runs from minus N times S up to minus N. Constants add the same value to both bounds. This calculator walks the expression left to right, accumulates those contributions, and returns a stable result object.
There is no continuous approximation and no random sampling of rolls—the engine either finishes with exact integer bounds or fails closed with a clear message.
What you can do with it
Tabletop damage and attack formulas
Read 2d6+3, 1d8+1d6, or d20+5 and show players the true floor and ceiling before the roll.
Homebrew and encounter balancing
Check that weapon lines and trap damage sit inside the hit-point band you intend for each tier.
FAQ
What does the dice notation min and max calculator cost?
It is free in your browser on this page.
How are minimum and maximum defined?
Each die shows an integer from 1 through its sides. Positive NdS terms contribute N through N×S; negative dice terms flip those bounds; constants shift both totals by the same amount.
Which notation forms are supported?
Classic additive forms such as 2d6, d20, 3d8+2, 1d20+1d4-1, and d%. Spaces and uppercase D are fine. Keep-highest, drop-lowest, explode, and multiply are rejected.
What happens if the notation is empty or invalid?
Missing fields, bare constants without a die, illegal sides, and unsupported operators are not charged.
Is this a probability calculator?
No. This tool returns only the extreme totals. Use a dice probability capability when you need the chance of a specific sum inside the band.
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-dice-notation-range \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"notation":"2d6+3"}'const res = await fetch("https://api.kit.forhosting.com/hobby/game-dice-notation-range", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"notation": "2d6+3"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/game-dice-notation-range",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"notation": "2d6+3"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/game-dice-notation-range", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"notation":"2d6+3"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"notation":"2d6+3"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/game-dice-notation-range", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"notation": "2d6+3"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.game_dice_notation_range",
"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
max_dice | 100 |
max_sides | 1000 |
max_notation_len | 200 |
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 dice-notation min and max mean and what the response contains
The response echoes the original notation string, a normalized form without spaces and with explicit counts, the integer min_total and max_total, the arithmetic range max minus min, possible_totals as range plus one (the count of integer values from floor to ceiling when every intermediate total is reachable under additive fair dice), the total dice_count across terms, the net constant, term_count, a structured terms array with kind, sign, count or value, sides when applicable, and each term’s own min and max, plus a short formula reminder. Rejected cases are different from extreme but valid totals: missing notation, empty strings after trim, unsupported keep-highest or exploding operators, zero or one-sided dice, bare constants without a die, leading zeros, and values above the published dice or sides ceilings produce invalid_input so a bad form cell never becomes a silent wrong band.
How notation is read, normalized, and kept reproducible
Whitespace around plus and minus signs is stripped; the die letter is accepted as lowercase or uppercase d; a missing count before d means one die, so d8 is the same as 1d8; and d% is accepted as a percentile die with one hundred faces. Multiple dice terms and constants may be chained with + and −, for example 1d20+1d4+3 or 4d6−2. The engine rejects advanced operators that change the extreme model in ways that are not a simple sum of independent face ranges—keep highest, drop lowest, explode, multiply, and divide—so the published min and max stay honest for the classic additive reading. The normalized string rewrites implicit ones and drops spaces so two clients that send 2D6 + 3 and 2d6+3 compare equal after normalization. The preferred field is notation for the full expression string, with aliases expression, dice, formula, expr, input, and text so spreadsheets, query strings, and typed forms can reuse the same contract without a rename layer. Dice count per term and total dice across the expression are capped by the documented maxima, and sides per die are capped likewise, which keeps browser and Worker paths inside a predictable budget. Pair the free browser run on this page with the priced API when you need the identical mathematical envelope inside an automated pipeline without re-implementing dice tokenization yourself. Failed validation is not charged, and nothing is stored after the response returns.
Where min–max dice ranges fit in play, design, and software
Players meet range questions when a weapon card prints 2d6+4 damage and they want to know whether a lucky swing can one-shot a foe or whether the floor still fails to crack light armor. Game masters and homebrew designers use the same numbers when tuning encounter budgets, critical-hit riders, and treasure tables so the table never sees a dead zone of impossible totals or an accidental ceiling that trivializes a boss. Teachers introduce sample spaces by first showing the envelope of two six-siders before counting the ways for each intermediate sum. Contest and homework drills need a fast offline source of exact bounds so students can check work without opaque calculator apps that silently treat d% differently or allow illegal zero-sided dice. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002. 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 dice probability endpoints when you need the full distribution inside the band, and with other hobby math helpers when you are building a small lab of free, deterministic tools for games and study.
Integration use cases
Deterministic game and CI fixtures
Generate reproducible min_total and max_total values for unit tests of virtual tabletops and sheet apps.