Regex for URL Slugs

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

• ^ Start of the string.
• [a-z0-9]+ The first word: one or more lowercase letters or digits.
• (?:-[a-z0-9]+)* Any number of further words, each introduced by exactly one hyphen.
• $ End of the string, so a trailing hyphen fails.

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.

Normalize, lowercase, replace anything that is not a letter or digit with a hyphen, then trim:

function slugify(title) {
  return title
    .normalize("NFKD")                 // é → e + combining accent
    .replace(/[\u0300-\u036f]/g, "")    // drop the accents
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")       // runs of anything else → one hyphen
    .replace(/^-+|-+$/g, "");          // no hyphen at either end
}

slugify("Crème Brûlée: 10 Tips!"); // "creme-brulee-10-tips"

The output always matches the slug regex (or is empty, which you should reject). Run the regex on slugs that users edit by hand as well, since the admin form is where doubled hyphens and capitals sneak in.

Google's URL structure guidelines recommend hyphens to separate words, because underscores join words together for search. Lowercase avoids a quieter problem: most servers treat paths as case-sensitive, so /Blog/Post and /blog/post would be two URLs with the same content.

For non-Latin titles, either transliterate (a library such as slugify or transliteration handles Cyrillic, Greek and more) or allow Unicode letters with ^[\p{Ll}\p{N}]+(?:-[\p{Ll}\p{N}]+)*$ and the u flag; browsers display those paths readably even though they are percent-encoded on the wire.

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 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;

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

console.log(isValid("hello-world"));

Python

import re

pattern = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*\Z")

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

print(is_valid("hello-world"))

• 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(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
	fmt.Println(re.MatchString("hello-world"))
}

C#

using System;
using System.Text.RegularExpressions;

// The timeout stops a pathological input from hanging the thread (ReDoS).
var regex = new Regex(@"^[a-z0-9]+(?:-[a-z0-9]+)*\z", RegexOptions.None, TimeSpan.FromSeconds(1));
Console.WriteLine(regex.IsMatch("hello-world"));

• 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 = '/^[a-z0-9]+(?:-[a-z0-9]+)*$/D';

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

var_dump(isValid('hello-world', $pattern));

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

• Regex for URL Validation: http and https links with a real domain, optional port, path, query and fragment.
• Regex for Usernames: 3–16 characters, starts with a letter, single separators between letters and digits.
• Regex for Alphanumeric Characters: Letters A–Z and digits only, with a Unicode variant for every script.
• Regex for Domain Names: Hostnames with valid labels, a 253-character limit and Punycode support.

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