Regex Reference

Where regex lives in Power Platform

Regex in the Power Platform is a Power Fx feature. Three functions take a pattern — IsMatch (validate), Match (extract the first hit), and MatchAll (extract every hit). They run anywhere Power Fx runs: canvas apps, model-driven custom pages, Copilot Studio, Power Pages, Dataverse low-code (formula columns and low-code plug-ins), and the Power Platform CLI. The full reference is IsMatch, Match, and MatchAll.

Power Fx runs on both JavaScript and .NET, so its regex dialect is a deliberately limited subset chosen to behave identically on every host. Patterns that work in other engines may be blocked or need a tweak — the Power Fx regex constraints section lists the differences. Full detail: Regular expressions in Power Fx.

IsMatch, Match & MatchAll

IsMatch( txtEmail.Text, Match.Email )            // true / false
Match( "Order 1042 shipped", "\d+" ).FullMatch   // "1042"
MatchAll( "a1 b2 c3", "\d" )                      // 3-row table: 1, 2, 3

What Match and MatchAll return

Match returns a single record; MatchAll returns a table of those records. Each record carries the full match, its position, and any submatches you captured.

With(
    { m: Match( "SKU-7781", "SKU-(?<id>\d+)" ) },
    m.FullMatch    // "SKU-7781"
    // m.StartMatch  -> 1
    // m.id          -> "7781"
)

Match options

Pass one or more MatchOptions as the third argument, combined with &. Each has an inline equivalent you can place at the very start of the pattern instead (for example (?i) for IgnoreCase).

IsMatch( "HELLO world", "hello", MatchOptions.Contains & MatchOptions.IgnoreCase )   // true

// Inline form — same as above, options at the very start of the pattern:
IsMatch( "HELLO world", "(?i)hello", MatchOptions.Contains )                        // true

Predefined Match enum patterns

The Match enum gives readable names for common pieces. Concatenate them with & and mix in your own literals — "A" & Match.MultipleDigits matches an "A" followed by one or more digits. Reach for these before hand-writing the equivalent regex.

Characters & escapes

Character classes

Unicode categories available to \p{} / \P{} include letters (L, Lu, Ll, Lt, Lm, Lo), marks (M, Mn, Mc, Me), numbers (N, Nd, Nl, No), punctuation (P, Pc, Pd, Ps, Pe, Pi, Pf, Po), symbols (S, Sm, Sc, Sk, So), separators (Z, Zs, Zl, Zp), and control/format (Cc, Cf).

Anchors & assertions

Assertions match a *position*, not characters — they don't consume any input.

Quantifiers

Groups, alternation & submatches

By default in the current Power Fx engine, plain (...) groups are non-capturing ("explicit capture") — capture only what you need with a named submatch (?<name>...), and reference it with \k<name>. Classic Power Apps defaults to MatchOptions.NumberedSubMatches, where (...) captures and you use \1-style backreferences. Named and numbered captures can't be mixed in one pattern.

With(
    { d: Match( "2026-06-16", "(?<y>\d{4})-(?<m>\d{2})-(?<day>\d{2})" ) },
    // d.y = "2026", d.m = "06", d.day = "16"
    DateValue( d.y & "-" & d.m & "-" & d.day )
)

Power Fx regex constraints

Because one pattern is compiled to both JavaScript and .NET, Power Fx restricts regex to a curated subset that behaves the same on every host. Anything outside it errors at authoring time — which is also why the pattern has to be a constant. Keep these in mind:

• Constant only — the pattern and options can't come from a variable, data source, or user input; build them from literals with & / Concatenate / Char / UniChar.
• Named vs numbered captures can't mix — named is the default in the current engine (plain groups don't capture); numbered is the default in classic Power Apps. Pick one.
• Negated shorthands \D \W \S \P{} can't be used inside a negated class [^…].
• A possibly-empty submatch can't be quantified — (?<x>a*)+ errors, but (?<x>a+)+ is fine. The same applies to optional or alternated submatches that could match nothing.
• No possessive quantifiers or atomic groups, no self-referencing captures ((a\1)), no two groups sharing a name, and no backreference into a look-around or a possibly-empty submatch.
• Surrogate pairs (U+10000 and above) aren't supported inside character classes, and \p{} category data is only guaranteed for the Basic Multilingual Plane.
• `\v` and octal escapes are disallowed — use \x0b and \x / \u codes.

Validation recipes

IsMatch defaults to Complete in Power Apps, so each pattern below validates the whole input — pair it with a text input control. Every pattern is a constant. Patterns are shown as you'd type them in the formula bar.

And(
    Len( txtPwd.Text ) >= 8,
    IsMatch( txtPwd.Text, "\d", MatchOptions.Contains ),       // a digit
    IsMatch( txtPwd.Text, "[a-z]", MatchOptions.Contains ),     // a lower-case letter
    IsMatch( txtPwd.Text, "[A-Z]", MatchOptions.Contains ),     // an upper-case letter
    IsMatch( txtPwd.Text, "[^\w\s]", MatchOptions.Contains )    // a symbol (not word / space)
)

IsMatch(
    txtPwd.Text,
    "(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[^\w\s]).{8,}",
    MatchOptions.Complete
)

Extraction & parsing recipes

Match and MatchAll default to Contains, so they find a pattern anywhere. Capture the parts you want with named submatches and read them by column name.

Match( "Invoice 4471 — due", "\d+" ).FullMatch    // "4471"

// MatchAll returns a table of records:
MatchAll( "loving #powerfx and #lowcode", "#\w+" )

// Flatten to "#powerfx, #lowcode":
Concat( MatchAll( txtPost.Text, "#\w+" ), FullMatch, ", " )

MatchAll(
    "env=prod;region=eus;tier=1",
    "(?<key>\w+)=(?<val>[^;]+)"
)
// each row: { key: "env", val: "prod", FullMatch: "env=prod", StartMatch: 1 }

With(
    { m: Match( "555-1234", "(\d{3})-(\d{4})", MatchOptions.NumberedSubMatches ) },
    Index( m.SubMatches, 1 ).Value & " / " & Index( m.SubMatches, 2 ).Value
)   // "555 / 1234"

Using regex in a Power App

Inline field validation message

If(
    IsBlank( txtEmail.Text ) || IsMatch( txtEmail.Text, Match.Email ),
    "",
    "Enter a valid email address"
)

Enable Submit only when the form is valid

And(
    !IsBlank( txtName.Text ),
    IsMatch( txtEmail.Text, Match.Email ),
    IsMatch( txtPhone.Text, "^\d{3}-\d{3}-\d{4}$" )
)

Colour the border by validity

// Text input BorderColor
If( IsMatch( Self.Text, "^\d{5}$" ), Color.Green, Color.Red )

Common gotchas

• Default scope differs — IsMatch is Complete (whole string) in Power Apps; Match / MatchAll are Contains. Add ^…$ or the explicit option when it matters.
• Pattern must be a constant — no variables or data sources; that's why unsupported syntax errors at authoring time, not run time.
• Named vs numbered captures can't mix — current engine captures only named groups by default; classic Power Apps numbers all groups (\1). Don't combine the two.
• `\D \W \S \P{}` can't go inside `[^…]` — and literal hyphens, leading brackets, and braces must be escaped inside a class.
• `.` skips newlines unless MatchOptions.DotAll — and DotAll / FreeSpacing aren't available in classic Power Apps.
• Look-around can't hold an unlimited quantifier or be quantified — the (?=.*\d) idiom may fail; prefer And() of several IsMatch(…, Contains) checks.
• No regex replace — Substitute() is literal only; rebuild via Match / MatchAll or offload.
• `Match.Email` is a form check, not full RFC validation — and IgnoreCase is culture-invariant.
• Just splitting? Use `Split` — it's simpler and faster than MatchAll.