RegEx String Generator

About Reverse RegEx

What is this?

I assume you've used regular expressions before, so, for example, to find "cat" or "dog" in a text with the pattern (cat|dog) is a common thing for you. Well, what you can do here is the exact opposite. Instead of finding text, you'll create strings by following the conventions and grammar of traditional regular expressions syntax. That said, the aforementioned expression would then generate either "cat" or "dog" (try it). Another example would be \w{5} to generate something like "3YWEp" ... you got the idea.

Just start by entering some regex pattern in the input field below.

Informations, HowTo & API-access | Regex quick reference | Changelog

Note: Infinite, greedy quantifiers like + or * are limited to a max of 100. For fixed quantifiers in curly braces, the max value (in case you didn't specify) is min value + 100 (so {2,} results in a number between 2 and 102).
One more info: use the backslash to escape a character to make it literal and remove any special meaning.

Pattern	Example(s)	Explanation
`Text`	Text	Just plain text
`(A\|B\|C)`	A B C	Group separated by `\|` pipe - one out of "A", "B" or "C"
`[abc]`	a b c	Character class - you'll get one of the characters inside the brackets.
`[A-Fx-z3-4]{10}`	zAFAyz3DzA 43yD3zAFBA CzDyCzxABz	Character class with specified range and length (A-F, x-z or 3-4 repeated 10 times).
`\w`	B f 7	An alpha-numerich character (A-Z, a-z, 0-9 and "_").
`\d`	2 9 5	Digit (0-9)
`\W`	? $ &	Non-alpha-numeric character (NOT A-Z, a-z, 0-9 or "_")
`\D`	G % #	Non-digit (any char except 0-9)
`cats?`	cat cats	Quantifier - repeats the previous token(s) 0 or 1 times (same as `{0,1}`).
`a+`	a aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa	1-or-more quantifier (same as `{1,}`).
`a*`	aaaaaaaaaaaaaaaaaaaaa aa	0-or-more quantifier (same as `{0,}`).
`a{3}`	aaa	Exact quantifier.
`a{2,4}`	aa aaa aaaa	Fixed quantifier within specified range (2, 3 or 4).
`a{3,9,3}`	aaa aaaaaa aaaaaaaaa	Quantifier ranges with step. You can add 3 values separated by comma to specify the 1) start, the 2) end and 3) the step. The example pattern generates "a" either 3, 6 or 9 times. Note: this is not a feature of traditional regular expressions.
`a{1\|2\|7}`	a aa aaaaaaa	Multiple exact specified quantifiers (like groups work). Separated by `\|` pipe, one of those options will be picked and used as quantifier. Note: you can mix the quantifiers in combination. Example: `\\|{3,9,3\|1\|50,51}` would generate the `\|` pipe character 1, 3, 6, 9, 50 or 51 times. Note: this is not a feature of traditional regular expressions.
`#0,100,10`	0 10 20 ... 90 100	Number ranges with steps. Format: `#<start>,<end>,<step>` Note: this is not a feature of traditional regular expressions.
`~Hello`	lleHo oHlel Helol lolHe ...	Shuffles strings. Format: `~<string>`. Note: this is not a feature of traditional regular expressions.
`.x0,10FFFF`{50}	A 6 𣑣 ~ 🍃	Unicode range. Format: `.<min>,<max>` or `.x<min>,<max>` as hex. Note: this is not a feature of traditional regular expressions.
`(A\|B\|C) repeat: \1`	C repeat: C A repeat: A B repeat: B	Backreference. Refers to the result of a previous group (in this case to group 1). Note: you'll always get the same result that was produced by the actual group.
`(A\|B\|C) or: \g1`	A or B C or B A or A C or A B or B ...	Backreference. Refers to a previous group (in this case to group #1 and parses this group again. Note: you'll always get a "different" result because the referenced group will be re-parsed again.
`.`	a G 9 %	"Any" character
`\( \] \\| \?`	( ] \| ?	Escapes a character and removes any special meaning.

POSIX character classes

Character class	Explanation
Default POSIX character classes
`[:alpha:]`	Any letter, so `[a-zA-Z]`
`[:upper:]`	Uppercase letters, so `[A-Z]`
`[:lower:]`	Lowercase letters, so `[a-z]`
`[:digit:]`	Any digit, so `[0-9]`
`[:alnum:]`	Any alphanumeric character, so `[a-zA-Z0-9]`
`[:xdigit:]`	Any hexadecimal digit, so `[0-9A-Fa-f]`
`[:space:]`	Tab, newline, vertical tab, form feed, carriage return or space, so `[\t\r\v\n ]`
`[:blank:]`	Space or tab, so `[\t ]`
`[:print:]`	Any visible/printable characters (from dec ascii char 32 to 126, each including), so `[ -~]` or `[\x20-\x7E]` or `[\#32-\#126]`
`[:punct:]`	Any of those characters: `!'#S%&'()*+,-./:;<=>?@\[/]^_{\|}~`
`[:word:]`	Letters, digits and underscore, so `[a-zA-Z0-9_]`
Additional character classes that are not a feature of traditional regular expressions:
`[:umlaut:]`	Umlauts, so `[äöüÄÖÜ]`
`[:-umlaut:]`	Lowercase umlauts, so `[äöü]`
`[:+umlaut:]`	Uppercase umlauts, so `[ÄÖÜ]`
`[:vowel:]`	Vowels, so `[aeiouAEIOU]`
`[:-vowel:]`	Lowercase vowels, so `[aeiou]`
`[:+vowel:]`	Uppercase vowels, so `[AEIOU]`
`[:consonant:]`	Consonants, so `[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]`
`[:-consonant:]`	Lowercase consonants, so `[bcdfghjklmnpqrstvwxyz]`
`[:+consonant:]`	Uppercase consonants, so `[BCDFGHJKLMNPQRSTVWXYZ]`

How to use

Just write your RegEx pattern and click the Generate button or press Enter.
Optional: set how many results you want to generate (default is "10", max. is 100)
Optional: instead of writing your own pattern, try some of the pre-defined example pattern templates from the dropdown below.
You can save your pattern after generating the results via the Save button below. This will then generate a unique URL for your pattern. If you change something later and save it again, version #2 will be created automatically (and version #3 after that and so on ..). You can then switch between all of your revisions. Here is an example.

Notes & restrictions

There are some restrictions in this online tool, check what you can or can't do.

Server-side processing runs for a maximum of 4 seconds.
Amount of generated results per request is limited to 100
Your Regex pattern string is limited to 2,048 - if your pattern is longer, the rest will be cut off.
Max quantifier in pattern is 1,000.
Max single result length is limited to 2,000.

Request via API

You can use RegEx String Generator via API as well.

API-URL: https://regex.xmgr.de/api/get?p=<PATTERN>&q=<QUANTITY>

Set the pattern via GET parameters in p key and the amount of results in the q key.
» Note: you can also use long parameters, so pattern for pattern and quantity for quantity.

Note: you can also provide the pattern in the raw request body, which is more flexible.

You can also set the format you'd like to receive the results via https://regex.xmgr.de/api/get/<FORMAT>, while format can be one of the following values:

json
Returns the results as JSON-string.
Example: https://regex.xmgr.de/api/get/json?p=\w{50}&q=10
Note: you can view details and furher informations by passing details via GET. This will then output not only the results but also some hashes of your results (e.g. md5, sha1, sha512, ...), base64-encoded version, string- and byte-length and hexdump.
Example: https://regex.xmgr.de/api/get/json?p=\w{50}&q=10&details=1
csv
Output comes as valid CSV string with 3 columns (result, byte-length and string-lenght)
Example: https://regex.xmgr.de/api/get/csv?p=\w{50}&q=10
concat
Concatenates the results by a specified delimiter (set delimiter (or d) in GET parameters)
Example: https://regex.xmgr.de/api/get/concat?p=\w{50}&q=10&d=;
html
Output is generated as HTML document with an un-ordered list of result strings.
Example: https://regex.xmgr.de/api/get/html?p=\w{50}&q=10
html-table
Output is generated as HTML document with a table of results.
Example: https://regex.xmgr.de/api/get/html-table?p=\w{50}&q=10

If you don't specify a special format, the resulting output is just a list of strings separated with an \n line-break (default Unix line feed).

Raw HTTP request

cURL

wget

PHP cURL

Changelog

See what features have been added or improved and what bugs were fixed over time.

Type	Content
Release*v2 2020-02-05	This tool has been rewritten completely, which results in much better performance. Most of all actions are at least 2 times faster, some operations up to 4x (Unicode ranges in character classes) and some even 20x faster than version 1.
Feature 2019-12-27	Better character class ranges. You can specify ranges by character, by hex notation, by decimal notation and by unicode notation. For example, to define a range between dec 40 and dec 72 (characters `(` to `H`) you can write decimal `[\#40-\#72]` or hex `[\x28-\x48]` or plain characters `[(-H]` or unicode notation `[\u+{0028}-\u+{0048}]` (or more simple `[\u28-\u48]`)
Feature 2019-12-04	Unicode-, hex-, character- and decimal-ranges in character class. Example: `[\u{2000}-\u{4000}]{20}` produces something like `ℂ⑤☣◐⹑⭢ⅴ⏆⠁◽Ⲅ⥼⡩≸⦯⋵⊉❎Ⓧⳉ♩Ω♃⒧⬬` and `[\u{1F600}-\u{1F64F}]{20}` makes emojis like `🔪🔑🖯💾🕩💔🗩👼👸🏵🕅🔡🐼🗭📽🕛🐳💄🖂📣`. » Try it yourself. Example: You could either write `\U+1F642` or `\xF0\x9F\x99\x82` to make the emoji 🙂 (which has a size of 4 bytes) - or you could just paste this symbol as is. See Unicode table for details.
Feature 2019-11-23	Added some POSIX character classes like `[:alnum:]`, `[:xdigit:]` and some more. Check the quick reference to see all supported classes. You'll find details here and here.
Feature 2019-11-19	Support for multiple exact specified quantifiers (like groups work). Example: `X{2\|8}` produces either "XX" or "XXXXXXXX", `X{1\|3\|5}` makes "X", "XXX" or "XXXXX". Note: this isn't a feature of traditional regular expressions syntax.
Feature 2019-10-26	Support for Unicode characters: try `\uaf31` to display "꼱". Different formats are supported like `\U+af31` or `\U{af31}` or even `\u+{af31}`. Note: it's better to use the curly braces as delimiters to avoid mixing your stuff. For example, `\u48AF` is the character 䢯, but you may just wanted the unicode `\u48` (which is a "H") followed by "AF". For that, the curly brace delimiter works just fine, so `\u{48}AF` produces "HAF" then.
Bugfix 2019-10-25	Special characters and unicode characters can be used natively. `[€µéÉèÈáÁàÀúÚùÙóÓòÒíÍìÌêÊâÂîÎôÔûÛ´°äöüßÄÖÜ]{50}`
Feature 2019-10-17	Support for decimal char-code notation, example: `\#66` makes a "B" and `\#72\#101\#108\#108\#111\#032\#087\#111\#114\#108\#100\#033` makes "Hello World!"
Feature 2019-10-17	Support for hex notation, example: `\x42` makes a "B" and `\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21` makes "Hello World!"
Bugfix 2019-10-11	Removed unnecessary redundant escape backslashes from special chars (produced too many literal `\` backslashes)
Performance 2019-10-04	Avoided unnecessary recursive calls.
Bugfix 2019-09-23	Fixed: when group is named, backreference via numeric index isn't possible.
Feature 2019-09-02	Added named groups like `(?<name>pattern)` that are accessible via `\k{name}` (fixed result) or `\g{name}` (re-parse)

Bugfix 2019-08-26	Fixed error on mutually exclusive patterns like `[^\w\W]`
Release*v1 2019-08-24	RegEx String Generator v1

Type Regex pattern (Press Enter to generate)

Amount of results

Generate strings Generate

Or: try some pre-defined example Regex pattern templates

Optional: Options for results