How do I generate a regex from sample strings without using AI?

Open PDFFlare's regex generator from sample strings, paste 2-5 example strings (one per line), click Generate. The algorithm tokenizes each sample into letter/digit/alnum runs separated by literal punctuation, verifies all samples share the same shape, then emits a generalized regex with character classes and {min,max} length quantifiers. Pure pattern induction — same input always produces the same output. No LLM, no API call, no per-query cost, no rate limits. Compare to ChatGPT-style generators which can produce inconsistent or invalid regex and depend on a remote service.

Is the regex generator deterministic?

Yes — same samples always produce the same regex. The algorithm has no randomness, no AI model, no external service. This means generated patterns are reproducible across teammates, can be regenerated months later from the same samples, and are safe to use in CI pipelines or audit logs. Compare to AI-based generators which produce different output on each run.

How many sample strings should I paste to get a good regex?

Minimum 1, recommended 3-5, no upper limit. With 1 sample you get a fixed-length regex matching exactly that shape. With 2-5 samples the algorithm finds the union character class (lowercase only? mixed case? alphanumeric?) and the min/max length range — that's the sweet spot. With 10+ samples the min/max quantifier becomes tighter but no fundamentally better generalization. Always include edge cases (shortest, longest, special characters) so the generated regex covers them.

Why does the generator say 'sample N has a different shape'?

All samples must share the same structural shape — same number of letter/digit/alnum runs in the same order, separated by the same literal characters. Sample 'alice@example.com' has shape [letter]@[letter].[letter]; sample '12345' has shape [digit]. Different shapes can't be combined into a single clean regex without alternation, which the generator deliberately avoids. Fix: split samples by shape, generate a regex for each group, combine manually if needed.

Will the generated regex match new strings I haven't shown it?

Yes, by design. The generator emits a generalized pattern, not a literal match for your exact samples. If you paste 3 ISO dates, the output \d{4}-\d{2}-\d{2} matches any 4-digit year + 2-digit month + 2-digit day pattern, including dates you didn't show. To verify the regex doesn't over-match (false positives), click Open in Regex Tester after generating and paste a longer test string with both valid and invalid examples — the live highlighting will show you exactly what gets matched.

May 8, 202610 min read

Regex Generator from Sample Strings: Build Regex (2026)

You have the data, you don't have the regex. Five email addresses, ten log timestamps, fifty internal ticket IDs — all clearly the “same shape” and you need a pattern that matches them. The lazy fix is to copy/paste the first one as a literal regex; the slightly-better fix is to ask ChatGPT and pray; the honest fix is a regex generator from sample strings that infers the pattern by walking through your data deterministically — no AI hallucinations, no API dependency, same input always produces the same regex.

In this guide you'll learn how to use PDFFlare's regex generator online to turn a handful of example strings into a working regex — call it a regex builder from text, an auto regex generator, a regex inference tool, or a regex from sample data engine; same idea, several names. You'll also see the algorithm itself (so you understand when it works and when it fails), how it compares to AI-based regex generators, and the workflow of generate → refine in the Regex Tester → ship to your codebase.

What a Regex Generator from Sample Strings Actually Does

A regex generator from sample strings takes 2-5 (or more) example strings and emits a regex that matches all of them, plus other strings of the same shape. PDFFlare's implementation uses pattern induction regex inference — it walks each sample character by character, identifies runs of letters / digits / alphanumerics, treats non-alphanumeric characters as literal anchors, then generalizes each run into a character class with a min/max length quantifier. No AI, no language model, no remote API. Same input always produces the same regex, which means you can rely on it in CI pipelines, share generated patterns with teammates, and reproduce results a year from now.

The killer feature is what the algorithm DOESN'T do — it doesn't guess. If your samples have different structural shapes (one has an @ where another has -), the generator reports a clear shape-mismatch error and stops. Compare to ChatGPT, which will confidently produce a wrong regex without telling you it's wrong. PDFFlare either gives you a verifiably-correct regex or refuses with a specific error pointing at the outlier sample.

How to Use the Regex Generator (Step by Step)

Paste 2-5 sample strings, one per line. For best results, include edge cases — your shortest example, your longest example, and a representative middle case. The min/max length quantifier is computed from your samples, so showing the full range matters.
Click Generate regex. PDFFlare tokenizes each sample, verifies all samples share the same structural shape, and emits a generalized regex with character classes and {min,max} quantifiers. The whole operation runs in your browser in under 10ms.
Verify the sample match check. The generator runs the regex against your originals — every sample should show ✓. If any show ✗, the regex needs tighter samples (paste more representative examples).
Click Open in Regex Tester.The generated pattern deep-links into PDFFlare's full Regex Tester with live highlighting, capture groups, code output for 10 programming languages, ReDoS detection, and substitution mode. Test against more real data, refine, and copy paste-ready code into your codebase.

The Algorithm in Plain English

PDFFlare's regex generator from sample strings runs four passes over your input:

Tokenize.Walk each sample character by character. Group consecutive letters into a “letter run,” consecutive digits into a “digit run,” mixed alphanumerics into an “alnum run.” Treat each non-alphanumeric character (@, ., -, /, etc.) as a literal anchor. Track whether each run has uppercase, lowercase, or both.
Verify shape. Compute a structural key for each tokenized sample: the sequence of run types and literal characters in order. If sample 1 isletter @ letter . letter and sample 2 isletter @ letter . letter . letter, the keys differ — the generator reports a shape mismatch and stops. Better to fail loudly than emit a wrong regex.
Generalize. For each run position across samples, compute the union character class (lowercase only → [a-z]; mixed case →[a-zA-Z]; digits → \d; mixed → \w) and the length range (same length → {N}; varying → {min,max}).
Emit. Concatenate the generalized character classes with the literal anchors in order, escaping regex metacharacters. The output is a ready-to-use regex that matches every input sample plus other strings of the same shape.

Real Examples — How to Generate Regex from Examples

How to generate a regex for email validation from sample addresses

Paste three sample emails: alice@example.com, bob.smith@test.io, charlie+work@sub.domain.co.uk. The generator outputs a regex like [\\w.+-]+@[\\w-]+\\.[\\w-]+\\.[\\w-]+ (exact form depends on your samples). It catches every email shaped like your samples — local part with letters, digits, dots, plus signs, hyphens; an @; domain parts with letters and hyphens; one or more dots with TLD parts. For 99% of forms, the generated simple version is what you want — a perfect RFC 5322 email regex is hundreds of characters and almost never worth it.

How to generate a regex for ISO dates from a few examples

Paste 2024-01-05, 2026-12-31,2025-06-15. The generator outputs \d{4}-\d{2}-\d{2}. Same length across all samples → fixed quantifiers. Note the literal hyphens are preserved as anchors. To match dates inside a longer string (not just standalone), open in Regex Tester after generating and remove the implicit anchors or wrap the pattern with \b word boundaries.

How to generate a regex for log file timestamps

Log timestamps are PERFECT for sample-based generation because they're fixed-format and you have millions of examples in your log files. Paste 2026-05-08 14:30:22, 2026-05-08 14:31:05, 2026-05-08 14:31:47. Generator outputs \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}. Drop into your log parser. Pair with the substitution mode in the Regex Tester to transform timestamps to another format (e.g., into Unix epoch, paired with PDFFlare's Timestamp Converter).

How to generate a regex for internal ticket IDs

Your company's ticket IDs are ORD-2024-A1B2, ORD-2025-X9Y8,ORD-2026-Q4R7. No published regex spec anywhere. Paste them, generate, get [A-Z]{3}-\d{4}-[A-Z0-9]{4}. Now you have a regex you can use for validation and extraction across your data warehouse, internal API gateway, or audit logs. The same algorithm works for SKUs, batch numbers, request IDs, transaction codes — any internally-shaped identifier with no public spec.

How to generate a regex when samples have varying lengths

Paste samples of different lengths but same shape: alice (5), bob (3), charlotte (9). Generator outputs [a-z]{3,9} — character class derived from the actual chars used (all lowercase letters in this case), length range from min to max across samples. The min/max quantifier is what makes sample-based generation more useful than a literal-match approach: the regex matches your originals AND new strings within the observed length range.

When Sample-Based Generation Works (and When It Fails)

Works great for:

Regularly-shaped data: emails, dates, timestamps, ticket IDs, postal codes, phone numbers in fixed format, hex hashes, MAC addresses, semver, file extensions.
Reverse-engineering an undocumented format: internal SKUs, batch numbers, log line prefixes, output of legacy systems with no schema.
Data extraction from logs: grep one example line, paste 3-5 variations, generate, run on the full log file.

Doesn't work for:

Free-form text:anything where the same logical field can have multiple shapes (a “phone number” field that contains 415-555-1234, +1 415 555 1234, and 4155551234 all in the same dataset). Solution: split into shape groups, generate per group, combine with alternation.
Optional segments:if some samples have a middle component and others don't. The structural shape differs, so the generator reports a mismatch. Solution: pre-classify samples by presence of the optional component.
Semantic validation:the generator doesn't know that 02-30-2026 is an invalid date — it just sees \d{2}-\d{2}-\d{4}. For semantic checks (calendar validity, checksum digits, Luhn validation), you need post-regex logic in your code.

Generator vs ChatGPT vs Hand-Written Regex

vs ChatGPT / Claude / autoregex.xyz: AI-based regex generators take natural-language intent (“match all email addresses”) and produce a regex. PDFFlare's generator takes concrete sample data and produces a regex. Different inputs, different tradeoffs. AI is more flexible but produces inconsistent output between runs and can be confidently wrong. PDFFlare is deterministic and verifiable but requires you to have actual samples — not an issue if you have the data, a blocker if you don't.

vs hand-written regex from memory: Hand-written regex is fastest IF you already know the right pattern. The generator is faster when you don't — paste samples, generate, refine. The generator's real value is in unfamiliar territory: weird internal identifiers, log formats you've never seen, exports from systems with no documented schema.

vs preset libraries (PDFFlare's 40+ built-in patterns):If your data shape is one of the common ones (email, URL, IPv4, UUID, credit card), PDFFlare's preset library in the Regex Tester is even faster than generating from samples. Check the presets first; reach for the generator when your shape is custom.

Privacy: Run Locally

PDFFlare's regex generator from sample strings runs entirely in your browser. The tokenization, shape comparison, and regex emission all happen client-side via plain JavaScript — no server, no API call, no log. Open DevTools → Network and you'll see zero requests while you generate. Safe for samples drawn from confidential data: production database rows, internal customer records, log files with PII. Recent generations are saved in your browser's localStorage; the actual sample input is NEVER persisted.

Common Mistakes

Pasting samples with different shapes and expecting the generator to figure it out. It won't — it'll report a shape mismatch. Pre-classify your samples by shape first.
Pasting only one sample and expecting generalization. With a single sample, the generator emits a fixed-length regex matching exactly that shape. Paste 3+ samples for proper generalization.
Skipping the sample match verification after generating. The ✓/✗ check at the bottom of the result is your sanity check — if any sample shows ✗, the regex is wrong, fix the samples.
Trusting the generated regex without testing on real data. The regex matches your samples; it may not match the rest of your dataset. Always click Open in Regex Tester and run against a larger test string.

Related Tools

Regex Generator — paste samples, get a regex. The tool this post describes.
Regex Tester — paste a regex (or load one from the generator), test against larger data, copy paste-ready code for 10 languages.
JWT Decoder — decode JWTs (which you might want to validate with a generated regex first).
Timestamp Converter — convert log timestamps you extracted with a generated regex to Unix epoch.

Wrapping Up

A regex generator from sample strings closes the loop between “I have data” and “I have a regex.” Deterministic pattern induction means reproducible output, no AI dependency, no per-query cost, and clear failure modes when the algorithm can't generalize. Pair with PDFFlare's Regex Tester for the full workflow: generate from samples, verify against more data, copy paste-ready code, ship.

Open PDFFlare's regex generator from sample strings — paste 2-5 examples, click Generate, get a working regex. Free, browser-based, no signup, no upload, no AI.