IFERROR vs IFNA — Which Error Wrapper Should You Use in 2026?
Home› IFERROR vs IFNA 2026
⚠ Comparison · Excel Errors

IFERROR vs IFNA — which error wrapper should you use?

Both functions catch errors and replace them with something friendlier. Both have identical syntax. And 90% of Excel users default to IFERROR for everything — which is often the wrong choice. IFNA is more surgical, catches only what you expect, and lets genuine bugs surface instead of hiding them. This is the definitive comparison with the honest verdict most tutorials skip.

⚡ The short answer

Use IFNA for lookup formulas (VLOOKUP, XLOOKUP, INDEX/MATCH) where missing values are expected but other errors would indicate real bugs. Use IFERROR only when you genuinely want to catch every possible error, or for calculations where any error should be replaced with a safe default. The default choice should be IFNA — reach for IFERROR only when you specifically need the broader catch.

The fundamental difference in one sentence

IFERROR catches every error type Excel has. IFNA catches only #N/A.

That's the entire distinction. Everything else in this article is about why that difference matters more than you might think.

Both functions arrived in Excel to solve the same problem: cells full of ugly error codes that scared end users and looked broken. Before wrappers, if a VLOOKUP couldn't find a value, users saw #N/A. If a division formula hit a zero, users saw #DIV/0!. Wrapping formulas in an error handler lets you show "Not found" or "N/A" or blank instead.

IFERROR arrived first in Excel 2007. Then Microsoft realized users often wanted to catch ONLY the missing-value case (from lookups) while still seeing real bugs like broken references. So they added IFNA in Excel 2013 — the surgical version.

Side-by-side syntax

IFERROR

=IFERROR(value, value_if_error)
  • value — the formula that might error
  • value_if_error — what to return if ANY error occurs

Catches all 9 error types

IFNA

=IFNA(value, value_if_na)
  • value — the formula that might return #N/A
  • value_if_na — what to return ONLY if #N/A

Catches only the #N/A error

Identical syntax. Same 2 arguments. The only functional difference is which errors trigger the fallback.

Which errors does each catch?

Excel has 9 error types. Here's exactly which wrapper catches which:

Error typeCommon causeIFERROR catches?IFNA catches?
#N/ALookup value not foundYesYes
#REF!Cell reference deleted or brokenYesNo
#NAME?Function name misspelledYesNo
#VALUE!Wrong data type in argumentYesNo
#DIV/0!Division by zero or blankYesNo
#NULL!Range intersection errorYesNo
#NUM!Invalid numeric operationYesNo
#SPILL!Dynamic array can't spillYesNo
#CALC!Dynamic array calc problemYesNo

IFERROR is a shotgun. IFNA is a scalpel. For lookups, you want the scalpel.

For more on each error type and how to prevent them at the source, see the Excel Errors Complete Guide.

The scenario where using IFERROR hides bugs

Say you build a report that looks up customer names by ID:

=IFERROR(VLOOKUP(A2, CustomerTable, 2, FALSE), "Unknown")

This looks reasonable. If the ID isn't in the customer table, you get "Unknown" instead of #N/A. Clean.

But now imagine someone deletes the CustomerTable range from your workbook. The VLOOKUP now returns #REF!. What happens?

IFERROR silently catches the #REF! and shows "Unknown" for every single row. Your report looks fine. Every customer shows as "Unknown". Nobody notices for weeks. The real bug — a deleted table — is invisible.

Now compare with IFNA:

=IFNA(VLOOKUP(A2, CustomerTable, 2, FALSE), "Unknown")

If a customer isn't found, you still get "Unknown" as intended. But if the CustomerTable is deleted, you now see #REF! in every cell — a screaming red flag that something is genuinely broken. You fix the root cause immediately instead of shipping broken data for weeks.

This is the single biggest reason to use IFNA

IFERROR is dangerous because it makes bugs invisible. IFNA only catches the ONE expected error type (missing lookups) and lets everything else surface. This distinction has saved countless workbooks from silent data corruption over the years.

Feature-by-feature scorecard

FeatureIFERRORIFNAWinner
Error types caughtAll 9Only #N/AIFERROR (broader)
Hides genuine bugsYes (dangerous)No (safe)IFNA
Best for lookupsOverkillPerfect fitIFNA
Best for math/calculationsCorrect choiceDoesn't catch DIV/0IFERROR
Excel version2007+2013+IFERROR (broader compat)
Syntax2 arguments2 argumentsTie
Google Sheets supportYesYesTie
PerformanceIdenticalIdenticalTie
Debugging friendlinessHides everythingLets bugs surfaceIFNA
Beginner-friendly"Catches errors" is simpleRequires understanding error typesIFERROR

Score: IFERROR wins 4, IFNA wins 4, 2 ties. Genuinely close — because they solve different problems, not the same problem differently.

Real-world examples — same formula, different wrappers

Scenario 1: VLOOKUP that might miss

=IFNA(VLOOKUP(A2, Products, 2, FALSE), "Not in catalog")

Use IFNA. Missing lookups are expected. Broken references or misspelled function names are bugs you need to see.

Scenario 2: Division that might hit zero

=IFERROR(Revenue/Units, 0)

Use IFERROR. Division errors (#DIV/0!) are the specific error you're guarding against. IFNA wouldn't catch it — it only catches #N/A.

Scenario 3: XLOOKUP already has built-in handling

=XLOOKUP(A2, IDs, Names, "Not found")

Use neither. XLOOKUP has an if_not_found argument built in as the 4th parameter. No wrapper needed. This is one of XLOOKUP's advantages over VLOOKUP — see the XLOOKUP vs VLOOKUP comparison for the full picture.

Scenario 4: FILTER that might return nothing

=IFERROR(FILTER(A2:A100, B2:B100="APAC"), "No matches")

Use IFERROR. FILTER returns #CALC! when no rows match — not #N/A. IFNA wouldn't catch it. Or better yet, use FILTER's built-in third argument: =FILTER(A2:A100, B2:B100="APAC", "No matches").

Scenario 5: Nested lookups where inner might miss

=IFNA(VLOOKUP(VLOOKUP(A2, IDs, 2, FALSE), Names, 2, FALSE), "Unknown")

Use IFNA. The lookups are the risky part. If they miss, you want the fallback. Any other error (broken tables, deleted ranges) should still surface.

The decision framework

Which wrapper should you use?

  • VLOOKUP, INDEX/MATCH lookup that might miss → IFNA
  • XLOOKUP that might miss → Use the built-in 4th argument, no wrapper needed
  • Division that might hit zero → IFERROR (specifically for #DIV/0!)
  • Math on possibly-text cells → IFERROR (for #VALUE!)
  • Dynamic array formulas (FILTER, UNIQUE) → IFERROR or the function's own error argument
  • Any calculation where you want a safe default for any failure → IFERROR
  • Any lookup where you want bugs to surface → IFNA
  • Building professional dashboards or client reports → IFNA by default, IFERROR only where justified
  • Quick personal spreadsheets, doesn't matter if bugs hide → Either, IFERROR is simpler
  • Backward compatibility with Excel 2010 → IFERROR (IFNA needs 2013+)

The older workaround — IF + ISNA and IF + ISERROR

Before IFNA (Excel 2013), the way to catch specific errors was to combine IF with an IS function. These older patterns still work and appear in legacy workbooks:

The old equivalent of IFNA:

=IF(ISNA(VLOOKUP(A2, Products, 2, FALSE)), "Not found", VLOOKUP(A2, Products, 2, FALSE))

The old equivalent of IFERROR:

=IF(ISERROR(VLOOKUP(A2, Products, 2, FALSE)), "Not found", VLOOKUP(A2, Products, 2, FALSE))

Both patterns evaluate the formula TWICE — once to check for the error, once to return the value. On large datasets this doubles the calculation load. IFERROR and IFNA evaluate the formula once and are faster.

Modernize legacy IF+ISERROR patterns

If you inherit a workbook using IF(ISERROR(x), fallback, x), converting to IFERROR(x, fallback) makes the formula shorter, faster, and easier to read. Same behavior, better implementation. But if the original was IF(ISNA(x), ...), convert to IFNA — not IFERROR — to preserve the surgical behavior.

Common mistakes to avoid

1. Wrapping everything in IFERROR "just to be safe"

This is the #1 IFERROR mistake. Blanket-wrapping every formula converts bugs into invisible data corruption. If a formula shouldn't error under normal conditions, don't wrap it — let it error so you know something changed.

2. Using IFNA on a formula that returns other errors

=IFNA(A2/B2, "Error")

This won't catch division-by-zero. If B2 is 0, you get #DIV/0! because IFNA only catches #N/A. Use IFERROR here instead.

3. Nesting error wrappers unnecessarily

=IFERROR(IFNA(VLOOKUP(A2, T, 2, FALSE), "N/A"), "Error")

Redundant. If you want to catch all errors, just use IFERROR. If you want to catch only #N/A, just use IFNA. Combining them is almost always a sign of unclear thinking about what errors you're actually guarding against.

4. Using error wrappers instead of fixing root causes

An error wrapper is a band-aid. If your VLOOKUP keeps missing values, ask WHY. Data entry issue? Trailing spaces? Wrong table? Fix the source of the problem when possible instead of hiding it with a wrapper.

Related resources

Frequently asked questions

What is the difference between IFERROR and IFNA?

IFERROR catches all 9 Excel error types — #REF, #NAME, #VALUE, #DIV/0, #N/A, #NULL, #NUM, #SPILL, #CALC. IFNA catches only the #N/A error. This means IFNA is more surgical — it handles missing lookups gracefully while letting other errors surface as bugs to fix. IFERROR is a bigger hammer that hides everything.

Which is better — IFERROR or IFNA?

For lookup formulas like VLOOKUP, XLOOKUP, and INDEX/MATCH, IFNA is better because it catches the expected missing-value case without hiding genuine bugs. For calculations where any error should be replaced with a default, IFERROR is appropriate. The rule: use IFNA whenever you can, IFERROR only when you truly want any error hidden.

Should I always use IFERROR to hide errors?

No. IFERROR hides bugs. If you wrap every formula in IFERROR, you will not notice when a lookup table is deleted, a function is misspelled, or a reference breaks. The formula will just show your fallback value silently. Use IFERROR only when you have a specific expected error and know what fallback should apply.

Does IFNA work in Excel 2010?

No, IFNA requires Excel 2013 or newer. Excel 2010 and older versions do not have IFNA. For backward compatibility, use the older workaround: IF(ISNA(formula), fallback, formula). IFERROR requires Excel 2007 or newer, so it works in slightly older versions than IFNA.

Can IFERROR catch #SPILL and #CALC errors?

Yes. IFERROR catches all 9 error types including modern #SPILL and #CALC errors that appear with dynamic array formulas. IFNA does not catch these — it only catches #N/A. If you use FILTER, UNIQUE, or other dynamic array functions, IFERROR is the wrapper that handles their potential errors.

What is the syntax for IFERROR and IFNA?

Both functions have identical syntax: =IFERROR(formula, value_if_error) and =IFNA(formula, value_if_na). You wrap your original formula as the first argument and provide the fallback value as the second argument. The only difference is which errors each function catches — everything else about how you use them is identical.

Do IFERROR and IFNA work in Google Sheets?

Yes, both functions work identically in Google Sheets with the same syntax as Excel. IFERROR has been in Google Sheets since day one. IFNA was added later but has been stable for years. All examples and patterns in this article transfer directly between Excel and Google Sheets. See Excel vs Google Sheets for more platform comparisons.

Do I still need IFERROR when using XLOOKUP?

Usually no. XLOOKUP has a built-in 4th argument for "if not found" — you can specify a fallback directly without wrapping. For example: =XLOOKUP(A2, IDs, Names, "Unknown"). This is cleaner than =IFNA(XLOOKUP(A2, IDs, Names), "Unknown"). XLOOKUP eliminated one of the biggest reasons to use IFNA.

Which is faster — IFERROR or IFNA?

Performance is essentially identical. Both functions evaluate the wrapped formula once and check the result. Neither will make a meaningful difference in workbook calculation speed. The old IF(ISERROR(formula), fallback, formula) pattern is measurably slower because it evaluates the formula twice — but that's not IFERROR or IFNA, that's a legacy pattern to avoid.

· · ·

Bottom line: Use IFNA by default. Use IFERROR only when you truly need the broader catch. The difference between the two is the difference between a professional workbook that surfaces bugs and a beginner workbook that hides them.