Find & Replace
Advanced text search with regex support, live preview, and replacement history.
100% private100% private
Search and replace across a block of text with literal-string, case-insensitive, or full regex modes — and a live preview showing every match before you commit. Capture groups in replacements ($1, $2) are supported for the kind of structural changes that go beyond a one-to-one swap. Useful for batch-fixing product descriptions, normalising terminology in a long document, or reformatting log files. Everything happens client-side, so confidential text never leaves your tab.
Processed in your browser — your text never leaves your device.
No matches
Next steps
Text Cleaner
RecommendedFix messy text in one click — collapse extra spaces, blank lines, and tabs.
Text Diff
RecommendedPaste two texts and instantly see what changed between them.
Case Converter
Switch text between uppercase, lowercase, title case, and more.
Remove Duplicates
Clean up lists by removing duplicate lines — keeps original order.
Runs right inside your browser tab. No uploads. Your files stay private.
How Find and Replace Works in This Tool
Find and Replace is a thin UI on top of the browser's native RegExp engine. Every search compiles a JavaScript RegExp object with the global flag 'g' (and 'i' when case-insensitive is on), then walks the input with regex.exec() in a loop to collect every match index. Plain-text mode escapes regex metacharacters before compiling so that dots, parentheses, and dollar signs are treated literally.
Whole-word mode wraps your query with the \b word-boundary anchor on both sides. That works as expected for ASCII identifiers but has known gaps with Unicode: \b is defined against [A-Za-z0-9_], so a search for 'caf' inside 'cafe' counts as a word boundary against the 'e' even when the trailing letter is accented (cafe vs café). For non-Latin scripts, whole-word and exact-phrase matching are unreliable; fall back to regex mode with explicit character classes for those cases.
Regex mode passes your pattern straight to new RegExp(), so most of the JavaScript flavor is available: alternation, character classes, lookaheads and lookbehinds, capture groups, and named groups. Patterns compile with the 'g' flag (plus 'i' when case-insensitive), but not the 'u' flag, so Unicode property escapes like \p{Letter} are not supported here — use explicit character classes or ranges instead. Capture groups can be referenced in the replacement as $1, $2, and so on. An invalid pattern surfaces the engine error message inline rather than crashing the page.
Preserve-case mode inspects the original match before replacing: ALL CAPS matches become ALL CAPS replacements, Title Case matches become Title Case replacements, lowercase stays lowercase, and mixed case falls back to the literal replacement string. This is helpful when renaming a term that appears at the start of sentences as well as inside them.
Ignore-extra-spaces builds a flexible regex that allows any run of whitespace (\s+) wherever your query has a single space. Match indices are calculated against the original text so highlights line up correctly even though the underlying pattern was loosened. This is the right choice when copy-pasting from PDFs or Word documents that introduce stray spaces.
Live preview, replace history, and the side-by-side or output-only view are all client-side state. Settings and the last twenty replace operations persist via localStorage under 'find-replace-settings' and 'find-replace-history' keys, so your preferences survive a reload without anything ever reaching a server.
Performance is dominated by regex.exec rather than rendering. Inputs in the multi-megabyte range are still interactive, but pathological patterns (catastrophic backtracking with nested quantifiers like (a+)+) can hang the tab — that is a property of every JavaScript regex engine, not specific to this tool. If a pattern looks slow, anchor it with ^ or $ where possible, or simplify the alternation.
Common Use Cases
01
Bulk variable rename
Toggle whole-word mode and replace 'userId' with 'accountId' across a pasted code block without touching 'userIdList' or 'userIdentifier'.
02
Date format migration
Use regex (\d{2})/(\d{2})/(\d{4}) and replacement $3-$1-$2 to convert MM/DD/YYYY dates into ISO-8601 YYYY-MM-DD across a CSV column.
03
Stripping HTML tags
Run the regex <[^>]+> with an empty replacement to remove every angle-bracketed tag from copied web content while keeping the text.
04
PII redaction
Replace email addresses with [REDACTED] using the regex [\w.+-]+@[\w.-]+\.[A-Za-z]{2,} before sharing logs externally.
Frequently Asked Questions
Whatever the browser's JavaScript engine implements: alternation, lookaheads, lookbehinds, named groups, and backreferences. The 'g' flag is always on; 'i' is added when case-insensitive is enabled. Patterns compile without the 'u' flag, so Unicode property escapes (\p{...}) are not available. Patterns are compiled with new RegExp() and any syntax error is shown inline.
Standard JavaScript replacement syntax: $1 through $9 reference numbered groups, $& references the entire match, and $$ inserts a literal dollar sign. Named groups are supported via $<name>. Capture groups only fire in regex mode; in plain-text mode the replacement string is used verbatim.
It wraps your query with \b on both sides. \b is a zero-width assertion at the boundary between a word character (A-Z, a-z, 0-9, underscore) and a non-word character. That means searches for ASCII identifiers behave correctly, but accented characters and CJK text are treated as word boundaries because they fall outside the \w class.
It detects whether the matched text is ALL CAPS, Title Case, or all lowercase, then applies the same casing pattern to the replacement before inserting it. Use it when the same term appears at the start of sentences and inside them, and you want both forms updated without writing two separate find-replace passes.
Each space in your search query is replaced with \s+ inside the compiled regex, so any number of whitespace characters (including newlines and tabs) will satisfy that position. Match indices still point to the original text so highlighting and replacement length stay accurate.
JavaScript's regex engine is backtracking, which means nested quantifiers like (a+)+ on long inputs can hit catastrophic backtracking and freeze the tab. Anchor patterns with ^ or $, prefer atomic alternatives, and avoid overlapping quantifiers. That behavior is engine-wide, not unique to this tool.
No. Both settings and the last twenty replace actions are written to localStorage in your browser. The keys are 'find-replace-settings' and 'find-replace-history'. Clear them by clicking History then the trash icon, or via DevTools > Application > Local Storage.
Yes. Each replace creates a history entry with the original find and replace strings and the count. Click an entry to reload that pattern, but the tool does not auto-revert the text — copy the original input back from the History panel or paste it again.
Yes, with caveats. Match collection is O(n) for simple patterns, so logs in the low megabyte range stay interactive. The render layer caps highlight rendering above a threshold to keep scrolling smooth; the underlying replace still runs over the full text.
The regex engine treats the input as a single string, so . does not match newlines. To match across line breaks in regex mode, use the pattern [\s\S] in place of a dot. ^ and $ match the start and end of the whole string. JavaScript does not support inline flag groups like (?s) or (?m) — they throw a syntax error — and this tool does not expose the 's' or 'm' flags, so use [\s\S] for dot-all behavior.