Regex Patterns Library

Match and validate email addresses in the standard user@domain.tld format.

Match US phone numbers in common formats: (555) 867-5309, 555-867-5309, 5558675309.

Match 16-digit credit card numbers with optional spaces or hyphens between groups of 4.

Match US ZIP codes in 5-digit (12345) and ZIP+4 (12345-6789) formats.

Match US Social Security Numbers in the canonical XXX-XX-XXXX format.

Match Canadian postal codes in the A1A 1A1 or A1A1A1 format with valid first-letter prefixes.

Match UK postcodes in the common outward + inward format (e.g. SW1A 1AA, EC1V 9LB).

Match 10-digit ISBNs, allowing optional hyphens or spaces between groups.

Match 13-digit ISBNs starting with 978 or 979, with optional hyphens or spaces.

Validate usernames that are 3–16 characters long and contain only letters, digits, underscores, and hyphens.

Validate phone numbers in ITU-T E.164 international format: a + sign followed by 2–15 digits, first digit non-zero.

Match Twitter/X @handles — 1 to 15 characters of letters, digits, or underscores preceded by @.

Validate standard 5-field Unix cron expressions: minute, hour, day-of-month, month, day-of-week.

Match strings containing only letters (A–Z, a–z) and digits (0–9), with no spaces or special characters.

Match international phone numbers in a variety of loose formats including country codes, area codes, and separators.

Validate MIME media type strings like text/html, application/json, or image/png; charset=utf-8.

Validate IBAN bank account identifiers: 2-letter country code, 2 check digits, 11–30 alphanumerics.

Validate SWIFT/BIC bank identifier codes — 8 chars (head office) or 11 chars (branch).

Validate just the local part of an email address (the bit before the @).

Validate passwords requiring at least one lowercase, one uppercase, one digit, and minimum 8 characters — no special characters required.

Validate 3-letter ISO 4217 currency codes (USD, EUR, GBP, JPY, etc.) — structural check only.

Validate 2-letter ISO 3166-1 alpha-2 country codes (US, GB, FR, JP, etc.) — structural check only.

Validate just the domain portion of an email address — the bit after the @.

Validate 6-field Quartz/Spring cron expressions including the seconds field at the front.

Validate BCP 47 language tags like `en`, `en-US`, `zh-Hant-TW`, or `pt-BR`.

Match http and https URLs with optional www prefix, paths, query strings, and fragments.

Match CSS hex color codes in both 3-digit (#RGB) and 6-digit (#RRGGBB) formats.

Validate URL slugs: lowercase letters and digits separated by single hyphens, no leading/trailing hyphens.

Match paired HTML tags and capture the tag name and inner content using a back-reference.

Match HTML comments, including multi-line comments and empty ones.

Match CSS rgb() and rgba() color functions, including an optional alpha channel.

Match HTML attributes of the form name="value" or name='value' and capture both parts.

Match base64-encoded data URIs, including the MIME type and the base64 payload.

Extract 11-character YouTube video IDs from long URLs, short URLs, or embed URLs.

Match CSS hsl() and hsla() color functions, capturing hue (0–360), saturation, lightness, and optional alpha.

Match HTML entities in named (`&`), numeric (`{`), or hex (`💩`) form.

Extract the value of a `class="..."` attribute from raw HTML, handling double or single quotes.

Match GitHub repository URLs and capture the owner and repo segments.

Match CSS custom properties (variables) like `--brand-color` or `--font-size-lg`.

Validate URL slugs allowing Unicode letters (`café-rénové`), as supported by Next.js i18n routing.

Validate the value of an HTML5 `<input type="color">` — exactly 6 hex digits with leading hash.

Match Twitter/X profile and status URLs, capturing the handle and (optional) tweet ID.

Match LinkedIn profile URLs and capture the profile slug.

Extract the query string portion of a URL (everything between `?` and `#` or end-of-string).

Parse the value of an HTTP Content-Type header, capturing the media type and optional charset.

Match individual `/segment` parts of a URL path, capturing each one.

Match XML namespace declarations (`xmlns="..."` and `xmlns:prefix="..."`), capturing the prefix and URI.

Match OpenAPI / Express-style path templates with `{param}` (or `:param` after substitution) placeholders.

Parse name=value pairs from an HTTP `Cookie:` header value.

Match XML processing instructions like `<?xml version="1.0" encoding="utf-8"?>` or `<?xml-stylesheet href="..."?>`.

Match valid IPv4 addresses with each octet constrained to 0–255.

Match full (non-compressed) IPv6 addresses written as eight colon-separated hextets.

Match 48-bit MAC addresses written with colon or hyphen separators (e.g. 00:1A:2B:3C:4D:5E).

Match port numbers (1–65535) following a colon, as you'd find in host:port strings.

Match fully-qualified domain names like example.com or api.sub.example.co.uk.

Match 3-digit HTTP status codes in the 1xx–5xx range.

Match IPv4 addresses with CIDR prefix notation such as 10.0.0.0/8 or 192.168.1.0/24.

Match IPv4 addresses in the RFC 1918 private ranges: 10/8, 192.168/16, and 172.16/12.

Validate a single-label hostname per RFC 1123: 1–63 chars, letters/digits/hyphens, can't start or end with hyphen.

Match MongoDB connection URIs in both standard `mongodb://` and SRV `mongodb+srv://` formats.

Parse generic URL-form connection strings: `protocol://[user[:pass]@]host[:port][/database]`.

Match Redis connection URLs in both `redis://` and `rediss://` (TLS) forms, capturing user, password, host, port, and DB index.

Match PostgreSQL DSN connection strings (`postgres://` or `postgresql://`), capturing the standard URL components.

Match FTP and FTPS URLs, capturing optional credentials, host, port, and path.

Match JDBC connection URLs in the standard `jdbc:driver://host[:port][/database]` form.

Match dates in ISO 8601 format: YYYY-MM-DD with valid month (01–12) and day (01–31) ranges.

Match US-style dates in MM/DD/YYYY format with range validation.

Match European-style dates in DD/MM/YYYY format with valid day (01–31) and month (01–12) ranges.

Match 24-hour time formats HH:MM or HH:MM:SS with valid hour (00–23) and minute/second (00–59) ranges.

Match 12-hour time formats with AM or PM suffix — e.g. 9:30 AM, 11:45:15 pm.

Match 10-digit Unix timestamps (seconds since epoch) for dates between 2001 and 2286.

Match full ISO 8601 date-times with timezone offset or Z suffix (e.g. 2024-01-15T14:30:00Z).

Enforce strong passwords: min 8 chars, at least one lowercase, uppercase, digit, and special character.

Match JSON Web Tokens (JWTs) — three base64url-encoded segments separated by dots.

Match generic long alphanumeric tokens (32+ chars) typical of API keys and access tokens.

Match Bitcoin addresses in legacy (P2PKH/P2SH) and SegWit Bech32 (bc1) formats.

Match bcrypt password hashes in their canonical $2a$/$2b$/$2y$ prefixed format.

Match AWS access key IDs (both long-term AKIA and temporary ASIA prefixes).

Match Bearer token values from HTTP Authorization headers, capturing the raw token string.

Match PEM-encoded certificate and key blocks, capturing the block type and base64 content.

Match SSH public keys in OpenSSH `authorized_keys` format, including the optional comment field.

Match Stripe API keys: secret (sk_), publishable (pk_), or restricted (rk_), in test or live mode.

Match GitHub Personal Access Tokens (classic + fine-grained) and OAuth tokens by their `ghX_` prefix.

Match PEM-encoded private key blocks across the common variants (RSA, EC, DSA, OpenSSH, encrypted, PGP).

Match RFC 4122 UUIDs (versions 1–5) in the standard 8-4-4-4-12 hex format.

Match semantic version strings like 1.2.3, 1.2.3-beta.1, or 1.2.3+build.42.

Match MongoDB ObjectId values — 24-character hexadecimal strings.

Match 26-character ULIDs (Universally Unique Lexicographically Sortable Identifiers).

Match Git commit hashes, both short (7 chars) and full (40 chars) forms.

Match Docker image references with an explicit tag — e.g. nginx:1.21, mycorp/service:v2.3.1.

Match Slack user mentions in their raw form <@U01234ABC> as delivered by the Events API.

Validate npm package names including scoped packages (@org/package), per the npm naming spec.

Match git remote URLs in both `git@host:org/repo` and `https://host/org/repo` forms.

Match AWS ARNs (Amazon Resource Names) across commercial, China, and GovCloud partitions.

Validate Kubernetes label `key=value` pairs per the K8s naming spec.

Validate AWS S3 bucket names per the standard naming rules: 3–63 chars, lowercase, alphanumeric + dots + hyphens.

Match `${{ expression }}` interpolations used in GitHub Actions workflow YAML.

Validate Python distribution package names per PEP 508: letters, digits, dots, underscores, hyphens.

Validate Kubernetes pod names per the RFC 1123 DNS label rules — lowercase, ≤63 chars, no leading/trailing hyphen.

Match Markdown links [link text](url) and capture both the display text and the URL.

Matches markdown ATX-style headings (# through ######).

Matches Markdown image syntax .

Matches lines containing only whitespace (or empty lines).

Detects consecutive duplicate words using a backreference.

Matches sentence boundaries (punctuation followed by whitespace and a capital letter).

Match hashtags (# followed by word characters) in social media posts, including accented Latin characters.

Match Base64-encoded strings, including proper padding with = and == characters.

Match leading and/or trailing whitespace on a string — the regex equivalent of .trim().

Match Unix shell environment variable references in both $VAR and ${VAR} forms.

Validate Conventional Commits format: type(scope)!: description.

Match emoji characters across the main Unicode emoji ranges — requires the Unicode flag in JavaScript.

Demonstrate named capture groups by extracting year/month/day from ISO-style dates.

Use positive lookahead `(?=...)` to require the password contain at least one digit and one uppercase letter.

Use negative lookbehind `(?<!...)` to match decimal numbers NOT preceded by a dollar sign.

Match the whole word `cat` without matching it inside other words like `concatenate` or `category`.

Use non-capturing groups `(?:...)` to alternate without polluting the captured-groups list.

Match trailing spaces and tabs at the end of each line — the regex linters use to flag dirty whitespace.

Match `{expression}` placeholders inside Python f-strings (or any single-brace template syntax).

Match `${expression}` placeholders inside JavaScript template literals.

Match triple-quoted strings (Python docstrings, TypeScript triple-quote, etc.) including newlines.

Demonstrate lazy quantifiers `+?` by matching the SHORTEST HTML-like tag rather than the longest greedy span.

Extract simple `"key": value` pairs from JSON-ish text (strings, numbers, booleans, null).

Match the column list and table name from a SQL SELECT ... FROM statement.

Match Python `import x` and `from x import y` statements, capturing the module and target.

Match C-style /* ... */ block comments across multiple lines.

Match single-line comments using either the `//` (C-family) or `#` (shell, Python, Ruby, YAML) marker.

Match Keep-a-Changelog style version headers like `## [1.2.3] - 2024-01-15` or `## 2.0.0`.

Match JSON-spec numbers — disallows leading zeros (no `01`), allows decimals and exponents.

Match GraphQL operation headers — `query`, `mutation`, or `subscription` — capturing the operation name.

Match JavaScript / TypeScript variable declarations (`var`, `let`, `const`), capturing the keyword and identifier name.

Use negative lookahead `(?!...)` to match words that are NOT in a blocklist (here: log-level keywords).

Match literal tab characters — the regex behind every formatter / linter that yells about indentation.

Match runs of non-ASCII characters (anything outside U+0000–U+007F).

Match JSON `true`, `false`, and `null` literal values, with word boundaries to avoid partial matches.

Match the opening line of a Terraform `resource "type" "name" {` block, capturing the resource type and local name.

Match Terraform / HCL references like `var.name`, `local.foo`, `module.x.output`, or `data.aws_ami.ubuntu.id`.

Match Java `package com.example.app;` declarations and capture the dotted package path.

Matches whole integers, including negative numbers.

Matches decimal numbers, including integers and negatives.

Matches USD currency amounts with optional $ sign, thousands separators, and cents.

Matches percentage values with optional decimal and a trailing % sign.

Matches numbers in scientific/exponential notation (e.g., 1.5e10).

Match US dollar amounts inline in text: `$1,234.56`, `$99`, `$1,000,000.00`.

Match hexadecimal number literals like `0xFF`, `0x1A2B`, or `0XdeadBeef`.

Match binary number literals like `0b1010` or `0B11110000`.

Match floating-point and scientific-notation numbers including `1.5`, `.25`, `1e10`, `-3.14E-2`.

Match modern ECMAScript-style octal literals (`0o755`) — strict per ES6+ syntax.

Matches absolute Unix/Linux file paths.

Matches absolute Windows file paths (e.g., C:\Users\file.txt).

Captures the file extension from a filename.

Matches relative file paths (./, ../, or path/to/file).

Matches Unix-style hidden files (dotfiles) like .gitignore or .env.

Match common image file extensions: jpg, jpeg, png, gif, webp, svg, avif, bmp, ico, tif, tiff.

Parse KEY=value lines from .env config files, handling quoted values and trailing comments.

Match common video file extensions: mp4, mov, avi, mkv, webm, m4v, flv, wmv, mpg, mpeg.

Match Dockerfile `ENV KEY=value` (or `ENV KEY value`) instructions, capturing key and value.

Parses Apache Common Log Format entries.

Parses RFC 5424 syslog messages.

Matches standard log level keywords in log lines.

Matches a single Java stack trace frame line.

Parses Nginx error log lines.

Parse key=value pairs from logfmt-style log lines, supporting both quoted and unquoted values.

Match a single-line JSON object — typical of structured logging from services like slog, Bunyan, or Pino.

Match Log4j / Logback PatternLayout conversion specifiers like `%d{yyyy-MM-dd}`, `%-5p`, or `%c{1}`.

Match AWS CloudWatch log group / stream paths like `/aws/lambda/my-function` or `/aws/ecs/cluster-name`.