For a permanent move, send each old URL to its specific equivalent with a server-side 301 or 308, in one hop, and keep it in place for at least a year. Google follows up to 10 hops but advises ideally 3 or fewer, and treats 302 and 307 as weaker signals than 301 and 308. The Change of Address tool applies only to domain or subdomain moves, and its effects last 180 days. Most migration failures trace to unmapped URLs, redirects to the home page, dropped parameters, slash mismatches, and staging blocks left in place.
A redirect sends a visitor or crawler from one URL to another, and it tells Google which of the two should represent the page. For anything that moved for good, the documented answer is a server-side permanent redirect (301 or 308) from each old URL to its specific equivalent, in one hop, kept in place for at least a year. Most real migration damage comes from departing from that sentence: no redirect, a redirect to the wrong page, a long chain, or a temporary status code left in place.
The redirect itself isn't what costs you. Google's site move guide says 301 and other permanent redirects don't cause a loss in PageRank. The costs sit in the surrounding work: URLs that were never mapped, signals that still point at old addresses, and blocks carried over from staging. Google's redirect documentation frames the choice by what you want shown in results. Permanent redirects show the new target, and temporary ones keep the source page.
| Situation | What to do | Note |
|---|---|---|
| Pages get new URLs on the same site | Permanent redirect per URL. Update internal links and sitemaps. | No Change of Address request. |
| HTTP to HTTPS, or www to non-www | Permanent redirects, plus consistent canonical signals. | No Change of Address request. |
| New domain or subdomain | Redirect every URL, then file Change of Address for each verified variant of the old domain. | You must own both properties. |
| New host or CDN, same URLs | No redirects. Test on a noindex hostname, then switch DNS. | Separate hosting guide. |
| Service down for a while | Temporary redirect (302 or 307) to an explanation page. | Keeps the original URL in results. |
| Two pages merged | Redirect both old URLs to the merged page. | Accepted when content was consolidated. |
| Page removed, nothing equivalent | Return 404 or 410. | A home page redirect can read as a soft 404. |
RFC 9110, section 15.4 says 301, 302, 307, and 308 mean the resource is available at the URI in the Location header. 303 says the Location URI is a different resource that gives an indirect answer, and it is mostly used to send the result of a POST to a page that can be fetched and bookmarked.
| Code | Meaning | Method on follow-up | Cached by default | Google's reading |
|---|---|---|---|---|
| 301 Moved Permanently | New permanent URI | May change POST to GET | Yes | Strong signal that the target is canonical |
| 308 Permanent Redirect | Same as 301 | Method preserved | Yes | Equivalent to 301 |
| 302 Found | Temporarily elsewhere. Keep using the original. | May change POST to GET | Only with explicit freshness | Weak signal |
| 307 Temporary Redirect | Same as 302 | Must not change method | Only with explicit freshness | Equivalent to 302 |
| 303 See Other | Indirect answer at another resource | Follow-up is GET or HEAD | Only with explicit freshness | Listed as temporary |
RFC 9110 explains that 301 and 302 were originally method-preserving, but early clients split on whether to resend a redirected POST as POST or GET, and practice converged on GET. 307 and 308 were added to settle it. For pages people read, this rarely matters. It matters for form posts, APIs, webhooks, and payment callbacks, where a 301 can turn the request into a GET and drop the body. Apache's Redirect documentation notes that POSTs are discarded.
Section 15.1 of RFC 9110 lists the status codes caches may reuse with heuristic freshness. 301 and 308 are on it, along with 404 and 410. 302, 303, and 307 are not, so a cache needs explicit freshness such as Cache-Control: max-age before it stores them, as RFC 9111 describes. For a stored 301 with no explicit lifetime, RFC 9111 encourages caches to use a fraction of the time since Last-Modified and mentions 10% as typical. It sets no fixed duration.
A wrong permanent redirect can therefore linger in browsers and shared caches for a period you don't control. If you're unsure of a destination, use a short explicit Cache-Control lifetime until the target is checked.
Google's crawler documentation says Googlebot follows a 301 and treats it as a strong signal that the target should be processed, and follows a 302 as a weak signal. It lists 307 as equivalent to 302 and 308 as equivalent to 301, and adds that the codes are semantically different, so the right one helps other clients. The redirect page says a temporary redirect's target might still be indexed if other canonicalization signals are present.
On the long run, the best-sourced statement is John Mueller's of April 8, 2021, relayed by Search Engine Roundtable. He said a temporary redirect expresses a preference for the source URL and a permanent one for the destination, that Google uses far more than redirects to pick a canonical. That is why a 302 often ends up treated like a 301 over time. If all internal and external links point to the destination, Google should probably pick the destination too. He said there is no fixed cut-off time.
Google's redirect documentation orders methods by how reliably Google interprets them. Server-side redirects come first. If you can't set status codes, a meta refresh is next, then a JavaScript redirect, and last a plain link to the new location, which Google calls a crypto redirect and says may not be recognized as a redirect. The platform may already have a built-in solution: the documentation names Blogger and Shopify as examples, so check platform settings before settling for a workaround.
Google reads an instant meta refresh (0 seconds) as permanent and a delayed one as temporary, and the HTTP Refresh header follows the same rule. A script redirect runs in Google's Web Rendering Service after the crawl, and rendering can fail, so Google might never see it. The documentation says to use one only when neither a server-side redirect nor a meta refresh is possible. curl doesn't execute scripts, so a JavaScript redirect won't appear in its output.
<meta http-equiv="refresh" content="0; url=https://example.com/newlocation"><script>
window.location.href = "https://www.example.com/newlocation";
</script>With a server-side redirect, the crawler documentation says any content Google receives from the redirecting URL is ignored and the target's content is processed instead.
A chain is a redirect whose target also redirects, and chains usually build up over time. A site moved to HTTPS, later dropped www, later changed a path structure, and each change added a rule. Google's crawler documentation says Googlebot follows up to 10 redirect hops by default. The move guide advises redirecting straight to the final destination and otherwise keeping chains ideally to 3 and under 5, because chains add latency and not every user agent supports long ones.
| Source | Limit or behavior |
|---|---|
| Google crawler documentation | Up to 10 hops by default. Google Inspection Tools is documented as not following redirects. |
| Google site move guide | Go straight to the final URL. Otherwise ideally 3 or fewer, and fewer than 5. |
| Page indexing report | A redirect error covers a chain that was too long, a loop, an over-long redirect URL, or a bad or empty URL in the chain. |
| RFC 9110, section 15.4 | Clients should detect loops. An older version recommended at most five, and some clients may enforce a fixed limit. |
The Page indexing help says the live URL Inspection test follows redirects and tests the final URL without showing that it did, so for a chain audit use curl or a crawler that lists every response.
Loops usually come from two systems normalizing the same thing in opposite directions, such as a CMS that adds a trailing slash and a server rule that removes it. The Next.js documentation warns that omitting the slash before a colon in a path parameter makes the pattern a literal string and risks infinite redirects. The nginx documentation shows rewrite ... last inside a location making the server cycle 10 times and return a 500.
Flatten on the mapping data rather than rule by rule. Follow each destination through the full list of pairs until it stops redirecting, and replace the target with that final URL. When you add a move on top of an old one, edit the old rules to point at the newest destination. Handle scheme and host in one rule, so http://www.old.example.com/page reaches https://new.example.com/page in one response.
Google's crawl budget documentation lists long redirect chains among the things that hurt crawling, next to soft 404 pages, which it says waste budget. The move guide says Google crawls the new site more heavily than usual afterward, because crawls of old URLs are redirected on top of normal crawling, so the new servers need capacity. Each extra hop is another request on that path.
The snippets below are examples that use reserved example.com names, based on the vendor documentation cited with each. Test them on staging, since the right rule depends on your URL structure.
The `return` directive accepts a redirect URL for 301, 302, 303, 307, and 308. nginx didn't treat 307 as a redirect before versions 1.1.16 and 1.0.13, or 308 before 1.13.0. The variable $request_uri holds the full original URI with arguments, according to the core module documentation, so it keeps both path and query string.
server {
listen 80;
listen 443 ssl;
server_name old.example.com www.old.example.com;
# TLS certificate directives for the old names go here
return 301 https://new.example.com$request_uri;
}
# One moved page, query string kept
location = /old-pricing {
return 301 /pricing$is_args$args;
}
# A pattern
rewrite ^/blog/[0-9]{4}/(.+)$ /articles/$1 permanent;In rewrite, the permanent flag returns a 301. If the replacement includes new arguments, nginx appends the previous ones after them, and a trailing question mark prevents that. The old host needs a valid TLS certificate too, since an HTTPS request to the old name fails before the server can send a redirect.
In mod_alias, Redirect defaults to a temporary 302, and permanent returns 301. It matches a prefix on whole path segments, so /old also catches /old/anything, and GET parameters carry over. RedirectMatch takes a regular expression, and gone returns 410 with no target. The documentation sends you to mod_rewrite for query string work.
RewriteRule matches the URL path only, so matching a query string takes a RewriteCond on %{QUERY_STRING}. The flags documentation says R uses 302 unless you give a code, R almost always belongs with L, and a target with no query string receives the original one unless you add QSD.
# One moved page (query string passes through, POST bodies do not)
Redirect permanent "/old-pricing" "https://example.com/pricing"
# A pattern: /blog/2019/some-post to /articles/some-post
RedirectMatch permanent "^/blog/[0-9]{4}/(.+)$" "https://example.com/articles/$1"
# A removed page: 410 Gone, no target
Redirect gone "/discontinued-widget"
# Match one query string, then drop it from the target
RewriteEngine On
RewriteCond %{QUERY_STRING} (^|&)id=42(&|$)
RewriteRule ^product\.php$ /products/blue-widget [R=301,L,QSD]Single Redirects use wildcards or expressions. Bulk Redirects are account-level lists for large numbers of redirects, and they run after the WAF, so a request the WAF blocks never reaches the redirect. Cloudflare's domain move example maps http*://example.com/* to https://example.net/${2} with a 301 and the query string preserved.
When incoming requests match (wildcard pattern):
Request URL: http*://old.example.com/*
Then:
Target URL: https://new.example.com/${2}
Status code: 301
Preserve query string: enabledBulk Redirects don't support string replacement or regular expressions. The parameters page sets the defaults: Preserve query string is off, and when on it discards any query string on the target, even if the request had none. Subpath matching and Include subdomains are off. The status code defaults to 301, and a source without a scheme matches both http and https.
Next.js reads redirects from next.config.js. The documentation says permanent: true sends a 308 and permanent: false a 307, so the request method is preserved. Query values pass through. Patterns are anchored to the start of the path, :slug doesn't match nested paths, and :slug* matches zero or more segments. The characters ( ) { } : * + ? have regex meaning and need escaping when literal.
module.exports = {
async redirects() {
return [
{ source: '/old-blog/:slug', destination: '/news/:slug', permanent: true },
{ source: '/legacy/:path*', destination: '/docs/:path*', permanent: true },
]
},
}Google treats 308 as equivalent to 301, so Next.js's permanent redirects are fine for search. Your platform may limit rule counts, so check before launch.
| Tool | Default | To change it |
|---|---|---|
| nginx return | Nothing carried over | Use $request_uri or $is_args$args |
| nginx rewrite | Old arguments appended after new | End replacement with ? to drop |
| Apache Redirect | Passes through | Use mod_rewrite |
| Apache RewriteRule | Copied if target has none, replaced if it has its own | QSA merges, QSD discards |
| Cloudflare Bulk Redirects | Dropped | Enable Preserve query string |
| Next.js | Passes through | Not applicable |
^.(.*) sent to one fixed URL creates the blanket-redirect problem described later.rewrite directives sequentially, and Apache's Redirect outranks Alias regardless of file order, so a broad early rule can shadow a specific one.} or ;.Google's post on trailing slashes says Google treats /foo/ and /foo as separate URLs. If both return 200, you can leave it, but the post suggests choosing one, using it in internal links and the sitemap, and 301 redirecting the other so the preferred version returns 200. Google's URL guidance says URL handling is case sensitive, so /APPLE and /apple are two URLs, and recommends converting to one case when your server treats them as the same page.
Redirect maps built from crawls often lose or invent slashes. If the map says /pricing and the new site serves /pricing/, every redirect gains a hop. The Next.js `trailingSlash` setting shows how framework defaults interact: by default /about/ redirects to /about, and with trailingSlash: true the other way, except file URLs with extensions and .well-known paths. Make the map's destination column match the form the new site serves with a 200.
Google publishes a guide for moves where URLs change, a guide for moves where they don't, and a help page for the Change of Address tool. They cover different cases.
The hosting guide covers switching providers or adding a CDN with identical URLs. No redirects are involved. It says to test a copy on a temporary hostname with noindex, confirm with URL Inspection that Googlebot can reach the new infrastructure, lower the DNS TTL to a few hours at least a week ahead, and keep Search Console verification working. At the switch you remove temporary blocks and update DNS. Expect a temporary drop in crawl rate, then a rise over a few days. Shut down the old host once its traffic reaches zero.
The move guide, last updated August 20, 2026, covers HTTP to HTTPS, domain changes, merges, and path changes. It says to split the move if that makes sense, change one thing at a time (domain first, redesign later), pick a lower-traffic period, and expect ranking fluctuation while Google recrawls. Small and medium sites should move all URLs at once, and large sites can move in sections. The move is complete when Googlebot has visited every old and new URL at least once.
Before the switch, the guide asks for a production robots.txt, a list of URLs to strip noindex from, 404 or 410 for content not moving, every variant of both properties verified, and server capacity. After it, confirm canonicals and robots meta rules, test the redirects, file Change of Address if the domain or subdomain changed, and submit the new sitemap.
The help page says to use the tool after you've moved and redirected, for a move from one domain or subdomain to another, and not for HTTP to HTTPS, moves within a site, www to non-www, or hosting changes. Its requirements:
example.com or m.example.com, not a path.www, aren't moved. Submit every verified variant of the old domain, even unused ones.http://example.com also moves https://example.com.The tool tells Google to emphasize crawling and indexing the new site, forwards signals, and prefers the new site for canonical selection, for 180 days. It doesn't erase the old site from the index. Old URLs without an equivalent can keep appearing. A request can be cancelled within 180 days by removing the redirects, adding redirects back, and clicking Cancel Move. Keeping the same architecture passes signals more directly, and combining the move with a redesign will probably cost some traffic.
| When | What Google says or what to do | Source |
|---|---|---|
| A week before a hosting move | Lower the DNS TTL to a few hours. | Hosting guide |
| Before launch | Verify all variants, prepare robots.txt and the noindex removal list, confirm capacity, save old and new sitemaps. | Move guide |
| Launch day | Enable redirects, check canonicals and robots rules, test, file Change of Address if the domain changed, submit the new sitemap. | Move guide |
| First days | Watch logs and error codes. Old sitemap warnings about redirects are expected. | Move guide |
| First few weeks | A few weeks for most pages of a small or medium site, longer for large ones. Visibility may fluctuate, then settle. | Move guide |
| Up to 180 days | Change of Address handling runs and can be cancelled. Keep redirects at least this long, more if search traffic still arrives through them. | Change of Address help |
| At least 1 year | Keep redirects generally this long, and consider keeping them indefinitely for users. | Move guide, Change of Address help |
| After 180 days | Google no longer recognizes a relationship between old and new, and treats a still-crawlable old site as unrelated. | Change of Address help |
The redirect map is the center of a migration, and everything else either prepares for it or verifies it.
Google's move guide suggests sitemaps, server logs or analytics for the most-visited URLs, the Links report in Search Console for pages with links, and the CMS's own URL list, and says to include images, videos, scripts, and stylesheets. A crawl of the old site adds pages no sitemap mentions. For a pure domain change with identical paths, a wildcard rule replaces the list.
| Mapping | Use when | Watch for |
|---|---|---|
| One to one | The page exists on the new site. This is the default. | The destination answers 200 directly, with correct slash and case. |
| Many to one | Several old pages were merged. | Fine for consolidated content. For unrelated pages it can read as a soft 404. |
| One to many | One page was split. | Pick the closest single successor. |
| No equivalent | The content is gone. | Return 404 or 410, not a home page redirect. |
Google's status code documentation says all 4xx codes except 429 are treated the same: indexed URLs are dropped, new ones aren't processed, and crawling gradually decreases. The crawl budget documentation says to return 404 or 410 for permanently removed pages and calls 404 a strong signal not to crawl a URL again. Google documents no difference between them. My reading is that 410 states intent more explicitly, and 404 is adequate. If a removed page had links and a close successor exists, map to the successor.
Compare old and new for title, meta description, headings, copy, internal links, alt text, and structured data, since a redesign can drop any of them. The move guide says each new URL needs a self-referencing rel=canonical, hreflang annotations must use the new URLs, internal links should be updated from the map, and the sitemap should list the new URLs. Google's canonicalization guide adds that HTTPS-to-HTTP redirects, or HTTP URLs in a sitemap or hreflang set, can push Google toward HTTP. The guides don't discuss structured data, so also confirm that absolute URLs inside it point at the new addresses.
Crawl staging with the old URL list and compare each old URL to its destination. Seer's case study, below, includes crawling staging to find unredirected URLs. Staging should block indexing, and the removal list should have an owner.
Verification means reading the status line and Location header of each response. curl -I sends a HEAD request and prints headers, -s silences progress output, and -L follows redirects. This output comes from a real run in October 2026 against a Google documentation URL that redirects twice.
curl -sIL http://developers.google.com/search/docs/crawling-indexing/http-network-errors | grep -i -E '^(HTTP|location)'
HTTP/1.1 301 Moved Permanently
location: https://developers.google.com/search/docs/crawling-indexing/http-network-errors
HTTP/2 301
location: /crawling/docs/troubleshooting/http-status-codes
HTTP/2 200The first response is a 301 that changes only the scheme. A second 301 carries a relative Location, which clients resolve against the current URL, and moves the path. Then comes the final 200. The protocol change and the path change were separate rules, which is how chains form. A flattened version would answer the first request with one 301 to the final HTTPS URL.
curl -s -o /dev/null -L -w '%{http_code} hops=%{num_redirects} %{url_effective}\n' http://old.example.com/old-pagewhile IFS=, read -r old new; do
out=$(curl -s -o /dev/null -w '%{http_code} %{redirect_url}' "$old")
code=${out%% *}; loc=${out#* }
if [ "$code" != "301" ] || [ "$loc" != "$new" ]; then
echo "MISMATCH $old -> $code $loc (expected $new)"
fi
done < redirect-map.csvThe map check inspects the first response only, so a scheme-only hop reports a mismatch against the final destination, as the Google URL above does. Run the hop-count form over the same list to find every URL with more than one redirect.
| You see | It means | Do this |
|---|---|---|
| One 301 or 308, then 200 | A direct permanent redirect. | Nothing. This is the target state. |
| 301, 301, then 200 | A two-hop chain. | Point the first rule at the final URL. |
| Final 404 | The destination is wrong or missing. | Fix the map. |
| Final 200 on the home page for a deep URL | A blanket redirect. | Map to a relevant page or return 404 or 410. |
| curl error 47, maximum redirects followed | A loop. | Find the rules that undo each other. |
| 200 with noindex in header or HTML | A staging rule carried over. | Remove it. Check X-Robots-Tag too. |
Also check the new site's robots.txt and a sample of new URLs in Search Console's URL Inspection tool. If a CDN or WAF sits in front of the origin, run the checks from outside your own network too.
Each failure below has a documented source and a symptom you can find in Search Console, a crawl, or server logs.
The move guide says not to redirect many old URLs to one irrelevant destination such as the new home page, which might be treated as a soft 404, with an exception for consolidated content. The Page indexing help defines a soft 404 as a page that shows a not-found message without a 404 status. Expect a growing Soft 404 count and old URLs that stay out of the index.
A rule that drops the query string loses campaign tags, filters, and pagination. The reverse failure is a new site making parameter URLs indexable at scale, which Seer lists among its findings. Check each rule against Table 4.
A map listing /pricing where the site serves /pricing/ puts a second redirect behind every first one. Google's slash post says the preferred version should return 200 and the other should 301 to it. Check the destination column before launch.
Google's canonicalization guide says it prefers HTTPS unless there's an invalid certificate, insecure dependencies, an HTTPS page that redirects through or to HTTP, or a canonical pointing to HTTP. Bad certificates and HTTPS-to-HTTP redirects make it prefer HTTP very strongly.
The move guide's troubleshooting list opens with leftover noindex rules and crawl blocks. The Page indexing help reports them as blocked-by-robots and excluded-by-noindex reasons. On launch day, fetch the new host's /robots.txt and check sample page headers.
Each internal link still pointing at an old URL costs an extra request on every visit and crawl, and the guide says to update them right after the move. Crawl the new site and report any internal link that returns a 3xx.
The move guide says people frequently redirect to wrong, non-existent URLs, with a spike in Not found errors as the sign. Leadpages, below, found two crawlable copies of its old site on internal subdomains, so list every hostname that ever served the site.
Detailed, verifiable migration post-mortems are scarce. Google's documentation publishes no outcome data, and I found no public dataset, such as HTTP Archive material, measuring migration outcomes or redirect chain prevalence. Company write-ups exist, and they are useful for failure modes and weak as evidence of effect size.
Seer Interactive's case study covers a consumer packaged goods client that redesigned its site and changed CMS, URLs, and information architecture. Seer reports a 26% traffic decline the month after launch, and an audit that found 163,198 URLs not properly redirected and about 90 thousand 404 pages from URLs missed in the redirect map or from directories that never had content. A new map weighted by traffic and backlinks cut 404s by 94%, from 90 thousand to 5 thousand, alongside blocked parameters, 301s for duplicate folders, 410s for low-value URLs, and corrected canonicals. Seer reports a later 126% organic traffic gain (its summary text says 125%) and 30% organic revenue gain year over year. It is a vendor's undated account of its own work, with no control, and several fixes were applied together, so the gains can't be assigned to the map alone.
The Leadpages post-mortem is a company's first-person account of replatforming about 1,500 pages and moving from www to the bare domain in April. A domain-level redirect shipped without a page-level map. Six lost pages were caught in the first week, four were rebuilt by hand, and a repair of nearly 400 page-level redirects shipped three months after the move. Its weekly chart showed three drops. The first, about a quarter, lined up with the migration. Lost URLs contributed about 3% of the total by its audit, and the largest drop, more than half in two weeks in mid-June, matched a core update. The measurements are its own, the company isn't an SEO firm, and the post says its first two diagnoses were wrong. The useful part is dating each drop before assigning a cause.
Neither case shows that redirects alone decide the outcome. Both show that missing or wrong redirects are a large, detectable part of the problem. Separating migration effects from other events takes weekly data and a dated timeline.
Confirm the scope against Table 1 and give every old URL a mapping type before setting a date. A permanent move that isn't mapped isn't ready to launch.
noindex and canonical URL.Three conditions change the plan. A site too large to move at once can move in sections, starting with a stable one. A platform that can't issue server-side redirects needs meta refresh or JavaScript, with the risk that Google doesn't read them as intended. And when the URLs don't change at all, only the hosting guide applies: no redirects, no Change of Address, and a DNS switch tested on a hostname Google can't index.
Sources were last checked on October 14, 2026. Documentation changes, so confirm any detail that matters to a decision against the source itself.
Indexive Research. (2026, August 5). Redirects and site moves, as the documentation describes them. Indexive AI. https://indexive.ai/research/redirects-and-site-moves
Straight answers about how we work. Still have a question? The free audit is the fastest way to get one answered for your site.
Either works for Google, which treats 308 as equivalent to 301. Use 308 when the redirected requests include non-GET methods that must keep their body, and 301 for ordinary pages.
A free execution audit: your prioritized backlog, effort estimates, and what we'd ship first. Read-only access, no contract.