indexive
ServicesSolutionsIndustriesResearch
Log inFree execution audit
GuidePublished August 5, 2026·Sources checked October 14, 2026·23 min read

Redirects and site moves, as the documentation describes them

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.

By Indexive Research · every source is linked at the end
Key points
10 hops
Googlebot follows by default
180 days
Change of Address window
1 year
keep redirects, generally at least

Matching the situation to the redirect plan

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.

SituationWhat to doNote
Pages get new URLs on the same sitePermanent redirect per URL. Update internal links and sitemaps.No Change of Address request.
HTTP to HTTPS, or www to non-wwwPermanent redirects, plus consistent canonical signals.No Change of Address request.
New domain or subdomainRedirect 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 URLsNo redirects. Test on a noindex hostname, then switch DNS.Separate hosting guide.
Service down for a whileTemporary redirect (302 or 307) to an explanation page.Keeps the original URL in results.
Two pages mergedRedirect both old URLs to the merged page.Accepted when content was consolidated.
Page removed, nothing equivalentReturn 404 or 410.A home page redirect can read as a soft 404.
Table 1. Common situations and the documented approach

Status codes compared

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.

CodeMeaningMethod on follow-upCached by defaultGoogle's reading
301 Moved PermanentlyNew permanent URIMay change POST to GETYesStrong signal that the target is canonical
308 Permanent RedirectSame as 301Method preservedYesEquivalent to 301
302 FoundTemporarily elsewhere. Keep using the original.May change POST to GETOnly with explicit freshnessWeak signal
307 Temporary RedirectSame as 302Must not change methodOnly with explicit freshnessEquivalent to 302
303 See OtherIndirect answer at another resourceFollow-up is GET or HEADOnly with explicit freshnessListed as temporary
Table 2. Redirect status codes, from RFC 9110 and Google's crawler documentation

Method preservation

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.

Caching

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.

How Google treats permanent and temporary over time

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.

Meta refresh, JavaScript, and other client-side redirects

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">
Example instant meta refresh, read by Google as permanent
<script>
  window.location.href = "https://www.example.com/newlocation";
</script>
Example JavaScript redirect, last resort

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.

Redirect chains, loops, and crawl cost

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.

SourceLimit or behavior
Google crawler documentationUp to 10 hops by default. Google Inspection Tools is documented as not following redirects.
Google site move guideGo straight to the final URL. Otherwise ideally 3 or fewer, and fewer than 5.
Page indexing reportA 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.4Clients should detect loops. An older version recommended at most five, and some clients may enforce a fixed limit.
Table 3. Documented limits for redirect chains

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 and flattening

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.

Crawl budget in brief

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.

Writing redirect rules in common servers

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.

nginx

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;
Example nginx, whole-domain move, path and query string preserved

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.

Apache

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]
Example Apache .htaccess

Cloudflare

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: enabled
Adapted from Cloudflare's documented Single Redirect example

Bulk 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

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 },
    ]
  },
}
Example Next.js redirects in next.config.js

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.

Query strings and regular expressions

ToolDefaultTo change it
nginx returnNothing carried overUse $request_uri or $is_args$args
nginx rewriteOld arguments appended after newEnd replacement with ? to drop
Apache RedirectPasses throughUse mod_rewrite
Apache RewriteRuleCopied if target has none, replaced if it has its ownQSA merges, QSD discards
Cloudflare Bulk RedirectsDroppedEnable Preserve query string
Next.jsPasses throughNot applicable
Table 4. Default query string handling
  • Unanchored patterns match more than intended. Apache's documentation suggests starting with ^.
  • A catch-all such as (.*) sent to one fixed URL creates the blanket-redirect problem described later.
  • Order matters. nginx runs rewrite directives sequentially, and Apache's Redirect outranks Alias regardless of file order, so a broad early rule can shadow a specific one.
  • Quote any nginx regex that contains } or ;.

Trailing slashes and case

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's documented site move process

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.

Moves with no URL change

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.

Moves with URL changes

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 Change of Address tool

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:

  • You own both properties, using the same Google account.
  • The property is at the domain level, such as example.com or m.example.com, not a path.
  • Subdomains below the property, including www, aren't moved. Submit every verified variant of the old domain, even unused ones.
  • All protocols move together, so http://example.com also moves https://example.com.
  • Moves can't be chained (A to B, then B to C right away), and merging several sites into one location at once can cause confusion and traffic loss.

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.

WhenWhat Google says or what to doSource
A week before a hosting moveLower the DNS TTL to a few hours.Hosting guide
Before launchVerify all variants, prepare robots.txt and the noindex removal list, confirm capacity, save old and new sitemaps.Move guide
Launch dayEnable redirects, check canonicals and robots rules, test, file Change of Address if the domain changed, submit the new sitemap.Move guide
First daysWatch logs and error codes. Old sitemap warnings about redirects are expected.Move guide
First few weeksA 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 daysChange 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 yearKeep redirects generally this long, and consider keeping them indefinitely for users.Move guide, Change of Address help
After 180 daysGoogle no longer recognizes a relationship between old and new, and treats a still-crawlable old site as unrelated.Change of Address help
Table 5. Migration timeline, using timings stated in Google's documents

Planning the URL map and the migration

The redirect map is the center of a migration, and everything else either prepares for it or verifies it.

Build the inventory

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.

Choose a mapping type for each URL

MappingUse whenWatch for
One to oneThe page exists on the new site. This is the default.The destination answers 200 directly, with correct slash and case.
Many to oneSeveral old pages were merged.Fine for consolidated content. For unrelated pages it can read as a soft 404.
One to manyOne page was split.Pick the closest single successor.
No equivalentThe content is gone.Return 404 or 410, not a home page redirect.
Table 6. Mapping types

404 or 410

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.

Carry over what search engines read

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.

Test on staging

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.

The sequence

  1. Decide scope: one change at a time, all at once or in sections.
  2. Inventory the old site from sitemaps, logs, analytics, the CMS, Search Console links, and a crawl, including media.
  3. Build the map with a type and a 200-returning destination for every URL.
  4. Prepare the new site with canonicals, hreflang, internal links, metadata, and a new sitemap, behind a staging block.
  5. Write the rules and test the whole map on staging for chain depth, query strings, and status codes.
  6. Verify every Search Console variant, save old and new sitemaps, and confirm capacity with the host.
  7. Launch: remove blocks, enable redirects, test live, file Change of Address if it applies, submit the sitemap.
  8. Update links you control, then monitor both properties and keep the redirects at least a year.

Verifying redirects with curl

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 200
Example, following a chain and printing each hop

The 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-page
Example, final status, hop count, and final URL for one URL
while 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.csv
Example, compare a whole map (CSV of old,new with absolute URLs and no commas inside them)

The 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 seeIt meansDo this
One 301 or 308, then 200A direct permanent redirect.Nothing. This is the target state.
301, 301, then 200A two-hop chain.Point the first rule at the final URL.
Final 404The destination is wrong or missing.Fix the map.
Final 200 on the home page for a deep URLA blanket redirect.Map to a relevant page or return 404 or 410.
curl error 47, maximum redirects followedA loop.Find the rules that undo each other.
200 with noindex in header or HTMLA staging rule carried over.Remove it. Check X-Robots-Tag too.
Table 7. Reading common results

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.

Common migration failures and what they look like

Each failure below has a documented source and a symptom you can find in Search Console, a crawl, or server logs.

Blanket redirects to the home page

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.

Parameters dropped or multiplied

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.

Lost or invented trailing slashes

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.

Mixed protocols

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.

robots.txt and noindex from staging

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.

Internal links that rely on redirects

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.

Wrong destinations and forgotten hostnames

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.

What published cases show, and their limits

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.

Launch checklist and what to do now

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.

Before launch

  • Every old URL, including media, has a mapping type and a destination that returns 200 directly.
  • Destinations use the same slash and case form the new site serves.
  • Canonicals, hreflang, internal links, and sitemap entries use new HTTPS URLs.
  • Staging is blocked, and the removal list for robots.txt and noindex rules has an owner.
  • Every variant of the old and new properties is verified in Search Console.
  • The old hostname has a valid certificate, capacity is confirmed, and the map has passed the curl comparison on staging.

Launch day

  • Remove staging blocks, then enable redirects.
  • Run the map comparison and hop count against production, and check sample pages for noindex and canonical URL.
  • Submit the new sitemap, keep the old one for monitoring, and file Change of Address for each variant if the domain changed.
  • Update links you control, such as profiles and ad campaigns.

After launch

  • Watch logs for Googlebot, unexpected 4xx and 5xx responses, and redirect volume.
  • Compare indexed counts for old and new sitemaps, expecting redirect warnings on the old one.
  • Review the Page indexing report weekly for Not found, Soft 404, Redirect error, blocked, and noindex reasons, and chart clicks weekly so a dip can be dated.
  • Keep redirects and the old domain for at least a year.
  • Set a date in advance when waiting becomes auditing, since Google gives no recovery date.

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

  1. [1]
    Redirects and Google Search
    Google Search Central. Permanent versus temporary redirects, meta refresh, JavaScript and crypto redirects, alternate names. Last updated 2026-04-14.
  2. [2]
    How to move a site with URL changes
    Google Search Central. Site move process, mapping, chain advice, soft 404 warning, redirect duration, troubleshooting. Last updated 2026-08-20.
  3. [3]
    Changing your hosting
    Google Search Central. Moves where URLs do not change: testing, TTL, crawl-rate behavior. Last updated 2025-12-10.
  4. [4]
    Change of Address tool
    Google Search Console Help. When to use the tool, requirements, the 180-day window, cancelling a move.
  5. [5]
    How HTTP status codes affect Google's crawlers
    Google Crawling Infrastructure. 10-hop default, 301/302/307/308 treatment, 4xx handling. Last updated 2026-02-04.
  6. [6]
    Page indexing report
    Google Search Console Help. Redirect error, Page with redirect, Soft 404, blocked and noindex reasons.
  7. [7]
    Crawl budget management for large sites
    Google Crawling Infrastructure. Redirect chains, soft 404s, and 404/410 for removed pages. Last updated 2026-07-22.
  8. [8]
    URL structure best practices
    Google Search Central. Case sensitivity of URLs and parameter guidance.
  9. [9]
    To slash or not to slash
    Google Search Central Blog (2010). Trailing slash and non-slash URLs treated as separate; 301 to the preferred version.
  10. [10]
    How to specify a canonical URL with rel=canonical and other methods
    Google Search Central. Redirects as a canonical signal; HTTPS preference and HTTP pitfalls.
  11. [11]
    RFC 9110, HTTP Semantics
    IETF. Section 15.4 redirect semantics, method handling, heuristically cacheable status codes.
  12. [12]
    RFC 9111, HTTP Caching
    IETF. Storage requirements and heuristic freshness.
  13. [13]
    Module ngx_http_rewrite_module
    nginx. return and rewrite directives, flags, argument handling.
  14. [14]
    Module ngx_http_core_module
    nginx. $request_uri, $is_args, $args variables.
  15. [15]
    mod_alias
    Apache HTTP Server. Redirect, RedirectMatch, status keywords, prefix matching.
  16. [16]
    mod_rewrite
    Apache HTTP Server. RewriteRule pattern matching and query string conditions.
  17. [17]
    RewriteRule flags
    Apache HTTP Server. R, L, G, QSA, and QSD flag behavior.
  18. [18]
    Bulk Redirects
    Cloudflare. Account-level redirects; execution after the WAF.
  19. [19]
    URL redirect parameters
    Cloudflare. Bulk Redirect fields, defaults, and query string behavior.
  20. [20]
    Redirect requests from one domain to another
    Cloudflare. Wildcard Single Redirect example with preserved query string.
  21. [21]
    redirects in next.config.js
    Next.js. permanent true as 308, false as 307, path matching, query pass-through.
  22. [22]
    trailingSlash in next.config.js
    Next.js. Default and configured trailing slash redirects.
  23. [23]
    Why Google often treats 302 redirects as 301 redirects
    Search Engine Roundtable. John Mueller's April 8, 2021 comments on long-lived temporary redirects, relayed by Barry Schwartz.
  24. [24]
    Website Migration Support Leads to 126% Increase in Traffic
    Seer Interactive. Vendor-published migration case study with redirect and 404 counts.
  25. [25]
    What happens when you move a 1,500-page website
    Leadpages. First-person migration post-mortem with weekly decomposition of the decline.

Sources were last checked on October 14, 2026. Documentation changes, so confirm any detail that matters to a decision against the source itself.

How to cite

Indexive Research. (2026, August 5). Redirects and site moves, as the documentation describes them. Indexive AI. https://indexive.ai/research/redirects-and-site-moves

Keep reading
Guide · 23 min
How Google picks the canonical URL for a page
Guide · 22 min
Who needs to worry about crawl budget and what wastes it
Field note · 16 min
Why we confirm every SEO change on the live page

Frequently asked questions.

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.

Google's crawler documentation says Googlebot follows up to 10 by default, but the site move guide advises redirecting straight to the final URL and, failing that, ideally no more than 3 and fewer than 5.

No. Google's help page lists HTTP to HTTPS, www to non-www, and moves within a site as cases where the tool is not used. It is for moving from one domain or subdomain to another.

The move guide says as long as possible, generally at least one year, and the Change of Address help says at least 180 days. For users, consider keeping them indefinitely.

No. Google's move guide warns that redirecting many old URLs to one irrelevant page can be treated as a soft 404. Return 404 or 410 when nothing equivalent exists.

See your first 30 days of execution.

A free execution audit: your prioritized backlog, effort estimates, and what we'd ship first. Read-only access, no contract.

By continuing you agree to our Privacy Policy and Terms.
indexive
ServicesResearchContentTechnical SEOImplementationGEO / AI searchPerformanceMigrations
SolutionsDeclining traffic recoveryAI search visibilitySEO backlog executionTechnical debt cleanupContent at scaleHeads of SEOVPs of Marketing & CMOsLean teams with no SEO
IndustriesB2B SaaSDeveloper toolsCybersecurityFintechHealthcare & life sciencesE-commerceMarketplacesManufacturing & industrialProfessional services
CompanyResearchFree auditSecurityContactLog in
© 2026 Indexive AIPrivacyTermsSan Francisco, CA