Regex for UUIDs (Versions 1–8)

Read it left to right. Each piece below matches one part of the input:

• ^[0-9a-f]{8} 8 hex digits. With the i flag, A–F are accepted too.
• -[0-9a-f]{4} A hyphen and 4 hex digits.
• -[1-8][0-9a-f]{3} The version digit (1–8) and 3 more hex digits. Version 4 is random, version 7 is time-ordered.
• -[89ab][0-9a-f]{3} The variant: the first digit is 8, 9, a or b, the RFC 9562 layout.
• -[0-9a-f]{12}$ 12 hex digits and the end of the string.

Flags: i (ignore case).

The whole input must match, from the first character to the last. Every row below is checked against the pattern by our automated test suite before each release.

Replace the version class:

Version 7 (RFC 9562, 2024) puts a millisecond timestamp in the first 48 bits, so v7 IDs sort by creation time and index well in databases. Version 4 is 122 random bits. To generate either, use the UUID generator; for an even more compact time-sortable ID, see ULID.

RFC 9562 defines two special values that this pattern rejects because their version digit is not 1–8: the nil UUID 00000000-0000-0000-0000-000000000000 and the max UUID ffffffff-ffff-ffff-ffff-ffffffffffff. Allow them explicitly if they are meaningful in your system.

Other spellings you may meet:

• No hyphens (550e8400e29b41d4a716446655440000): ^[0-9a-f]{12}[1-8][0-9a-f]{3}[89ab][0-9a-f]{15}$.
• Braces or a urn:uuid: prefix: strip them before validating.
• Uppercase: valid input, but RFC 9562 says to output lowercase, so normalize before storing to keep comparisons exact.

The pattern is translated for each engine rather than pasted as is: named groups, anchors, escapes, shorthand classes and flags are adjusted so each snippet behaves as closely to the JavaScript version as its engine allows. Differences that remain (Go's RE2 has no lookarounds or backreferences, for example) are called out under each one. The Code tab in the tester above also exports Dart, and updates as you edit the pattern.

JavaScript and TypeScript

const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

function isValid(value) {
  return regex.test(value);
}

console.log(isValid("550e8400-e29b-41d4-a716-446655440000"));

Python

import re

pattern = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\Z", re.IGNORECASE)

def is_valid(value: str) -> bool:
    return pattern.search(value) is not None

print(is_valid("550e8400-e29b-41d4-a716-446655440000"))

• JavaScript's $ only matches at the very end of the string. Python's $ also matches before a trailing newline, so the pattern uses \Z instead.

Go

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`)
	fmt.Println(re.MatchString("550e8400-e29b-41d4-a716-446655440000"))
}

C#

using System;
using System.Text.RegularExpressions;

// The timeout stops a pathological input from hanging the thread (ReDoS).
var regex = new Regex(@"^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z", RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));
Console.WriteLine(regex.IsMatch("550e8400-e29b-41d4-a716-446655440000"));

• JavaScript's $ only matches at the very end of the string. .NET's $ also matches before a trailing newline, so the pattern uses \z instead.

PHP

<?php

$pattern = '/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iD';

function isValid(string $value, string $pattern): bool
{
    return preg_match($pattern, $value) === 1;
}

var_dump(isValid('550e8400-e29b-41d4-a716-446655440000', $pattern));

• The D modifier makes $ match only at the very end, like JavaScript (PCRE's $ also matches before a trailing newline).

• Regex for Semantic Versioning (SemVer): major.minor.patch with optional prerelease and build metadata, per semver.org.
• Regex for JWT (JSON Web Token) Format: Three base64url segments separated by dots: header, payload and an optional signature.
• Regex for Hex Color Codes: CSS hex colors in 3, 4, 6 or 8 digits with a leading hash.
• Regex for MAC Addresses: Six hex pairs with consistent : or - separators, or Cisco's dotted form.

Browse all 25 patterns in the regex pattern library, or build your own in the regex tester.