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.

· 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 todayURLsShare
One permanent hop to a specific page (clean)5313.4%
A specific page, but through a chain or a temporary code11930.1%
A page that canonicalises elsewhere, is noindex or reads as a 4047318.5%
The new homepage246.1%
Still served on the old domain, no redirect338.4%
An error: 404, origin down, dead DNS or a broken certificate9323.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.

ToolBest forPhasePrice (2026-11-19)
Google Search ConsoleWhat Google indexed, Change of Address, sitemapsBefore and afterFree
Screaming Frog SEO SpiderRedirect maps in list mode, staging vs live comparisonBefore and launch dayFree up to 500 URLs; £199 a year
SitebulbAudit comparisons on large sitesBefore and after14-day trial; Cloud from £95 a month
AhrefsWhich old URLs have backlinksBeforeFree for verified sites; Lite $129 a month
BugVisoA before-and-after audit with a client-ready PDFBefore and afterFirst report free; then $1.49 a report or plans from $29 a month
The free script belowTracing every old URL, even without the old listLaunch day and afterFree

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.

PhaseJobTool that does it
Before (2–6 weeks out)List every old URLCrawler, Search Console export, server logs; Common Crawl when the list is lost
BeforeRank URLs by valueSearch Console clicks + Ahrefs "Best by links"
BeforeBenchmark auditBugViso or Sitebulb, saved for comparison
StagingCompare staging with liveScreaming Frog crawl comparison with URL Mapping
Launch dayOne permanent hop per old URLScreaming Frog list mode or the script below
Launch daySignal a domain changeSearch Console Change of Address (domain moves only)
After (weeks 1–4)Errors and dropped pagesPage 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.

  1. Redirects. Every old URL answers with one 301 or 308 to its new equivalent.
  2. Indexing. No noindex in HTML or the X-Robots-Tag header, no Disallow: / left from staging.
  3. Canonicals. Each new page names itself on the new host, not the old domain.
  4. Content. Titles, H1s, word counts and structured data match the benchmark.
  5. 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.

python
#!/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:

text
$ 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 itself

The 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

· 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.

Found this useful? Share it.

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 how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.