Critical value calculator
At a 0.05 significance level the critical z is about 1.96 for a two-tailed test and about 1.645 for a one-tailed one. Pick the tail, enter alpha and get the standard normal cutoff without a printed table. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Significance level
- 0.05
- Test type
- Two tailed
- Critical value
- 1.9599639861
- Tail probability
- 0.025
- Quantile
- 0.975
A critical value is the z cutoff that separates the rejection region from the non-rejection region in a hypothesis test that assumes a standard normal sampling distribution. Given a significance level alpha strictly between zero and one, and a test type — two-tailed, left-tailed, or right-tailed — this calculator returns the corresponding critical value of Z ~ N(0,1). Two-tailed tests invert one minus alpha over two so both tails together have total mass alpha. A right-tailed test inverts one minus alpha; a left-tailed test inverts alpha and returns a negative cutoff. Significance levels outside (0, 1) fail with a clear validation error and are not billed.
How a standard-normal critical value is defined
In a hypothesis test that treats the test statistic as standard normal under the null, the significance level alpha is the probability of landing in the rejection region when the null is true. That region is a tail — or a pair of tails — of Z ~ N(0,1), and the critical value is the quantile that marks its inner edge.
For a two-tailed test the total Type I mass alpha is split equally, so each tail has probability alpha over two and the conventional positive cutoff is the upper (1 − α/2) quantile of the standard normal. You then reject when the absolute value of the observed z exceeds that cutoff. For a right-tailed (upper) test the entire mass alpha sits on the positive side, so the cutoff is the upper (1 − α) quantile and you reject when z is larger than that number.
For a left-tailed (lower) test the mass sits on the negative side: the cutoff is the α quantile itself, which is negative, and you reject when z is smaller than that number. Classic classroom landmarks fall out immediately: alpha 0.05 two-tailed is about 1.96; alpha 0.05 one-tailed is about 1.645 in absolute value; alpha 0.01 two-tailed is about 2.576.
The calculator evaluates the inverse standard-normal cumulative distribution function with a published rational approximation, so every evaluation is pure floating-point arithmetic with no printed table, no random seed, and no wall-clock dependence.
Where this calculator shows up in real work
Quality and process teams that run large-sample mean tests against a known sigma look up the same cutoffs when they write control limits or decide whether a shift is large enough to reject a stable-process null. Medical and social-science notebooks that already have a z statistic from a large sample need the matching two-sided or one-sided threshold before they can say whether the result crosses the pre-registered alpha.
If you later need to convert a raw score into a z-score, to compute the area between two given z bounds, or to read a Student-t critical value for a small-sample mean, treat those as separate search intents and landings rather than overloading this critical-value page. The calculator does not ingest a data list, does not compute a p-value, and does not switch families when the sample is small: it answers only the inverse-normal cutoff question.
What you can do with it
Homework critical-z lookups
Students and graders obtain z* for a stated alpha and tail without scanning a printed standard-normal table.
Large-sample mean tests
Analysts with a known sigma compare an observed z statistic to the matching two-sided or one-sided standard-normal cutoff.
Control-limit and SOP thresholds
Quality teams encode a pre-registered alpha as a documented z cutoff for stable-process or incoming-inspection rules.
FAQ
What formula does this critical value calculator use?
For a two-tailed test, z* = Φ⁻¹(1 − α/2). For a right-tailed test, z* = Φ⁻¹(1 − α). For a left-tailed test, z* = Φ⁻¹(α). Φ⁻¹ is the standard normal quantile and Z ~ N(0,1).
What is the difference between two-tailed and one-tailed critical values?
Two-tailed splits alpha across both tails, so α = 0.05 gives about ±1.96. A one-tailed test puts all of alpha on one side, so α = 0.05 gives about +1.645 or −1.645.
Does this return a t, chi-square, or F critical value?
No. This landing is the standard-normal (z) critical value only. Small-sample t cutoffs and other families are separate tools with different search intent.
What does the critical value calculator cost?
The browser tool is free and runs locally.
What is the critical z value for a 0.01 significance level?
For a two-tailed test it is about 2.576, so you reject when the observed z is further than 2.576 from zero in either direction. A one-tailed test at the same level uses a smaller cutoff on a single side.
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/critical-value \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"significance_level":0.05,"test_type":"two_tailed"}'const res = await fetch("https://api.kit.forhosting.com/stat/critical-value", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"significance_level": 0.05,
"test_type": "two_tailed"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/critical-value",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"significance_level": 0.05,
"test_type": "two_tailed"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/critical-value", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"significance_level":0.05,"test_type":"two_tailed"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"significance_level":0.05,"test_type":"two_tailed"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/critical-value", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"significance_level": 0.05,
"test_type": "two_tailed"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.critical_value",
"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
The same deterministic inverse-normal routine powers the free browser form and the prepaid API, so a homework key and a production script never disagree on the same pair. Successful API calls use the published base of $0.002 per item.
What you send and what you get back
The field also accepts classroom synonyms such as two-sided, upper, and lower, so a script written with textbook wording does not need a rename step. A short formula string restates the identity that was used. Classic checks include alpha 0.05 two-tailed near 1.96, alpha 0.05 right-tailed near 1.645, and alpha 0.05 left-tailed near minus 1.645. Send two required fields. significance_level is a finite number strictly between zero and one — typical classroom choices are 0.10, 0.05, and 0.01 — and also accepts the aliases alpha, alpha_level, and a. test_type is a closed list with three values: two_tailed, left_tailed, and right_tailed. Missing fields, empty strings, NaN, Infinity, and any significance level that is not strictly between zero and one fail with invalid_input and are not charged; zero and one are rejected because the matching standard-normal quantile is infinite. On success the response echoes the cleaned significance level and the canonical test type, returns critical_value as the signed z cutoff you compare against, returns tail_probability as the mass in each rejected tail (alpha over two when the test is two-tailed, otherwise alpha), and returns quantile as the probability p that was inverted, so Φ⁻¹(p) equals the critical value.
Where this calculator shows up in real work
Introductory inference courses assign page after page of “find the critical z for this alpha and this tail” drills; a single trusted oracle that returns cleaned JSON speeds grading and demo setup without scanning a printed normal table or arguing about whether 1.96 or 1.9600 is the official key. 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.
Technical questions
Why must the significance level be between 0 and 1?
Alpha is a Type I error probability. Values of 0 or 1 (or anything outside that open interval) do not define a finite standard-normal cutoff, so the request fails with invalid_input.