Correctly match URL against domain name without killing yourself with regular expressions

; Date: Tue Oct 26 2021

Tags: Node.JS »»»» JavaScript

The Internet relies on domain names as a more user-friendly humane address mechanism than IP addresses. That means we must often write code checking if a URL is "within" domain A or domain B, and to act accordingly. You might think a regular expression is the way to go, but it has failings because while a URL looks like a text string it's actually a data structure. A domain name comparison has to recognize that it's dealing with a data structure, and to compare correctly. Otherwise a URL with domain name "" might match the regular expression /$/i and do the wrong thing.

What do I mean that a domain name is a data structure? A domain name like ( sure looks like a string, and we store it as a string in software. The first thing to notice is a domain name like is deeply nested. In production systems, the hardware elements (routers, etc) will often be named with deeply nested domain names reflecting the geographical location and other identifiers. Or consider that many sites, like, have lots of subdomains, like or

The domain name looks like a string, but is a nested data structure. At the top is .com, then, then, and so forth. Domain names are case insensitive, FWIW. The test of whether a domain name is a subdomain of another is not a simple case-less string comparison. By convention the domain is often equal to The natural way to describe any subdomain of is with the pattern match *, but where do we get a suitable matching algorithm? These are examples of why I'm insisting you must treat a domain name as a data structure, rather than as a simple string.

A common task is matching a domain name or a URL to see if it's associated with a specific domain name. You then act on the domain name correctly for the domain name.

For example, in ( AkashaCMS has two plugins which must do this. One, the External Links plugin, looks for <a href=...> tags for outbound links, and will add rel=nofollow or other attributes depending on the domain. Another, Affiliate Links, looks to see if the outbound link matches a domain for which there is an affiliate relationship, it will add rel=nofollow, and additionally add the affiliate tag if it is missing.

These modules must do things like these:

  • Not match a domain like as if it is
  • Correctly match a subdomain like as being associated with

Example code

In AkashaCMS there was the following loop:

let href = ... the href= attribute of the link to modify
let urlP = url.parse(href, true, true);
    { country: "com", domain: /amazon\.com$/i },
    { country: "ca",  domain: /amazon\.ca$/i },
    { country: "co-jp",  domain: /amazon\.co\.jp$/i },
    { country: "co-uk",  domain: /amazon\.co\.uk$/i },
    { country: "de",  domain: /amazon\.de$/i },
    { country: "es",  domain: /amazon\.es$/i },
    { country: "fr",  domain: /amazon\.fr$/i },
    { country: "it",  domain: /amazon\.it$/i }
].forEach(amazonSite => {
    let amazonCode = getAmazonAffiliateCodeForCountry(;
    if (amazonSite.domain.test(urlP.hostname) && amazonCode) {
        ... operate on the link

The code as it stands "works" to a degree. It knows a set of Amazon domains, and uses the regular expression to match against the hostname portion of the URL.

But as I noted in the introduction, this doesn't match the domain name properly. Yes, I've made sure to use the case-less modifier (i) and to escape the . characters so I'm assuredly correctly matching the domain name. But, did I prevent it from matching a domain of Nope.

What's desired is for the match to work like a domain name match should work. While I'm sure the predominant technique for matching domain names is regular expressions, they aren't a good mechanism for matching domain names.

Instead, as we noted earlier, the natural way to describe a subdomain match is the pattern *

For example you want to match and and any other subdomain of One would possibly encode a more complete match in a more comprehensive regular expression ... e.g. /^amazon\.com$|.*\.amazon\.com$/i might work, or it might not though an expression like that would work. As you start accounting for more corner cases the regular expression starts to be more and more complex. You're on a slippery slope into regular expression hell, and perhaps it's necessary to take a step back and consider the situation.

Wouldn't a match expression like * make more sense? In other words, doesn't rewriting the above loop as so make more sense?

let href = ... the href= attribute of the link to modify
let urlP = url.parse(href, true, true);
    { country: "com", domain: '*' },
    { country: "ca",  domain: '*' },
    { country: "co-jp",  domain: '*' },
    { country: "co-uk",  domain: '*' },
    { country: "de",  domain: '*' },
    { country: "es",  domain: '*' },
    { country: "fr",  domain: '*' },
    { country: "it",  domain: '*' }
].forEach(amazonSite => {
    let amazonCode = getAmazonAffiliateCodeForCountry(;
    if (domainMatch(amazonSite.domain, href) && amazonCode) {
        ... operate on the link

The question is where to get the domainMatch function.

Introducing the Domain Match package

Try: (

USAGE is as above, or:

var domainMatch = require('domain-match');
var matched = domainMatch('*', '');
// matched == true

In other words, you don't even have to parse the URL, the domainMatch function does it for you. But more importantly, it does domain name matching the way it's supposed to be done. The matching expression in this case is simple and straight-forward and natural to the task of matching domain names.

$ node
> const domainMatch = require('domain-match');
> domainMatch('*', '');
> domainMatch('*', '');

Even more interesting is it matches not just the domain name but the other parts of the URL. In this case changing prefix to prefix2 caused the URL comparison to not match.

A related package

The domain-match package is what came up first in my search on Another package popped up in a broader search:

It's curious why domain-match is so thinly used, and why aren't there more packages of this sort? Or does everyone just use regular expressions or even worse simple string comparison?

About the Author(s)

( David Herron : David Herron is a writer and software engineer focusing on the wise use of technology. He is especially interested in clean energy technologies like solar power, wind power, and electric cars. David worked for nearly 30 years in Silicon Valley on software ranging from electronic mail systems, to video streaming, to the Java programming language, and has published several books on Node.js programming and electric vehicles.

Books by David Herron