HomeCalculatorsMathPercent Error Calculator
Math calculator

Percent Error Calculator

Compute percent error between experimental and accepted values for lab and measurement checks. Interactive calculations run locally; shared URLs and REST use the same engine. Free — no sign-up.

Instant result
Result

Enter values to calculate.

Inputs
Mode
Formula
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Engineering assurance
Input interpretation
Enter values to calculate.
Result
Assurance
Engineering
Declared partition coverage
PASS · 5/5 declared partitions (forward, inverse-observed, inverse-true, verify, invalid-domain) · Matrix
Known limitations
  • T≠0; solve_for p|o|t; all three fields verify; absolute reverse-solves are multi-valued
  • Core CVP does not include live graph, viewport, or pointer interaction.
Model
Percent error, absolute error, and relative error; or the missing observed/accepted/% error when two are known. Absolute-mode reverse solves publish both ± candidates.
Scope
Interactive evaluation runs locally in the browser. Shared URLs and REST may evaluate the same versioned engine on the server (query SSR).
Verification
Engine tested · Source checked · v1.1.4 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Engineering assurance· View Manifest · CVP overview · Specification
Versions
Calculation 1.1.4 · CVP protocol 1.0.0-proposed
CVP identity
3/3 property · digest 620c0f56d567
Legacy regression
14/14 tests · Production surface contract 3/3
Reference
O1 model · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
6/6 golden · 4/4 CVP boundary · 4/4 invalid · 3/3 property · 1/1 metamorphic · 7/7 round-trip · 1/1 cross-interface · 1/1 CVP contract · Manifest
Sources
Sources
Evidence
10 legacy golden · 4 legacy boundary · legacy regression suite · 6/6 oracle-backed golden · 4/4 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.1.4 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Percent error (lab convention)% error = |O − T| / |T| × 100% [2][4]
Measurement errorε = O − T [1]
Absolute error|ε| = |O − T| [1][4]
Relative errorrelative = |O − T| / |T| [3]
Signed (optional)% error = (O − T) / T × 100% [4]
iO = observed/experimental/measured; T = accepted/reference (true/theoretical/expected are synonyms). VIM [1] defines measurement error as measured quantity value minus a reference quantity value — it does not define relative error (VIM §2.18 is measurement bias), and it does not define a separate term “absolute error.” Displayed absolute error is the magnitude of that measurement error [1][4]. NIST PERCERR [2] documents percent error from accepted vs observed. NIST RELERR [3] documents relative error and notes that absolute value is a convention. Absolute-value percent error, signed opt-in, and reverse-solve states are CalculatorX convention [4]. T = 0 is undefined. Small % error means the measurement is close to the accepted value.

How to use

1

Choose Solve for

Default solves percent error from observed and accepted / reference values. Switch to Observed or Accepted / reference to reverse-solve.

2

Enter the two input fields

The solved field is calculated and cannot silently disagree with the inputs.

3

Optional: allow signed error

Default uses absolute value (always ≥ 0). Turn off to keep the signed relative error (algebraic sign). For a negative reference, that sign is not the same as above/below.

4

Read % error, absolute error, and relative error

Steps show the formula with your numbers. Absolute mode reverse-solves show both ± candidates.

Example calculations

Common configurations with formula and result.

ϟ

Lab boiling point

Measured 101.5°C vs 100°C

|101.5−100|/100×100%
1.5%
ϟ

Speed of sound

329 vs 343 m/s

14/343×100%
≈ 4.082%
ϟ

Decimal sample

56.891 vs 62.327

|56.891−62.327|/62.327×100%
≈ 8.722%
ϟ

Signed error

Observed 7, accepted 9

(7−9)/9×100%
−22.222%

Quick examples

Common values at a glance.

ObservedAccepted% error
56.89162.327≈ 8.722%
101.5°C100°C1.5%
329 m/s343 m/s≈ 4.082%
10.3 oz10 oz3%
981002%
i Without absolute value, observed 7 and accepted 9 give −22.222% (observed smaller than accepted). Magnitude of error is usually what matters.

Percent Error calculator specification

Version 1.1.4 · Engine tested

Calculation status

Review policy · Evidence

Definition
Percent error measures how far an observed (experimental, measured) value is from an accepted (true, reference) value, as a percentage of the accepted value. Exactly two of observed, accepted, and percent error are inputs; the Solve for field is the output.
What it calculates
Percent error, absolute error, and relative error; or the missing observed/accepted/% error when two are known. Absolute-mode reverse solves publish both ± candidates.
Inputs
  • Observed / experimental value O
  • Accepted / reference value T (true/theoretical/expected are synonyms)
  • Percent error P (when solving for O or T)
  • Solve for: p (default) | o | t
  • Absolute-value toggle (default on)
Outputs
  • Percent error
  • Absolute error |O − T| (magnitude of the VIM measurement error; not a VIM-defined term)
  • Relative error |O − T| / |T|
  • When solving for O or T in absolute mode: two candidates when they differ
  • When solving T at P = 100% with O ≠ 0: one valid candidate; the zero-denominator ± branch is omitted
  • When O = 0, P = 100%, solve T: INFINITELY_MANY with constraint T ≠ 0
  • When O = 0, P = −100%, signed, solve T: INFINITELY_MANY with constraint T ≠ 0
Formula
Absolute: P = |O−T|/|T|×100%; O = T(1±P/100); T = O/(1±P/100). Signed: P = 100(O−T)/T; O = T(1+P/100); T = O/(1+P/100). Signed T is undefined at P = −100% (then INFINITELY_MANY if O = 0, else NO_REAL_SOLUTION).
Assumptions
  • Interactive evaluation runs locally in the browser. Shared URLs and REST may evaluate the same versioned engine on the server (query SSR).
  • Accepted value T ≠ 0.
  • Default formula uses absolute value so % error ≥ 0.
  • Exactly two fields are inputs. Explicit solve_for selects the output. If all three are supplied without solve_for, they are checked for consistency rather than overwritten.
Units
  • O and T in the same units; result in %
Boundary conditions
  • T = 0 → TRUE_VALUE_ZERO (undefined)
  • Fewer than two inputs → MISSING_REQUIRED_INPUT
  • Invalid solve_for → INVALID_SOLVE_FOR
  • Negative P in absolute mode → INVALID_PERCENT
  • O = 0, P = 100%, absolute, solve T → INFINITELY_MANY (any T ≠ 0)
  • O = 0, P ≠ 100%, absolute, solve T → NO_REAL_SOLUTION
  • O ≠ 0, P = 100%, absolute, solve T → T = O/2; the 1 − P/100 branch is omitted (not a full calculation error)
  • O = 0, P = −100%, signed, solve T → INFINITELY_MANY (any T ≠ 0)
  • O = 0, P ≠ −100%, signed, solve T → NO_REAL_SOLUTION
  • O ≠ 0, P = −100%, signed, solve T → NO_REAL_SOLUTION
  • Solving from P may yield two candidates (±) when absolute mode is on
  • All three values filled without solve_for and not matching the formula → INCONSISTENT_INPUTS
Numerical precision
  • Computation uses IEEE-754 binary64 (JavaScript Number).
  • Displayed results use up to 10 significant digits; trailing zeros are stripped. Scientific notation is used when |value| ≥ 1e12 or 0 < |value| < 1e-6.
  • REST and SSR return the engine object. result_detail.value is the solved number, or both candidates when absolute reverse-solve has two real solutions. display.percent_error is the rounded page string.
  • rounding.mode is auto with significant_digits 10. The raw field keeps full binary64 precision.
  • Interactive evaluation, shared URLs, and REST use the same formulas, solve_for contract, and error codes.
Example
|101.5 − 100| / 100 × 100% = 1.5%
Validation cases

12 published on this page · 14/14 tests · Production surface contract 3/3 · View evidence

  • O=101.5, T=100 → 1.5%
  • O=56.891, T=62.327 → ≈8.722%
  • O=329, T=343 → ≈4.082%
  • O=7, T=9, signed → −22.222%
  • T=100, P=2% (solve O, absolute) → 98 or 102
  • O=98, T=100, P=20% (no solve_for) → error INCONSISTENT_INPUTS
  • T=0 → error TRUE_VALUE_ZERO
  • O=0, P=100%, solve T, absolute → INFINITELY_MANY (any T ≠ 0)
  • O=50, P=100%, solve T, absolute → T=25 (1 − P/100 branch omitted)
  • O=0, P=−100%, solve T, signed → INFINITELY_MANY (any T ≠ 0)
  • O=50, P=−100%, solve T, signed → error NO_REAL_SOLUTION
  • O=0, P=50%, solve T, signed → error NO_REAL_SOLUTION
Sources
  • JCGM 200:2012 — International vocabulary of metrology (VIM) — §2.16 measurement error · accessed 2026-08-28
    Supports: Defines measurement error as measured quantity value minus a reference quantity value (ε = O − T). Does not define relative error — VIM §2.18 is measurement bias, not relative error. Does not prescribe a percent-error ×100% laboratory convention.
  • NIST Dataplot PERCERR — Percent error of a true/accepted value vs an observed value · accessed 2026-08-28
    Supports: Documents percent error from an accepted (true) value and an observed value, and notes that some conventions take the absolute value. Instantly readable page — not the frameset handbook root.
  • NIST Dataplot RELERR — Relative error of a true/accepted value vs an observed value · accessed 2026-08-28
    Supports: Documents relative error (Xt − Xo)/Xt. Notes that some sources take the absolute value, and some reverse numerator order — those change sign, not magnitude.
  • CalculatorX laboratory convention — Absolute-value percent error, signed opt-in, and reverse-solve states
    Supports: Default % error = |O−T|/|T|×100% so the result is ≥ 0; signed (O−T)/T×100% is opt-in. Displayed absolute error is |ε|, the magnitude of VIM measurement error — not a separate VIM term. Absolute reverse-solves publish both ± candidates, omit a zero-denominator branch, and publish INFINITELY_MANY when every T ≠ 0 works. Signed P = −100% with O ≠ 0 is NO_REAL_SOLUTION.
Calculation version
1.1.4

Background

Interpretation and common distinctions.

What is percent error?

Percent error (approximation error) is how far an observed value is from an accepted / reference value, expressed as a percentage of that accepted value. It is used in science labs to judge whether a measurement is close to the accepted result.

  • Observed — experimental, measured, estimated
  • Accepted / reference — also called true, theoretical, expected, or actual. In measurement work we often do not know a metaphysical “true” value, so an accepted or reference value is the practical denominator.

A small percent error means the values are close; a large one may mean a mistake or an unreliable method.

Percent error vs percent difference

Use percent error when one value is an accepted or reference value.

Use percent difference when comparing two experimental values without a known reference — the denominator is then the average of the two values, not a preferred true value.

Related tool: Percent difference.

Other calculators in this family: Percent difference, Percentage, Percentage change, Division .

}

Frequently asked questions

Key distinctions behind the calculation.

What is percent error?

It quantifies the discrepancy between an observed (measured) value and an accepted (reference) value as a percentage of the accepted value.

What is the percent error formula?

% error = |observed − accepted| / |accepted| × 100%. Absolute error is |observed − accepted|; relative error is that difference divided by |accepted|.

Observed vs accepted — which terms are used?

Observed is also called experimental, measured, estimated, or approximate. Accepted is also called true, theoretical, expected, exact, reference, or actual. In the lab we often do not know a metaphysical true value, so accepted/reference is the better name.

Can percent error be negative?

With the usual absolute-value formula it is never negative. If you omit the absolute value, (O − T)/T keeps the algebraic sign of the relative error. With a positive accepted value, observed below reference is negative — that is direction, not “better.” With a negative accepted value, the same sign is not above/below on the number line.

Is a small percent error good?

Usually yes: it means measured and accepted values are close. A very large percent error often signals a mistake or a poor method.

What if the accepted value is unknown?

Classic percent error needs a known accepted/reference value. If both numbers are experimental and neither is a reference, use percent difference instead. For spreads of repeated measurements, use statistics such as standard deviation.

Percent error vs percent difference?

Use percent error when one value is an accepted/reference value. Use percent difference when comparing two experimental values without a known reference — the denominator is then the average of the two values, not a preferred true value.

How is this different from percent change?

Percent change compares an old value to a new value. Percent error compares a measurement to an accepted reference value.

Percent error vs margin of error / standard error?

Percent (relative) error is |O−T|/|T|. Standard error describes sampling accuracy; margin of error relates to confidence intervals—different concepts.

Why can solving for observed give two answers?

Absolute percent error discards direction, so O = T(1 ± P/100). For T = 100 and P = 2%, both 98 and 102 are valid. Signed mode has a single solution.

Why can solving for the accepted value give infinitely many answers?

When observed is 0 and absolute percent error is 100%, |0 − T| / |T| × 100% = 100% for every T ≠ 0. In signed mode the analog is O = 0 and P = −100%. The engine publishes INFINITELY_MANY with constraint T ≠ 0 instead of picking one T. If observed is 0 and P is not that special value, there is no real solution. If observed is nonzero and absolute P is 100%, one branch is T = O/2 and the 1 − P/100 branch is omitted. If observed is nonzero and signed P is −100%, T = O/(1 + P/100) has no real solution (it would require O = 0).

Do shared URLs still run only in the browser?

Interactive typing calculates locally in your browser. A shared result URL and the REST API use the same versioned engine and may be evaluated on the server (query SSR). Inputs in a share URL are part of the HTTP request.