URL & Path Validation Regular Expression

A valid URL (Uniform Resource Locator) follows the format defined in RFC 3986. This regex validates HTTP and HTTPS URLs with optional www prefix, domain names, paths, query strings, and fragments. URLs are essential for web navigation and API endpoints.

Recommended Solution

^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$

Explanation

^ - Start of the string.
https? - Protocol: http or https.
:\/\/ - Literal "://" separator.
(?:www\.)? - Optional "www." prefix.
[-a-zA-Z0-9@:%._\+~#=]{1,256} - Domain name or subdomain (1-256 characters). See domain validation for more details.
\.[a-zA-Z0-9()]{1,6} - Top-level domain (e.g., .com, .org) with 1-6 characters.
\b - Word boundary to ensure proper domain ending.
(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*) - Optional path, query string, and fragment.
$ - End of the string.

Notes

This regex validates the format of URLs but does NOT verify if the URL is accessible or exists.
This pattern only supports HTTP and HTTPS protocols. To support other protocols (ftp, mailto, etc.), modify the protocol part.
Port numbers are implicitly allowed through the character class but not explicitly validated.
IP addresses (IPv4/IPv6) are not fully supported by this pattern. Use a dedicated IP address validation regex if needed.
International domain names (IDN) must be in Punycode format to be validated correctly.
Query parameters and fragments are allowed but not individually validated for correctness.
For more robust validation, consider using built-in URL parsing libraries in your programming language.

Implementation

const urlRegex = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$/;
const isValidURL = (url) => urlRegex.test(url);

import re

def is_valid_url(url):
  urlRegex = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
  return re.match(urlRegex, url) is not None

use regex::Regex;

fn is_valid_url(url: &str) -> bool {
  let urlRegex = Regex::new("^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$")
    .expect("Could not parse URL validation regex");
  urlRegex.is_match(url)
}

package main

import (
  "fmt"
  "regexp"
)

func isValidURL(url string) bool {
  urlRegex := "^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
  re := regexp.MustCompile(urlRegex)
  return re.MatchString(url)
}

import Foundation

func isValidURL(_ url: String) -> Bool {
  let urlRegex = "^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
  return NSPredicate(format: "SELF MATCHES %@", urlRegex).evaluate(with: url)
}

using System;
using System.Text.RegularExpressions;

class Application {
  static bool IsValidURL(string url) {
    string urlRegex = "^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$";
    return Regex.IsMatch(url, urlRegex);
  }
}

import java.util.regex.*;

public class Application {
  public static boolean isValidURL(String url) {
    String urlRegex = "^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$";
    Pattern pattern = Pattern.compile(urlRegex);
    Matcher matcher = pattern.matcher(url);
    return matcher.matches();
  }
}

<?php
function isValidURL($url) {
  $urlRegex = "^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$";
  return (bool) preg_match("/" . $urlRegex . "/", $url);
}
?>

Test Cases

URL	Valid
https://www.example.com
http://example.com
https://example.com/path/to/resource
https://example.com/path?query=value
https://example.com:8080/path
https://subdomain.example.com
http://example.com/path#fragment
https://example.com/path?key1=value1&key2=value2
https://example.co.uk
https://192.168.1.1
ftp://example.com
https://
example.com
www.example.com
https://example
https://example.
https://ex ample.com
(empty string)
http:/example.com
https//example.com