What is domain forwarding and when should you use it?

Domain forwarding, also called URL forwarding or domain redirection, automatically sends anyone who visits one domain to a different web address. When someone types example.net into their browser, a server answers with an HTTP redirect, and the browser loads example.com instead. You should use it when you own extra domains that don't need their own website, such as misspellings, alternative extensions, old brand names or short campaign domains, and you want all of that traffic to land in one place. Done properly with a permanent 301 redirect, it's simple, free at most registrars, and safe for SEO.

Forwarding looks like a single checkbox in a registrar dashboard, but there's more going on underneath: DNS, a web server, HTTP status codes and HTTPS certificates all play a part. This guide explains how domain forwarding actually works, the difference between 301 and 302 redirects, why masked forwarding is usually a bad idea, how to set up forwarding at a registrar or on your own server, how to test it, and when you should use something else.

How Domain Forwarding Works

DNS on its own can't redirect a web page. DNS only turns a name into an IP address or another name. A redirect is an HTTP response, so something has to receive the browser's request and answer it. Domain forwarding always involves two parts:

1. DNS: The forwarded domain points to a server that handles redirects. At most registrars, this is a shared redirect service the registrar runs for you.
2. HTTP redirect: That server replies to every request with a status code such as 301 and a Location header containing the destination URL.

Here's what a browser sees when it requests a forwarded domain:

GET / HTTP/1.1
Host: example.net

HTTP/1.1 301 Moved Permanently
Location: https://example.com/

The browser then makes a fresh request to https://example.com/ and shows that page. The address bar changes to the new domain.

When you switch on forwarding in a registrar dashboard, the registrar usually adds or changes the domain's A record (and sometimes the www record) so it points at its redirect servers. That's why forwarding normally only works when the domain uses the registrar's own nameservers. If you've moved DNS elsewhere, see registrar DNS vs third-party DNS for how the two fit together.

Forwarding Is Not the Same as a CNAME

A common misconception is that a CNAME record forwards a domain. It doesn't. A CNAME tells resolvers that one name is an alias of another for DNS purposes, but the browser still sends a request with the original host name, and the server at the other end has to be configured to accept it. The address bar never changes. If you want visitors to end up on a different URL, you need an HTTP redirect.

Types of Domain Forwarding

301 Permanent Redirect

A 301 tells browsers and search engines that the move is permanent. Search engines consolidate ranking signals onto the destination and eventually drop the old URL from their index. Browsers may cache a 301, so later visits go straight to the destination.

Use a 301 for almost everything: extra extensions, typo domains, old brand names and retired domains.

302 Temporary Redirect

A 302 (or the stricter 307) says the move is temporary. Search engines generally keep the original URL indexed and don't treat the destination as its replacement. Use it for genuinely short-lived situations, such as pointing a domain at a holding page while a new site is built, or sending a seasonal campaign domain to a landing page you'll change later.

308 Permanent Redirect

A 308 is the permanent equivalent of 307. It behaves like a 301 but guarantees the browser repeats the same HTTP method, which matters for form submissions and APIs. For ordinary page forwarding, 301 and 308 are treated the same way by search engines.

Masked Forwarding (Frame Forwarding)

Masked forwarding, sometimes called stealth or cloaked forwarding, keeps the original domain in the address bar. The registrar serves a small HTML page that loads the destination inside a full-screen frame:

<!doctype html>
<html>
  <head><title>Example</title></head>
  <frameset rows="100%">
    <frame src="https://example.com/">
  </frameset>
</html>

It looks attractive because the visitor sees example.net the whole time, but it causes real problems:

• Many sites refuse to be framed: Headers such as X-Frame-Options: DENY or a Content-Security-Policy with frame-ancestors make the frame show a blank page or an error.
• SEO suffers: Search engines see a nearly empty page on the forwarded domain and the content belongs to another URL.
• Deep links don't work: The address bar never changes as visitors browse, so they can't bookmark or share a specific page.
• Mixed security: If the outer page is HTTP and the framed page is HTTPS, or the reverse, browsers may warn or block content.

If you want a different domain to show your site in the address bar, the correct approach is to host the site on that domain, not to frame it.

Path Forwarding vs Root-Only Forwarding

Registrars differ in how they handle anything after the domain name:

Setting	Visitor requests	Visitor ends up at
Root only	example.net/pricing	https://example.com/
Path forwarding	example.net/pricing	https://example.com/pricing
Path and query	example.net/pricing?ref=ad	https://example.com/pricing?ref=ad

If the forwarded domain used to have its own website, keep paths so old links land on the matching page. If it never had content, root-only forwarding is fine.

When You Should Use Domain Forwarding

Forwarding is the right tool when a domain doesn't need its own content. Typical cases:

• Alternative extensions: You own example.net, example.co.uk and example.io and want them all to reach example.com. See should you register multiple domain extensions for when owning these is worth it.
• Typo and misspelling domains: exmaple.com sends lost visitors to the right place and keeps it out of the hands of typosquatters.
• Old brand names: After a rebrand, the old domain keeps working for anyone with an old business card or bookmark.
• Short or memorable campaign domains: A domain printed on a poster or spoken in a podcast advert forwards to a specific landing page.
• Consolidating several sites: When you merge sites into one, the retired domains forward to the matching sections of the main site.
• Social or profile links: A personal domain that simply forwards to a portfolio or profile page.

When You Shouldn't Use Registrar Forwarding

• Full site migrations: If you're moving an established website to a new domain, you need page-by-page 301 redirects that you control, not a basic registrar toggle. That's covered in how to move your website to a new domain without losing SEO.
• Root to www on your main site: Handle this on your web server or CDN. See how to redirect the root domain to www.
• When you need email on the domain: Forwarding is for web traffic only. Email needs MX records, which are separate. Some registrars offer email forwarding as a different feature, and you can use both on the same domain.
• When you want the visitor to stay on the forwarded domain: Host the site there instead of masking.

How to Set Up Forwarding at Your Registrar

The menus differ, but the process is much the same everywhere:

1. Log in to your registrar and open the domain you want to forward.
2. Find the forwarding setting: Look for Forwarding, URL Redirect, Redirect Domain or Web Forwarding.
3. Enter the destination URL: Include the scheme, for example https://example.com/.
4. Choose the redirect type: Pick Permanent (301) unless you have a clear reason for a temporary redirect.
5. Choose forwarding mode: Select standard forwarding, not masked.
6. Decide on paths: Turn on path forwarding if the domain has old links worth preserving.
7. Include www: Make sure www.example.net is forwarded as well as the bare domain. Some registrars handle this automatically, others need a separate rule.
8. Save and wait: The registrar updates DNS for you. Changes usually work within minutes but can take longer while old records are cached.

If the domain uses third-party nameservers, the registrar's forwarding service won't receive any traffic. Either set up redirects at your DNS or CDN provider, or point the domain's A record at a server you control and redirect there.

Setting Up Forwarding Yourself

When you want full control over status codes, paths and HTTPS, run the redirect on your own server or CDN.

Nginx

This server block forwards every request for example.net and www.example.net to the same path on example.com:

server {
    listen 80;
    listen [::]:80;
    server_name example.net www.example.net;
    return 301 https://example.com$request_uri;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name example.net www.example.net;

    ssl_certificate     /etc/letsencrypt/live/example.net/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.net/privkey.pem;

    return 301 https://example.com$request_uri;
}

$request_uri includes the path and query string, so example.net/pricing?ref=ad becomes https://example.com/pricing?ref=ad. On Nginx versions older than 1.25.1, use listen 443 ssl http2; instead of the separate http2 on; line.

Apache

In a virtual host for the forwarded domain:

<VirtualHost *:80>
    ServerName example.net
    ServerAlias www.example.net
    Redirect permanent / https://example.com/
</VirtualHost>

The Redirect directive keeps the rest of the path, so /pricing becomes https://example.com/pricing. Add a matching *:443 virtual host with a certificate to handle HTTPS requests.

Cloudflare

If the forwarded domain is on Cloudflare, the DNS record must be proxied (orange cloud) so Cloudflare receives the HTTP request. A common pattern is a placeholder record:

example.net.      300  IN  A     192.0.2.1
www.example.net.  300  IN  A     192.0.2.1

192.0.2.1 is a reserved documentation address that never answers, which is fine because Cloudflare handles the request before it would reach an origin. Then create a Redirect Rule (Rules, then Redirect Rules) with a dynamic target such as:

When incoming requests match: Hostname is in {"example.net" "www.example.net"}
Then: Dynamic redirect
Expression: concat("https://example.com", http.request.uri.path)
Status code: 301
Preserve query string: on

For dozens of forwarded domains, Cloudflare's Bulk Redirects feature is easier to manage than individual rules.

The HTTPS Problem With Forwarding

Before a browser can receive a redirect over HTTPS, it has to complete a TLS handshake with a valid certificate for the forwarded domain. If someone types https://example.net and the redirect server has no certificate for example.net, the visitor sees a security warning instead of being forwarded.

Many registrars now issue certificates automatically for forwarded domains, but not all do, and some only cover the bare domain and not www. Test both. If your registrar can't handle HTTPS, use your own server with a free certificate from Let's Encrypt, or a CDN that provides certificates automatically. More background is in what is an SSL/TLS certificate.

How to Test Domain Forwarding

Use curl to see exactly what the server returns. The -I flag fetches headers only:

curl -sI http://example.net/pricing

HTTP/1.1 301 Moved Permanently
Server: nginx
Location: https://example.com/pricing

Check the HTTPS version and www too:

curl -sI https://example.net/
curl -sI https://www.example.net/

To follow the whole chain and see every hop:

curl -sIL http://www.example.net/ | grep -iE "^(HTTP|location)"

HTTP/1.1 301 Moved Permanently
Location: https://www.example.net/
HTTP/2 301
location: https://example.com/
HTTP/2 200

This example has two hops: HTTP to HTTPS on the forwarded domain, then to the destination. That's acceptable, but a single hop is better. Aim to redirect straight to the final URL wherever you can.

If you get no response at all, check where the domain points with dig +short example.net A and compare it with what your registrar or CDN expects. The dig command guide covers more lookups.

Checking Many Forwarded Domains at Once

If you forward a handful of extensions and typo domains, a short script confirms they all reach the right place:

#!/usr/bin/env bash
TARGET="https://example.com/"
for d in example.net www.example.net example.org exmaple.com; do
  final=$(curl -s -o /dev/null -L --max-time 10 -w '%{url_effective}' "https://$d/")
  code=$(curl -s -o /dev/null --max-time 10 -w '%{http_code}' "https://$d/")
  if [ "$code" = "000" ]; then
    echo "FAIL  $d (no response or TLS error)"
  elif [ "$final" = "$TARGET" ] && { [ "$code" = "301" ] || [ "$code" = "308" ]; }; then
    echo "OK    $d ($code) -> $final"
  else
    echo "CHECK $d ($code) -> $final"
  fi
done

OK    example.net (301) -> https://example.com/
OK    www.example.net (301) -> https://example.com/
CHECK example.org (302) -> https://example.com/
FAIL  exmaple.com (no response or TLS error)

Here example.org uses a temporary redirect that should be changed to 301, and exmaple.com fails over HTTPS, probably because of a missing certificate.

Domain Forwarding and SEO

Forwarding extra domains with a 301 doesn't hurt the destination site. Search engines simply treat the forwarded domain as an alias that points to your main site. A few rules keep it clean:

• Use 301 or 308, not 302, for permanent forwarding.
• Avoid masking, which creates thin, framed pages.
• Keep chains short, ideally one hop.
• Preserve paths for domains that had content and backlinks.
• Don't forward unrelated or spammy domains to your site in the hope of gaining ranking. Search engines can ignore those signals, and a domain with a bad history can bring trouble. Check a domain's history before pointing it at your main site.

---

FAQ: Domain Forwarding

---

Conclusion

Domain forwarding is an HTTP redirect from one domain to another, set up through DNS that points at a redirect server. It's the simplest way to put extra extensions, typo domains, old brand names and campaign domains to work, and with a 301 redirect it sends both visitors and search engines to your main site without any downside.

Keep it simple: use permanent redirects, avoid masking, forward both the bare domain and www, and make sure HTTPS works on the forwarded domain. For big moves, such as migrating a whole website, use proper server-side redirects that map every old page to its new home. Test with curl after every change, and your extra domains will quietly do their job.