Summary

The Excel TEXTJOIN function joins multiple text strings or cell ranges into a single string, inserting a delimiter of your choice between each item. What makes TEXTJOIN better than manually concatenating cells with & is that it can accept an entire range (like A1:A100) instead of requiring you to list every cell individually, and it has a built-in option to automatically skip empty cells so you never end up with double commas or double separators in your output.

The ignore_empty argument is the feature that makes TEXTJOIN particularly useful for real-world data. When you join a range that might have some blank cells, setting ignore_empty to TRUE means those gaps are simply skipped — the result is a clean list with no extra delimiters. Setting it to FALSE preserves the blank positions, which is useful when you need to maintain fixed-position alignment in the output.

Syntax

=TEXTJOIN(delimiter, ignore_empty, text1, [text2], ...)

TEXTJOIN takes at least three arguments. delimiter is the separator to insert between each item — use ", " for comma-space, "/" for slash, or "" for no separator. ignore_empty is required and must be TRUE or FALSE — TRUE skips blank cells, FALSE keeps them as empty slots. text1 onward can be individual cells, ranges, or typed strings — you can mix them freely. TEXTJOIN accepts up to 252 text arguments total.

Arguments

• delimiter — [Required] The text to insert between each item. Can be any text or an empty string "".
• ignore_empty — [Required] TRUE skips empty cells (no double separators). FALSE includes blank positions in the output.
• text1, text2, ... — [Required] The cells, ranges, or text strings to join. You can mix individual cells and ranges.

TEXTJOIN vs Other Functions

TEXTJOIN is the most capable of the three text-joining functions. Choosing between them depends on how complex your joining needs are.

TEXTJOIN is only available in Excel 2019 and Microsoft 365. If your file will be opened in Excel 2016 or older, you need to use CONCAT or CONCATENATE instead. CONCAT is available in Excel 2016+ and handles ranges, but it does not support the ignore_empty option or a delimiter. For older compatibility, CONCATENATE is the fallback — though it requires listing each cell individually.

Using TEXTJOIN

The most common real-world use of TEXTJOIN is building a comma-separated or semicolon-separated list from a column of values — like creating an email recipient list, a list of active tags, or a comma-delimited ID string. Instead of writing =A1&", "&A2&", "&A3 and expanding it for every new row, you write =TEXTJOIN(", ", TRUE, A1:A100) once and it handles the whole range, skipping blanks automatically.

A particularly powerful pattern pairs TEXTJOIN with IF to build a filtered list. For example, =TEXTJOIN(", ", TRUE, IF(B2:B10="Late", A2:A10, "")) creates a list of names from column A where the corresponding column B says "Late". Enter this as an array formula with Ctrl+Shift+Enter in older Excel, or just Enter in Microsoft 365.

• Use ignore_empty TRUE for clean output when your range might have blank cells in it.
• Use TEXTJOIN with a range like A1:A100 instead of listing every cell — it handles growth automatically.
• Combine with IF to build filtered lists that only include rows meeting a condition.

Example 1 — Joining Individual Cells with a Comma

The simplest use: give TEXTJOIN the cells you want to combine and the separator to put between them. Blank cells in the argument list are skipped when ignore_empty is TRUE, producing a clean result without double separators.

=TEXTJOIN(", ", TRUE, A1, B1, C1)
// A1="Apples", B1="", C1="Oranges" → "Apples, Oranges"
// B1 is skipped because ignore_empty is TRUE

Example 2 — Joining a Range and Skipping Blanks

Providing a range instead of individual cells makes TEXTJOIN much more powerful — it handles any number of cells without you needing to list them one by one. Blanks inside the range are handled cleanly by the ignore_empty argument.

=TEXTJOIN("-", TRUE, A1:C1)
// "Apples" | "" | "Oranges" → "Apples-Oranges"
// Compare with FALSE: "Apples--Oranges" (blank preserved)

Example 3 — Building a Slash-Separated ID List

This is a common data-prep task: combining a column of IDs into a single slash-separated string for a report header or system input. TEXTJOIN handles gaps in the list automatically without producing "ID1//ID4".

=TEXTJOIN("/", TRUE, B2:B5)
// B2="ID1", B3="ID2", B4="", B5="ID4"
// Result: "ID1/ID2/ID4" (blank B4 skipped)

Example 4 — Keeping Blank Cells as Empty Slots

Setting ignore_empty to FALSE preserves blank positions in the output. This is useful when the position of each item matters — for example, building a fixed-column CSV where an empty field must still appear as an empty slot between its surrounding delimiters.

=TEXTJOIN("|", FALSE, A1:C1)
// "Apples" | "" | "Oranges" → "Apples||Oranges"
// The double || shows the blank position was preserved

TEXTJOIN has a limit: the combined result cannot exceed 32,767 characters. For most use cases this is more than enough, but if you are joining hundreds of long strings it is worth checking. Also, if you use an array formula pattern with IF inside TEXTJOIN, remember to press Ctrl+Shift+Enter in Excel 2019 — in Microsoft 365 this is no longer necessary.

• TEXTJOIN is available in Excel 2019 and Microsoft 365 only — use CONCAT for Excel 2016 compatibility.
• The result is text — numbers in the range are automatically converted to their text representation.
• To build a list of only items meeting a condition, combine TEXTJOIN with IF: =TEXTJOIN(",",TRUE,IF(B1:B10="Y",A1:A10,"")).

A quick comparison: if you just need to combine cells without a separator, CONCAT is simpler. If you need a separator and want blank cells handled cleanly, TEXTJOIN is the right choice.

Conclusion Recap

• Summary: TEXTJOIN joins multiple cells or ranges into one string with a custom delimiter between items.
• Syntax: =TEXTJOIN(delimiter, ignore_empty, text1, ...) — all three base arguments are required.
• Arguments: The separator, whether to skip blanks (TRUE/FALSE), and the cells or ranges to join.
• Key advantage: Accepts full ranges and can skip blanks — no double separators or trailing commas.
• Practical usage: Building comma-separated or semicolon-separated lists, email recipient strings, and ID concatenations.
• Best pattern: Use =TEXTJOIN(", ", TRUE, A1:A100) for a clean list from a large column with possible blanks.