Bonferroni correction calculator
A significance level of 0.05 spread over 10 comparisons gives a per-test cutoff of 0.005. Enter the original level and the number of planned tests, and judge each p-value against that stricter threshold before you read the results. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Alpha
- 0.05
- Comparisons
- 10
- Adjusted alpha
- 0.005
When you run several hypothesis tests on the same family of questions, the chance of at least one false positive grows with every extra comparison. The Bonferroni correction is the classic, conservative answer to that problem: divide the original family-wise significance level alpha by the number of comparisons m so that each individual test is judged against the stricter threshold alpha over m. This Bonferroni correction calculator takes those two numbers and returns the adjusted significance level you should use as the per-test cutoff.
What the correction does and what you get back
The family-wise error rate is the probability of making at least one Type I error among a planned set of tests. If every comparison is judged at the unadjusted alpha, that family-wise chance grows roughly like one minus one minus alpha to the power of m, so ten independent tests at five percent already give a better than forty percent chance of a stray star.
Carlo Emilio Bonferroni’s inequality supplies a simple bound that does not need independence: keep the family-wise rate no larger than alpha by testing each comparison at alpha divided by m. That single division is the entire mathematical core of this calculator. You send a finite original significance level in the open-closed interval from just above zero through one, plus a positive integer count of comparisons, and the engine returns the adjusted alpha together with the cleaned inputs, the method name Bonferroni, and the formula string alpha-adj equals alpha over m.
Classic textbook checks include five percent over ten comparisons, which yields an adjusted threshold of one half of one percent, and one percent over five comparisons, which yields two tenths of one percent. A single comparison is a valid success: the adjusted alpha equals the original alpha, because there is nothing to split. The procedure is conservative on purpose.
It does not estimate dependence among tests, it does not rank p-values the way Holm–Bonferroni does, and it is not a studentized-range post-hoc such as Tukey HSD. Those are different search intents and different landings. What you get here is the threshold you write next to a planned family of tests when the assignment, the protocol, or the reviewer asked specifically for a Bonferroni-adjusted significance level.
Where Bonferroni-adjusted alpha shows up in real work
Product analytics teams that run several pairwise variant checks against a control can convert the planned family size into a per-test cutoff before they look at p-values, which is the honest order of operations. Genomics and screening notebooks that apply thousands of independent tests still teach Bonferroni as the conservative baseline even when they later switch to false-discovery-rate control; having a deterministic α over m helper keeps that baseline pinned.
Keep requests inside the documented limits, pin the rounded adjusted alpha in tests, and you get reproducible Bonferroni thresholds for homework, LMS plugins, and edge workers without standing up a statistics library of your own. If you later need Holm step-down, Šidák, Tukey HSD, or Benjamini–Hochberg FDR, treat those as separate search intents and landings rather than overloading this Bonferroni correction page.
What you can do with it
Classroom multiple-comparison drills
Let students submit a family-wise alpha and a planned number of tests, then verify that the Bonferroni cutoff equals alpha divided by m, including the single-comparison edge case.
FAQ
What happens if the number of comparisons is not a positive integer?
Zero, negatives, fractions, and non-numeric text are not comparison counts and are not charged.
Is alpha 0.05 over 10 comparisons a valid example?
A single comparison returns the original alpha unchanged.
Is this the same as Tukey HSD or Holm–Bonferroni?
No. This landing only divides alpha by m. Tukey HSD is a studentized-range post-hoc on group means; Holm ranks p-values. Those are different tools.
What does it cost?
The browser tool is free and runs locally.
Why do several tests need a correction at all?
Because every extra test raises the chance of at least one false positive. Ten independent tests at five percent already give better than a forty percent chance of a stray significant result; dividing the level by the number of tests keeps that risk at or below the original level.
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/stat/bonferroni-correction \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"alpha":0.05,"comparisons":10}'const res = await fetch("https://api.kit.forhosting.com/stat/bonferroni-correction", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"alpha": 0.05,
"comparisons": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/bonferroni-correction",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"alpha": 0.05,
"comparisons": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/bonferroni-correction", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"alpha":0.05,"comparisons":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"alpha":0.05,"comparisons":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/bonferroni-correction", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"alpha": 0.05,
"comparisons": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.bonferroni_correction",
"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_comparisons | 1 |
max_comparisons | 1000000000 |
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 number of comparisons must be a positive integer; fractions, zero, negatives, and non-numeric text are rejected with invalid_input instead of a silent floor or a guessed count. Successful API calls are billed at $0.002; invalid input is not charged.
Input contract, aliases, and error behaviour
Provide exactly one of those names so a client does not accidentally send two conflicting numbers. After parsing, the engine requires a value strictly greater than zero and at most one. That check is intentional: a raw percentage such as five instead of zero point zero five is a common spreadsheet mistake, and clamping it would hide an upstream scale error. Comparisons must be a positive integer. Zero, negatives, fractions such as two point five, scientific notation that is not an integer, and values above the published one-billion cap all fail with a message that names the field and states that a positive integer is required. That is the contract the capability advertises: a non-integer comparison count is not silently floored. POST a JSON body with two required fields. The first is alpha, the original family-wise significance level; classroom and form aliases significance, significance_level, and alpha_level are accepted so spreadsheets and typed widgets can reuse the same contract. Alpha may arrive as a JSON number or as a numeric string; empty strings, missing fields, non-numeric text, NaN, and Infinity fail with invalid_input naming the field. The second field is comparisons, the number of simultaneous tests m, with aliases m, n_comparisons, num_comparisons, and k. On success the body echoes the cleaned alpha and the integer comparison count, returns adjusted_alpha as alpha divided by m at a stable display precision, and includes method and formula for teaching widgets and documentation side panels. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance and return the same invalid_input code the rest of the KIT catalog uses for client-side mistakes.
Where Bonferroni-adjusted alpha shows up in real work
Secondary-school and college statistics units constantly assign multiple-comparison drills, planned contrast write-ups, and “adjust alpha for m tests” word problems; a single trusted oracle that returns cleaned JSON speeds grading, demo setup, and interactive lesson design. Clinical and lab protocols still write Bonferroni into the analysis plan when a small family of primary endpoints must share a five percent family-wise rate, and the adjusted threshold belongs next to each endpoint rather than being recomputed by hand in every draft. Curriculum authors building browser widgets want the same JSON shape free on the page and paid through the API so offline worksheets and online auto-graders stay aligned. Because this capability is a pure parse engine, every successful call costs the published $0.002 base price with no model tokens and no outbound network, and failed validation does not consume balance.
Integration use cases
Protocol and analysis-plan thresholds
Turn a pre-specified family size into the per-endpoint significance level that belongs in a clinical, lab, or product experiment write-up.
Grading fixtures and pipeline checks
Generate deterministic expected adjusted alphas for unit tests, LMS auto-graders, and batch notebooks that must reject a non-integer comparison count.
Technical questions
What is the Bonferroni-adjusted significance level?
α_adj = α / m. Send the original family-wise alpha and a positive integer of comparisons; the API returns the per-test threshold adjusted_alpha.