How does the inference work?

Each line is tokenized position-by-position into character categories (digit, letter, whitespace, punctuation, literal). Adjacent runs of the same category collapse with min/max length quantifiers — for example three samples of 3, 4, and 5 digits become \\d{3,5}.

Will the generated regex match strings I did not provide?

Often yes — the inferred pattern is intentionally a generalization, not an alternation of literals. Add more diverse examples (including edge cases) to tighten the result.

Does the tool send my samples anywhere?

No. Inference runs entirely in your browser. Samples and inferred patterns stay local.

infer · samples · auto-pattern

Build a regex from example strings

Paste lines that should all match, and the inferrer guesses a pattern using character classes and length ranges. Runs locally.

Regex from Samples

Samples

non-empty

Matches

verified

Mismatches

failing

Status

ready

live

input · one sample per line

output · pattern + verification

Inferred pattern

/^[a-z]{3}-\d{3}$/

Verification

okabc-123

okxyz-456

okfoo-789

Quick Start

How to infer a regex from samples

Paste lines that should all match, and the inferrer guesses a pattern by reading character classes and run-lengths.

01
Paste samples
Drop one example per line. Every line should be something the final regex must match.
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 · literalsamples · regex
abc-123 xyz-456
loaded · ECMAScriptPCRE · ready
02
Read the guess
The pattern uses \d, [a-z], [A-Z] and friends, plus quantifiers chosen from the shortest and longest runs.
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 · optionspattern · flags
^[a-z]{3}-\d{3}$
flags applied · liveECMA · live
03
Verify each line
Every sample gets a ✓ or ✗. If anything fails, edit it and the pattern re-infers.
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 · outputverify · matches
✓ abc-123 ✓ xyz-456
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 start from examples

Inferring a pattern beats staring at an empty editor.

Bootstrap a validator

Skip the blank page and start from real examples. 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

Learn regex

See how a tool infers \d{3} from "123" and "456". 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

Audit a format

Paste your codes — find out if the format is consistent. 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

Compare formats

Mix shapes in one input to see how loose the guess gets. 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

Document expectations

Drop the inferred regex into a spec or README. 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

Catch outliers

An ✗ tells you a line breaks the pattern of the rest. 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

How accurate is the guess?

It's a heuristic — good for uniform formats like IDs, codes, and dates. Complex grammars need a hand-written regex.

Do you escape special chars?

Yes — anything in the punctuation class is regex-escaped automatically.

What about case?

Lower- and uppercase letters become [a-z] / [A-Z]. Mixed runs widen to [A-Za-z].

Can I copy and tweak?

Yes — the toolbar Copy button grabs the pattern. Refine it manually in the Regex Tester.

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!