Overview
Regex Tester compiles `pattern` with JavaScript's built-in RegExp engine and `flags` (any of g, i, m, s, u, y), so syntax follows ECMAScript rules: lookbehind and named groups work, while PCRE-only features such as possessive quantifiers do not. `pattern` is limited to 500 characters and `text` to 20,000. If compilation fails, the response has `is_valid_regex: false`, the engine's `error` message and `suggestions` drawn from simple checks for unclosed brackets, groups and quantifiers.
`test_type` selects the operation, defaulting to `test`. `test` returns a boolean `result`; `match` returns `matches`, `match_count`, `first_match` and `all_matches`, where without the g flag the array is the first match followed by its capture groups; `search` returns the `index` of the first match or -1; `replace` returns `replaced_text`, `replacement_count` and `text_changed`, using `replacement` with standard $1-style references; `split` returns `segments`. Each result carries `execution_time_ms`, measured at millisecond resolution, so fast operations read 0.
The operation runs in a sandbox with a 1.5-second limit; a catastrophically backtracking pattern that exceeds it returns a 400 error instead of hanging. `regex_info` reports the parsed flags, `last_index` after the operation and a `complexity` rating of Low, Medium, High or Very High scored from pattern length, metacharacters, groups and quantifiers. `pattern_analysis` is a textual scan of the pattern for anchors, quantifiers, group counts, character classes and escapes.
On paid plans `performance` re-runs `test` up to 1,000 times within a 50 ms budget and reports `iterations`, total and average time and a rating: under 1 ms average is Excellent, under 5 Good, under 10 Fair, otherwise Poor. A benchmark that cannot finish one pass in time is reported as a single Poor iteration. It is null on the Free plan.
Live Test Regex Tester Skill Skill →
The tool
Once your client is connected to the VerveKit server, this appears in its tool list as RegexTesterSkill. It is read-only and open-world — it fetches and never mutates anything on your side — so most clients call it without asking you to confirm.
{
"name": "RegexTesterSkill",
"arguments": {
"pattern": "\\d{3}-\\d{2}-\\d{4}",
"text": "My SSN is 123-45-6789"
}
}You do not name the tool yourself; the model picks it. Asking about \d{3}-\d{2}-\d{4} in the terms this skill covers is enough for it to reach for RegexTesterSkill on its own — naming it explicitly also works, and is the way to force the call.
Connecting
One server URL covers every skill in the catalog, including this one. Authorization is OAuth: the client opens a browser once, and there is no key to paste into a config file.
{
"mcpServers": {
"vervekit": {
"url": "https://api.vervekit.com/v1/mcp"
}
}
}https://api.vervekit.com/v1/mcpPer-client setup — Claude, Cursor, VS Code, ChatGPT — is on the MCP setup page.
Arguments
These are the properties on the tool's inputSchema, so a well-behaved client validates them before the call is made. Premium arguments are accepted on every plan but only take effect on plans that include them.
| Argument | Type | Description |
|---|---|---|
patternRequired | string | The regular expression pattern to test. Maximum 500 characters length 0–500 |
textRequired | string | The text to test the pattern against. Maximum 20000 characters length 0–20000 |
flagsOptional | string | Regex flags: g (global), i (case insensitive), m (multiline), s (dotall), u (unicode), y (sticky) |
test_typeOptional | string | Operation typetestmatchsearchreplacesplitdefault test |
replacementOptional | string | Replacement text for 'replace' operation |
What the model gets back
The result carries a structuredContent object matching the tool's declared outputSchema, so a client reads fields without parsing prose. status is "ok" and error is null on success; a null field means the value was not available for that input, not that the call failed.
{
"status": "ok",
"error": null,
"data": {
"pattern": "\\d{3}-\\d{2}-\\d{4}",
"text": "My SSN is 123-45-6789 and my friend's is 987-65-4321",
"flags": "g",
"test_type": "test",
"replacement": null,
"is_valid_regex": true,
"regex_info": {
"pattern": "\\d{3}-\\d{2}-\\d{4}",
"flags": {
"global": true,
"ignore_case": false,
"multiline": false,
"sticky": false,
"unicode": false,
"dot_all": false
},
"source": "\\d{3}-\\d{2}-\\d{4}",
"last_index": 21,
"pattern_length": 17,
"complexity": "Medium"
},
"test_results": {
"operation": "test",
"result": true,
"execution_time_ms": 0,
"description": "Returns true if pattern matches anywhere in text, false otherwise"
},
"performance": {
"iterations": 192,
"total_time_ms": 0,
"average_time_ms": 0,
"performance_rating": "Excellent"
},
"pattern_analysis": {
"contains_anchors": {
"start_anchor": false,
"end_anchor": false,
"word_boundary": false
},
"contains_quantifiers": {
"zero_or_more": false,
"one_or_more": false,
"zero_or_one": false,
"specific_count": true,
"range_count": false
},
"contains_groups": {
"capturing_groups": 0,
"non_capturing_groups": 0,
"named_groups": 0
},
"contains_character_classes": {
"predefined_classes": true,
"custom_classes": false,
"negated_classes": false
},
"contains_special_chars": {
"wildcard": false,
"pipe": false,
"escape_sequences": 3
}
},
"suggestions": [
"Consider anchoring with ^ or $ if you need exact matches"
],
"common_patterns": [
{
"name": "Email Address",
"pattern": "^[\\w\\.-]+@[\\w\\.-]+\\.[a-zA-Z]{2,}$",
"description": "Matches valid email addresses",
"example": "[email protected]"
},
{
"name": "Phone Number (US)",
"pattern": "^\\(?(\\d{3})\\)?[-.\\s]?(\\d{3})[-.\\s]?(\\d{4})$",
"description": "Matches US phone numbers in various formats",
"example": "(123) 456-7890"
},
{
"name": "URL",
"pattern": "^https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)$",
"description": "Matches HTTP and HTTPS URLs",
"example": "https://www.example.com"
},
{
"name": "IP Address (IPv4)",
"pattern": "^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$",
"description": "Matches valid IPv4 addresses",
"example": "192.168.1.1"
},
{
"name": "Credit Card Number",
"pattern": "^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3[0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$",
"description": "Matches major credit card formats",
"example": "4532123456789012"
},
{
"name": "Social Security Number",
"pattern": "^\\d{3}-?\\d{2}-?\\d{4}$",
"description": "Matches SSN with or without dashes",
"example": "123-45-6789"
},
{
"name": "Date (MM/DD/YYYY)",
"pattern": "^(0[1-9]|1[0-2])\\/(0[1-9]|[12][0-9]|3[01])\\/(19|20)\\d{2}$",
"description": "Matches MM/DD/YYYY date format",
"example": "12/31/2023"
},
{
"name": "Time (24-hour)",
"pattern": "^([01]?[0-9]|2[0-3]):[0-5][0-9]$",
"description": "Matches 24-hour time format",
"example": "14:30"
},
{
"name": "Hexadecimal Color",
"pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$",
"description": "Matches hex color codes",
"example": "#FF5733"
},
{
"name": "Strong Password",
"pattern": "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$",
"description": "At least 8 chars with uppercase, lowercase, digit, and special char",
"example": "MyP@ssw0rd"
}
],
"regex_guide": {
"basic_syntax": [
{
"symbol": ".",
"description": "Matches any single character except newline"
},
{
"symbol": "*",
"description": "Matches 0 or more of the preceding character"
},
{
"symbol": "+",
"description": "Matches 1 or more of the preceding character"
},
{
"symbol": "?",
"description": "Matches 0 or 1 of the preceding character"
},
{
"symbol": "^",
"description": "Matches start of string"
},
{
"symbol": "$",
"description": "Matches end of string"
},
{
"symbol": "|",
"description": "OR operator"
},
{
"symbol": "\\",
"description": "Escape character"
}
],
"character_classes": [
{
"symbol": "[abc]",
"description": "Matches any character in the set"
},
{
"symbol": "[^abc]",
"description": "Matches any character NOT in the set"
},
{
"symbol": "[a-z]",
"description": "Matches any lowercase letter"
},
{
"symbol": "[A-Z]",
"description": "Matches any uppercase letter"
},
{
"symbol": "[0-9]",
"description": "Matches any digit"
},
{
"symbol": "\\d",
"description": "Matches any digit (equivalent to [0-9])"
},
{
"symbol": "\\w",
"description": "Matches any word character [a-zA-Z0-9_]"
},
{
"symbol": "\\s",
"description": "Matches any whitespace character"
}
],
"quantifiers": [
{
"symbol": "{n}",
"description": "Matches exactly n times"
},
{
"symbol": "{n,}",
"description": "Matches n or more times"
},
{
"symbol": "{n,m}",
"description": "Matches between n and m times"
},
{
"symbol": "*?",
"description": "Non-greedy: matches 0 or more (lazy)"
},
{
"symbol": "+?",
"description": "Non-greedy: matches 1 or more (lazy)"
},
{
"symbol": "??",
"description": "Non-greedy: matches 0 or 1 (lazy)"
}
],
"groups": [
{
"symbol": "(abc)",
"description": "Capturing group"
},
{
"symbol": "(?:abc)",
"description": "Non-capturing group"
},
{
"symbol": "(?<name>abc)",
"description": "Named capturing group"
},
{
"symbol": "(?=abc)",
"description": "Positive lookahead"
},
{
"symbol": "(?!abc)",
"description": "Negative lookahead"
},
{
"symbol": "(?<=abc)",
"description": "Positive lookbehind"
},
{
"symbol": "(?<!abc)",
"description": "Negative lookbehind"
}
],
"flags": [
{
"flag": "g",
"description": "Global - find all matches"
},
{
"flag": "i",
"description": "Case insensitive"
},
{
"flag": "m",
"description": "Multiline - ^ and $ match line breaks"
},
{
"flag": "s",
"description": "Dot matches newline characters"
},
{
"flag": "u",
"description": "Unicode mode"
},
{
"flag": "y",
"description": "Sticky - matches from lastIndex position"
}
]
}
}
}
Response fields
Paths are relative to data. Premium fields are absent rather than zeroed on plans that do not include them, so check for presence instead of comparing to 0.
| Field | Type | Example | Description |
|---|---|---|---|
pattern | string | \d{3}-\d{2}-\d{4} | The regular expression pattern that was tested |
text | string | My SSN is 123-45-6789 and my friend's is 987-65-4321 | The input text the pattern was tested against |
flags | string | g | The regex flags that were applied (g, i, m, s, u, y) |
test_type | string | test | The operation that was run: test, match, search, replace, or split |
replacement | object | null | The replacement text supplied for a replace operation, or null when not applicable |
is_valid_regex | boolean | true | Whether the supplied pattern compiled into a valid regular expression |
regex_info | object | {…} | Details about the compiled regex, including its flags, source, and a computed complexity rating |
regex_info.pattern | string | \d{3}-\d{2}-\d{4} | The regular expression pattern that was tested |
regex_info.flags | object | {…} | The regex flags that were applied (g, i, m, s, u, y) |
regex_info.flags.global | boolean | true | |
regex_info.flags.ignore_case | boolean | false | |
regex_info.flags.multiline | boolean | false | |
regex_info.flags.sticky | boolean | false | |
regex_info.flags.unicode | boolean | false | |
regex_info.flags.dot_all | boolean | false | |
regex_info.source | string | \d{3}-\d{2}-\d{4} | |
regex_info.last_index | number | 21 | |
regex_info.pattern_length | number | 17 | |
regex_info.complexity | string | Medium | |
test_results | object | {…} | The result of the requested operation. Its shape depends on test_type; the fields below are those returned for the default test operation. |
test_results.operation | string | test | The operation that was actually run against the text |
test_results.result | boolean | true | Whether the pattern matched anywhere in the text; returned when test_type is 'test' |
test_results.execution_time_ms | number | 0 | How long the regex operation took to execute, in milliseconds |
test_results.description | string | Returns true if pattern matches anywhere in text, false otherwise | Human-readable explanation of what the operation's result means |
performancePremium | object | {…} | Performance metrics from re-running the pattern many times to measure its average execution speed |
performance.iterationsPremium | number | 192 | |
performance.total_time_msPremium | number | 0 | |
performance.average_time_msPremium | number | 0 | |
performance.performance_ratingPremium | string | Excellent | |
pattern_analysis | object | {…} | Structural analysis of the pattern: which anchors, quantifiers, groups, character classes, and special characters it uses |
pattern_analysis.contains_anchors | object | {…} | |
pattern_analysis.contains_anchors.start_anchor | boolean | false | |
pattern_analysis.contains_anchors.end_anchor | boolean | false | |
pattern_analysis.contains_anchors.word_boundary | boolean | false | |
pattern_analysis.contains_quantifiers | object | {…} | |
pattern_analysis.contains_quantifiers.zero_or_more | boolean | false | |
pattern_analysis.contains_quantifiers.one_or_more | boolean | false | |
pattern_analysis.contains_quantifiers.zero_or_one | boolean | false | |
pattern_analysis.contains_quantifiers.specific_count | boolean | true | |
pattern_analysis.contains_quantifiers.range_count | boolean | false | |
pattern_analysis.contains_groups | object | {…} | |
pattern_analysis.contains_groups.capturing_groups | number | 0 | |
pattern_analysis.contains_groups.non_capturing_groups | number | 0 | |
pattern_analysis.contains_groups.named_groups | number | 0 | |
pattern_analysis.contains_character_classes | object | {…} | |
pattern_analysis.contains_character_classes.predefined_classes | boolean | true | |
pattern_analysis.contains_character_classes.custom_classes | boolean | false | |
pattern_analysis.contains_character_classes.negated_classes | boolean | false | |
pattern_analysis.contains_special_chars | object | {…} | |
pattern_analysis.contains_special_chars.wildcard | boolean | false | |
pattern_analysis.contains_special_chars.pipe | boolean | false | |
pattern_analysis.contains_special_chars.escape_sequences | number | 3 | |
suggestions | array | ["Consider anchoring with ^ or $ if you need exact matches"] | Suggestions for fixing an invalid pattern, or optimization tips for a valid one |
common_patterns | array[10] | Reference library of common regex patterns (email, phone, URL, and similar) for comparison | |
common_patterns.0.name | string | Email Address | Name of the ready-made pattern, for example "Email Address". |
common_patterns.0.pattern | string | ^[\w\.-]+@[\w\.-]+\.[a-zA-Z]{2,}$ | The regular expression source for the ready-made pattern. |
common_patterns.0.description | string | Matches valid email addresses | What the ready-made pattern matches. |
common_patterns.0.example | string | [email protected] | An example string the ready-made pattern matches. |
regex_guide | object | {…} | Reference guide to regex syntax covering basic syntax, character classes, quantifiers, groups, and flags |
regex_guide.basic_syntax | array[8] | ||
regex_guide.basic_syntax.0.symbol | string | . | |
regex_guide.basic_syntax.0.description | string | Matches any single character except newline | |
regex_guide.character_classes | array[8] | ||
regex_guide.character_classes.0.symbol | string | [abc] | |
regex_guide.character_classes.0.description | string | Matches any character in the set | |
regex_guide.quantifiers | array[6] | ||
regex_guide.quantifiers.0.symbol | string | {n} | |
regex_guide.quantifiers.0.description | string | Matches exactly n times | |
regex_guide.groups | array[7] | ||
regex_guide.groups.0.symbol | string | (abc) | |
regex_guide.groups.0.description | string | Capturing group | |
regex_guide.flags | array[6] | The regex flags that were applied (g, i, m, s, u, y) | |
regex_guide.flags.0.flag | string | g | |
regex_guide.flags.0.description | string | Global - find all matches |
Failure modes
Errors come back as tool errors carrying a sentence the model can act on, not a bare status code. Error handling covers the full list.
| Status | What it means |
|---|---|
400 / 422 | The arguments did not validate. The message names the offending one. |
401 | The OAuth session is invalid or expired — reconnect the server. |
403 | Blocked by a key restriction or an IP allow-list. Never a bad identity. |
404 | This skill is not part of VerveKit. Check the catalog. |
429 | Out of credits, or a brief rate limit. The message tells them apart. |
A call costs 1 credit each time the tool actually runs; a model that reasons about the tool without calling it costs nothing.
Use cases
- Pattern Development
- Test and debug regex patterns before implementing them in production code to ensure correct matching
- Data Validation
- Validate regex patterns for input validation in forms, APIs, and data processing pipelines
- Text Processing
- Test regex patterns for text extraction, replacement, and parsing operations
- Learning Tool
- Learn regex syntax with detailed guides, common pattern examples, and real-time testing feedback
Other ways to use Regex Tester Skill
Set up Regex Tester Skill on VerveKit, or reach the same source a different way. Your VerveKit account and credits work on all of them — one key, one balance.
Related
More in Text Processing: