Best Website Migration SEO Tools 2027: Top 5 Compared
The best website migration SEO tools for 2027, by phase, plus 395 old URLs from 16 sites that moved domain, traced today: only 13% still land in one clean hop.
Kazi Khalid Hasan Tamim · BugViso Team
16 min read
The best website migration SEO tools for 2027 are Google Search Console for what Google sees, Screaming Frog SEO Spider for redirect maps and staging crawls, Sitebulb for comparing audits on large sites, Ahrefs for finding the old URLs with backlinks, and BugViso for a before-and-after audit a client can read. No single tool covers a whole migration.
We traced 395 old URLs from 16 well-known sites that moved to a new domain: only 53 (13.4%) still take one permanent hop to a page that canonicalises to itself, 93 (23.5%) end in an error and 24 (6.1%) land on the homepage.
By the end you will know which tool fits each phase of a move, what each costs, and how to trace your own old URLs for free.
Data used: 16 sites whose old domain now redirects to a different domain (developer documentation, SaaS products and one retired consumer app), checked on 2026-11-19. Old URLs come from free Common Crawl indexes captured before each move (2017, 2019 or 2021): up to 25 HTML pages per site on the old domain or its subdomains that returned a 200 at the time, picked at random with a fixed seed, 395 in total (212 on subdomains). Each was traced with the script in this post. Tool facts come from each vendor's site, fetched the same day. We make BugViso, one of the tools listed, and don't name the sites in the sample.
Website Migration and SEO: What Happened to 395 Old URLs
Only 53 of 395 old URLs (13.4%) still do what a migration should: one permanent hop to a working page that canonicalises to itself. The other 342 lose something on the way.
| Where the old URL ends up today | URLs | Share |
|---|---|---|
| One permanent hop to a specific page (clean) | 53 | 13.4% |
| A specific page, but through a chain or a temporary code | 119 | 30.1% |
A page that canonicalises elsewhere, is noindex or reads as a 404 | 73 | 18.5% |
| The new homepage | 24 | 6.1% |
| Still served on the old domain, no redirect | 33 | 8.4% |
| An error: 404, origin down, dead DNS or a broken certificate | 93 | 23.5% |
Of the 308 old URLs that redirect at all, 148 (48.1%) need two or more hops, 28 need three or more, and the longest takes 6. 84 (27.3%) pass through a temporary 302 or 307, and 39 redirect only to land on a 404: every one kept its old path on a new site that no longer has it.
The 93 errors are 45 404s, 25 Cloudflare 522s (the old origin no longer answers), 20 hosts that no longer resolve and 3 certificate failures. All 48 of the last three sit on old subdomains (docs, help centres, forums) the move left behind. Per site, 5 of 16 lost half or more of their sampled URLs to an error or the homepage, and 13 had at least one chain.
Website Migration SEO Tools at a Glance
Pick tools by job, not by brand: one to see what Google sees, one crawler, one backlink source and one audit you can repeat after launch.
| Tool | Best for | Phase | Price (2026-11-19) |
|---|---|---|---|
| Google Search Console | What Google indexed, Change of Address, sitemaps | Before and after | Free |
| Screaming Frog SEO Spider | Redirect maps in list mode, staging vs live comparison | Before and launch day | Free up to 500 URLs; £199 a year |
| Sitebulb | Audit comparisons on large sites | Before and after | 14-day trial; Cloud from £95 a month |
| Ahrefs | Which old URLs have backlinks | Before | Free for verified sites; Lite $129 a month |
| BugViso | A before-and-after audit with a client-ready PDF | Before and after | First report free; then $1.49 a report or plans from $29 a month |
| The free script below | Tracing every old URL, even without the old list | Launch day and after | Free |
The 5 Best Website Migration SEO Tools
1. Google Search Console: best for seeing what Google sees
Search Console is the only tool that shows how Google itself reacted to your move, and it's free. The Page indexing report shows old URLs moving to "Page with redirect" and new ones being indexed; URL Inspection covers single pages, and Sitemaps takes the new URL list.
For a domain change, the Change of Address tool tells Google to favour the new site, and Google says its effects "continue for 180 days." It doesn't move subdomains, including www, and it can't check a redirect map before launch.
2. Screaming Frog SEO Spider: best for redirect maps and staging vs live
Screaming Frog's list mode is built for checking a redirect map. Its migration tutorial crawls the old URLs in list mode with "Always Follow Redirects" on, then exports "All Redirects": chain type, hop count, loops and final address.
Before launch, crawl comparison with URL Mapping matches a staging crawl to the live site with a regex, and change detection flags changed titles, H1s, word counts, internal links or structured data. Its guide says comparison needs database storage mode and a licence. The free version stops at 500 URLs; a licence is £199 a year.
3. Sitebulb: best for comparing audits on large sites
Sitebulb compares one audit with the next ("compare audits to see what's changed"), the core of a pre- and post-launch check, on its Pro plan. Lite audits up to 10,000 URLs; Pro up to 500,000 by default and 2 million on request.
Sitebulb Cloud starts at £95 a month according to its pricing FAQ, and Pro has a 14-day free trial. The pricing page didn't show Lite and Pro monthly prices when we checked.
4. Ahrefs: best for deciding which old URLs matter most
Ahrefs tells you which old URLs have backlinks, and those are the redirects you check by hand. Its "Best by links" report ranks a site's pages by the links pointing at them; filter it by 404 after launch to find linked pages you forgot to redirect.
Ahrefs Free covers sites you verify: Site Audit with 5,000 crawl credits per project per month and up to 1,000 backlinks in Site Explorer. Paid plans start at $129 a month (Lite, 100,000 crawl credits).
5. BugViso: best for a before-and-after audit a client can read
BugViso audits the site before and after a move and reports what changed: the score move, fixed, new and worse issues, on screen and in the PDF.
Where others go further: BugViso has no redirect-map upload, doesn't connect to Search Console, and crawls 75 to 300 pages per audit depending on plan. The comparison is with the previous audit of the same host, so a move to a new domain starts a fresh record.
How to Choose Website Migration SEO Tools by Phase
Choose tools by phase: inventory and benchmarks before, redirect checks on launch day, repeat audits after.
| Phase | Job | Tool that does it |
|---|---|---|
| Before (2–6 weeks out) | List every old URL | Crawler, Search Console export, server logs; Common Crawl when the list is lost |
| Before | Rank URLs by value | Search Console clicks + Ahrefs "Best by links" |
| Before | Benchmark audit | BugViso or Sitebulb, saved for comparison |
| Staging | Compare staging with live | Screaming Frog crawl comparison with URL Mapping |
| Launch day | One permanent hop per old URL | Screaming Frog list mode or the script below |
| Launch day | Signal a domain change | Search Console Change of Address (domain moves only) |
| After (weeks 1–4) | Errors and dropped pages | Page indexing report + a re-run of the script |
| After (months 1–3) | Did anything regress? | BugViso re-audit, or a Sitebulb audit comparison |
💡 Rule of thumb: If you can afford one paid tool, buy the crawler; the rest of this table has free options.
The order of the work itself (benchmark crawl, redirect map, staging, launch day, 30 days of monitoring) is in our website migration SEO checklist; for the functional and accessibility QA pass on the new site, see our website QA testing tools comparison.
SEO Website Migration Audits: What Each Pass Must Check
SEO website migration audits are three crawls of the same site (a benchmark before the move, one on staging, one after launch) compared against each other. Each pass checks the same five things.
- Redirects. Every old URL answers with one 301 or 308 to its new equivalent.
- Indexing. No
noindexin HTML or theX-Robots-Tagheader, noDisallow: /left from staging. - Canonicals. Each new page names itself on the new host, not the old domain.
- Content. Titles, H1s, word counts and structured data match the benchmark.
- Links. Internal links, hreflang and the sitemap point at final URLs, not redirects.
Google treats 301 and 308 as permanent and shows the new URL, while 302, 303 and 307 are temporary and keep the old one in results, according to its redirects guide.
Run It Yourself: Trace Every Old URL After a Migration
This script traces each old URL hop by hop and checks the page it lands on: status, chain length, temporary codes, homepage dumps, canonical, noindex and a soft-404 title. It reads a URL list or an old_url,new_url map, or rebuilds a lost list from Common Crawl.
#!/usr/bin/env python3
"""Trace old URLs after a site migration: hops, codes, final page, canonical, noindex.
Usage:
python3 migration_check.py old_urls.txt # one URL per line, or a CSV: old_url,new_url
python3 migration_check.py --commoncrawl old-domain.com CC-MAIN-2021-04 # rebuild a lost list
"""
import csv, http.client, json, random, re, socket, sys, time
import urllib.error, urllib.request
from concurrent.futures import ThreadPoolExecutor
from html.parser import HTMLParser
from urllib.parse import urljoin, urlsplit
UA = "Mozilla/5.0 (compatible; migration-check/1.0)"
PERMANENT, TEMPORARY = {301, 308}, {302, 303, 307}
class NoFollow(urllib.request.HTTPRedirectHandler):
def redirect_request(self, *args, **kwargs):
return None # surface every 3xx so we count the hops ourselves
OPENER = urllib.request.build_opener(NoFollow)
class Head(HTMLParser):
def __init__(self):
super().__init__()
self.canonical, self.noindex, self.title, self.in_title = None, False, "", False
def handle_starttag(self, tag, attrs):
a = {k: v or "" for k, v in attrs}
if tag == "link" and "canonical" in a.get("rel", "").lower().split() and self.canonical is None:
self.canonical = a.get("href", "").strip()
elif tag == "meta" and a.get("name", "").lower() in ("robots", "googlebot"):
self.noindex |= "noindex" in a.get("content", "").lower()
self.in_title = tag == "title"
def handle_data(self, data):
if self.in_title:
self.title += data
def trace(url, max_hops=10): # Googlebot follows up to 10 hops
hops = []
while True:
req = urllib.request.Request(url, headers={"User-Agent": UA})
try:
with OPENER.open(req, timeout=20) as r:
status, location, headers = r.status, None, r.headers
body = r.read(400_000) if "html" in (headers.get("Content-Type") or "") else b""
except urllib.error.HTTPError as e:
status, location, headers, body = e.code, e.headers.get("Location"), e.headers, b""
except Exception as e: # DNS, TLS, timeout: report it, keep going
reason = getattr(e, "reason", e)
return hops, "DNS" if isinstance(reason, socket.gaierror) else type(reason).__name__, url, None
hops.append(status)
if status in PERMANENT | TEMPORARY and location:
url = urljoin(url, location)
if len(hops) >= max_hops:
return hops, "TOO MANY", url, None
continue
head = Head()
head.feed(body.decode("utf-8", "replace"))
head.noindex |= "noindex" in (headers.get("X-Robots-Tag") or "").lower()
return hops, status, url, head
def norm(u):
p = urlsplit(u)
return f"{p.scheme.lower()}://{p.netloc.lower()}{p.path or '/'}" + (f"?{p.query}" if p.query else "")
def classify(old, hops, status, final, head, expected=None):
"""Problems for one old URL; an empty list means it is handled well."""
redirects = [s for s in hops if s in PERMANENT | TEMPORARY]
flags = [] if status == 200 else [f"BROKEN {status}"]
if not redirects:
flags.append("NOT REDIRECTED")
if len(redirects) > 1:
flags.append(f"CHAIN {len(redirects)}")
if any(s in TEMPORARY for s in redirects):
flags.append("TEMPORARY")
if expected and norm(final) != norm(expected):
flags.append("WRONG TARGET")
# shortcut: only a bare "/" counts as the homepage; add locale roots such as /en/ if you use them
if redirects and urlsplit(old).path not in ("", "/") and urlsplit(final).path in ("", "/"):
flags.append("HOMEPAGE")
if head and status == 200:
if head.canonical and norm(urljoin(final, head.canonical)) != norm(final):
flags.append("CANONICAL ELSEWHERE")
if head.noindex:
flags.append("NOINDEX")
if re.search(r"\b404\b|not found", head.title, re.I):
flags.append("SOFT 404")
return flags
def commoncrawl(domain, crawl, limit=50):
"""Old HTML URLs that answered 200 on `domain` in one Common Crawl index."""
api = (f"https://index.commoncrawl.org/{crawl}-index?url={domain}&matchType=domain"
"&output=json&filter=status:200&filter=mime:text/html&limit=1000")
for attempt in range(8): # the free index often answers 502/504: back off and retry
try:
with urllib.request.urlopen(urllib.request.Request(api, headers={"User-Agent": UA}), timeout=120) as r:
urls = sorted({json.loads(x)["url"] for x in r.read().decode().splitlines() if x.strip()})
break
except (OSError, ValueError, http.client.HTTPException):
time.sleep(5 * (attempt + 1))
else:
sys.exit("Common Crawl index unavailable, try again later")
urls = [u for u in urls if "?" not in u]
random.Random(1).shuffle(urls)
return [(u, None) for u in urls[:limit]]
def check(item):
old, expected = item
hops, status, final, head = trace(old)
return old, final, classify(old, hops, status, final, head, expected)
if __name__ == "__main__":
if sys.argv[1:2] == ["--commoncrawl"]:
items = commoncrawl(sys.argv[2], sys.argv[3])
else:
with open(sys.argv[1], newline="", encoding="utf-8") as f:
rows = [r for r in csv.reader(f) if r and r[0].strip() and r[0].strip() != "old_url"]
items = [(r[0].strip(), r[1].strip() if len(r) > 1 else None) for r in rows]
with ThreadPoolExecutor(4) as pool: # 4 at a time: polite to the server you are testing
results = list(pool.map(check, items))
for old, final, flags in results:
print(f"{', '.join(flags) or 'OK':30} {old} -> {final}")
ok = sum(not flags for _, _, flags in results)
print(f"\n{ok} of {len(results)} old URLs: one permanent hop to a 200 page that canonicalises to itself")
sys.exit(ok != len(results))A real run against three of our own URLs, unedited:
$ python3 migration_check.py redirects.csv
OK http://bugviso.com/pricing -> https://bugviso.com/pricing
CHAIN 2 http://www.bugviso.com/blog/redirect-chains-and-loops-find-fix -> https://bugviso.com/blog/redirect-chains-and-loops-find-fix
BROKEN 404, NOT REDIRECTED, WRONG TARGET https://bugviso.com/blog/old-migration-guide -> https://bugviso.com/blog/old-migration-guide
1 of 3 old URLs: one permanent hop to a 200 page that canonicalises to itselfThe second row is a real chain on our own site: http://www. goes to https://www. and only then to the apex domain, two 308s where one would do. The third is a URL we never redirected. Our guide to redirect chains and loops shows how to flatten the first.
For --commoncrawl, pick a crawl id from before your move on the Common Crawl index server. The free index is often busy, so the script retries. For a single URL, a redirect checker is quicker.
How BugViso Audits a Site Before and After a Migration
BugViso crawls the site in a real browser before the move, again after it, and lists what changed between the two audits.
The canonical checks flag a canonical on the wrong protocol, one that names the other www or apex host, and inner pages that canonicalise to the homepage. The audit also requests a URL that can't exist to catch soft 404s, flags pages whose canonical, og:url or internal links still name the www or apex twin that redirects, and checks every link and image on each crawled page for 404s, loops and server errors.
After launch, scheduled re-scans on any monthly plan and an email alert when the score drops below a threshold you set catch regressions from the next deploy. The site crawl and white-label reports page shows the crawl.
What This Test Can't Tell You
The sample shows well-known sites years after a move, not a typical small-business migration.
- Selection: we started from 32 candidates; 2 didn't redirect to another domain when we checked, and for 14 the free Common Crawl index timed out on the day.
- Order: the index returns URLs alphabetically, so each site's sample comes from the first 1,000 HTML URLs captured.
- Intent: some old URLs (profiles, build logs, forum threads) may have been retired on purpose.
Frequently Asked Questions
What tools do you need for a website migration?
You need Search Console for what Google sees, a crawler such as Screaming Frog or Sitebulb for the old site, staging and the redirect map, a backlink source such as Ahrefs to rank old URLs by value, and a repeatable audit such as BugViso to compare before and after launch.
What does a bad website migration do to SEO?
A bad website migration sends old URLs to errors, the homepage or long chains, so Google drops pages it can't match to a new equivalent. In our test of 395 old URLs from 16 moved sites, 93 (23.5%) end in an error and 24 (6.1%) land on the homepage.
How does a website migration affect SEO?
A migration with page-to-page permanent redirects usually causes a temporary dip while Google recrawls. Google's site move guide says a medium-sized site can take "a few weeks or more" for new URLs to show.
How long should you keep redirects after a site migration?
Keep redirects "for as long as possible, generally at least 1 year," according to Google's site move guide. For a domain change, Change of Address runs for 180 days.
Do I need the Change of Address tool for an HTTP to HTTPS move?
No. Google's help page says not to use Change of Address for HTTP-to-HTTPS or www-to-non-www changes; permanent redirects and canonicals are enough. Use it only when you move from one domain or subdomain to another, after verifying every variant of the old domain.
How do I find old URLs after a migration if nobody kept a list?
Rebuild the list from a Common Crawl index captured before the move: query the old domain, keep URLs that returned 200, then trace each one. The script in this post does both. Add Search Console's top pages, which matter most.
The Migration Test Most Teams Skip
Most teams check that the homepage and top pages redirect, then stop; in our sample, the losses sat in subdomains and deep paths nobody listed. Trace every old URL you can find and keep a benchmark audit to compare against: a BugViso audit before and after the move gives you that comparison in one report.
Written by
Kazi Khalid Hasan Tamim · BugViso Team
Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.
Summarise with AI
Open this guide in your assistant.
Follow BugViso
New guides and audit data as we publish them.
AI visibility tracker
Is your brand in AI answers?
See how often AI assistants mention you, cite your site and rank you against your competitors.
- ChatGPT
- Gemini
- Perplexity
- Claude
- AI Overviews
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.