Do the rules apply to the original text or to the running result?

Each rule runs against the output of the previous rule — a pipeline. That means earlier substitutions can feed into later patterns, which is useful for staged cleanup but can cause surprises if a later rule re-matches an earlier replacement.

Can I disable a rule without deleting it?

Yes — toggle a rule off and the pipeline skips it while preserving its definition.

Is my text or rule list uploaded?

No. The whole pipeline executes locally in the browser. Rules and text never leave your device.

bulk regex · chained rules · per-rule counts

Apply many regex replaces in one pass

Define a list of pattern/replacement rules and watch the text flow through every step. Per-rule counts and errors update live.

Bulk Regex Replace

Rules

in order

Replacements

total

Errors

clean

Output

75 B

after

input · rules + sample

Rules (applied in order)

#12x

#22x

output · result (4)

Order [id:1234] placed on 18/05/2026. Order [id:5678] placed on 17/05/2026.

Quick Start

How to chain bulk regex replacements

Define a list of pattern/replacement rules; each runs in order against the running output.

01
Add rules
Each rule is pattern + flags + replacement. Use + Add to append, drag handles to reorder.
Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.
patternECMAScriptliterallive
input · literalrules · regex
#(\d+) -> [id:$1]
loaded · ECMAScriptPCRE · ready
02
Type text
Drop sample text in the input panel. Rules cascade top to bottom.
Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.
flagsoptionsg · i · mlive
config · optionstext · flags
Order #1234
flags applied · liveECMA · live
03
Inspect counts
Per-rule replacement counts surface inline. Errors highlight in red.
Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.
matchgroupshighlightReDoS-safe
run · outputstats · matches
2x · 4x
matches · livegroups · live
04
Copy or export
Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.
Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.
copyexportclipboardblob
export · exportedready · saved
Copied
ready to shipsuccess

Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren’t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Use Cases

When to chain replacements

Anywhere a single regex isn't enough.

Sanitize logs

Strip secrets, rotate IDs, rewrite paths in one pipeline. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Migration scripts

Translate identifiers, API calls, or markup across a file. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

Build datasets

Normalize free-form text into a single canonical shape. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Refactor code

Run dozens of safe rewrites at once. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Strip markup

Remove tags, scripts, and noise with chained passes. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Mock data

Anonymize names, emails, and IDs in one shot. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready

FAQ

Frequently asked questions

What runs first?

Rules execute top to bottom on the running output, so later rules see the result of earlier ones.

Can I disable a rule?

Clear its pattern. Empty pattern rules are skipped.

Are replacements live?

Yes — every keystroke re-runs the pipeline and updates counts and errors.

What about named groups?

Yes — use $<name> in any rule's replacement and named captures are looked up correctly.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!