Excel FIND Function

FIND tells you where a specific character or piece of text sits inside a longer text string, counting from the left. It returns a number representing the position, not the text itself. If FIND can't locate what you're looking for, it doesn't return a blank or a zero. It throws a #VALUE! error, and that error slips past a plain IF statement, which is the mistake that catches most beginners.

Syntax

=FIND(find_text, within_text, [start_num])

Parameter	Required	Description
find_text	Yes	The character or substring you're searching for. Case matters here: "Excel" and "excel" are treated as different text.
within_text	Yes	The full text string you're searching inside. Usually a cell reference.
start_num	No	The character position where the search should begin. Defaults to 1 (the very start of the string) if you leave it out.

Basic Example

Say you're cleaning up a list of employee email addresses in column A and you need to know where the @ symbol sits in each one, so you can split the username from the domain later.

=FIND("@", A2)

// "@"  = the character you're searching for
// A2   = "j.torres@company.com"

FIND scans the text in A2 one character at a time, starting from position 1. It finds @ at position 9 and returns 9. That number on its own isn't very useful, but it becomes the building block for extracting the username with LEFT or the domain with MID, which you'll see below.

How FIND Works

FIND is case-sensitive

FIND treats uppercase and lowercase letters as different characters. =FIND("e", "Excel") returns 4, because it skips the capital "E" and matches the lowercase "e" further in. If you need a case-insensitive search, use SEARCH instead. It's the same syntax, just blind to case.

FIND doesn't support wildcards

Typing * or ? into find_text doesn't act as a wildcard with FIND. Excel searches for those literal characters instead. SEARCH does support wildcards, so if your search needs pattern matching (like "any character" or "any sequence"), that's the function to reach for, not FIND.

Position counting includes every character, including spaces and Unicode

FIND counts every character in the string, including spaces, punctuation, and even multi-byte characters like accented letters or emoji. This matters if you're working with international text or names imported from another system. A string like "café" has 4 characters to FIND, same as "cafe", because Excel treats the accented "é" as a single character rather than two bytes. Where this gets messier is with certain emoji and East Asian characters stored as surrogate pairs. Occasionally FIND counts one visual character as two positions, which can throw off substring extraction formulas by exactly one character. Test with real data before trusting position numbers blindly in mixed-language spreadsheets.

start_num shifts where the search begins, not what gets returned

The position FIND returns is always counted from the beginning of the full string, even when you set start_num to skip ahead. =FIND("a", "banana", 3) starts scanning from position 3 and finds the next "a" at position 4, not position 2 relative to where it began.

FIND can spill across a range

If within_text is a range instead of a single cell, FIND returns an array of results, one for each cell, and spills them down or across depending on the shape of the range. =FIND("-", A2:A10) returns nine separate position numbers, no CTRL+SHIFT+ENTER needed on Excel 365. This is useful for scanning a whole column at once instead of copying a single formula down manually.

Common Use Cases

Splitting a name into first and last

You're building a mailing list and the full name sits in one cell. You need the first name pulled out separately.

=LEFT(A2, FIND(" ", A2) - 1)

// A2            = "Maria Gonzalez"
// FIND(" ", A2) = finds the space at position 6
// - 1           = trims the space itself, returning "Maria"

Testing whether a cell contains specific text

You want a TRUE/FALSE flag for whether an order description contains the word "urgent," without caring about exact position.

=ISNUMBER(FIND("urgent", B2))   // returns TRUE if found, FALSE if not

Wrapping FIND in ISNUMBER converts the position number (or the error) into a clean logical value. This is the standard workaround for the fact that FIND alone doesn't give you a simple yes/no answer.

Locating the second occurrence of a delimiter

You've got product codes like "SKU-4471-A-Warehouse2" and you need the position of the second dash, not the first.

=FIND("-", A2, FIND("-", A2) + 1)

// inner FIND("-", A2)      = finds the first dash
// + 1                      = starts the next search one character past it
// outer FIND(..., A2, ...) = finds the second dash from that new starting point

This nested approach looks awkward the first time you see it, but it's the standard technique for pulling apart delimited codes with more than one separator.

Building a "find and replace" formula instead of using the dialog box

Ctrl+H works fine for one-time cleanup, but if you need the replacement to update automatically as source data changes, combine FIND with REPLACE.

=REPLACE(A2, FIND("-", A2), 1, "/")

// FIND("-", A2) = locates the dash to replace
// 1             = how many characters to replace (just the dash)
// "/"           = the new character

Unlike the Find and Replace dialog, this formula recalculates live if A2 changes, which matters if the sheet is feeding a report that updates daily.

Handling Errors

FIND throws #VALUE! when it can't complete the search. This is a real, catchable error, not a silent zero or blank.

Common causes of #VALUE!:

• find_text genuinely doesn't exist anywhere in within_text
• start_num is set higher than the total length of the text, so there's nothing left to search
• start_num is zero or negative, which FIND doesn't accept
• A case mismatch you didn't notice: searching for "Manager" when the cell contains "manager"

=IFERROR(FIND("@", A2), "No @ symbol found")

IFERROR catches the #VALUE! and swaps in a readable message instead of an error code spreading through downstream formulas.

Notes & Gotchas

What is the difference between FIND and SEARCH?

FIND is case-sensitive and doesn't support wildcards. SEARCH ignores case and does support wildcards like * and ?. =FIND("e", "Excel") returns 4 because it skips the capital E, while =SEARCH("e", "Excel") returns 1 because it treats E and e as the same character. Use FIND when case matters, like validating that a code starts with an uppercase prefix; use SEARCH for general "does this contain that" checks.

Is the FIND function case-sensitive in Excel?

Yes. FIND treats "Invoice" and "invoice" as completely different strings and will fail to match one when searching for the other. This is the single most common source of unexpected #VALUE! errors in FIND formulas, especially when data comes from different sources with inconsistent capitalization. If case shouldn't matter for your search, switch to SEARCH instead of trying to work around FIND.

How do you find and replace text in Excel using formulas?

Combine FIND with REPLACE: use FIND to locate the position of the text you want to change, then feed that position into REPLACE along with the new value. Unlike the Find and Replace dialog (Ctrl+H), a formula-based approach updates automatically whenever the source cell changes, which matters for live reports rather than one-time cleanup jobs.

Does FIND work the same way with dates and numbers as it does with text?

Not directly. FIND expects text, so if you feed it a date or number stored as its actual numeric value, Excel first converts it to its default text representation, which may not match what's displayed on screen. A date cell showing "07/13/2026" might actually store as a serial number internally, so searching for "07" with FIND can behave unpredictably unless the cell is explicitly formatted as text or wrapped in TEXT() first.

What happens if find_text is an empty string?

FIND doesn't throw an error on an empty find_text. It returns start_num (or 1 if start_num is omitted), treating an empty search string as an automatic match at that position. This is the same behavior SEARCH has in this specific case, not a point of difference between them. It's easy to build a false "contains" positive this way: =ISNUMBER(FIND("", B2)) returns TRUE even for a blank or unrelated cell, since an empty find_text always matches. Add an explicit check with ISBLANK or a <>"" comparison instead of relying on FIND to catch an empty search term for you.

Is there a newer alternative to FIND for pattern matching?

If you're on Excel 365, REGEXTEST and related REGEX functions can test for patterns far more flexible than FIND allows, like matching any digit sequence or any string starting with a specific prefix regardless of length. FIND still wins for simple, fast, literal substring searches where you don't need pattern logic. For anything approaching "match a pattern, not just literal text," REGEX functions are worth learning even though the syntax has a steeper learning curve.

Related Functions

Function	Use this when...
SEARCH	You need a case-insensitive search or want to use wildcards.