MSE calculator
Four predictions whose squared misses add up to 0.6 give a mean squared error of 0.15. Paste the predicted and actual values in matching order; each gap is squared, so misses in either direction count and big ones weigh most. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Predicted
- 2.5, 0, 2.1, 7.8
- Actual
- 3, -0.5, 2, 7.5
- N
- 4
- Sse
- 0.6
- Mse
- 0.15
This mean squared error calculator compares two parallel numeric series—one of predicted values and one of actual observations—and returns the average of the squared residuals. You paste or send two arrays of equal length; the engine subtracts each actual from its paired prediction, squares that difference, averages the squares, and reports the MSE together with the pair count and the raw sum of squared errors. The result is always non-negative and is zero only when every prediction matches its actual value exactly. The path is deterministic: no network, no random sampling, and no clock.
What mean squared error measures and how it differs from MAD, SEE, and ANOVA MSE
Mean squared error answers a pairing question: given a list of predictions and a list of actual values of the same length, how large is the typical squared residual? Algebraically the residual for each pair is the predicted value minus the actual value, each residual is squared so that over-forecasts and under-forecasts do not cancel, and the mean squared error is the average of those squares. Written out, MSE equals one over n times the sum of predicted minus actual, all squared.
The result lives in squared units of the original measurements and is always non-negative. It is exactly zero only when every prediction matches its paired actual value. Squaring is the feature that distinguishes MSE from mean absolute error: a residual of two contributes four, while a residual of one contributes one, so large misses dominate the average.
That is why model-evaluation pages, regression homework, and loss-function tutorials search for an MSE calculator rather than a one-sample spread statistic. This page always compares two given series. It does not fit a line, does not divide by residual degrees of freedom, and does not report the ANOVA mean square that appears inside a Tukey honest-significant-difference table.
Those are different search intents served by other tools. Mean absolute deviation of a single list about its own mean is a different landing. The standard error of the estimate is residual size around a fitted least-squares line, not the average squared error of two series you already have.
Empty lists, non-finite numbers, and series beyond the published length or magnitude limits fail the same way with a field-level message and are not billed.
Where MSE fits in study, science, product work, and reporting
Students meet mean squared error when a statistics or machine-learning course moves from residuals to a single loss number that punishes large misses more than small ones. Teachers can pre-generate answer keys for modest paired series without trusting opaque apps that round intermediate squares differently or hide whether they used n, n minus one, or n minus two in the denominator.
Laboratory and engineering groups use MSE when comparing a sensor forecast to later readings, a calibration prediction to measured responses, or a baseline model to a hold-out set that already exists as two columns. Product and analytics teams watch MSE of latency forecasts, demand predictions, or scoring models when a squared-error loss is the documented training objective and they need a number that matches the loss they optimized. Researchers report MSE next to MAE so readers see both the squared-unit loss and the linear-scale companion.
Pair it with the mean absolute deviation calculator when you want linear spread of one series about its mean, and with the standard error of the estimate calculator when your question is residual size around a fitted line rather than the average squared error of two given series. If the two arrays do not line up, fix the pairing first: this calculator will not invent missing observations or silently drop extras.
What you can do with it
Homework and model labs
Compute MSE for textbook predicted-versus-actual series so students report the average of squared residuals with the correct divide-by-n definition.
Forecast and sensor evaluation
Score forecasts, calibrations, and hold-out predictions against observed values when the documented loss is mean squared error.
FAQ
What does the MSE calculator cost?
It is free in your browser on this page.
Do you divide by n or by n minus one?
By n. This is the standard machine-learning and regression definition MSE = (1/n) Σ (ŷᵢ − yᵢ)², not residual variance and not the ANOVA mean square.
How is this different from MAD or the standard error of the estimate?
MAD here is one-sample spread about a list mean. SEE is residual size around a fitted line. This page compares two given series and returns their mean squared error.
Is the result exact for every data set?
Results are deterministic for the same input; very large series may show ordinary double-precision limits.
Why does one large miss raise the MSE so much?
Because every gap is squared: a miss of 2 contributes 4, while a miss of 1 contributes only 1. Large misses therefore dominate the average, unlike in the mean absolute error.
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/mse \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"predicted":[2.5,0,2.1,7.8],"actual":[3,-0.5,2,7.5]}'const res = await fetch("https://api.kit.forhosting.com/stat/mse", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"predicted": [
2.5,
0,
2.1,
7.8
],
"actual": [
3,
-0.5,
2,
7.5
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/mse",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"predicted": [
2.5,
0,
2.1,
7.8
],
"actual": [
3,
-0.5,
2,
7.5
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/mse", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"predicted":[2.5,0,2.1,7.8],"actual":[3,-0.5,2,7.5]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"predicted":[2.5,0,2.1,7.8],"actual":[3,-0.5,2,7.5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/mse", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"predicted": [
2.5,
0,
2.1,
7.8
],
"actual": [
3,
-0.5,
2,
7.5
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.mse",
"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_n | 10000 |
max_abs | 1000000000000000 |
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
Arrays of different lengths are rejected with invalid_input, because pairing would be ambiguous.
What mean squared error measures and how it differs from MAD, SEE, and ANOVA MSE
Arrays of different lengths are rejected with invalid_input because pairing would be ambiguous.
How paired inputs are read and how the MSE algorithm runs
Each element is parsed as a finite decimal; optional leading signs and scientific notation are allowed, while empty tokens, bare letters, Infinity, and NaN fail with a field index in the message so a bad cell never becomes a silent zero. Computation is a single deterministic pass: for each aligned index the residual is predicted minus actual, that residual is squared, the squares accumulate into the sum of squared errors SSE, and MSE is SSE divided by n. Returning n, SSE, MSE, and a short formula string lets a student or a reviewer check the arithmetic by hand and avoids the common spreadsheet mistake of dividing residual squares by n minus one or by n minus two. This is the standard machine-learning and regression definition of mean squared error, not residual variance and not root mean squared error. The preferred fields are predicted and actual, each an array of finite numbers of equal length with at least one pair. Aliases such as y_hat, y_pred, forecasts, and estimates are accepted for the predicted series, and y, y_true, observed, observations, and targets are accepted for the actual series, so spreadsheets, typed forms, and older scripts can reuse the same contract without renaming columns. A single comma-separated, semicolon-separated, or whitespace-separated string of numbers is also accepted for each series when a form posts plain text instead of a JSON array. The engine enforces a hard maximum of ten thousand pairs and a per-value magnitude ceiling so memory and latency stay inside a predictable budget on the free browser path and on the edge Worker. 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 squared-error averaging yourself.
Where MSE fits in study, science, product work, and reporting
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic CI fixtures
Generate a reproducible MSE, SSE, and pair count for unit tests and model-evaluation gates without hand-maintaining residual tables.
Technical questions
What happens if the predicted and actual arrays have different lengths?
The calculator rejects that case with invalid_input. Pairing would be ambiguous, so no MSE is invented and the request is not billed.