stringr str_match_all() in R: All Regex Capture Groups

The str_match_all() function in stringr extracts EVERY regex match plus its capture groups from each input string. Unlike str_match(), which returns one matrix for the first match per string, str_match_all() returns a list of matrices, one per input. Reach for it when a single string can contain many matches.

str_match_all(x, "(\\d+)")                 # all numbers per string
str_match_all(x, "(\\w+)=(\\w+)")          # key=value pairs
str_match_all(x, "(?<k>\\w+)=(?<v>\\w+)")  # named groups
str_match_all(x, "(\\w+)@(\\w+)")[[1]]     # matrix for string 1
do.call(rbind, str_match_all(x, "(\\d+)")) # flatten to one matrix
length(str_match_all(x, "\\d+")[[1]])      # count matches in string 1
str_match_all(x, "<(\\w+)>([^<]+)</\\1>")  # paired XML-like tags

What str_match_all() does in one sentence

str_match_all(string, pattern) returns a list with one character matrix per input string. Each matrix has one row per match and one column for the full match plus one column per regex capture group.

That list-of-matrices shape is the whole story. Rows in matrix i are the matches found in string i; columns are the full match (column 1) and the capture groups (columns 2 onward). Strings with zero matches return a 0-row matrix, not NULL.

Syntax and return shape

The return type is list, not matrix. This is the single most common surprise for readers coming from str_match(). You must subset with [[i]] to reach the matrix for input i.

The first input contained two key=value pairs, so result[[1]] is a 2-row, 3-column matrix. The third input had no match, so result[[3]] is a 0-row matrix with the right column count, ready to bind without errors.

From list of matrices to a flat data frame

do.call(rbind, ...) stacks the per-string matrices into one matrix. This is the bridge from stringr's list output to a tidy frame you can tibble::as_tibble() and filter.

This loses the source-string index unless you add it back. To keep it, use Map(cbind, str_match_all(...), id = seq_along(x)) and bind after. The result is a one-row-per-match frame ready for analysis.

Four practical patterns

1. Extract every key=value pair from a log line

Suitable for unstructured logs where pairs appear in varying order:

Columns 2 and 3 are the structured fields. Pivoting the resulting matrix wide gives you a one-row-per-event frame.

2. Pull all email addresses with user and host

When a free-text comment field can contain several emails:

The second input returns a 0-row matrix, which is what you want for rbind later.

3. Named groups for self-documenting matrices

Named groups put labels on columns, which makes downstream code less brittle:

Subset by name with out[[1]][, "minor"] rather than [, 3]. Adding a new group later does not shift your indices.

4. Paired open/close tags with a backreference

Backreferences (\\1) match the same text twice, useful for paired markers:

For real HTML, use a parser like rvest::read_html() instead. Regex on nested markup breaks on edge cases.

str_match_all() vs str_match() vs str_extract_all()

Three closely-named functions, three distinct outputs. Pick by what you need to recover, not by what sounds familiar.

The _all variants always return a list because the count of matches per input varies. The non-_all variants return a fixed-shape result because there is exactly one slot per input.

Common pitfalls

Three more traps to avoid:

• Greedy quantifiers swallow neighbors. (\\w+)=(.+) against a=1 b=2 matches once with b in group 1 and 1 b=2 in group 2. Use [^\\s]+ or non-greedy .+? for delimited fields.
• Zero-match inputs return a 0-row matrix, not NULL. That is helpful for rbind, but it can fool a naive length(result[[i]]) check; use nrow(result[[i]]) instead.
• Capture-group count must match across inputs. Different alternatives in the same pattern can yield missing groups; check the column count is what you expect before binding.

Try it yourself

Related stringr functions

• str_match(): same idea, first match only, returns a single matrix.
• str_extract_all(): every match as a list of vectors, no capture groups.
• str_locate_all(): start and end positions of every match.
• str_count(): count matches per string, faster when you do not need the text.
• str_replace_all(): replace every match with a substitution.

For an end-to-end stringr walkthrough, see the parent stringr in R guide. The official reference lives at stringr.tidyverse.org/reference/str_match.html.

FAQ

How is str_match_all() different from str_match() in R?

str_match() returns a single character matrix with one row per input string and only the FIRST regex match per row. str_match_all() returns a list of matrices, with one matrix per input string containing every match. Use the _all variant when any input string can have more than one match. The list shape preserves the parallel structure with the input vector.

Why does str_match_all() return a list instead of a matrix?

Each input string can contain a different number of matches, so a single matrix cannot represent the result without padding. A list lets each element have its own row count. To flatten the list into one matrix, call do.call(rbind, str_match_all(...)); to keep the source-string index, prepend it with Map(cbind, result, id = seq_along(x)) before binding.

How do I extract named capture groups from str_match_all()?

Use (?<name>pattern) syntax inside the regex. The returned matrices then have named columns matching your group names, so you can subset with result[[1]][, "name"] instead of positional indices. Named groups make code resilient when you later add or reorder capture groups.

What does str_match_all() return when there are no matches?

For each input with zero matches, the corresponding list element is a character matrix with 0 rows and the expected column count (1 + number of capture groups). It is NOT NULL or NA. Use nrow(result[[i]]) == 0 to detect no-match cases; do.call(rbind, ...) then skips those rows automatically.

Can str_match_all() handle vectorized input?

Yes. Pass a character vector as the first argument; you get a list of the same length back. Each list element corresponds to one input string by position, so result[[i]] is always the matches for x[i]. This makes it safe to combine results with the original data via mapply or Map.