staticdata.dev
Menu
Datasets About Contact

Regex Patterns

A curated catalogue of validation patterns developers reach for repeatedly — email, URL, IPv4 and IPv6, UUID, semver, phone numbers, postal codes, credit cards, IBAN, JWT, base64, hex colours, dates, file paths, locale tags — each with the pattern itself, an example match, an example non-match, and a citation to the source the pattern is based on.

v1.0.0 MIT 78 records Updated 2026-10-05 stable Source:  RFC 5322 (Email), WHATWG HTML, RFC 9562 (UUID), Semantic Versioning 2.0.0, Regular-Expressions.info (email, credit card patterns)

Quick fetch

Stable URL. CORS-enabled. No auth.

bash 
curl https://staticdata.dev/v1/regex-patterns.json

Or use as a typed import: import { regexPatterns } from "https://staticdata.dev/v1/regex-patterns.ts"

Formats

  • JSON 24.5 KB

    /v1/regex-patterns.json

    Open

    min: 20.9 KB · /v1/regex-patterns.min.json

  • CSV 14.5 KB

    /v1/regex-patterns.csv

    Open
  • TypeScript 24.7 KB

    /v1/regex-patterns.ts

    export const regexPatterns

    type RegexPattern = (typeof regexPatterns)[number]

    Open

Schema

Each record in the dataset has the following shape.

Schema
Field Type Description Example
id string Stable identifier (kebab-case) email
name string Human-readable name Email address (RFC 5322 simplified)
pattern string The regex source string (no anchors stripped)
description string What the pattern matches and any caveats Matches a typical email address.
example string A string the pattern matches jane.doe@example.com
nonExample string A string the pattern does not match jane.doe@example
source string URL or specification the pattern is derived from https://www.regular-expressions.info/email.html

Preview

First 10 records.

Data preview
idnamepatterndescriptionexamplenonExample
emailEmail address (RFC 5322 simplified)^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$Matches a typical email address (the regular-expressions.info pattern with lowercase letters added). Not RFC 5322 compliant: it accepts some invalid addresses (e.g. consecutive dots) and rejects some valid ones, but is sufficient for most input validation.jane.doe@example.comjane.doe@example
email-strictEmail address (HTML5 input[type=email])^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$The WHATWG HTML valid e-mail address pattern used by input[type=email]. Deliberately looser than RFC 5322 in the local part (e.g. consecutive dots are allowed) and requires no TLD.a.b+c@example.co.uka.b@example..com
urlHTTP/HTTPS URL^https?://[^\s/$.?#].[^\s]*$Matches an http:// or https:// URL.https://example.com/path?q=1ftp://example.com
url-strictURL (full RFC 3986 scheme set)^[a-zA-Z][a-zA-Z\d+\-.]*:[^\s]+$Matches an absolute URI: an RFC 3986-valid scheme followed by a colon and non-whitespace characters. Does not validate the rest of the URI.mailto:user@example.com://example
ipv4IPv4 address^((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]?)$Matches a dotted-quad IPv4 address with 0-255 octets.192.168.1.1256.0.0.1
ipv6IPv6 address^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$Matches the canonical IPv6 address forms (full, shortened, and ::).2001:db8::12001:zz::1
mac-addressMAC address (EUI-48)^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$Matches a MAC address with colon or hyphen separators.01:23:45:67:89:AB01-23-45-67-89
uuid-v4UUID v4^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$Matches a UUID v4 (random, with version and variant bits).f47ac10b-58cc-4372-a567-0e02b2c3d479f47ac10b-58cc-3372-a567-0e02b2c3d479
uuid-anyUUID (any version)^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$Matches a UUID of any version 1-8.01890dfd-c0d6-7c0a-bc6e-7b9b6c4a7e17not-a-uuid
hex-colorHex color (#RGB / #RRGGBB / #RRGGBBAA)^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$Matches a 3-, 4-, 6-, or 8-digit hex color.#1a1a19#xyzxyz

Showing 10 of 78. View full data:  JSON · CSV

Fetch examples

Drop-in snippets in five languages.

curl 
curl -sSL https://staticdata.dev/v1/regex-patterns.json | jq '.[0]'
JavaScript 
import type { RegexPattern } from "https://staticdata.dev/v1/regex-patterns.ts";

const res = await fetch("https://staticdata.dev/v1/regex-patterns.min.json");
if (!res.ok) throw new Error(`Fetch failed: ${res.status}`);
const regexPatterns: RegexPattern[] = await res.json();
console.log(regexPatterns[0]);
Python 
import urllib.request, json

with urllib.request.urlopen("https://staticdata.dev/v1/regex-patterns.min.json") as r:
    regexPatterns = json.load(r)

print(regexPatterns[0])
Go 
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("https://staticdata.dev/v1/regex-patterns.min.json")
	if err != nil { panic(err) }
	defer resp.Body.Close()

	var data []map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		panic(err)
	}
	fmt.Println(data[0])
}
Rust 
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = ureq::get("https://staticdata.dev/v1/regex-patterns.min.json").call()?.into_string()?;
    let data: Vec<Value> = serde_json::from_str(&body)?;
    println!("{:?}", data.first());
    Ok(())
}

Sources and methodology

Regex validation is famously imperfect. The patterns here are pragmatic: they reject the most common malformed inputs without trying to fully implement the underlying spec. For email and URL in particular, prefer real parsers when correctness matters — these patterns are for input-time UX hints, not security boundaries.

Where a pattern depends on regex engine features:

  • Unicode mode (u flag): required for unicode-letter, emoji. The dataset stores the pattern as the source string; you must apply the flag yourself.
  • Lookahead: hostname, password-strong, ssn-us and non-empty use lookaheads. PCRE, ECMAScript, .NET, Java and Python re support them; RE2 (Go, and Rust’s regex crate) does not.
  • Backreferences: none of the patterns use backreferences.

The pattern field is the bare regex source, written for ECMAScript (JavaScript) syntax and tested against each record’s example and nonExample: anchors (^…$) are included where the pattern is intended to match the full string. Strip them if you want to use the pattern in a match-anywhere fashion.

The nonExample is one example of a string that does not match — useful for testing your validation paths.

Versioning

URLs under /v1/ are stable: field names and types will not change in a way that breaks consumers. Values can be corrected or records added when the upstream source changes; schema-incompatible updates ship under a new version path. See the regex-patterns changelog for this dataset's history.

More Code datasets