FIND and SEARCH in Excel - Deep Dive

Overview - FIND and SEARCH

What is it?

FIND and SEARCH are Excel functions used to locate the position of one text string inside another. They return the number of the character where the searched text starts. FIND is case-sensitive and does not allow wildcards, while SEARCH is case-insensitive and supports wildcards like ? and *. Both help you find text within cells quickly.

Why it matters

Without FIND and SEARCH, locating specific text inside larger text strings would be slow and manual. These functions let you automate tasks like extracting parts of text, validating data, or cleaning messy information. They save time and reduce errors in managing text data in spreadsheets.

Where it fits

Before learning FIND and SEARCH, you should understand basic Excel formulas and text data. After mastering these, you can learn related functions like LEFT, RIGHT, MID for extracting text, and SUBSTITUTE for replacing text. They fit into the broader topic of text manipulation in spreadsheets.

Mental Model

Core Idea

FIND and SEARCH tell you exactly where a smaller piece of text starts inside a bigger text string.

Think of it like...

It's like using a map to find the exact street number where a friend lives inside a long street address.

Text:  H e l l o   W o r l d
Index: 1 2 3 4 5 6 7 8 9 10
FIND("W", "Hello World") → 7

Build-Up - 7 Steps

1

Foundation

Basic use of FIND function

Concept: Learn how FIND locates text position with case sensitivity.

The FIND function syntax is FIND(find_text, within_text, [start_num]). It looks for find_text inside within_text starting at start_num (default 1). It returns the position of the first character of find_text. Example: FIND("a", "Banana") returns 2 because 'a' first appears at the second character.

Result

FIND("a", "Banana") returns 2.

Understanding FIND's case sensitivity helps you know it treats uppercase and lowercase letters differently, which affects search results.

2

Foundation

Basic use of SEARCH function

Concept: Learn how SEARCH locates text position ignoring case and supports wildcards.

SEARCH syntax is SEARCH(find_text, within_text, [start_num]). It works like FIND but ignores case and allows wildcards: '?' for any single character and '*' for any sequence. Example: SEARCH("a", "Banana") returns 2, same as FIND, but SEARCH("A", "Banana") also returns 2 because it ignores case.

Result

SEARCH("A", "Banana") returns 2.

Knowing SEARCH ignores case and supports wildcards makes it flexible for fuzzy or case-insensitive searches.

3

Intermediate

Using start_num to control search position

🤔Before reading on: If you start searching from character 4 in "Banana", will FIND("a", "Banana", 4) return 2 or 5? Commit to your answer.

Concept: Learn how the optional start_num argument changes where the search begins.

Both FIND and SEARCH let you specify start_num to begin searching from that character position. For example, FIND("a", "Banana", 4) starts looking from the 4th character. Since the first 'a' after position 4 is at position 5, it returns 5. This helps find multiple occurrences by moving the start point.

Result

FIND("a", "Banana", 4) returns 5.

Understanding start_num lets you find later occurrences of text, enabling more complex text parsing.

4

Intermediate

Difference between FIND and SEARCH functions

🤔Before reading on: Does FIND find 'A' in 'Banana' if searching for uppercase 'A'? Commit yes or no.

Concept: Compare how FIND and SEARCH handle case sensitivity and wildcards.

FIND is case-sensitive and does not support wildcards. SEARCH is case-insensitive and supports '?' and '*'. For example, FIND("A", "Banana") returns an error because uppercase 'A' is not found, but SEARCH("A", "Banana") returns 2. This difference guides which to use based on your needs.

Result

FIND("A", "Banana") returns #VALUE! error; SEARCH("A", "Banana") returns 2.

Knowing these differences prevents errors and helps pick the right function for your text search.

5

Intermediate

Using wildcards with SEARCH function

🤔Before reading on: Will SEARCH("b?n", "Banana") find a match? Commit yes or no.

Concept: Learn how to use '?' and '*' wildcards in SEARCH to match patterns.

The '?' wildcard matches any single character, '*' matches any number of characters. For example, SEARCH("b?n", "Banana") looks for 'b' followed by any character, then 'n'. It returns 1 because 'Ban' matches. This allows flexible pattern matching inside text.

Result

SEARCH("b?n", "Banana") returns 1.

Using wildcards expands SEARCH's power to find patterns, not just exact text.

6

Advanced

Handling errors when text not found

🤔Before reading on: What happens if FIND("x", "Banana") is used? Does it return 0, error, or something else? Commit your guess.

Concept: Learn how FIND and SEARCH behave when the text is missing and how to handle errors gracefully.

If FIND or SEARCH cannot find the text, they return a #VALUE! error. To avoid breaking formulas, wrap them in IFERROR or ISNUMBER checks. Example: IFERROR(FIND("x", "Banana"), 0) returns 0 instead of error. This is important for robust spreadsheets.

Result

FIND("x", "Banana") returns #VALUE! error; IFERROR(FIND("x", "Banana"), 0) returns 0.

Knowing error behavior and handling prevents formula crashes and improves user experience.

7

Expert

Combining FIND/SEARCH with other text functions

🤔Before reading on: Can you extract the domain from an email using FIND or SEARCH combined with MID? Commit yes or no.

Concept: Learn how to use FIND or SEARCH with MID, LEFT, RIGHT to extract parts of text dynamically.

You can find the position of a character (like '@') with FIND or SEARCH, then use MID to extract text after it. For example, to get domain from email in A1: MID(A1, FIND("@", A1) + 1, LEN(A1)). This extracts everything after '@'. Combining these functions allows powerful text parsing.

Result

If A1 contains "[e-mail]", formula returns "example.com".

Understanding how to combine these functions unlocks advanced text manipulation and data cleaning.

Under the Hood

FIND and SEARCH scan the text string character by character starting from start_num. FIND compares characters exactly including case, while SEARCH converts both strings to uppercase internally to ignore case and interprets wildcards. They return the index of the first matching character or an error if none found.

Why designed this way?

FIND was designed for exact, case-sensitive searches to match programming and data needs. SEARCH was added later to allow more flexible, user-friendly searches ignoring case and supporting wildcards. This separation keeps functions simple and specialized.

┌───────────────┐
│ Input Text    │
│ "Banana"    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ FIND/SEARCH   │
│ Search for   │
│ "a"         │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Compare chars │
│ (case-sensitive or
│  case-insensitive)
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Return index  │
│ or error      │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does FIND ignore case when searching text? Commit yes or no.

Common Belief: FIND ignores case and finds text regardless of uppercase or lowercase.

Reality: FIND is case-sensitive and only finds text that matches the exact case.

Why it matters: Using FIND expecting case-insensitivity causes missed matches and errors in data processing.

Quick: Can SEARCH find text using wildcards like '*'? Commit yes or no.

Common Belief: Neither FIND nor SEARCH support wildcards in their search text.

Reality: SEARCH supports wildcards '?' and '*', but FIND does not.

Why it matters: Not knowing this limits your ability to perform flexible pattern searches with SEARCH.

Quick: If FIND does not find the text, does it return 0 or an error? Commit your answer.

Common Belief: FIND returns 0 if the text is not found.

Reality: FIND returns a #VALUE! error when the text is missing.

Why it matters: Assuming 0 leads to incorrect formulas and crashes if error handling is missing.

Quick: Does SEARCH always find the first occurrence of text? Commit yes or no.

Common Belief: SEARCH can find all occurrences of text at once.

Reality: SEARCH only finds the first occurrence; to find others, you must adjust start_num.

Why it matters: Expecting multiple matches at once causes confusion and incorrect formula design.

Expert Zone

1

FIND and SEARCH return the position of the first character of the found text, not the whole substring length.

2

SEARCH's wildcard support can cause unexpected matches if wildcards are used unintentionally.

3

Using start_num greater than the text length returns an error, so bounds checking is important in dynamic formulas.

When NOT to use

Avoid FIND and SEARCH when you need to find multiple occurrences at once or perform complex pattern matching; use FILTERXML, REGEX functions (in Excel 365), or Power Query instead.

Production Patterns

Professionals use FIND/SEARCH combined with MID/LEFT/RIGHT to parse emails, extract codes, or clean data. Wrapping them in IFERROR prevents crashes. They also use SEARCH with wildcards for flexible validation and conditional formatting.

Connections

Regular Expressions

SEARCH's wildcard pattern matching is a simplified form of regular expressions.

Understanding SEARCH wildcards helps grasp the basics of pattern matching before learning full regex.

String Indexing in Programming

FIND and SEARCH return character positions similar to string index functions in programming languages.

Knowing how string indexing works in code clarifies how these functions count characters starting at 1.

Text Search in Databases

FIND and SEARCH are like SQL's LIKE and POSITION functions for searching text within fields.

Recognizing this connection helps when moving between spreadsheet and database text operations.

Common Pitfalls

#1 Using FIND expecting case-insensitive search.

Wrong approach:

FIND("a", "Apple")

Correct approach:

SEARCH("a", "Apple")

Root cause:

Misunderstanding that FIND is case-sensitive causes missed matches.

#2 Not handling errors when text is missing.

Wrong approach:

FIND("x", "Banana")

Correct approach:

IFERROR(FIND("x", "Banana"), 0)

Root cause:

Ignoring that FIND returns errors breaks formulas when text is absent.

#3 Using wildcards with FIND expecting them to work.

Wrong approach:

FIND("b?n", "Banana")

Correct approach:

SEARCH("b?n", "Banana")

Root cause:

Assuming FIND supports wildcards leads to errors or wrong results.

Key Takeaways

FIND and SEARCH locate the position of text inside another text string, returning the starting character number.

FIND is case-sensitive and does not support wildcards; SEARCH is case-insensitive and supports '?' and '*' wildcards.

Both functions return errors if the text is not found, so error handling is important for stable formulas.

Using the optional start_num argument lets you find later occurrences of text, enabling more complex searches.

Combining FIND or SEARCH with text extraction functions like MID unlocks powerful text parsing capabilities.