Docs/Skills/Regex Tester Skill

Regex Tester Skill

Test and validate regular expressions

OperationalCredits 2 per callp50 139msText Processing

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.

Tool call
{
  "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"
    }
  }
}

Per-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.

ArgumentTypeDescription
patternRequiredstringThe regular expression pattern to test. Maximum 500 characters
length 0–500
textRequiredstringThe text to test the pattern against. Maximum 20000 characters
length 0–20000
flagsOptionalstringRegex flags: g (global), i (case insensitive), m (multiline), s (dotall), u (unicode), y (sticky)
test_typeOptionalstringOperation type
testmatchsearchreplacesplit
default test
replacementOptionalstringReplacement 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.

Result
{
  "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.

FieldTypeExampleDescription
patternstring\d{3}-\d{2}-\d{4}The regular expression pattern that was tested
textstringMy SSN is 123-45-6789 and my friend's is 987-65-4321The input text the pattern was tested against
flagsstringgThe regex flags that were applied (g, i, m, s, u, y)
test_typestringtestThe operation that was run: test, match, search, replace, or split
replacementobjectnullThe replacement text supplied for a replace operation, or null when not applicable
is_valid_regexbooleantrueWhether the supplied pattern compiled into a valid regular expression
regex_infoobject{…}Details about the compiled regex, including its flags, source, and a computed complexity rating
regex_info.patternstring\d{3}-\d{2}-\d{4}The regular expression pattern that was tested
regex_info.flagsobject{…}The regex flags that were applied (g, i, m, s, u, y)
regex_info.flags.globalbooleantrue
regex_info.flags.ignore_casebooleanfalse
regex_info.flags.multilinebooleanfalse
regex_info.flags.stickybooleanfalse
regex_info.flags.unicodebooleanfalse
regex_info.flags.dot_allbooleanfalse
regex_info.sourcestring\d{3}-\d{2}-\d{4}
regex_info.last_indexnumber21
regex_info.pattern_lengthnumber17
regex_info.complexitystringMedium
test_resultsobject{…}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.operationstringtestThe operation that was actually run against the text
test_results.resultbooleantrueWhether the pattern matched anywhere in the text; returned when test_type is 'test'
test_results.execution_time_msnumber0How long the regex operation took to execute, in milliseconds
test_results.descriptionstringReturns true if pattern matches anywhere in text, false otherwiseHuman-readable explanation of what the operation's result means
performancePremiumobject{…}Performance metrics from re-running the pattern many times to measure its average execution speed
performance.iterationsPremiumnumber192
performance.total_time_msPremiumnumber0
performance.average_time_msPremiumnumber0
performance.performance_ratingPremiumstringExcellent
pattern_analysisobject{…}Structural analysis of the pattern: which anchors, quantifiers, groups, character classes, and special characters it uses
pattern_analysis.contains_anchorsobject{…}
pattern_analysis.contains_anchors.start_anchorbooleanfalse
pattern_analysis.contains_anchors.end_anchorbooleanfalse
pattern_analysis.contains_anchors.word_boundarybooleanfalse
pattern_analysis.contains_quantifiersobject{…}
pattern_analysis.contains_quantifiers.zero_or_morebooleanfalse
pattern_analysis.contains_quantifiers.one_or_morebooleanfalse
pattern_analysis.contains_quantifiers.zero_or_onebooleanfalse
pattern_analysis.contains_quantifiers.specific_countbooleantrue
pattern_analysis.contains_quantifiers.range_countbooleanfalse
pattern_analysis.contains_groupsobject{…}
pattern_analysis.contains_groups.capturing_groupsnumber0
pattern_analysis.contains_groups.non_capturing_groupsnumber0
pattern_analysis.contains_groups.named_groupsnumber0
pattern_analysis.contains_character_classesobject{…}
pattern_analysis.contains_character_classes.predefined_classesbooleantrue
pattern_analysis.contains_character_classes.custom_classesbooleanfalse
pattern_analysis.contains_character_classes.negated_classesbooleanfalse
pattern_analysis.contains_special_charsobject{…}
pattern_analysis.contains_special_chars.wildcardbooleanfalse
pattern_analysis.contains_special_chars.pipebooleanfalse
pattern_analysis.contains_special_chars.escape_sequencesnumber3
suggestionsarray["Consider anchoring with ^ or $ if you need exact matches"]Suggestions for fixing an invalid pattern, or optimization tips for a valid one
common_patternsarray[10]Reference library of common regex patterns (email, phone, URL, and similar) for comparison
common_patterns.0.namestringEmail AddressName of the ready-made pattern, for example "Email Address".
common_patterns.0.patternstring^[\w\.-]+@[\w\.-]+\.[a-zA-Z]{2,}$The regular expression source for the ready-made pattern.
common_patterns.0.descriptionstringMatches valid email addressesWhat the ready-made pattern matches.
common_patterns.0.examplestring[email protected]An example string the ready-made pattern matches.
regex_guideobject{…}Reference guide to regex syntax covering basic syntax, character classes, quantifiers, groups, and flags
regex_guide.basic_syntaxarray[8]
regex_guide.basic_syntax.0.symbolstring.
regex_guide.basic_syntax.0.descriptionstringMatches any single character except newline
regex_guide.character_classesarray[8]
regex_guide.character_classes.0.symbolstring[abc]
regex_guide.character_classes.0.descriptionstringMatches any character in the set
regex_guide.quantifiersarray[6]
regex_guide.quantifiers.0.symbolstring{n}
regex_guide.quantifiers.0.descriptionstringMatches exactly n times
regex_guide.groupsarray[7]
regex_guide.groups.0.symbolstring(abc)
regex_guide.groups.0.descriptionstringCapturing group
regex_guide.flagsarray[6]The regex flags that were applied (g, i, m, s, u, y)
regex_guide.flags.0.flagstringg
regex_guide.flags.0.descriptionstringGlobal - 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.

StatusWhat it means
400 / 422The arguments did not validate. The message names the offending one.
401The OAuth session is invalid or expired — reconnect the server.
403Blocked by a key restriction or an IP allow-list. Never a bad identity.
404This skill is not part of VerveKit. Check the catalog.
429Out 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.

Call it as a REST APIOne HTTPS endpoint and an x-api-key header, with SDKs for Node, Python and .NET.APIVerve →Reference →

More in Text Processing:

Was this page helpful?