URL Regex Pattern — Match and Validate URLs with Regular Expressions

The definitive guide to URL validation with regex. Get patterns for matching HTTP/HTTPS URLs, extracting links from text, and validating user-submitted URLs.

Standard URL Regex Pattern

https?:\/\/[^\s]+

Matches HTTP and HTTPS URLs. Captures everything after the protocol until the next whitespace character. Works for most URL extraction tasks.

//
Flags:

Substitution

No matches found

How URL Regex Works

A URL has several distinct parts, and a comprehensive regex pattern can validate each one. Understanding URL structure helps you write better patterns:

https?

Protocol: Matches http or https. The ? makes the s optional, so both protocols are matched.

:\/\/

Protocol separator: The literal ://. The backslashes escape the forward slashes since / is a regex delimiter in some languages.

[^\s]+

URL body: Matches one or more non-whitespace characters. This captures the domain, path, query string, and fragment — everything until a space or newline.

URL Regex Patterns Compared

Different use cases require different levels of URL validation. Here are patterns ranging from simple to comprehensive:

Simple — URL Extraction

https?:\/\/[^\s]+

Quick extraction: finds all http/https URLs in text. Use the global flag (g) to match all occurrences. Good for parsing logs, messages, or documents.

Standard — Basic Validation

https?:\/\/(www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?

Validates protocol, optional www, domain with TLD, and optional path. Good balance of strictness and flexibility for most web applications.

Strict — Full URL Validation

^https?:\/\/(www\.)?[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}(:\d{1,5})?(\/[^\s?#]*)?(\?[^\s#]*)?(#\S*)?$

Comprehensive validation with port, path, query string, and fragment support. Enforces domain label rules and uses anchors for full-string matching.

Anatomy of a URL

Understanding URL structure helps you write better regex patterns. Here's a breakdown of a complete URL:

https://www.example.com:443/path/to/page?key=value&foo=bar#section

Protocol

https — identifies the communication protocol

Domain

www.example.com — the hostname

Port

:443 — optional port number (default: 80 for HTTP, 443 for HTTPS)

Path

/path/to/page — the resource location on the server

Query String

?key=value&foo=bar — parameters passed to the server

Fragment

#section — client-side anchor, not sent to server

Common URL Regex Patterns

Here are ready-to-use URL regex patterns for common scenarios:

HTTP/HTTPS URLs

https?:\/\/[^\s]+

Matches any HTTP or HTTPS URL — the most common extraction pattern

URLs with www

(https?:\/\/)?www\.[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?

Matches URLs with optional protocol and required www prefix

Domain Only

[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b(\/[^\s]*)?

Matches domains with optional path, no protocol required

URL with Port

https?:\/\/[a-zA-Z0-9.-]+:\d{1,5}(\/[^\s]*)?

Matches URLs that include a port number like :8080

URL with Query String

https?:\/\/[^\s?]+\?[a-zA-Z0-9._~:/?#\[\]@!$&'()*+,;=-]+

Matches URLs that include query parameters

Image URLs

https?:\/\/[^\s]+\.(jpg|jpeg|png|gif|webp|svg)(\?[^\s]*)?

Matches URLs pointing to image files

URL Regex Edge Cases

URLs can be tricky to match correctly. Here are edge cases to consider:

URLs with authentication

https://user:pass@example.com — contains @ in the authority section

IP address URLs

http://192.168.1.1:8080/path — uses IP instead of domain name

URLs with fragments

https://example.com/page#section — hash fragments at the end

Encoded characters

https://example.com/path%20with%20spaces — percent-encoded characters

URLs ending with punctuation

Visit https://example.com. — period at end of sentence may be captured

Non-HTTP protocols

ftp://, file://, mailto: — other protocols need different patterns

Best Practices for URL Validation

  • Choose the right pattern for your use case

    Use simple patterns for extraction and strict patterns for validation. Don't over-validate if you just need to find URLs in text.

  • Consider using URL parsing APIs

    JavaScript's new URL() constructor provides robust URL parsing with built-in validation. Use regex for extraction, URL APIs for parsing.

  • Handle trailing punctuation carefully

    When extracting URLs from prose, periods, commas, and parentheses at the end of a URL are usually not part of the URL. Adjust your pattern or post-process matches.

  • Test with real-world URLs

    Test your pattern with URLs from your actual data — including long paths, query strings, and special characters that your users might submit.

URL Regex in Code

Here's how to use URL regex in popular programming languages:

JavaScript — Extract URLs from text

const text = "Visit https://example.com and http://test.org/path?q=1";
const urlRegex = /https?:\/\/[^\s]+/g;
const urls = text.match(urlRegex);
// ["https://example.com", "http://test.org/path?q=1"]

JavaScript — Validate a URL

const urlRegex = /^https?:\/\/[^\s]+$/;
const isValid = urlRegex.test("https://example.com/path"); // true
const isInvalid = urlRegex.test("not a url"); // false

JavaScript — Using URL API (recommended for parsing)

try {
  const url = new URL("https://example.com:8080/path?q=1#hash");
  console.log(url.hostname); // "example.com"
  console.log(url.port);     // "8080"
  console.log(url.pathname); // "/path"
} catch {
  console.log("Invalid URL");
}

When to Use Regex vs. URL APIs

Use Regex When:

  • • Extracting URLs from text content
  • • Quick format validation in forms
  • • Finding links in log files
  • • Pattern matching in strings
  • • Working without URL parsing APIs

Use URL APIs When:

  • • Parsing URL components
  • • Modifying query parameters
  • • Building URLs programmatically
  • • Strict RFC-compliant validation
  • • Working with relative URLs

Test Your URL Regex Now

Use the tester above to verify your URL regex with actual data. Extract, validate, and debug — all in your browser.