ISERROR Function in OpenOffice Calc: Syntax & Example

Quick answer

ISERROR answers one question: does this value or expression contain a spreadsheet error? When an error is detected—including #N/A—it returns the logical value TRUE; otherwise it returns FALSE. This is particularly useful for flagging calculation problems in a worksheet before deciding how to display or investigate them. Apache OpenOffice’s ISERROR reference specifically contrasts ISERROR with ISERR, which excludes #N/A. [O1][O2]

The official Apache example =ISERROR(NA()) returns TRUE, because NA() produces the #N/A error. By contrast, =ISERR(NA()) returns FALSE according to Apache’s ISERR page. Do not treat these two functions as interchangeable. [O1][O2][O3]

Syntax, argument and result

=ISERROR(value)

Position	Argument	Required	Accepted forms	Default
1	`value`	Yes	A cell reference, a scalar value, or an expression whose result should be tested	None

The official syntax documents one required argument. It does not specify additional optional arguments, alternate argument ordering, or a default if omitted. The result is a Boolean TRUE or FALSE, rather than a replacement for the source value. [O1]

Since this function has only one parameter, there is no separator inside its own argument list. The multi-argument examples below use ; between arguments to other functions, consistent with Apache’s published Calc IF examples. Your installation’s language and formula settings can affect the displayed function names and separators; check the formula bar and function wizard rather than copying Excel syntax blindly. [O4][O5]

Scope: This guide targets the Apache OpenOffice Calc desktop application; the official download page identified version 4.1.16 as the latest released build when checked on 2026-10-12. Apache’s historical wiki pages are function-reference evidence, not proof that every edge case was executed in 4.1.16. No LibreOffice-only feature is used as evidence of Apache support. [O6]

Reproducible example 1: error tests without setup

Enter each formula into an otherwise empty Calc cell. The outcomes in the first two rows come directly from Apache’s examples; the third is the same documented rule applied to a literal number. [O1]

Formula	Expected displayed result	Why
`=ISERROR(SQRT(-1))`	`TRUE`	Apache documents the attempted real square root of −1 as an error.
`=ISERROR(NA())`	`TRUE`	`NA()` deliberately produces `#N/A`, and ISERROR includes that error.
`=ISERROR(123)`	`FALSE`	The numeric value `123` is not an error.

These are documented or documentation-derived expected outcomes, not freshly measured native results. The text "#N/A" typed as ordinary text is different from the error produced by NA(); this guide does not claim that a text string automatically becomes an error value.

Reproducible example 2: inspect a cell’s calculation

Set up columns A through C as shown. For formula entries, type the leading =. Enter the literal number and the literal word normally; leave A6 physically empty. Enter the indicated formula into each cell in column B. The C column gives the expected interpretation. [O1][O2]

Row	A: example input	B: type this formula	C: expected B result and interpretation
2	`75`	`=ISERROR(A2)`	`FALSE` — ordinary number
3	`=NA()`	`=ISERROR(A3)`	`TRUE` — `#N/A` error
4	`=SQRT(-1)`	`=ISERROR(A4)`	`TRUE` — calculation error
5	`ready` (text)	`=ISERROR(A5)`	`FALSE` — plain text is not an error
6	(leave empty)	`=ISERROR(A6)`	`FALSE` — an empty input is not itself an error

To reproduce: create a blank worksheet; enter A2 through A5; leave A6 blank; then enter the B formulas. Check which rows require attention. Columns B and C are expected examples. Rows 2–4 follow the rule and Apache’s examples; rows 5–6 follow the absence-of-error condition. Native execution and locale-specific display strings were not independently observed for these examples. [O1]

For a row-by-row audit, copy the formula in B2 down to B6 using Calc’s fill mechanism: a relative reference A2 becomes A3, A4, and so on. This guide does not require an array formula or unsupported custom function.

Advanced example: display a message instead of an error

Assume cell B2 contains a result produced by some other calculation. In C2, type:

=IF(ISERROR(B2);"Investigate calculation";B2)

Apache documents IF(test; value1; value2) as returning the second argument when the test is true and the third argument when it is false. Combined with Apache’s ISERROR semantics, the expected results are as follows. [O1][O4]

What B2 contains	Expected C2 result	Explanation
`42`	`42`	ISERROR is false, so IF returns B2.
`=NA()`	`Investigate calculation`	ISERROR recognizes `#N/A`; IF returns the text message.
`=SQRT(-1)`	`Investigate calculation`	The error test is expected to be true; IF returns the message.

This pattern can make an operational summary easier to read without changing the underlying error in B2. Do not delete the source calculation or replace every error with zero, as doing so can hide a genuine problem in a data source or model. For a workbook used in auditing or financial reporting, keep the original error visible on a diagnostics sheet. The examples above are an application of two documented functions, not an application-executed test. [O1][O4]

If the distinction between unavailable lookup data and other errors matters, use the correct predicate instead of masking everything: ISNA is catalogued for #N/A, ISERR for errors other than #N/A, and ISERROR for all errors. The Apache Information functions catalogue lists all three separately. [O2][O3]

A documented caveat: ISERROR does not catch every expression cleanly

Apache’s ISERROR page documents a significant limitation with the expression:

=ISERROR(CHOOSE(0;"A";"B";"C";"D"))

According to that official page, the nested CHOOSE expression produces Err:502 and the enclosing ISERROR also returns Err:502 instead of TRUE, because the error propagates before the error test can evaluate it. This is a historically documented behaviour, not a new 4.1.16 observation. Do not promise that wrapping an arbitrary failing expression directly in ISERROR will always convert it to TRUE. [O1]

For more predictable auditing, a useful investigation step is to calculate an expression in a separate cell, then point ISERROR at that cell. Even that should be checked in your installed version for unusual errors; the example is an operational suggestion, not a claim that Apache’s documented CHOOSE edge case is fixed by a specific workaround.

Troubleshooting and error types

Symptom	Likely explanation	Practical check
`ISERROR(NA())` is `TRUE` but `ISERR(NA())` is `FALSE`	This is intentional: only ISERROR includes `#N/A`.	Use `ISNA` when only missing-data errors matter. [O1][O2]
A cell appears to contain `#N/A`, but ISERROR reports `FALSE`	The cell may contain the literal text string rather than an actual error value.	Recreate it with `=NA()` and compare; keep the original visible for diagnostics.
An error still appears despite wrapping an expression with ISERROR	Some nested expressions can propagate an error instead of yielding a Boolean.	See Apache’s `CHOOSE`/`Err:502` example; isolate the calculation and test behaviour in your version. [O1]
A formula shows an unknown-name or syntax error	The function name, separators, quotes or locale may not match your installation.	Use Insert → Function to inspect available names and syntax; compare the semicolon-separated IF pattern with Apache’s documentation. [O4]
A formula unexpectedly shows a number instead of the word `TRUE` or `FALSE`	Display formatting may be showing the underlying logical value numerically.	Check the cell’s number format; Apache describes logical results as `0` and `1` under the hood. [O5]
A report hides missing information after using IF with ISERROR	A catch-all message combines `#N/A` and other errors.	Decide whether a missing-data message and a calculation-error message should be different. [O1][O2]

Important limits: The official single-value syntax does not establish array-spill behaviour, a maximum number of simultaneous checked cells, treatment of add-in-specific exceptions, or compatibility with every third-party file format. Those cases are out of scope without native testing. Do not assume Excel or LibreOffice error handling reproduces Apache’s historical CHOOSE behaviour. [O1]

Function	What Apache documents	Expected result with `=NA()` inside
`ISERROR(value)`	Any spreadsheet error, including `#N/A`	`=ISERROR(NA())` → `TRUE` [O1]
`ISERR(value)`	Errors except `#N/A`	`=ISERR(NA())` → `FALSE` [O2]
`ISNA(value)`	Tests for the `#N/A` error specifically	Catalogued for this purpose; a 4.1.16 runtime outcome was not executed for this guide. [O3]

This distinction matters during import cleanup, lookup troubleshooting, and formula audits. ISERROR answers whether any error occurred; it does not tell you which one. To identify a specific failure, inspect the original cell or use the dedicated predicate where supported. [O1][O2][O3]

Cross-compatibility and version notes

Apache OpenOffice documentation is the authority for this guide. Similar function names exist in other spreadsheet programs, but a shared name is not proof of identical coercion, propagation, display, or locale behaviour. Particularly, Apache itself documents the unusual CHOOSE propagation issue, which must not be overwritten with a blanket cross-application compatibility claim. [O1]

When exchanging an .xlsx workbook, inspect the formulas and error-result cells in the application receiving the file. This guide does not claim that every Excel/LibreOffice error result has been reproduced in Apache OpenOffice Calc 4.1.16, nor does it claim native execution. For Apache’s version and download scope, see the official release information. [O6]

Official references and verification

The references below were checked on 2026-10-12. They explain the claims identified by bracketed evidence IDs throughout this guide. Older Apache wiki reference pages are not a native-test log for the current release.

[O1] ISERROR reference: Apache OpenOffice Calc — ISERROR. Syntax, all-error behaviour, examples and the documented CHOOSE/Err:502 caveat.
[O2] ISERR reference: Apache OpenOffice Calc — ISERR. Exclusion of #N/A and contrast with ISERROR.
[O3] Information functions list: Apache OpenOffice Calc — Information functions. Official category inventory and related predicates.
[O4] IF reference: Apache OpenOffice Calc — IF. Semicolon-separated syntax, true/false branches, and conditional evaluation.
[O5] Logical functions documentation: Apache OpenOffice Calc — Logical functions. Display and numeric representation of logical values.
[O6] Official release information: Apache OpenOffice official download. Release listing for 4.1.16, checked 2026-10-12.

Verification status: Official Apache documentation checked; formula examples are either reproduced as documented examples or independently reasoned from the documented rule, as identified above. Not executed in Apache OpenOffice Calc. No genuine Calc screenshots are included; this guide uses neither mock application images nor fabricated test results.

Validation note

The examples show expected results checked against Apache OpenOffice documentation and independent arithmetic, text mapping, or logical reasoning. They were not run in Apache OpenOffice Calc. Platform, locale, import, and unusual error cases are not certified.

Quick answer▾

Syntax, argument and result▾

Reproducible example 1: error tests without setup▾

Reproducible example 2: inspect a cell’s calculation▾

Advanced example: display a message instead of an error▾

A documented caveat: ISERROR does not catch every expression cleanly▾

Troubleshooting and error types▾

ISERROR compared with related Calc functions▾

Cross-compatibility and version notes▾

Official references and verification▾

Validation note▾