---
title: URL Functions reference
meta:
    description: Functions for working with URLs.
headingMaxLevels: 3
---

# Functions for working with URLs

The following functions are available for working with URLs.

You can generally use the non-`RFC` function variants when working with publicly registered domains that contain neither user strings nor `@` symbols.

## Functions that Extract Parts of a URL

If the relevant part isn’t present in a URL, an empty string is returned.

### protocol

Extracts the protocol from a URL.

#### Syntax

```sql
protocol(url)
```

#### Arguments

- `url`: URL to extract protocol from. String.

#### Returned value

- Protocol, or an empty string if it can't be determined. String.

Examples of typical returned values: http, https, ftp, mailto, tel, magnet.

#### Example

```sql
SELECT protocol('https://tinybird.co/')
```

Result:

```result
┌─protocol('https://tinybird.co/')─┐
│ https                            │
└──────────────────────────────────┘
```

### domain

Extracts the hostname from a URL.

#### Syntax

```sql
domain(url)
```

#### Arguments

- `url`: URL. String.

The URL can be specified with or without a protocol. Examples:

```text
svn+ssh://some.svn-hosting.com:80/repo/trunk
some.svn-hosting.com:80/repo/trunk
https://tinybird.co/time/
```

For these examples, the `domain` function returns the following results:

```text
some.svn-hosting.com
some.svn-hosting.com
tinybird.co
```

#### Returned values

- Host name if the input string can be parsed as a URL, otherwise an empty string. String.

#### Example

```sql
SELECT domain('svn+ssh://some.svn-hosting.com:80/repo/trunk')
```

```text
┌─domain('svn+ssh://some.svn-hosting.com:80/repo/trunk')─┐
│ some.svn-hosting.com                                   │
└────────────────────────────────────────────────────────┘
```

### domainRFC

Extracts the hostname from a URL. Similar to domain, but RFC 3986 conformant.

#### Syntax

```sql
domainRFC(url)
```

#### Arguments

- `url`: URL. String.

#### Returned values

- Host name if the input string can be parsed as a URL, otherwise an empty string. String.

#### Example

```sql
SELECT
    domain('http://user:password@example.com:8080/path?query=value#fragment'),
    domainRFC('http://user:password@example.com:8080/path?query=value#fragment')
```

```text
┌─domain('http://user:password@example.com:8080/path?query=value#fragment')─┬─domainRFC('http://user:password@example.com:8080/path?query=value#fragment')─┐
│                                                                           │ example.com                                                                  │
└───────────────────────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────────────┘
```

### domainWithoutWWW

Returns the domain without leading `www.` if present.

#### Syntax

```sql
domainWithoutWWW(url)
```

#### Arguments

- `url`: URL. String.

#### Returned values

- Domain name if the input string can be parsed as a URL (without leading `www.`), otherwise an empty string. String.

#### Example

```sql
SELECT domainWithoutWWW('http://paul@www.example.com:80/')
```

```text
┌─domainWithoutWWW('http://paul@www.example.com:80/')─┐
│ example.com                                         │
└─────────────────────────────────────────────────────┘
```

### domainWithoutWWWRFC

Returns the domain without leading `www.` if present. Similar to domainWithoutWWW but conforms to RFC 3986.

#### Syntax

```sql
domainWithoutWWWRFC(url)
```

#### Arguments

- `url`: URL. String.

#### Returned values

- Domain name if the input string can be parsed as a URL (without leading `www.`), otherwise an empty string. String.

#### Example

Query:

```sql
SELECT
    domainWithoutWWW('http://user:password@www.example.com:8080/path?query=value#fragment'),
    domainWithoutWWWRFC('http://user:password@www.example.com:8080/path?query=value#fragment')
```

Result:

```result
┌─domainWithoutWWW('http://user:password@www.example.com:8080/path?query=value#fragment')─┬─domainWithoutWWWRFC('http://user:password@www.example.com:8080/path?query=value#fragment')─┐
│                                                                                         │ example.com                                                                                │
└─────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────┘
```

### topLevelDomain

Extracts the the top-level domain from a URL.

```sql
topLevelDomain(url)
```

#### Arguments

- `url`: URL. String.

{% callout type="info" %}
The URL can be specified with or without a protocol. Examples:

```text
svn+ssh://some.svn-hosting.com:80/repo/trunk
some.svn-hosting.com:80/repo/trunk
https://tinybird.co/time/
```
{% /callout %}

#### Returned values

- Domain name if the input string can be parsed as a URL. Otherwise, an empty string. String.

#### Example

Query:

```sql
SELECT topLevelDomain('svn+ssh://www.some.svn-hosting.com:80/repo/trunk')
```

Result:

```text
┌─topLevelDomain('svn+ssh://www.some.svn-hosting.com:80/repo/trunk')─┐
│ com                                                                │
└────────────────────────────────────────────────────────────────────┘
```

### topLevelDomainRFC

Extracts the the top-level domain from a URL.
Similar to topLevelDomain, but conforms to RFC 3986.

```sql
topLevelDomainRFC(url)
```

#### Arguments

- `url`: URL. String.

{% callout type="info" %}
The URL can be specified with or without a protocol. Examples:

```text
svn+ssh://some.svn-hosting.com:80/repo/trunk
some.svn-hosting.com:80/repo/trunk
https://tinybird.co/time/
```
{% /callout %}

#### Returned values

- Domain name if the input string can be parsed as a URL. Otherwise, an empty string. String.

#### Example

Query:

```sql
SELECT topLevelDomain('http://foo:foo%41bar@foo.com'), topLevelDomainRFC('http://foo:foo%41bar@foo.com')
```

Result:

```text
┌─topLevelDomain('http://foo:foo%41bar@foo.com')─┬─topLevelDomainRFC('http://foo:foo%41bar@foo.com')─┐
│                                                │ com                                               │
└────────────────────────────────────────────────┴───────────────────────────────────────────────────┘
```

### firstSignificantSubdomain

Returns the “first significant subdomain”. The first significant subdomain is a second-level domain for `com`, `net`, `org`, or `co`, otherwise it's a third-level domain.

#### Syntax

```sql
firstSignificantSubdomain(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- The first significant subdomain. String.

#### Example

Query:

```sql
SELECT firstSignificantSubdomain('http://www.example.com/a/b/c?a=b')
```

Result:

```result
┌─firstSignificantSubdomain('http://www.example.com/a/b/c?a=b')─┐
│ example                                                       │
└───────────────────────────────────────────────────────────────┘
```

### firstSignificantSubdomainRFC

Returns the “first significant subdomain”. The first significant subdomain is a second-level domain for `com`, `net`, `org`, or `co`, otherwise it's a third-level domain.

#### Syntax

```sql
firstSignificantSubdomainRFC(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- The first significant subdomain. String.

#### Example

Query:

```sql
SELECT
    firstSignificantSubdomain('http://user:password@example.com:8080/path?query=value#fragment'),
    firstSignificantSubdomainRFC('http://user:password@example.com:8080/path?query=value#fragment')
```

Result:

```result
┌─firstSignificantSubdomain('http://user:password@example.com:8080/path?query=value#fragment')─┬─firstSignificantSubdomainRFC('http://user:password@example.com:8080/path?query=value#fragment')─┐
│                                                                                              │ example                                                                                         │
└──────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────┘
```

### cutToFirstSignificantSubdomain

Returns the part of the domain that includes top-level subdomains up to the “first significant subdomain”.

#### Syntax

```sql
cutToFirstSignificantSubdomain(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain if possible, otherwise returns an empty string. String.

#### Example

Query:

```sql
SELECT
    cutToFirstSignificantSubdomain('https://news.tinybird.co.tr/'),
    cutToFirstSignificantSubdomain('www.tr'),
    cutToFirstSignificantSubdomain('tr')
```

Result:

```result
┌─cutToFirstSignificantSubdomain('https://news.tinybird.co.tr/')─┬─cutToFirstSignificantSubdomain('www.tr')─┬─cutToFirstSignificantSubdomain('tr')─┐
│ tinybird.co.tr                                                 │ tr                                       │                                      │
└───────────────────────────────────────────────────────────────────┴──────────────────────────────────────────┴──────────────────────────────────────┘
```

### cutToFirstSignificantSubdomainRFC

Returns the part of the domain that includes top-level subdomains up to the “first significant subdomain”.
Similar to cutToFirstSignificantSubdomain but conforms to RFC 3986.

#### Syntax

```sql
cutToFirstSignificantSubdomainRFC(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain if possible, otherwise returns an empty string. String.

#### Example

Query:

```sql
SELECT
    cutToFirstSignificantSubdomain('http://user:password@example.com:8080'),
    cutToFirstSignificantSubdomainRFC('http://user:password@example.com:8080')
```

Result:

```result
┌─cutToFirstSignificantSubdomain('http://user:password@example.com:8080')─┬─cutToFirstSignificantSubdomainRFC('http://user:password@example.com:8080')─┐
│                                                                         │ example.com                                                                │
└─────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────┘
```


### cutToFirstSignificantSubdomainWithWWW

Returns the part of the domain that includes top-level subdomains up to the "first significant subdomain", without stripping `www`.

#### Syntax

```sql
cutToFirstSignificantSubdomainWithWWW(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain (with `www`) if possible, otherwise returns an empty string. String.

#### Example

Query:

```sql
SELECT
    cutToFirstSignificantSubdomainWithWWW('https://news.tinybird.co.tr/'),
    cutToFirstSignificantSubdomainWithWWW('www.tr'),
    cutToFirstSignificantSubdomainWithWWW('tr')
```

Result:

```result
┌─cutToFirstSignificantSubdomainWithWWW('https://news.tinybird.co.tr/')─┬─cutToFirstSignificantSubdomainWithWWW('www.tr')─┬─cutToFirstSignificantSubdomainWithWWW('tr')─┐
│ tinybird.co.tr                                                        │ www.tr                                          │                                             │
└──────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────┴─────────────────────────────────────────────┘
```

### cutToFirstSignificantSubdomainWithWWWRFC

Returns the part of the domain that includes top-level subdomains up to the "first significant subdomain", without stripping `www`.
Similar to cutToFirstSignificantSubdomainWithWWW but conforms to RFC 3986.

#### Syntax

```sql
cutToFirstSignificantSubdomainWithWWW(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain (with "www") if possible, otherwise returns an empty string. String.

#### Example

Query:

```sql
SELECT
    cutToFirstSignificantSubdomainWithWWW('http:%2F%2Fwwwww.nova@mail.ru/economicheskiy'),
    cutToFirstSignificantSubdomainWithWWWRFC('http:%2F%2Fwwwww.nova@mail.ru/economicheskiy')
```

Result:

```result
┌─cutToFirstSignificantSubdomainWithWWW('http:%2F%2Fwwwww.nova@mail.ru/economicheskiy')─┬─cutToFirstSignificantSubdomainWithWWWRFC('http:%2F%2Fwwwww.nova@mail.ru/economicheskiy')─┐
│                                                                                       │ mail.ru                                                                                  │
└───────────────────────────────────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────────────────────────┘
```

### cutToFirstSignificantSubdomainCustom

Returns the part of the domain that includes top-level subdomains up to the first significant subdomain.
Accepts custom TLD list name.
This function can be useful if you need a fresh TLD list or if you have a custom list.

#### Syntax

```sql
cutToFirstSignificantSubdomain(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain. String.

#### Example

Query:

```sql
SELECT cutToFirstSignificantSubdomainCustom('bar.foo.there-is-no-such-domain', 'public_suffix_list')
```

Result:

```text
┌─cutToFirstSignificantSubdomainCustom('bar.foo.there-is-no-such-domain', 'public_suffix_list')─┐
│ foo.there-is-no-such-domain                                                                   │
└───────────────────────────────────────────────────────────────────────────────────────────────┘
```


### cutToFirstSignificantSubdomainCustomRFC

Returns the part of the domain that includes top-level subdomains up to the first significant subdomain.
Accepts custom TLD list name.
This function can be useful if you need a fresh TLD list or if you have a custom list.
Similar to cutToFirstSignificantSubdomainCustom but conforms to RFC 3986.

#### Syntax

```sql
cutToFirstSignificantSubdomainRFC(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain. String.


### cutToFirstSignificantSubdomainCustomWithWWW

Returns the part of the domain that includes top-level subdomains up to the first significant subdomain without stripping `www`.
Accepts custom TLD list name.
It can be useful if you need a fresh TLD list or if you have a custom list.

#### Syntax

```sql
cutToFirstSignificantSubdomainCustomWithWWW(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain without stripping `www`. String.

#### Example

Query:

```sql
SELECT cutToFirstSignificantSubdomainCustomWithWWW('www.foo', 'public_suffix_list')
```

Result:

```text
┌─cutToFirstSignificantSubdomainCustomWithWWW('www.foo', 'public_suffix_list')─┐
│ www.foo                                                                      │
└──────────────────────────────────────────────────────────────────────────────┘
```


### cutToFirstSignificantSubdomainCustomWithWWWRFC

Returns the part of the domain that includes top-level subdomains up to the first significant subdomain without stripping `www`.
Accepts custom TLD list name.
It can be useful if you need a fresh TLD list or if you have a custom list.
Similar to cutToFirstSignificantSubdomainCustomWithWWW but conforms to RFC 3986.

#### Syntax

```sql
cutToFirstSignificantSubdomainCustomWithWWWRFC(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- Part of the domain that includes top-level subdomains up to the first significant subdomain without stripping `www`. String.


### firstSignificantSubdomainCustom

Returns the first significant subdomain.
Accepts customs TLD list name.
Can be useful if you need fresh TLD list or you have custom.

#### Syntax

```sql
firstSignificantSubdomainCustom(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- First significant subdomain. String.

#### Example

Query:

```sql
SELECT firstSignificantSubdomainCustom('bar.foo.there-is-no-such-domain', 'public_suffix_list')
```

Result:

```text
┌─firstSignificantSubdomainCustom('bar.foo.there-is-no-such-domain', 'public_suffix_list')─┐
│ foo                                                                                      │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```


### firstSignificantSubdomainCustomRFC

Returns the first significant subdomain.
Accepts customs TLD list name.
Can be useful if you need fresh TLD list or you have custom.
Similar to firstSignificantSubdomainCustom but conforms to RFC 3986.

#### Syntax

```sql
firstSignificantSubdomainCustomRFC(url, tld)
```

#### Arguments

- `url`: URL. String.
- `tld`: Custom TLD list name. String.

#### Returned value

- First significant subdomain. String.


### port

Returns the port or `default_port` if the URL contains no port or can't be parsed.

#### Syntax

```sql
port(url [, default_port = 0])
```

#### Arguments

- `url`: URL. String.
- `default_port`: The default port number to be returned. UInt16.

#### Returned value

- Port or the default port if there is no port in the URL or in case of a validation error. UInt16.

#### Example

Query:

```sql
SELECT port('http://paul@www.example.com:80/')
```

Result:

```result
┌─port('http://paul@www.example.com:80/')─┐
│                                      80 │
└─────────────────────────────────────────┘
```

### portRFC

Returns the port or `default_port` if the URL contains no port or can't be parsed.
Similar to port, but RFC 3986 conformant.

#### Syntax

```sql
portRFC(url [, default_port = 0])
```

#### Arguments

- `url`: URL. String.
- `default_port`: The default port number to be returned. UInt16.

#### Returned value

- Port or the default port if there is no port in the URL or in case of a validation error. UInt16.

#### Example

Query:

```sql
SELECT
    port('http://user:password@example.com:8080'),
    portRFC('http://user:password@example.com:8080')
```

Result:

```result
┌─port('http://user:password@example.com:8080')─┬─portRFC('http://user:password@example.com:8080')─┐
│                                             0 │                                             8080 │
└───────────────────────────────────────────────┴──────────────────────────────────────────────────┘
```

### path

Returns the path without query string.

Example: `/top/news.html`.

### pathFull

The same as above, but including query string and fragment.

Example: `/top/news.html?page=2#comments`.

### queryString

Returns the query string without the initial question mark, `#` and everything after `#`.

Example: `page=1&lr=213`.

### fragment

Returns the fragment identifier without the initial hash symbol.

### queryStringAndFragment

Returns the query string and fragment identifier.

Example: `page=1#29390`.

### extractURLParameter(url, name)

Returns the value of the `name` parameter in the URL, if present, otherwise an empty string is returned.
If there are multiple parameters with this name, the first occurrence is returned.
The function assumes that the parameter in the `url` parameter is encoded in the same way as in the `name` argument.

### extractURLParameters(url)

Returns an array of `name=value` strings corresponding to the URL parameters.
The values aren't decoded.

### extractURLParameterNames(url)

Returns an array of name strings corresponding to the names of URL parameters.
The values aren't decoded.

### URLHierarchy(url)

Returns an array containing the URL, truncated at the end by the symbols /,? in the path and query-string.
Consecutive separator characters are counted as one.
The cut is made in the position after all the consecutive separator characters.

### URLPathHierarchy(url)

The same as above, but without the protocol and host in the result. The / element (root) isn't included.

```text
URLPathHierarchy('https://example.com/browse/CONV-6788') =
[
    '/browse/',
    '/browse/CONV-6788'
]
```

### encodeURLComponent(url)

Returns the encoded URL.

Example:

```sql
SELECT encodeURLComponent('http://127.0.0.1:8123/?query=SELECT 1;') AS EncodedURL
```

```text
┌─EncodedURL───────────────────────────────────────────────┐
│ http%3A%2F%2F127.0.0.1%3A8123%2F%3Fquery%3DSELECT%201%3B │
└──────────────────────────────────────────────────────────┘
```

### decodeURLComponent(url)

Returns the decoded URL.

Example:

```sql
SELECT decodeURLComponent('http://127.0.0.1:8123/?query=SELECT%201%3B') AS DecodedURL
```

```text
┌─DecodedURL─────────────────────────────┐
│ http://127.0.0.1:8123/?query=SELECT 1; │
└────────────────────────────────────────┘
```

### encodeURLFormComponent(url)

Returns the encoded URL. Follows rfc-1866, space(` `) is encoded as plus(`+`).

Example:

```sql
SELECT encodeURLFormComponent('http://127.0.0.1:8123/?query=SELECT 1 2+3') AS EncodedURL
```

```text
┌─EncodedURL────────────────────────────────────────────────┐
│ http%3A%2F%2F127.0.0.1%3A8123%2F%3Fquery%3DSELECT+1+2%2B3 │
└───────────────────────────────────────────────────────────┘
```

### decodeURLFormComponent(url)

Returns the decoded URL. Follows rfc-1866, plain plus(`+`) is decoded as space(` `).

Example:

```sql
SELECT decodeURLFormComponent('http://127.0.0.1:8123/?query=SELECT%201+2%2B3') AS DecodedURL
```

```text
┌─DecodedURL────────────────────────────────┐
│ http://127.0.0.1:8123/?query=SELECT 1 2+3 │
└───────────────────────────────────────────┘
```

### netloc

Extracts network locality (`username:password@host:port`) from a URL.

#### Syntax

```sql
netloc(url)
```

#### Arguments

- `url`: URL. String.

#### Returned value

- `username:password@host:port`. String.

#### Example

Query:

```sql
SELECT netloc('http://paul@www.example.com:80/')
```

Result:

```text
┌─netloc('http://paul@www.example.com:80/')─┐
│ paul@www.example.com:80                   │
└───────────────────────────────────────────┘
```

## Functions that remove part of a URL

If the URL doesn't have anything similar, the URL remains unchanged.

### cutWWW

Removes leading `www.` (if present) from the URL’s domain.

### cutQueryString

Removes query string, including the question mark.

### cutFragment

Removes the fragment identifier, including the number sign.

### cutQueryStringAndFragment

Removes the query string and fragment identifier, including the question mark and number sign.

### cutURLParameter(url, name)

Removes the `name` parameter from a URL, if present.
This function doesn't encode or decode characters in parameter names, e.g. `Client ID` and `Client%20ID` are treated as different parameter names.

#### Syntax

```sql
cutURLParameter(url, name)
```

#### Arguments

- `url`: URL. String.
- `name`: name of URL parameter. String or Array of Strings.

#### Returned value

- url with `name` URL parameter removed. String.

#### Example

Query:

```sql
SELECT
    cutURLParameter('http://bigmir.net/?a=b&c=d&e=f#g', 'a') as url_without_a,
    cutURLParameter('http://bigmir.net/?a=b&c=d&e=f#g', ['c', 'e']) as url_without_c_and_e
```

Result:

```text
┌─url_without_a────────────────┬─url_without_c_and_e──────┐
│ http://bigmir.net/?c=d&e=f#g │ http://bigmir.net/?a=b#g │
└──────────────────────────────┴──────────────────────────┘
```