Standard error calculator
A sample standard deviation of 10 with 25 observations gives a standard error of exactly 2, since 10 is divided by the square root of 25. Enter the two numbers from your paper or notebook and see each step of the identity. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Std dev
- 10
- Sample size
- 25
- Sqrt n
- 5
- Sampling variance
- 4
- Standard error
- 2
This standard error calculator reports how precisely a sample mean estimates the population mean when you already know the sample standard deviation and the sample size. You enter a non-negative sample standard deviation s and a positive integer n; the engine returns SE equals s divided by the square root of n, together with the square root of n and the sampling variance s squared over n so you can check a paper, a lab notebook, or a spreadsheet cell by cell. Classic checks include a sample standard deviation of ten with twenty-five observations, which yields a standard error of exactly two, and a sample standard deviation of four with sixteen observations, which yields a standard error of one. The path is deterministic floating-point arithmetic only: no raw data pass, no network calls, no random resampling, and no date-dependent shortcuts.
What the standard error measures and how SE = s over square root of n is formed
The standard error of the mean answers a different question from ordinary standard deviation. Standard deviation describes how spread out individual observations are around the sample mean; the standard error describes how much that sample mean itself would be expected to wobble if you drew many independent samples of the same size from the same process.
Under the usual independent and identically distributed assumptions, the sampling variance of the mean is the population variance divided by n, so an estimator of the standard error is the sample standard deviation divided by the square root of n. This page takes those two numbers as given: you already have s from a paper, a statistics package, or a previous pass over the raw series, and you already know the count n.
The engine does not recompute s from a list of values; it evaluates the closed-form scale SE equals s over square root of n and returns the supporting pieces so a methods section or a homework write-up can show the full identity. That is a different search and a different contract from a raw-data SEM tool that first estimates s from an array, and from a proportion standard-error tool that uses p-hat times one minus p-hat over n.
Students meet this object when a textbook quotes s and n and asks for the standard error, when a lab report lists a sample standard deviation and a replicate count, and when a published table must be turned into an uncertainty on the mean without reconstructing the original measurements. Sample size must be a positive integer because n is a count of observations; a decimal, zero, or negative n is not a valid count for this formula. Sample standard deviation must be a finite non-negative number.
Where a standard error from s and n earns its keep
Classrooms and tutoring platforms use a standard error calculator so learners can check SE equals s over square root of n for arbitrary published values without mixing the formula up with a raw-data SEM pass, a proportion standard error, or a regression residual SEE. Exam-prep generators need a deterministic oracle that rejects a non-integer sample size instead of silently flooring n and producing a plausible-looking but wrong standard error that a buggy grader might treat as success.
Researchers writing methods sections often have s and n from a statistics package or from another paper and need the standard error for a confidence interval or a forest plot without reconstructing the original measurements. Lab notebooks list a sample standard deviation and a replicate count; converting those two figures into an uncertainty on the mean is exactly this closed form.
Product and operations teams watch the precision of a metric mean when they already know last week's sample standard deviation and this week's sample size; that is a different question from re-ingesting every observation. Keep n a positive integer, keep s non-negative and finite, and you get a reproducible standard error for worksheets, LMS plugins, and edge workers without standing up a statistics package of your own.
If you still have the raw series and need s computed first, use the dedicated raw-data SEM tool; if you have a sample proportion rather than a standard deviation, use the proportion standard-error tool instead.
What you can do with it
Homework from published s and n
Check SE = s/√n for textbook items and lab reports that already quote a sample standard deviation and a positive integer sample size.
Papers, plots, and metric precision
Turn a published sample SD and sample size into an uncertainty on the mean for methods sections, forest plots, and dashboard annotations.
FAQ
What happens if the sample size is not a positive integer?
Sample size is a count of observations, so zero, negatives, and decimals such as 2.5 are rejected and are not billed.
Can the sample standard deviation be zero?
Yes. When s is zero the standard error is exactly zero. A negative s is rejected because a standard deviation cannot be negative.
How is this different from a standard error of the mean calculator that takes raw data?
This tool takes s and n as given. The raw-data SEM calculator estimates the sample standard deviation from a list of values and then applies the same SE = s/√n scale.
What is the difference between standard deviation and standard error?
Standard deviation describes how spread out the individual observations are. Standard error describes how much the sample mean itself would wobble if you drew many samples of the same size, so it is always smaller once you have more than one observation.
How do I calculate the standard error from s and n by hand?
Divide the sample standard deviation by the square root of the sample size. With a standard deviation of 10 and 25 observations, the square root of 25 is 5, and 10 divided by 5 gives a standard error of 2.
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/standard-error \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"std_dev":10,"sample_size":25}'const res = await fetch("https://api.kit.forhosting.com/stat/standard-error", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"std_dev": 10,
"sample_size": 25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/standard-error",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"std_dev": 10,
"sample_size": 25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/standard-error", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"std_dev":10,"sample_size":25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"std_dev":10,"sample_size":25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/standard-error", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"std_dev": 10,
"sample_size": 25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.standard_error",
"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
What the standard error measures and how SE = s over square root of n is formed
The engine never invents a bootstrap histogram or a random draw: it evaluates the square-root formula on finite numbers and either returns a cacheable JSON object or rejects the request with invalid_input. Use the free browser path to check a textbook item, then the API at $0.002 per successful call when you need the same standard error in an automated key or pipeline.
Input contract, integer sample size, and the shape of a successful response
Each value is parsed as a finite decimal; optional leading signs and scientific notation are allowed, while empty tokens, bare letters, and non-numeric objects fail with a clear field name in the message so a bad cell does not become a silent zero. After parsing, the engine requires the sample standard deviation to be non-negative and requires the sample size to be a positive integer, not merely a number greater than or equal to one. A negative s is rejected for the same reason a textbook would refuse it: a standard deviation cannot be negative. Boundary cases are intentional and useful: when s is exactly zero the standard error is exactly zero, matching a sample with no residual spread even though real-world intervals may need other corrections elsewhere. The preferred fields are std_dev and sample_size, but aliases s, sd, sample_std_dev, sigma, and standard_deviation map to the sample standard deviation, while n and size map to the sample size, so spreadsheets, query strings, and typed forms can reuse the same contract without renaming columns. Providing more than one alias for the same role at once is rejected to avoid ambiguous precedence. A value such as two point five, zero, or negative three fails with invalid_input naming the sample-size field, because a standard error of the mean is defined on a count of observations. Computation is then a handful of arithmetic steps: sqrt_n is the positive square root of n, sampling_variance is s squared divided by n, and standard_error is s divided by sqrt_n, which is identical to the square root of the sampling variance. Pair the free browser run on this page with the priced API when you need the identical descriptive result inside an automated pipeline without re-implementing the square-root formula yourself.
Where a standard error from s and n earns its keep
Each successful API request costs the published $0.002 with no model tokens and no outbound network; invalid input does not consume balance.
Integration use cases
Deterministic CI fixtures
Generate reproducible standard-error values for unit tests and teaching keys without re-implementing the square-root scale in every notebook.
Technical questions
How do I compute the standard error from sample standard deviation and sample size?
Send a non-negative finite std_dev (s) and a positive integer sample_size (n). The API returns SE = s / √n, plus √n and the sampling variance s²/n.
What does the standard error calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.