How do I reference capture groups in the replacement?

Use $1, $2 and so on for numbered groups, $& for the entire match, and $$ for a literal dollar sign — the same syntax as JavaScript String.replace.

What do the flags do?

Global (g) replaces every match instead of just the first; ignore-case (i) makes matching case-insensitive; multiline (m) makes ^ and $ match line boundaries; dotall (s) lets the dot match newlines.

Is my text uploaded anywhere?

No. The regular expression runs through your browser's built-in JavaScript engine, so your pattern and text stay on your device.

Why does only the first match get replaced?

Without the global flag, regex replace stops after the first match. Turn on the global (g) flag to replace every occurrence in the text.

Can I use named groups or lookbehind?

Yes, the tool uses the modern JavaScript regex engine, so named groups (? ...), lookahead, and lookbehind are supported in patterns. In the replacement you can reference numbered groups with $1, $2 or named groups with $ .

What does the match count tell me?

It shows how many times the pattern matched the input, which is a quick way to confirm your expression is hitting the intended spots before you trust the replaced output.

My pattern is not matching — what is wrong?

Common causes are forgetting to escape special characters (. + * ? etc.), missing the global flag for multiple matches, or needing the multiline (m) flag for ^ and $ to match line boundaries. Adjust the flags or escape the literals.

What is the Regex Replace Tool?

Free regex find-and-replace tool — test a regular expression against your text and apply a replacement with capture-group references like $1 and $2. Toggle global, ignore-case, multiline and dotall flags. Everything runs in your browser, nothing uploaded. It runs free in your browser on Gera Tools, with nothing uploaded.

Regex Replace Tool — Gera Tools

Name: Regex Replace Tool
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click unsubscribe any time.

A focused regex find-and-replace tool: enter a pattern, a replacement string, pick your flags, and watch the substituted output update live. Capture-group references let you reorder and reshape matched text — ideal for reformatting dates, cleaning data, bulk-editing code, and one-off text transformations.

How it works

The tool builds a JavaScript RegExp from your pattern and the flags you select, then runs String.replace against your input. In the replacement string you can use the standard substitution tokens: $1, $2 for the first, second numbered capture group, $& for the whole match, $<name> for a named group, and $$ for a literal dollar sign. The flags control matching: g (global) replaces every match instead of just the first, i ignores case, m (multiline) makes ^ and $ match at line breaks, and s (dotall) lets . match newlines. A live match count confirms how many replacements were applied.

Replacement token reference

Token	Meaning	Example
`$1`, `$2`, …	Numbered capture groups	`(\d+)` → `$1`
`$&`	Entire match	prefix: `$&_copy`
`$<name>`	Named capture group	`(?<year>\d{4})` → `$<year>`
$`	Text before the match	rarely needed
`$'`	Text after the match	rarely needed
`$$`	Literal dollar sign	escape a `$`

Worked examples

1. Reformat ISO dates to day/month/year

Find: (\d{4})-(\d{2})-(\d{2}) (global flag on)
Replace: $3/$2/$1
Input: 2026-05-28 and 2025-12-01
Output: 28/05/2026 and 01/12/2025

2. Extract and reorder name parts

Find: (\w+),\s+(\w+) (global)
Replace: $2 $1
Input: Smith, John → Output: John Smith

3. Wrap all numbers in brackets

Find: \d+ (global)
Replace: [$&]
Input: There are 3 cats and 12 dogs.
Output: There are [3] cats and [12] dogs.

4. Strip HTML tags

Find: <[^>]+> (global)
Replace: “ (empty string)
Input: <b>Bold</b> and <i>italic</i>
Output: Bold and italic

Common mistakes to avoid

Forgetting the global flag — without g, only the first match is replaced. Turn it on for any bulk substitution.
Not escaping dots — . matches any character in a pattern. A literal period needs \..
Using $1 when there is no group — if your pattern has no capturing parentheses, $1 pastes literally. Add a group around what you want to reference.
Confusing $& with $0 — JavaScript uses $& for the whole match, not $0 (which is not a valid token in the replacement string).

Patterns use the standard JavaScript engine, so what works here works in your code. Nothing is uploaded; all matching happens in your browser.