Overview JavaScript/TS Python Go PHP Rust detect()Patterns Contributing

v1.0.8·MIT License·106 patterns

`regex.to/validators`

A polyglot regular expression registry. One single source of truth for 106+ patterns (email, URLs, dates, country-specific identifiers, markdown formats), distributed as zero-dependency native packages for your backend or frontend of choice.

Overview

Maintaining custom regex patterns across multiple languages is prone to bugs. `regex.to` solves this by packaging the exact same validated JSON pattern registry into native, optimized libraries for:

JavaScript / TypeScript: First-class Zod support and full validation schema.
Python: Native, type-hinted package.
Go: Advanced PCRE-compatible support using `regexp2` (avoids RE2 lookaround limitations).
PHP: Full native PCRE pattern validation.
Rust: Fast compiled validation using `fancy-regex` (supports lookarounds).

Each library exposes the exact same unified interface: `validate` (strict full string match), `test` (partial substring match), and `detect` (automatically identify pattern types).

JavaScript / TypeScript (NPM)

Install the `@regexto/validators` package:

bash

npm install @regexto/validators

Usage

typescript

import { validate, test, getRegex } from '@regexto/validators';

// Full validation match
const res = validate('email', 'hello@regex.to'); // { valid: true, ... }

// Fast boolean check
const isUrl = test('url', 'https://regex.to'); // true

// Fetch compiled RegExp object
const rx = getRegex('email'); // /[a-zA-Z0-9...]/

Zod Integration

Import Zod-specific helpers directly:

typescript

import { zodSchema, zodObjectSchema } from '@regexto/validators/zod';
import { z } from 'zod';

const schema = zodObjectSchema({
  email: 'email',
  website: 'url',
});

Python (PyPI)

Install the `regexto-validators` package:

bash

pip install regexto-validators

Usage

python

from regexto_validators import validate, test

# Full validation match
is_valid = validate("email", "hello@regex.to") # True

# Fast boolean check
is_url = test("url", "https://regex.to") # True

Go (pkg.go.dev)

Download the module. Uses PCRE-compatible `regexp2` under the hood:

bash

go get github.com/regex-to/validators-go

Usage

package main

import (
    "fmt"
    "github.com/regex-to/validators-go"
)

func main() {
    valid, _ := validators.Validate("email", "hello@regex.to")
    fmt.Println(valid) // true
}

PHP (Packagist)

Require via Composer:

bash

composer require regexto/validators

Usage

php

<?php

use RegexTo\Validators\Validator;

$isValid = Validator::validate('email', 'hello@regex.to'); // true

Rust (Crates.io)

Add to your dependencies. Uses `fancy-regex` to cleanly support patterns with lookarounds:

bash

cargo add regexto-validators

Usage

rust

use regexto_validators::validate;

fn main() {
    let is_valid = validate("email", "hello@regex.to").unwrap();
    println!("Valid? {}", is_valid); // true
}

detect() — Auto-detect string type

Pass any unknown string and get back an ordered list of matching patterns. `detect` is available in all supported languages, utilizing the exact same ranking heuristics.

typescript

// Example showing auto-detection structure
import { detect } from '@regexto/validators';

detect('hello@regex.to');
// → [{ pattern: { slug: 'email', ... }, matchType: 'full', coverage: 1 }]

Results are sorted by confidence: full matches first, then by coverage ratio. Minimum match length is 4 characters and 20% coverage to filter trivial hits.

API Reference

Function	Description
`test(slug, value)`	Quick boolean substring match
`validate(slug, value)`	Full strict match validation
`detect(input)`	Auto-detect type of an unknown string
`getAllPatterns()`	All patterns as an array

Patterns (106)

Address4 patterns

fr-postal

French Postal Code

Matches a French postal code — exactly 5 digits, starting with 0–9.

de-plz

German Postal Code (PLZ)

Matches a German postal code (Postleitzahl / PLZ) — exactly 5 digits.

uk-postcode

UK Postcode

Matches a UK postcode in the standard format (e.g. SW1A 1AA, EC1A 1BB).

us-zip

US ZIP Code

Matches a US ZIP code in 5-digit or ZIP+4 (5-4) format.

Cloud1 patterns

aws-arn

AWS ARN

Validates Amazon Web Services ARNs (Amazon Resource Names) across all AWS services and partitions.

Content1 patterns

isbn-13

ISBN-13

Validates 13-digit International Standard Book Numbers (ISBN-13) with optional hyphens or spaces.

Crypto10 patterns

crypto-mnemonic-word

BIP-39 Mnemonic Phrase

Matches a BIP-39 mnemonic seed phrase — 12, 15, 18, 21, or 24 lowercase English words separated by single spaces.

bitcoin-address

Bitcoin Address (Legacy)

Matches a legacy Bitcoin address — P2PKH (starting with 1) or P2SH (starting with 3), 25–34 Base58 characters.

bech32-address

Bitcoin Bech32 Address (SegWit)

Matches a Bitcoin native SegWit address in Bech32 format — starts with bc1 followed by 6–87 lowercase alphanumeric characters.

ens-name

ENS Name (Ethereum Name Service)

Matches an Ethereum Name Service domain — alphanumeric label(s) ending with .eth.

ethereum-address

Ethereum Address

Matches an Ethereum address — 0x followed by exactly 40 hexadecimal characters.

txhash-eth

Ethereum Transaction Hash

Matches an Ethereum transaction hash — 0x followed by exactly 64 hexadecimal characters.

ipfs-cid

IPFS CID

Matches an IPFS Content Identifier (CIDv0 starting with Qm, or CIDv1 starting with bafy/bafk).

lightning-invoice

Lightning Network Invoice (BOLT-11)

Matches a Bitcoin Lightning Network payment invoice in BOLT-11 format — starts with lnbc, lntb, or lnbcrt.

monero-address

Monero Address

Matches a Monero (XMR) standard address — starts with 4 and is exactly 95 Base58 characters.

solana-address

Solana Address

Matches a Solana public key — 32–44 Base58 characters (no 0, O, I, l).

Database3 patterns

mongodb-uri

MongoDB Connection URI

Validates MongoDB connection strings, supporting both standard 'mongodb://' and DNS-seedlist 'mongodb+srv://' protocols.

redis-url

Redis Connection URI

Validates Redis and Redis SSL connection URLs (redis://, rediss://) with optional user, password, port, and DB index.

sql-identifier

SQL Identifier

Validates SQL table, column, and schema names (unquoted or quoted with double quotes or backticks).

Date & Time5 patterns

date-eu

Date (European Format)

Matches a European-style date in DD/MM/YYYY, DD.MM.YYYY, or DD-MM-YYYY format.

date-us

Date (US Format)

Matches a US-style date in MM/DD/YYYY format.

iso-date

ISO 8601 Date

ISO 8601 date format (YYYY-MM-DD) with month and day range validation.

datetime-iso

ISO 8601 DateTime

Matches an ISO 8601 datetime string with timezone offset or Z (UTC).

time-24h

Time (24-hour)

Matches a time in 24-hour format. Supports both HH:MM and HH:MM:SS.

Design2 patterns

hsl-color

HSL Color

Matches a CSS HSL color value in the format hsl(H, S%, L%).

rgb-color

RGB Color

Matches an RGB color value in the format rgb(R, G, B) where each channel is 0–255.

Dev2 patterns

git-sha

Git Commit SHA

Matches a Git commit SHA — either short form (7+ chars) or full 40-character SHA-1 hash.

semver

Semantic Version

SemVer 2.0 compliant version string including optional pre-release and build metadata.

Dev Tools3 patterns

conventional-commit

Conventional Commit Message

Validates git commit messages adhering to the Conventional Commits specification.

cron-expression

Cron Expression

Validates cron schedule expressions (5 fields: minute, hour, day of month, month, day of week) structurally.

openai-api-key

OpenAI API Key

Validates OpenAI API keys, specifically supporting the standard project keys starting with 'sk-proj-'.

DevOps1 patterns

docker-image

Docker Image Name

Validates Docker image references including optional registry host, namespace, name, tag, and digest.

Developer Tools3 patterns

git-branch

Git Branch Name

Validates standard Git branch names (e.g. feature/login, bugfix/issue-123, main, release/v1.0.4).

npm-package-name

NPM Package Name

Validates scoped and unscoped NPM package names according to npm naming rules.

semver-range

SemVer Range Specifier

Validates Semantic Versioning (SemVer) ranges such as ^1.2.3, ~0.1.0, >=1.0.0, or 1.x.

Finance7 patterns

credit-card

Credit Card Number

Generic credit card number validator supporting Visa, Mastercard, American Express, and Discover card formats.

vat-eu

EU VAT Number

Validates European Union VAT numbers across all 27 member states. Each country has a 2-letter ISO prefix followed by 8–12 alphanumeric characters.

iban

IBAN

Matches an International Bank Account Number (IBAN) — 2-letter country code, 2 check digits, and up to 30 alphanumeric characters.

pl-nip

Polish NIP (Tax ID)

Polish NIP (Numer Identyfikacji Podatkowej) — the 10-digit tax identification number used by businesses and self-employed individuals in Poland, supported in unhyphenated and official hyphenated formats.

pl-vat

Polish VAT Number (VAT-UE)

Validates Polish VAT identification numbers (VAT-UE / NIP do celów VAT). Matches standard 10-digit NIP numbers with optional or required 'PL' country prefix and official Polish hyphenation formats.

stripe-key

Stripe API Key

Validates Stripe publishable and secret API keys in both live and test modes.

swift-bic

SWIFT / BIC Code

Matches a SWIFT/BIC (Bank Identifier Code) — 6-letter institution code + 2-letter country + optional 2-3 character branch.

Geo3 patterns

coordinates

GPS Coordinates

Matches a latitude,longitude coordinate pair separated by a comma.

latitude

Latitude

Matches a geographic latitude coordinate between -90 and +90 degrees, with up to 6 decimal places.

longitude

Longitude

Matches a geographic longitude coordinate between -180 and +180 degrees, with up to 6 decimal places.

Identifiers1 patterns

ulid

ULID

Validates 26-character Crockford Base32 Universally Unique Lexicographically Sortable Identifier (ULID) strings.

Identity19 patterns

au-abn

Australian ABN

Matches an Australian Business Number (ABN) — 11 digits, optionally space-separated in groups.

br-cnpj

Brazilian CNPJ

Matches a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) — company identifier in formatted or unformatted form.

br-cpf

Brazilian CPF

Matches a Brazilian CPF (Cadastro de Pessoas Físicas) number in formatted (NNN.NNN.NNN-NN) or unformatted (NNNNNNNNNNN) form.

ca-sin

Canadian SIN

Validates Canadian Social Insurance Numbers (SIN): 9 digits optionally formatted as NNN-NNN-NNN.

cn-resident-id

Chinese Resident ID

Matches a Chinese national resident identity card number — 17 digits followed by one digit or X (checksum digit).

fr-siren

French SIREN Number

Matches a French SIREN (Système d'Identification du Répertoire des ENtreprises) number — 9 digits.

fr-siret

French SIRET Number

Matches a French SIRET (Système d'Identification du Répertoire des Établissements) number — 14 digits.

de-steuerid

German Tax ID (Steuer-IdNr)

Matches a German personal tax identification number (Steuerliche Identifikationsnummer) — 11 digits, first digit 1–9.

in-pan

Indian PAN Card

Matches an Indian Permanent Account Number (PAN) — 10 characters: 5 uppercase letters, 4 digits, 1 uppercase letter.

it-codice-fiscale

Italian Codice Fiscale

Matches an Italian fiscal code (Codice Fiscale) — 16 alphanumeric characters encoding name, birth date, gender, and municipality.

pl-pesel

Polish PESEL

Polish national identification number (PESEL) — an 11-digit number encoding date of birth, gender, and a checksum, assigned to every citizen.

pl-regon

Polish REGON

Matches a Polish REGON (National Business Registry Number) — 9 digits for businesses and companies, 14 digits for local administrative units.

ru-inn

Russian INN (ИНН)

Matches a Russian taxpayer identification number (ИНН) — 10 digits for organisations, 12 digits for individuals.

es-nif

Spanish NIF / DNI

Matches a Spanish National Identity Document number (NIF/DNI) — 8 digits followed by a letter, or an NIE starting with X, Y, or Z.

uk-nino

UK National Insurance Number (NINO)

Matches a UK National Insurance Number in the format AA 99 99 99 A.

uk-nhs

UK NHS Number

Validates UK National Health Service (NHS) numbers: 10 digits optionally separated by spaces in groups of 3-3-4.

us-ein

US Employer Identification Number (EIN)

Matches a US EIN (Federal Tax ID) in the NN-NNNNNNN format used by the IRS.

us-passport

US Passport Number

Validates United States passport numbers: 9 alphanumeric characters starting with 1-2 letters followed by digits.

us-ssn

US Social Security Number

Matches a US Social Security Number (SSN) in the standard NNN-NN-NNNN format.

Internet5 patterns

domain

Domain Name

Matches a valid domain name including subdomains and international TLDs.

email

Email Address

RFC 5321 compliant email address validation. Supports subdomains, plus-addressing, and international TLDs.

github-repo

GitHub Repository

Validates GitHub repository references in owner/repo format. Owner and repo names must be 1–100 characters and contain only alphanumerics, hyphens, underscores, or dots.

url

URL (HTTP/HTTPS)

Validates HTTP and HTTPS URLs including subdomains, paths, query strings, and anchors.

youtube-url

YouTube Video URL

Matches a YouTube video URL in both youtube.com/watch?v= and youtu.be/ formats and extracts the 11-character video ID.

Markdown9 patterns

markdown-blockquote

Markdown Blockquote

Matches a Markdown blockquote line beginning with > and captures the quoted text.

markdown-bold

Markdown Bold

Matches Markdown bold text wrapped in **double asterisks** or __double underscores__.

markdown-heading

Markdown Heading

Matches Markdown ATX-style headings — # through ###### followed by text. Captures both the level (number of #) and the heading text.

markdown-hr

Markdown Horizontal Rule

Matches a Markdown horizontal rule — three or more dashes, asterisks, or underscores on a line.

markdown-image

Markdown Image

Matches a Markdown image tag ![alt text](url) and captures both the alt text and the URL.

markdown-code-inline

Markdown Inline Code

Matches Markdown inline code wrapped in single `backticks` or ``double backticks``.

markdown-italic

Markdown Italic

Matches Markdown italic text wrapped in *single asterisk* or _single underscore_.

markdown-list-item

Markdown List Item

Matches Markdown unordered list items starting with -, *, or + and ordered items starting with a number.

markdown-table-row

Markdown Table Row

Matches a Markdown GFM table row — cells separated by pipe | characters.

Network4 patterns

ipv4

IPv4 Address

Validates a standard IPv4 address ensuring each octet is 0–255.

ipv6

IPv6 Address

Matches a full-form IPv6 address with 8 groups of 4 hexadecimal digits separated by colons.

mac-address

MAC Address

Matches a MAC (Media Access Control) address in both colon-separated and hyphen-separated formats.

port-number

Port Number

Matches a valid TCP/UDP port number from 0 to 65535.

Phone4 patterns

phone-de

German Phone Number

Validates German phone numbers in international (+49) and domestic (0) formats, with optional spaces, hyphens, or dots as separators.

phone-e164

Phone — E.164 International

Matches an international phone number in E.164 format: + followed by country code and subscriber number (max 15 digits total).

phone-uk

Phone — UK

Matches UK phone numbers in standard formats, starting with 0 or +44.

phone-us

Phone — US

Matches a US phone number in various formats: (555) 867-5309, 555-867-5309, 5558675309, or with +1 country code.

Security9 patterns

base64

Base64 Encoded String

Matches a valid Base64-encoded string with proper padding using = characters.

discord-bot-token

Discord Bot Token

Validates Discord bot API tokens consisting of user ID base64, timestamp, and HMAC hash.

jwt

JWT Token

Matches a JSON Web Token (JWT) — three Base64URL-encoded segments separated by dots.

md5

MD5 Hash

Matches an MD5 hash — exactly 32 hexadecimal characters.

sha256

SHA-256 Hash

Matches a SHA-256 cryptographic hash — exactly 64 hexadecimal characters.

slack-webhook

Slack Incoming Webhook URL

Validates Slack incoming webhook URLs (https://hooks.slack.com/services/T.../B.../...).

ssh-public-key

SSH Public Key

Validates SSH public keys, supporting common algorithms like ssh-rsa, ssh-ed25519, ssh-dss, and ecdsa variants.

password-strong

Strong Password

Matches a strong password: minimum 8 characters with at least one uppercase letter, one lowercase letter, one digit, and one special character.

uuid

UUID v4

Matches a UUID version 4 — randomly generated universally unique identifier in the standard 8-4-4-4-12 format.

Social3 patterns

mention

@Mention

Matches a social media @mention — @ followed by 3–30 word characters.

hashtag

Hashtag

Matches a social media hashtag — # followed by one or more word characters (letters, digits, underscores), starting with a letter.

username

Username

Matches a valid username: 3–20 characters, letters, digits, hyphens, and underscores. No leading/trailing hyphens or underscores.

Web7 patterns

css-variable

CSS Custom Property (Variable)

Validates CSS custom property (variable) names starting with double dashes (--).

color-oklch

CSS oklch() Color

Validates CSS oklch() color function values as defined in CSS Color Level 4. Supports lightness (0–1), chroma (0–0.4), hue (0–360), and optional alpha.

hex-color

Hex Color

CSS hex color code in #RGB or #RRGGBB format (case-insensitive).

html-tag

HTML Tag

Matches an HTML opening or self-closing tag with optional attributes.

markdown-link

Markdown Link

Matches a Markdown hyperlink in [text](url) format and captures both the link text and URL.

mime-type

MIME Media Type

Validates standard MIME / media type strings (e.g. application/json, image/png, text/html).

slug

URL Slug

Valid URL slug — lowercase alphanumeric characters separated by single hyphens, no leading or trailing hyphens.

Contributing a Pattern

All patterns are stored as small JSON files. Contributing is a 4-step process:

1
Fork the repository
Fork github.com/regex-to/validators and create a branch: pattern/your-pattern-name

Create the JSON file

json

{
  "slug": "your-pattern",
  "name": "Human Readable Name",
  "description": "What this regex validates.",
  "category": "Internet",
  "pattern": "your[regex]pattern+",
  "flags": "i",
  "examples": ["valid-input-1", "valid-input-2"],
  "counterExamples": ["invalid-1"],
  "tags": ["tag1", "tag2"]
}

Test your pattern

bash

npm test
# Or paste your pattern into the sandbox at regex.to

4
Open a Pull Request
Open a PR titled feat: add [pattern-name] pattern. Patterns are auto-discovered on merge.