Regex Tester API Reference

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.

Endpoint

One host, one path per API. The block below shows this call in four languages; every one of them is the same HTTP request. Making requests covers the timeouts, retries and parameter rules that apply to all of them. The SDKs wrap the same call in a typed client.

POSThttps://api.apiverve.com/v1/regextester

curl -X POST https://api.apiverve.com/v1/regextester \
  -H "x-api-key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "pattern": "\\d{3}-\\d{2}-\\d{4}",
  "text": "My SSN is 123-45-6789 and my friend's is 987-65-4321",
  "flags": "g"
}'

const res = await fetch('https://api.apiverve.com/v1/regextester', {
  method: 'POST',
  headers: {
    'x-api-key': 'your_api_key_here',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "pattern": "\\d{3}-\\d{2}-\\d{4}",
  "text": "My SSN is 123-45-6789 and my friend's is 987-65-4321",
  "flags": "g"
}),
});

if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);

const { data } = await res.json();
console.log(data);

import requests

res = requests.post(
    "https://api.apiverve.com/v1/regextester",
    headers={"x-api-key": "your_api_key_here"},
    json={
    "pattern": "\\d{3}-\\d{2}-\\d{4}",
    "text": "My SSN is 123-45-6789 and my friend's is 987-65-4321",
    "flags": "g"
},
    timeout=15,
)
res.raise_for_status()

print(res.json()["data"])

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "pattern": "\\d{3}-\\d{2}-\\d{4}",
  "text": "My SSN is 123-45-6789 and my friend's is 987-65-4321",
  "flags": "g"
}`)
	req, _ := http.NewRequest("POST", "https://api.apiverve.com/v1/regextester", body)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", "your_api_key_here")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

Replace your_api_key_here with the key from your dashboard. When the inputs arrive as a list rather than one at a time, batch requests run up to 200 of them through this same API in a single call.

Authentication

Send your key in the x-api-key header. That is the only auth step — there is no token exchange and no per-endpoint scope to configure. Authentication covers creating, rotating and revoking keys.

401 is the only auth verdict

A 401 means the key is missing, invalid or expired. A 403 means the key is valid but not permitted here — blocked by a key restriction or an IP allow-list. Running out of credits is a 429.

Parameters

Sent as JSON in the request body. Premium parameters are accepted on every plan but only take effect on plans that include them.

Parameter	Type	Description
`pattern`Required	string	The regular expression pattern to test
`text`Required	string	The text to test the pattern against
`flags`Optional	string	Regex flags: g (global), i (case insensitive), m (multiline), s (dotall), u (unicode), y (sticky)
`test_type`Optional	string	Operation type `testmatchsearchreplacesplit` default test
`replacement`Optional	string	Replacement text for 'replace' operation

Response

Every API returns the same three top-level keys, so one response handler covers your whole integration: status, error and data. Only data changes shape. Response format covers the envelope, the other output formats and how premium fields are withheld.

Sample response

{
  "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": "user@example.com"
      },
      {
        "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}"`
`text`	string	`"My SSN is 123-45-6789 and my friend's is 987-65-4321"`
`flags`	string	`"g"`
`test_type`	string	`"test"`
`replacement`	object	`null`
`is_valid_regex`	boolean	`true`
`regex_info`	object	`{...}`
`pattern`	string	`"\d{3}-\d{2}-\d{4}"`
`flags`	object	`{...}`
`global`	boolean	`true`
`ignore_case`	boolean	`false`
`multiline`	boolean	`false`
`sticky`	boolean	`false`
`unicode`	boolean	`false`
`dot_all`	boolean	`false`
`source`	string	`"\d{3}-\d{2}-\d{4}"`
`last_index`	number	`21`
`pattern_length`	number	`17`
`complexity`	string	`"Medium"`
`test_results`	object	`{...}`
`operation`	string	`"test"`
`result`	boolean	`true`	Result after replacement or split operation
`execution_time_ms`	number	`0`
`description`	string	`"Returns true if pattern matches anywhere in text, false otherwise"`
`performance`Premium	object	`{...}`	Performance metrics for the regex operation
`iterations`Premium	number	`192`
`total_time_ms`Premium	number	`0`
`average_time_ms`Premium	number	`0`
`performance_rating`Premium	string	`"Excellent"`
`pattern_analysis`	object	`{...}`
`contains_anchors`	object	`{...}`
`start_anchor`	boolean	`false`
`end_anchor`	boolean	`false`
`word_boundary`	boolean	`false`
`contains_quantifiers`	object	`{...}`
`zero_or_more`	boolean	`false`
`one_or_more`	boolean	`false`
`zero_or_one`	boolean	`false`
`specific_count`	boolean	`true`
`range_count`	boolean	`false`
`contains_groups`	object	`{...}`
`capturing_groups`	number	`0`
`non_capturing_groups`	number	`0`
`named_groups`	number	`0`
`contains_character_classes`	object	`{...}`
`predefined_classes`	boolean	`true`
`custom_classes`	boolean	`false`
`negated_classes`	boolean	`false`
`contains_special_chars`	object	`{...}`
`wildcard`	boolean	`false`
`pipe`	boolean	`false`
`escape_sequences`	number	`3`
`suggestions`	array	`[Consider anchoring with ^ or $ if you need exact matches]`
`common_patterns`	array[10]
`name`	string	`"Email Address"`
`pattern`	string	`"^[\w\.-]+@[\w\.-]+\.[a-zA-Z]{2,}$"`
`description`	string	`"Matches valid email addresses"`
`example`	string	`"user@example.com"`
`regex_guide`	object	`{...}`
`basic_syntax`	array[8]
`symbol`	string	`"."`
`description`	string	`"Matches any single character except newline"`
`character_classes`	array[8]
`symbol`	string	`"[abc]"`
`description`	string	`"Matches any character in the set"`
`quantifiers`	array[6]
`symbol`	string	`"{n}"`
`description`	string	`"Matches exactly n times"`
`groups`	array[7]
`symbol`	string	`"(abc)"`
`description`	string	`"Capturing group"`
`flags`	array[6]
`flag`	string	`"g"`
`description`	string	`"Global - find all matches"`

Errors

Read the HTTP status first, then error for the specific reason. The body names the parameter that has to change. Error handling covers the full status list and which of them are worth retrying.

Status	Meaning	What to do
`400`	Input was rejected	Read `error`; it names the parameter.
`401`	Key missing or invalid	Check the header name and the key value.
`403`	Key valid, but not permitted	A key restriction or IP allow-list; see key scoping.
`429`	Rate limited, or out of credits	Read `error` to tell them apart; see rate limits.

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

Set up Regex Tester on APIVerve, or reach the same source a different way. Your APIVerve account and credits work on all of them — one key, one balance.

Give it to an AI agentConnect over MCP and your agent calls it as a native tool — Claude, Cursor, ChatGPT.VerveKit →Reference →

Regex Tester