Overview
Regex Tester works by testing regular expressions against text and providing detailed results including matches, pattern analysis, performance metrics, and common pattern examples. Supports all standard regex flags and operations.
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 2 credits 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: