What is URL Regex in Go?

In Go (Golang), regular expressions are powered by the built-in regexp package. A URL regex is a pattern used to match valid website links such as https://example.com/path.

Use Go regex to:

• Validate website inputs (links, APIs)

• Clean up scraped URLs

• Build route matchers in backend systems

• Parse and extract components from URLs

  
  

Meta Characters Used in URL Regex

• ^ : Anchors the pattern to the start of the string.

• $ : Anchors the pattern to the end of the string.

• . : Matches any character except newline.

• + : One or more of the previous token.

• * : Zero or more of the previous token.

• ? : Zero or one of the previous token.

• [] : Matches one character from a set.

• () : Groups tokens together.

• | : Acts as a logical OR.

• \\ : Escapes a metacharacter.

  
  

 How It Works

1. Input your URL regex pattern.

2. Paste the URL string you want to validate.

3. Click “Validate” to check if it matches.

4. Use “Try Another” to repeat with different examples.

   
   

Example 1 – Basic URL Validator in Go

Test your full regex logic using the Go Regex Tester.

package main

import (
    "fmt"
    "regexp"
)

func isValidURL(url string) bool {
    var pattern = `^(http|https)://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:?#@!$&'()*+,;=]*)*$`
    urlRegex := regexp.MustCompile(pattern)
    return urlRegex.MatchString(url)
}

func main() {
    testURL := "https://www.example.com/search?q=test"
    fmt.Println("Valid URL:", isValidURL(testURL))
}

Examples:

• Input: "https://www.example.com/search?q=test"
  Output: Valid URL: true
  Explanation: The above URL is correctly formatted and matches the validation pattern.

• Input: "https://www.example.com/ ,search"
  Output: Valid URL: false
  Explanation: This URL contains a space after a comma, which makes it invalid according to the pattern.

  
  

Example 2 – Match Shortened URLs

Also test this pattern in the JavaScript Regex Tester if you’re working on frontend validation.

var shortURL = "http://bit.ly/3abc"
var regex = regexp.MustCompile(`^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-]*)?$`)
fmt.Println("Valid short URL:", regex.MatchString(shortURL))

Examples:

• Input: "http://bit.ly/3abc"
  Output: Valid short URL: true
  Explanation: This short URL fits the pattern for shortened links.

• Input: "http://bit.ly/ 3abc"
  Output: Valid short URL: false
  Explanation: A space after the domain causes validation to fail.

This approach checks for the full protocol, allows a broad set of characters in the domain and path, and can be quickly integrated into your client-side validation logic.

Tip: Whether you’re building a Go backend or a JavaScript frontend, always tailor your regular expressions to the expected input format and test thoroughly with real-world examples like shortened URLs from Bitly, TinyURL, or similar services.

Example 3 – Check for Optional Trailing Slash

Need a realistic domain or IP for testing? Use our Domain Name Generator or IPv4 Generator.

var urlWithSlash = "https://qodex.ai/"
var regex = regexp.MustCompile(`^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/?$`)
fmt.Println("URL has optional trailing slash:", regex.MatchString(urlWithSlash))

Examples:

• Input: "https://qodex.ai/"
  Output: true
  Explanation: This URL ends with a trailing slash, which is allowed by the pattern.

• Input: "https://qodex.ai"
  Output: true
  Explanation: The trailing slash is optional, so both forms are valid.

  
  

Time and Space Complexity for URL Validation

URL validation using regular expressions is highly efficient:

• Time Complexity: Since each character in the string is examined once by the regex engine, the time complexity is typically O(N), where N is the length of the input URL.

• Space Complexity: No significant extra memory is needed beyond a handful of variables; thus, the space complexity is O(1).

In summary, regex-based URL checks are both quick and lightweight, even for longer URLs. This makes them a solid fit for everything from lightning-fast form checks to large-scale data parsing tools.

Pro Tips for Using URL Regex in Go

• Always anchor patterns using ^ and $ to avoid partial matches.

• Escape . as \\. to match literal dots in domain names.

• Use https? to allow both HTTP and HTTPS protocols.

• Use + to allow multiple path characters.

• Validate full URLs including query strings and paths for robust checking.

  
  

Common Use Cases

• Form input validation (user-submitted URLs)

• Web scraper output cleaning

• API URL parsing

• CMS link validation

• Marketing campaign tracker validation

Example – URL Validation in Python

Regular expressions aren’t just for Go! If you’re building Python-powered backends, you can validate URLs with the re module in just a few lines.

Here’s a quick way to check that URLs meet your format requirements:

import re

def is_valid_url(url):
    # Basic URL validation regex
    pattern = r'^(https?://)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/[^\s]*)?$'
    return re.match(pattern, url) is not None

# Example usage
test_url = "https://www.example-site.org/path?query=123"
print("Valid URL:", is_valid_url(test_url))

A few pointers to keep in mind:

• The https?:// makes the protocol optional or allows both HTTP and HTTPS.

• Dots are escaped to ensure only real domain segments match.

• This pattern allows for optional paths or query strings after the root domain.

• Remember, for extremely strict validation (including ports, IPs, Unicode domains, etc.), you may want to expand the regex or use dedicated libraries like validators or urllib.parse.

Mix and match the above with your Go regex patterns to cover multiple languages as your project grows!

URL Validation in Java Using Regular Expressions

If you're working in Java and need to confirm whether a string is a properly formatted URL, you can use the Pattern and Matcher classes from the java.util.regex package. This approach allows you to construct a regular expression that checks for the required components of a URL, such as the protocol, domain, and optional path.

Here’s a practical way to validate URLs in Java:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class URLValidator {
    public static boolean isValidURL(String url) {
        // Basic URL regex for http/https with optional www and path
        String regex = "^(https?://)(www\\.)?[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:/?#@!$&'()*+,;=]*)?$";
        Pattern pattern = Pattern.compile(regex);
        if (url == null) return false;
        Matcher matcher = pattern.matcher(url);
        return matcher.matches();
    }

    public static void main(String[] args) {
        String testURL = "https://www.admin.google.com/";
        System.out.println("Is valid URL? " + isValidURL(testURL));
    }
}

How it works:

• The regex pattern supports http and https, with or without www.

• It matches domain names with standard domain extensions and allows for common URL characters in the path.

• Simply call isValidURL() with your input string to check if it matches the expected URL format.

For more advanced needs, you can adapt the regular expression or integrate external libraries for further URL validation. This approach works well for form input checks, data cleaning, or backend validation logic.

Combine with These Tools

• Email Regex Go Validator – Validate emails with regex

• Phone Number Generator – Get mock numbers for form testing

• Username Generator – Generate test usernames to build full test profiles

• Domain Name Generator – Use with URL regex to test subdomains

• Password Generator – Create complete login simulations