Match patterns are a way to specify groups of URLs: a match pattern matches a specific set of URLs. They are for extensions using WebExtensions APIs in a few places, most notably to specify which documents to load content scripts into, and to specify which URLs to add webRequest listeners to.

APIs that use match patterns usually accept a list of match patterns, and will perform the appropriate action if the URL matches any of the patterns. See, for example, the content_scripts key in manifest.json.

Match pattern structure

Note: Some browsers don’t support certain schemes.
Check the Browser compatibility table for details.

All match patterns are specified as strings. Apart from the special "<all_urls>" pattern, match patterns consist of three parts: scheme, host, and path. The scheme and host are separated by "://".



The scheme component may take one of two forms:

Form Matches
"*" Only "http" and "https" and in some browsers also "ws" and "wss".
One of "http", "https", "ws", "wss", "ftp", "ftps" or "file". Only the given scheme.


The host component may take one of three forms:

Form Matches
"*" Any host.
"*." followed by part of the hostname. The given host and any of its subdomains.
A complete hostname, without wildcards. Only the given host.

host must not include a port number.

host is optional only if the scheme is "file".

Note that the wildcard may only appear at the start.


The path component must begin with a "/".

After that, it may subsequently contain any combination of the "*" wildcard and any of the characters that are allowed in URL paths. Unlike host, the path component may contain the "*" wildcard in the middle or at the end, and the "*" wildcard may appear more than once.


The special value "<all_urls>" matches all URLs under any of the supported schemes: that is "http", "https", "ws", "wss", "ftp" and "file".


Pattern Example matches Example non-matches


Match all URLs.




(unsupported scheme)


Match all HTTP, HTTPS and WebSocket URLs.


(unmatched scheme)

(unmatched scheme)

(unmatched scheme)


Match all HTTP, HTTPS and WebSocket URLs that are hosted at "" or one of its subdomains.


(unmatched scheme)
(unmatched host)
(unmatched host)


Match all HTTP, HTTPS and WebSocket URLs that are hosted at exactly "".


(unmatched scheme)
(unmatched host)
(unmatched path)

Match only "".
(unmatched scheme)
(unmatched host)
(unmatched path)


Match HTTPS URLs on any host, whose path is "path".
(unmatched scheme)
(unmatched path)
(unmatched path)
(unmatched path)


Match HTTPS URLs on any host, whose path is "path/".
(unmatched scheme)
(unmatched path)
(unmatched path)
(unmatched path)*

Match HTTPS URLs only at "", with any path.
(unmatched scheme)
(unmatched host)

Match only this URL. Anything else.*/b/*/

Match HTTPS URLs hosted on "", whose path contains a component "b" somewhere in the middle.*/
(unmatched path)
(unmatched path)


Match any FILE URL whose path begins with "blah".



(unmatched path)

Invalid match patterns

Invalid pattern Reason
resource://path/ Unsupported scheme. No path.
https://mozilla.*.org/ "*" in host must be at the start.
https://* "*" in host must be the only character or be followed by ".".
http*:// "*" in scheme must be the only character. Host must not include a port number.
*://* Empty path: this should be "*://*/*".
file://* Empty path: this should be "file:///*".

Browser compatibility


ChromeEdgeFirefoxFirefox for AndroidOpera
Wildcard * scheme Yes144848 Yes
* matches ws and wss No ?5555 No
http Yes144848 Yes
https Yes144848 Yes
ws No ?5555 No
wss No ?5555 No
ftp Yes144848 Yes
ftps No No No1 No1 No
file Yes144848 Yes
data No ?482482 No

1. See bug 1463440

2. Doesn’t support injection of content scripts or stylesheets.

Converting Match Patterns to Regular Expressions

All match patterns can be represented by regular expressions. This code converts a match pattern to a regular expression:

 * Transforms a valid match pattern into a regular expression
 * which matches all URLs included by that pattern.
 * @param  {string}  pattern  The pattern to transform.
 * @return {RegExp}           The pattern's equivalent as a RegExp.
 * @throws {TypeError}        If the pattern is not a valid MatchPattern
function matchPatternToRegExp(pattern) {
    if (pattern === '') {
        return (/^(?:http|https|file|ftp|app):\/\//);

    const schemeSegment = '(\\*|http|https|ws|wss|file|ftp)';
    const hostSegment = '(\\*|(?:\\*\\.)?(?:[^/*]+))?';
    const pathSegment = '(.*)';
    const matchPatternRegExp = new RegExp(

    let match = matchPatternRegExp.exec(pattern);
    if (!match) {
         throw new TypeError(`"${pattern}" is not a valid MatchPattern`);

    let [, scheme, host, path] = match;
    if (!host) {
        throw new TypeError(`"${pattern}" does not have a valid host`);

    let regex = '^';

    if (scheme === '*') {
        regex += '(http|https)';
    } else {
        regex += scheme;

    regex += '://';

    if (host && host === '*') {
        regex += '[^/]+?';
    } else if (host) {
        if (host.match(/^\*\./)) {
            regex += '[^/]*?';
            host = host.substring(2);
        regex += host.replace(/\./g, '\\.');

    if (path) {
        if (path === '*') {
            regex += '(/.*)?';
        } else if (path.charAt(0) !== '/') {
            regex += '/';
            regex += path.replace(/\./g, '\\.').replace(/\*/g, '.*?');
            regex += '/?';

    regex += '$';
    return new RegExp(regex);

Document Tags and Contributors

Last updated by: Kwan,