Website profiles · Technology insights · Alternatives

redirect.name

No paid content found
Visit website
Profile views 16 Outbound visits 4 Normal
redirect.name Full homepage screenshot

At a glance

Category
Resources & Utilities
Language
English
Paid-content signal
No paid content foundObserved
Registered
2014
Hosting
FastlyInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is redirect.name?

redirect.name is a DNS-based URL redirection service. Instead of running a web server, configuring nginx, or signing up for a link-management dashboard, you describe each redirect in two DNS records. Your DNS provider becomes the single source of truth, and the service reads your TXT record at request time to decide where to send the visitor.

How it works

Two records do the job:

  • A CNAME points your hostname at alias.redirect.name (or an A record to the published IP if your provider can't flatten a CNAME at the apex).
  • A TXT record at _redirect.yourhostname contains the rule in near-plain English, for example Redirects to https://example.com/.

The _redirect. prefix exists because a CNAME and a TXT record can't sit at the same name. Once DNS propagates — usually a minute or two — visiting the hostname triggers the redirect.

What the rules can express

TXT value Behaviour
Redirects to … 302 temporary
Redirects permanently to … 301 permanent
Redirects from /path to … Matches only that path
Redirects from /path/* to …/* Wildcard, with * substituted into the destination
… with 308 (or 301/302/307) Explicit status code

Destinations can be http://, https://, ftp://, mailto:, magnet:, or an absolute path. You can stack multiple TXT records at one name: path-specific rules are evaluated first, and a catch-all only applies when nothing more specific matches.

Who it suits, and the trade-offs

This fits developers and small teams who already manage DNS and want redirects to live in the same place as the rest of their domain configuration — versionable, scriptable, no extra account to own. It's a natural fit for moving a docs subdomain, forwarding an old marketing hostname, or routing /api to separate documentation.

The trade-off is that everything you'd expect from a control panel is absent by design: no analytics on click volume, no per-link editing UI, no team permissions. Changing a redirect means editing a DNS record and waiting for propagation, which is fine for stable infrastructure and awkward for campaign links you tweak hourly. Also check that your DNS provider supports the record types you need at the apex before committing.

Next step: pick one throwaway subdomain, add the CNAME and a single Redirects to TXT record, and confirm the behaviour end to end before migrating anything that matters. If you'd rather manage redirects through a hosted interface with click tracking, a link shortener such as Bitly is the more conventional route.

How do I set up a redirect with redirect.name using DNS records?

Set up a redirect by pointing your hostname at redirect.name's server with a CNAME, then adding a TXT record at _redirect. that describes where to send visitors. There is no account or dashboard — your DNS provider holds the configuration.

The two records you need

Record Type Name Value
Pointer CNAME go.example.com. alias.redirect.name.
Rule TXT _redirect.go.example.com. Redirects to https://example.com/

The _redirect. prefix is required because a TXT record and a CNAME cannot sit at the same name. If your provider can't flatten a CNAME at the apex (sometimes called ALIAS or ANAME), use an A record pointing to 45.55.126.223 instead.

Writing the rule

The TXT value is the rule, written in plain English. Useful forms:

  • Redirects to https://example.com/ — 302, catch-all
  • Redirects permanently to https://new.example.com/ — 301, for moves that won't be undone
  • Redirects from /api to https://api-docs.example.com/ — path-specific
  • Redirects from /blog/* to https://blog.example.com/posts/* — wildcard, where * in the path replaces * in the destination

You can add several TXT records at the same name. Path-specific rules are evaluated first; catch-all rules only apply when nothing else matches. Destinations may use http://, https://, ftp://, mailto:, magnet:, or an absolute path.

A concrete example

Suppose you run documentation at docs.example.com and want /api to send readers to a separate API reference while everything else goes to the main docs site:

  1. CNAME docs.example.com. → alias.redirect.name.
  2. TXT _redirect.docs.example.com. → Redirects from /api to https://api-docs.example.com/
  3. TXT _redirect.docs.example.com. → Redirects to https://docs.example.com/

Wait a minute or two for propagation, then visit the hostname to confirm.

Trade-offs to weigh

This approach suits people who already manage DNS and want redirects without hosting a server or creating an account — useful for short links, domain moves, and path routing. The cost is that rules live in DNS records, so editing means going through your provider, and propagation delay applies to every change. If you need logging, analytics, or many frequently edited rules, a hosted redirect service or a small web server will be easier to operate.

If you don't already control the domain's DNS, start by confirming your provider supports CNAME records at the subdomain you plan to use, and check whether it offers CNAME flattening for an apex domain before choosing between the CNAME and A record options.

What redirect rule syntax can I put in a TXT record?

Put a plain-English rule in the TXT record's value, and the service reads it at request time to decide where and how to send the visitor. The record name must live under _redirect. (for example, _redirect.go.example.com), because a TXT record can't coexist with the CNAME at the same name.

The rule patterns

TXT value Behavior
Redirects to https://example.com/ 302 (temporary) to that URL
Redirects permanently to https://new.example.com/ 301 (permanent)
Redirects from /api to https://api-docs.example.com/ 302 only when the request path matches
Redirects from /api to https://api-docs.example.com/ with 308 Same match, explicit status
Redirects from /blog/* to https://blog.example.com/posts/* Wildcard: what * captures in the path replaces * in the destination

Status codes and destinations

You can name a status explicitly — 301, 302, 307, or 308 — instead of relying on the wording. Destinations accept http://, https://, ftp://, mailto:, magnet:, or an absolute path.

How multiple rules interact

You can add several TXT records at the same name. Path-specific rules (Redirects from …) are tried first; a catch-all rule (Redirects to …) applies only when no path rule matches. That makes the docs example work: /api goes to the API docs, and everything else falls through to the main docs site.

Practical decision points

  • Use 301/308 only for moves you won't undo, since browsers cache permanent redirects aggressively. For testing, start with 302.
  • Prefer 308 over 301 when the redirect must preserve the request method and body.
  • Wildcards are for path forwarding, not query strings — plan the destination path carefully.

Next step: write your rule, add it as a TXT record at _redirect.<your hostname>, wait for DNS to propagate, then test with curl -I to confirm the status code and Location header before announcing the change.

What is the difference between a permanent and temporary redirect on redirect.name?

On redirect.name, the difference is the HTTP status code the service returns, and that code tells browsers and search engines whether to treat the move as lasting.

  • Temporary (302 by default): the redirect is not cached as permanent. Use it while testing, during maintenance, or for short campaigns where the destination may change.
  • Permanent (301): browsers and search engines are told the move is lasting. Use it when an old URL will never serve content again, such as a rebranded domain or a retired path.

The service also supports explicit statuses: 301, 302, 307, and 308. The 307 and 308 variants preserve the original request method, which matters for non-GET traffic; 301 and 302 may be rewritten to GET by some clients.

Rule wording Status Practical use
Redirects to 302 Temporary catch-all, safe to change
Redirects permanently to 301 Permanent moves, SEO consolidation
Redirects from ... to ... with 308 308 Permanent move that must keep POST/PUT methods

A concrete scenario: you are migrating old.example.com to new.example.com. Start with Redirects to https://new.example.com/ while you verify links and analytics. Once the migration is stable, change the TXT record to Redirects permanently to https://new.example.com/. Because DNS is the source of truth, the change is just a TXT edit; no dashboard or account is involved. Note that permanent redirects can be cached aggressively by browsers, so test with a temporary rule first.

Next step: decide based on reversibility. If you might undo the move, use a 302. If the old address is gone for good, use a 301, or 308 when method preservation matters.

How do wildcard and path-specific redirects work on redirect.name?

Path-specific rules are checked first, and wildcard rules replace * in the destination with whatever * matched in the request path.

How the two rule types differ

Rule type TXT value shape When it applies
Path-specific Redirects from /path to https://... Only when the request path matches
Wildcard Redirects from /path/* to https://.../* When the path matches the pattern; * is substituted into the destination
Catch-all Redirects to https://... Only if no path-specific rule matches

Because path-specific rules are tried first, a catch-all acts as a fallback rather than an override. Multiple TXT records at the same _redirect. name let you combine these: one rule for /api, another catch-all for everything else.

Concrete example

For docs.example.com, you could set:

  • _redirect.docs.example.com. → Redirects from /api to https://api-docs.example.com/
  • _redirect.docs.example.com. → Redirects to https://docs.example.com/

A request to /api goes to the API docs; every other path goes to the main docs site. For wildcard forwarding, Redirects from /blog/* to https://blog.example.com/posts/* sends /blog/hello to https://blog.example.com/posts/hello.

Practical notes

  • The _redirect. prefix is required because TXT and CNAME records cannot share the same name.
  • Status codes are explicit when you use forms like Redirects from ... with 308 or Redirects permanently to for a 301.
  • Destinations can include http://, https://, ftp://, mailto:, magnet:, or an absolute path.

Next step: decide whether your redirect is a one-off path move or a pattern-based rewrite. If the destination needs to preserve part of the incoming path, use a wildcard; if only one exact path changes, use a path-specific rule and add a catch-all for everything else.

Can redirect.name handle redirects to mailto, magnet, or other non-HTTP destinations?

Yes. redirect.name's TXT-record rules explicitly allow destinations using http://, https://, ftp://, mailto:, magnet:, or an absolute path. So a rule like Redirects to mailto:[email protected] is a supported use, not a workaround.

H3 What this is practical for

  • mailto: A hostname such as hi.example.com becomes a short, memorable contact address that immediately opens the visitor's mail client, useful on business cards or slides where you don't want to print a full email address.
  • magnet: A short link can hand off to a BitTorrent client instead of a web page, which suits sharing a torrent identifier without pasting the long magnet URI.
  • ftp: Legacy but still occasionally needed for pointing at an old file server.
  • Absolute paths: Redirects to /pricing keeps the redirect on the same host, handy when you only want to change the path.

H3 Trade-offs to weigh

Non-HTTP destinations are only as reliable as the visitor's software. A mailto: link does nothing useful if no mail handler is registered; a magnet: link depends on a torrent client being installed and may show a browser prompt first. Because the redirect is issued by redirect.name's server based on your TXT record, the visitor's browser still has to hand off to the external application — you cannot control that step. Also note the _redirect. prefix is required, since a TXT record and the CNAME at the same name cannot coexist.

H3 A concrete next step

Decide whether you need a catch-all or a path rule first. Path rules (Redirects from /path to ...) are evaluated before catch-alls (Redirects to ...), so you can send /api to a set of API docs while everything else goes to your main site. Start with one TXT record, wait a minute or two for DNS to propagate, and test the hostname in a browser before adding more.

If you want to compare approaches, DNS-based redirects sit alongside services like Cloudflare (which offers redirect rules at the edge) and Namecheap (whose DNS panel supports similar records). The distinguishing point here is that redirect.name has no account or dashboard — your DNS provider remains the single source of truth.

Related questions

More questions →
What redirect rules can I write in a redirect.name TXT record?

You write the rule as the plain-English value of a TXT record at _redirect. followed by your hostname. The service reads that TXT record at request time and issues the redirect, so the rule text itself is the configuration. The available forms are: Redirects to <destination> (302), Redirects permanently to <destination> (301), Redirects from <path> to <destination> (302, matched by path), and Redirects from <path> to <destination> with 308 (or 301/302/307/308). Destinations can be http://, https://, ftp://, mailto:, magnet:, or an absolute path.

The rule syntax at a glance

TXT record value Behavior
Redirects to <destination> 302 to the destination
Redirects permanently to <destination> 301 to the destination
Redirects from <path> to <destination> 302 when the request path matches
Redirects from <path> to <destination> with 308 Same, with an explicit status: 301, 302, 307, or 308
Redirects from /path/* to https://example.com/* Wildcard: whatever * matches in the path replaces * in the destination

Destinations accept http://, https://, ftp://, mailto:, magnet:, or an absolute path.

How the records fit together

Two DNS records describe one redirect:

  • A CNAME pointing your hostname at alias.redirect.name. (or an A record to 45.55.126.223 if your provider can't flatten a CNAME at the apex).
  • A TXT record at _redirect.<your hostname> holding the rule.

The _redirect. prefix is required because TXT and CNAME records can't coexist at the same name. After you save the records, wait for DNS to propagate (usually a minute or two) and visit your hostname.

Path rules beat catch-all rules

You can add multiple TXT records at the same name. Path-specific rules (Redirects from ...) are tried first; catch-all rules (Redirects to ...) only apply if no path rule matches.

For example, to send one path to API docs and everything else to the main docs site:

TXT _redirect.docs.example.com.  Redirects from /api to https://api-docs.example.com/
TXT _redirect.docs.example.com.  Redirects to https://docs.example.com/

A request to /api hits the first rule; any other path falls through to the second.

Wildcards and other schemes

Wildcard forwarding replaces the * in the destination with whatever * matched in the path:

TXT _redirect.links.example.com.  Redirects from /blog/* to https://blog.example.com/posts/*

A request to /blog/hello goes to https://blog.example.com/posts/hello.

Non-HTTP destinations work the same way:

TXT _redirect.hi.example.com.  Redirects to mailto:[email protected]

Choosing a status code

Use Redirects to for temporary moves (302) and Redirects permanently to for moves that won't be undone (301). When you need a specific code, append with 301, with 302, with 307, or with 308 to a path rule.

What is redirect.name?

redirect.name is a DNS-based URL redirect service: you point a hostname at its server with a CNAME (or an A record), then describe the destination in a TXT record. There is no server to run, no signup, and no dashboard — your DNS provider holds the redirect rules, and redirect.name reads the TXT record at request time to issue the redirect. It suits anyone who controls DNS for a domain and wants simple, versionable redirects without deploying or maintaining anything.

How it works

Two DNS records describe one redirect:

  1. A CNAME (or A record) that points your hostname at redirect.name's server.
  2. A TXT record at _redirect. that describes where to send visitors.

At request time, redirect.name reads the TXT record and returns the redirect. Because DNS is the source of truth, changing a redirect means editing a DNS record — nothing to log into on the redirect side.

Setup

Point your hostname at alias.redirect.name:

Type Name Value
CNAME go.example.com. alias.redirect.name.

If your DNS provider doesn't support CNAME flattening at the apex (sometimes offered as an ALIAS or ANAME record), use an A record pointing to 45.55.126.223 instead.

Then add a TXT record at _redirect.:

Type Name Value
TXT _redirect.go.example.com. Redirects to https://example.com/

The _redirect. prefix is required because TXT and CNAME records can't coexist at the same name.

Wait for DNS to propagate (usually a minute or two), then visit your hostname.

Redirect rules

The TXT record value is the rule, written in plain English:

TXT record value Behavior
Redirects to 302 to the destination
Redirects permanently to 301 to the destination
Redirects from … to … 302 when the request path matches
Redirects from … to … with 308 Same, with an explicit status: 301, 302, 307, or 308
Redirects from /path/* to https://example.com/* Wildcard: whatever * matches in the path replaces * in the destination

Destinations can use http://, https://, ftp://, mailto:, magnet:, or an absolute path.

You can add multiple TXT records at the same name. Path-specific rules (Redirects from …) are tried first; catch-all rules (Redirects to …) only apply if no path rule matches.

Examples

Simple redirect — send all traffic to one URL:

Type Name Value
TXT _redirect.go.example.com. Redirects to https://www.example.com/

Permanent redirect — for moves that won't be undone:

Type Name Value
TXT _redirect.old.example.com. Redirects permanently to https://new.example.com/

Path routing — redirect one path, send the rest elsewhere:

Type Name Value
TXT _redirect.docs.example.com. Redirects from /api to https://api-docs.example.com/
TXT _redirect.docs.example.com. Redirects to https://docs.example.com/

Wildcard forwarding — whatever * matches in the path replaces * in the destination:

Type Name Value
TXT _redirect.links.example.com. Redirects from /blog/* to https://blog.example.com/posts/*

Other schemes — redirect to mail, magnet links, etc.:

Type Name Value
TXT _redirect.hi.example.com. Redirects to mailto:…

When to use it

Choose redirect.name when you already manage DNS for the domain and want redirects that are simple, declarative, and require no hosting. It fits short links, domain moves, path routing, and forwarding to non-HTTP schemes.

It is a poorer fit if you need redirect logic that depends on request headers, cookies, geo, or A/B testing — the rule language here is deliberately limited to paths and destinations. It's also worth checking your DNS provider's support for CNAME flattening (or ALIAS/ANAME) if you need redirects at the apex, since that determines whether you use a CNAME or the A record fallback.

Does redirect.name support HTTPS and apex domains?

Yes to both, with one caveat on each. HTTPS works because redirect.name serves your redirect from its own server, so the TLS certificate belongs to that server rather than to your DNS provider. Apex domains work as long as your DNS provider supports CNAME flattening, or offers an ALIAS or ANAME record type; if it doesn't, you point an A record at 45.55.126.223 instead.

HTTPS: what actually happens

redirect.name is a DNS-based redirect service. You don't run a server, and there's no signup or dashboard — your DNS provider holds the configuration, and redirect.name reads it at request time.

That matters for HTTPS because the redirect is issued by redirect.name's server, not by your DNS host. Two practical consequences:

  • Your hostname needs to resolve to redirect.name's server (via the CNAME to alias.redirect.name). Once it does, visitors hitting https://go.example.com reach that server and get redirected.
  • You don't manage a certificate for the redirecting hostname yourself. The TLS termination happens on the redirecting side, so you're not provisioning a cert for go.example.com just to bounce traffic elsewhere.

The destination can be any of http://, https://, ftp://, mailto:, magnet:, or an absolute path — so an HTTPS source redirecting to an HTTPS destination is the ordinary case, not a special one.

Apex domains: CNAME flattening, ALIAS, or A record

The standard setup is a CNAME:

Type Name Value
CNAME go.example.com. alias.redirect.name.

That works cleanly on a subdomain like go.example.com. The problem is the apex — example.com itself. DNS rules generally don't allow a CNAME at the apex alongside the other records a zone needs (SOA, NS, and often MX).

Three ways out, in order of preference:

  1. CNAME flattening. Some DNS providers resolve the CNAME target themselves and serve the resulting address as if it were an A record. If your provider offers this, use the CNAME above at the apex and you're done.
  2. ALIAS or ANAME records. These are provider-specific record types that behave like a CNAME at the apex. If your provider offers one, it's the same idea — point it at alias.redirect.name.
  3. A record. If neither is available, point an A record at 45.55.126.223. This is the documented fallback and works anywhere, but it hardcodes an IP address, so if that address ever changes you'd have to update your record.

So the honest answer on apex support is: yes, but the mechanism depends on what your DNS provider allows. Check for flattening, ALIAS, or ANAME first; fall back to the A record only if none exist.

The TXT record is separate from all of this

Whichever way you point the hostname, the redirect rule itself lives in a TXT record at a _redirect. prefixed name:

Type Name Value
TXT _redirect.go.example.com. Redirects to https://example.com/

The _redirect. prefix is required because TXT and CNAME records can't coexist at the same name — so the rule sits one level down from the hostname it governs.

This split is worth remembering when debugging: the CNAME (or A record) controls whether traffic reaches redirect.name at all, and the TXT record controls where it goes once it arrives. A redirect that isn't working is often a problem in the first half, not the rule syntax.

Setup steps and what to expect

  1. Add the CNAME (or ALIAS/ANAME, or the A record at the apex) pointing your hostname at alias.redirect.name. or 45.55.126.223.
  2. Add a TXT record at _redirect.<your-hostname> with a rule such as Redirects to https://example.com/.
  3. Wait for DNS to propagate — typically a minute or two — then visit your hostname.

If the redirect doesn't fire, the usual culprits are propagation not finished, a missing _redirect. prefix, or an apex record type your provider silently rejected.

Rule syntax, briefly

The TXT value is written in plain English. Useful forms:

  • Redirects to <destination> — 302
  • Redirects permanently to <destination> — 301
  • Redirects from <path> to <destination> — 302, only when the request path matches
  • Redirects from <path> to <destination> with 308 — explicit status; 301, 302, 307, and 308 are all available
  • Redirects from /path/* to https://example.com/* — wildcard, where whatever * matched in the path replaces * in the destination

You can add multiple TXT records at the same name. Path-specific rules are evaluated first; a catch-all rule only applies when no path rule matches. That ordering is what lets you send /api to one place and everything else to another:

Type Name Value
TXT _redirect.docs.example.com. Redirects from /api to https://api-docs.example.com/
TXT _redirect.docs.example.com. Redirects to https://docs.example.com/

Choosing between the options

  • Subdomain redirect, any provider: CNAME to alias.redirect.name. — no tradeoffs.
  • Apex redirect, provider supports flattening/ALIAS/ANAME: use that record type; it stays portable if the underlying address changes.
  • Apex redirect, no such support: A record to 45.55.126.223. Works everywhere, but you own the maintenance if the address moves.
  • Permanent move: use Redirects permanently to (301) rather than the default 302, so browsers and crawlers treat it as permanent.
How to Set Up a Redirect with redirect.name

To set up a redirect, you create two DNS records for your hostname: a CNAME pointing to alias.redirect.name (or an A record to 45.55.126.223 if your provider can't flatten a CNAME at the apex), and a TXT record at _redirect.<your-hostname> whose value is the redirect rule in plain English. Wait for DNS to propagate — usually a minute or two — then visit your hostname to confirm the redirect. There's no account, dashboard, or server to manage; your DNS provider is the source of truth, and redirect.name reads the TXT record at request time.

Before you start

You need:

  • Control over DNS records for the hostname you want to redirect.
  • A DNS provider that lets you add both a CNAME (or ALIAS/ANAME/A record) and a TXT record.
  • The destination URL you want visitors sent to.

No signup is required to use the service.

Step 1: Point the hostname at redirect.name

Add a CNAME record for the hostname you want to redirect:

Type Name Value
CNAME go.example.com. alias.redirect.name.

If your DNS provider doesn't support CNAME flattening at the apex (sometimes offered as an ALIAS or ANAME record), use an A record instead:

Type Name Value
A example.com. 45.55.126.223

Step 2: Add the TXT record with your redirect rule

Add a TXT record at _redirect.<your-hostname>. The _redirect. prefix is required because TXT and CNAME records can't coexist at the same name.

Type Name Value
TXT _redirect.go.example.com. Redirects to https://example.com/

The TXT value is the rule. The syntax is plain English:

TXT record value Behavior
Redirects to 302 to the destination
Redirects permanently to 301 to the destination
Redirects from <path> to <destination> 302 when the request path matches
Redirects from <path> to <destination> with 308 Same, with an explicit status: 301, 302, 307, or 308
Redirects from /path/* to https://example.com/* Wildcard: whatever * matches in the path replaces * in the destination

Destinations can use http://, https://, ftp://, mailto:, magnet:, or an absolute path.

You can add multiple TXT records at the same name. Path-specific rules (Redirects from ...) are tried first; catch-all rules (Redirects to ...) only apply if no path rule matches.

Step 3: Wait for propagation and test

DNS propagation usually takes a minute or two. Once it's done, visit your hostname in a browser and confirm you land on the destination. If the redirect doesn't fire, check that the CNAME (or A record) and the TXT record are both present and that the TXT name includes the _redirect. prefix.

Common setups

Simple redirect — send all traffic to one URL:

Type Name Value
TXT _redirect.go.example.com. Redirects to https://www.example.com/

Permanent redirect — for moves that won't be undone:

Type Name Value
TXT _redirect.old.example.com. Redirects permanently to https://new.example.com/

Path routing — redirect one path, send the rest elsewhere:

Type Name Value
TXT _redirect.docs.example.com. Redirects from /api to https://api-docs.example.com/
TXT _redirect.docs.example.com. Redirects to https://docs.example.com/

Wildcard forwarding — whatever * matches in the path replaces * in the destination:

Type Name Value
TXT _redirect.links.example.com. Redirects from /blog/* to https://blog.example.com/posts/*

Other schemes — redirect to mail, magnet links, and similar:

Type Name Value
TXT _redirect.hi.example.com. Redirects to mailto:...

Notes on HTTPS

The source material lists HTTPS as a topic but doesn't spell out the certificate behavior, so treat HTTPS handling as something to verify against your own hostname after setup rather than assume.

Why isn't my redirect.name redirect working?

Most redirect.name failures come down to one of three things: the hostname isn't pointed at redirect.name's server, the TXT rule record is missing or misnamed, or DNS hasn't propagated yet. Check those three in order before assuming the service is broken.

1. Confirm the hostname points at redirect.name

redirect.name only works if the hostname you want to redirect resolves to its server. That requires a CNAME (or an A record where CNAME flattening isn't available).

Type Name Value
CNAME go.example.com. alias.redirect.name.

If your DNS provider doesn't support CNAME flattening at the apex (sometimes offered as an ALIAS or ANAME record), use an A record instead:

Type Name Value
A example.com. 45.55.126.223

Common mistakes here:

  • Pointing the CNAME somewhere else. If the hostname still resolves to your old host or a parking page, redirect.name never sees the request.
  • Using a CNAME at the apex on a provider that doesn't flatten it. The record may be rejected or silently ignored. Switch to the A record above.
  • Forgetting the trailing dots. alias.redirect.name. and go.example.com. are fully qualified; some providers append your zone automatically and some don't. If your provider handles the zone suffix, enter the short form it expects.

Verify with a DNS lookup:

dig go.example.com CNAME +short

You should see alias.redirect.name. (or the A record resolving to 45.55.126.223). If you see anything else, fix the record first — nothing downstream will work until this is correct.

2. Check the TXT record name and prefix

The redirect rule lives in a TXT record, and it must be named with the _redirect. prefix. This prefix is required because TXT and CNAME records can't coexist at the same name — the prefix keeps them apart.

Type Name Value
TXT _redirect.go.example.com. Redirects to https://example.com/

Common mistakes here:

  • Missing _redirect. prefix. A TXT record at go.example.com instead of _redirect.go.example.com is never read.
  • Wrong hostname in the name field. The name must match the hostname you're redirecting, with the prefix in front. Redirecting docs.example.com needs _redirect.docs.example.com.
  • Rule text doesn't match the supported syntax. The value is read as plain English. Redirects to https://example.com/ works; free-form prose does not.

Verify the TXT record:

dig _redirect.go.example.com TXT +short

You should see your rule string. If it's empty, the record name is wrong or the record hasn't propagated.

3. Allow for DNS propagation

After you add or change records, wait for propagation — usually a minute or two, but it can take longer depending on your provider's TTL. Visiting the hostname immediately after saving often shows the old behavior or a failure that resolves itself shortly.

If it's been well past the expected window and lookups still return stale or empty results, check your provider's TTL setting and whether a previous record is cached.

4. Check for conflicting or shadowing records

Because the TXT and CNAME records must live at different names, a leftover record at the wrong name can interfere:

  • An old A or CNAME record at the redirect hostname that still points elsewhere will win over the intended target.
  • A TXT record without the _redirect. prefix is ignored, so if you only created that one, no rule exists.
  • Multiple TXT records at the same name are allowed and can be intentional. Path-specific rules (Redirects from ...) are tried first, and catch-all rules (Redirects to ...) only apply if no path rule matches. If a path rule is catching traffic you expected the catch-all to handle, that's the rule order working as designed — remove or adjust the path rule.

Quick diagnostic checklist

  1. dig <hostname> CNAME +short → should return alias.redirect.name. (or the A record → 45.55.126.223).
  2. dig _redirect.<hostname> TXT +short → should return your rule string.
  3. Wait a couple of minutes after any change before retesting.
  4. Remove any stale A/CNAME at the redirect hostname and any TXT record missing the _redirect. prefix.

If all four pass and the redirect still fails, the issue is in the rule text itself — recheck it against the supported syntax (Redirects to, Redirects permanently to, Redirects from ... to ..., wildcards, and the explicit status codes 301, 302, 307, 308).

Website Overview

An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality. Several search or sharing settings need attention. Together they may make snippets, preview images or preferred URLs less consistent across platforms.

Domain and Registration

Registered in 2014, this domain has about 12 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is Porkbun LLC, a widely used domain service provider. The domain uses the common .name extension, which is not an independent safety signal.

DNS and Email

Nameservers are provided by Cloudflare, indicating managed DNS hosting. No CNAME was found; the observed records resolve directly to addresses. No MX record was found. A conventional explicit inbound-mail route is not configured. DNSSEC signatures were not detected, so this additional DNS authenticity protection is not confirmed. The lowest observed DNS TTL is 300 seconds.

TLS and Certificates

The certificate uses an RSA 2048-bit public key, offering broad client compatibility. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued by Let's Encrypt, commonly associated with automated certificate services. The certificate's total validity is about 89 days, consistent with a short renewal cycle.

HTTP and Browser Security

The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. CORS permits any origin to read this response. This is common for public resources; sensitive responses need narrower handling. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. The x-cache, x-served-by, via response header indicates a CDN or caching proxy in the delivery path. No obvious internal addresses or debug information were found in the headers.

Technology Stack Analysis

The public page identifies Fastly without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

No homepage meta description was detected, leaving snippet selection more dependent on page text. No homepage canonical URL was detected. If duplicate URLs exist, consolidation may be less explicit. No Open Graph metadata was detected, so social previews may depend on platform inference. The title has 34 characters, within a common display range. The observed directives allow indexing and link following.

Hosting and Email

DNSCloudflare
HostingFastly
EmailUnknown
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) United States flagUnited States Inferred 185.199.108.153

Registration details

RDAP / WHOIS

RegistrarPorkbun LLC
Registered2014-07-17
Expires2027-07-17
Domain statusclient delete prohibited、client transfer prohibited
Nameserversduke.ns.cloudflare.com、nina.ns.cloudflare.com
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Aredirect.name185.199.108.153300—
Aredirect.name185.199.109.153300—
Aredirect.name185.199.110.153300—
Aredirect.name185.199.111.153300—
AAAAredirect.name2606:50c0:8000::153300—
AAAAredirect.name2606:50c0:8001::153300—
AAAAredirect.name2606:50c0:8002::153300—
AAAAredirect.name2606:50c0:8003::153300—
NSredirect.nameduke.ns.cloudflare.com86400—
NSredirect.namenina.ns.cloudflare.com86400—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjectredirect.name
IssuerLet's Encrypt
Valid until2026-11-18T03:12 · Remaining when checked: 47 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html; charset=utf-8
cache-controlmax-age=600
serverGitHub.com
access-control-allow-origin*

Identified technologies

Fastly

Pages, Search and Sharing

Meta descriptionNot detected
Canonical URLNot detected
LanguageEnglish (default)
Twitter CardNot detected

Unknown

No robots.txt found

No sitemaps found

User reviews (0)

  • No reviews yet.