How to Migrate a Website Without Losing Search Visibility

• Google Search Central: Changing Your Web Hosting
• Google Search Central: Site Moves with URL Changes

1. Transferring content and business data.
2. Replacing the original CMS and frontend.
3. Rebuilding templates and application functionality.
4. Changing hosting infrastructure.
5. Potentially changing the domain or URL structure.

• XML sitemaps.
• Google Search Console.
• Google Analytics or another analytics platform.
• Server access logs.
• Backlink reports.
• The website’s CMS.
• Automated website crawlers.

• Keep the original URL when it remains valid.
• Redirect it to a directly equivalent replacement.
• Redirect it to a new page that has absorbed the original content.
• Return 404 or 410 when the content has been removed and no suitable replacement exists.

• Page content and structure.
• Navigation and internal links.
• Forms and interactive components.
• Images, documents and other assets.
• Canonical URLs.
• Page titles and meta descriptions.
• Hreflang annotations.
• Structured data.
• XML sitemaps.
• Robots.txt.
• HTTP status codes.
• SSL certificates.
• Database connections.
• Payment and external service integrations.

• Database tables and records.
• Posts, pages and custom post types.
• Categories, tags and taxonomies.
• User accounts and permissions.
• Theme and plugin settings.
• Media attachments and metadata.
• Custom templates and application code.
• Configuration files and environment-specific settings.

• Retaining existing URL paths.
• Preserving trailing slash behaviour.
• Maintaining file extensions where required.
• Transferring images, fonts and downloadable documents.
• Configuring custom 404 responses.
• Transferring existing redirect rules.
• Maintaining environment variables and API connections.

• Client-side rendering (CSR).
• Static site generation (SSG).
• Server-side rendering (SSR).
• Hybrid rendering.

https://example.com/
https://example.com/services/
https://example.com/services/web-development/
https://example.com/contact/

import { createRouter, createWebHistory } from 'vue-router'

const router = createRouter({
  history: createWebHistory(),
  routes: [
    {
      path: '/',
      component: HomePage
    },
    {
      path: '/services/',
      component: ServicesPage
    },
    {
      path: '/services/web-development/',
      component: WebDevelopmentPage
    }
  ]
})

<IfModule mod_negotiation.c>
    Options -MultiViews
</IfModule>

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteBase /

    RewriteRule ^index\.html$ - [END]

    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d

    RewriteRule . /index.html [END]
</IfModule>

server {
    listen 80;
    server_name example.com;

    root /var/www/example.com/dist;
    index index.html;

    location ^~ /assets/ {
        try_files $uri =404;
    }

    location / {
        try_files $uri $uri/ /index.html;
    }
}

/** @type {import('next').NextConfig} */
const nextConfig = {
  async redirects() {
    return [
      {
        source: '/old-page',
        destination: '/new-page',
        permanent: true
      }
    ]
  }
}

module.exports = nextConfig

router.push('/new-page')

HTTP/1.1 301 Moved Permanently
Location: /new-page

https://example.com/valid-route/
HTTP 200

https://example.com/nonexistent-route/
HTTP 200

• Use server-side rendering or server-side routing that can return an actual HTTP 404 for an unknown route.
• Use a server or edge function that distinguishes valid routes from nonexistent routes.
• Where the SPA architecture cannot return a proper HTTP status, use Google’s documented JavaScript approaches, such as adding a noindex robots directive to the error page.

1. Creating a database backup.
2. Exporting the required tables and data.
3. Creating the destination database and user permissions.
4. Importing the database dump.
5. Updating application connection settings.
6. Checking database versions, tables and relationships.
7. Checking stored URLs and configuration.
8. Testing the application against the migrated database.

wp db export database-backup.sql

wp db import database-backup.sql

https://old-domain.com/wp-content/uploads/image.jpg

https://new-domain.com/wp-content/uploads/image.jpg

wp search-replace \
  'https://old-domain.com' \
  'https://new-domain.com' \
  --all-tables-with-prefix \
  --dry-run

wp search-replace \
  'https://old-domain.com' \
  'https://new-domain.com' \
  --all-tables-with-prefix

• New orders.
• Customer registrations.
• Payment confirmations.
• Order status changes.
• Stock changes.
• Refunds.
• Subscription renewals.

• Temporarily placing the original store into maintenance or read-only mode.
• Performing the final database export after new transactions have stopped.
• Using database replication or a controlled synchronization process.
• Recording and applying final data changes before activating the new store.

• WooCommerce: High-Performance Order Storage
• WooCommerce: HPOS Migration and Compatibility

• Images and product photographs.
• Uploaded documents and PDFs.
• Videos and other media.
• Fonts and design assets.
• Themes and plugins.
• Custom scripts and stylesheets.
• Application configuration.
• Environment files.
• Server configuration files.

• Database connection credentials.
• PHP, Node.js or other runtime versions.
• Environment variables.
• API endpoints and credentials.
• SMTP configuration.
• Payment gateway settings.
• Webhook URLs.
• Scheduled tasks and cron jobs.
• Search and indexing services.
• CDN configuration.
• SSL certificates.
• Object storage connections.
• Cache settings.

HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page/

• A page has moved permanently.
• A domain has changed.
• A URL structure has changed.
• Multiple websites have been consolidated.
• An old page has a relevant replacement.

HTTP/1.1 302 Found
Location: https://example.com/temporary-page/

• Netlify: Redirects and Rewrites
• Netlify: Rewrites and Proxies

1. Open WordPress Dashboard.
2. Navigate to Rank Math SEO.
3. Enable the Redirections module if it is not already enabled.
4. Open Rank Math SEO -> Redirections.
5. Click Add New.
6. Enter the old URL in Source URLs.
7. Enter the replacement URL in Destination URL.
8. Select the required redirection type.
9. Activate and save the rule.

• The migration involves a limited number of URLs.
• Website administrators need to maintain redirects through the dashboard.
• Redirects may need regular updates.
• Server configuration access is unavailable.

<IfModule mod_rewrite.c>
    RewriteEngine On

    RewriteRule ^old-page/?$ https://www.example.com/new-page/ [R=301,L]
</IfModule>

https://www.example.com/old-page
https://www.example.com/old-page/

https://www.example.com/new-page/

<IfModule mod_rewrite.c>
    RewriteEngine On

    RewriteCond %{HTTP_HOST} ^(www\.)?old-example\.com$ [NC]

    RewriteRule ^ https://www.new-example.com%{REQUEST_URI} [R=301,L]
</IfModule>

https://old-example.com/about-us/

https://www.new-example.com/about-us/

<IfModule mod_rewrite.c>
    RewriteEngine On

    RewriteRule ^blog/(.*)$ /insights/$1 [R=301,L]
</IfModule>

/blog/website-migration/

/insights/website-migration/

• Make sure mod_rewrite is enabled.
• The server must allow the necessary .htaccess overrides. Rewrite directives require AllowOverride FileInfo or an equivalent permission.
• The Options -MultiViews directive requires permission to use Options. If it is not allowed, configure it in the virtual host instead.
• Place migration rules before the CMS’s default rewrite block where appropriate.
• Test the rules against both slash and non-slash URL variants.
• Check for conflicting rules from the CMS or plugins.

• Apache: mod_rewrite
• Apache: Per-directory Rewrites
• Apache: RewriteRule Flags
• Apache: AllowOverride

server {
    listen 443 ssl;
    server_name www.example.com;

    ssl_certificate /path/to/certificate.pem;
    ssl_certificate_key /path/to/private-key.pem;

    location = /old-page/ {
        return 301 /new-page/;
    }
}

server {
    listen 80;
    server_name old-example.com www.old-example.com;

    return 301 https://www.new-example.com$request_uri;
}

server {
    listen 443 ssl;
    server_name old-example.com www.old-example.com;

    ssl_certificate /path/to/old-domain-certificate.pem;
    ssl_certificate_key /path/to/old-domain-private-key.pem;

    return 301 https://www.new-example.com$request_uri;
}

http://old-example.com/services/web-design/?ref=campaign

https://www.new-example.com/services/web-design/?ref=campaign

server {
    listen 443 ssl;
    server_name example.com;

    location ~ ^/blog/(.*)$ {
        return 301 /insights/$1$is_args$args;
    }
}

/blog/website-migration/?source=archive

/insights/website-migration/?source=archive

sudo nginx -t

sudo systemctl reload nginx

• Nginx: Rewrite Module
• Nginx: Core Module

/old-page/  /new-page/  301
/old-blog/* /insights/:splat 301

/*  /index.html  200

• Netlify: Redirects and Rewrites
• Netlify: Rewrites and Proxies

• Next.js: Redirects Configuration
• Vercel: Rewrites

• The old hosting server is no longer available.
• The website uses Cloudflare as its CDN.
• A large number of URLs must be migrated.
• Redirects should be processed before requests reach the application server.

<link
  rel="canonical"
  href="https://www.example.com/new-page/"
>

• Main navigation.
• Footer links.
• Contextual content links.
• Related articles.
• Product categories.
• Breadcrumbs.
• Image links.
• Download links.
• Structured data references.

/en-gb/services/
/sk-sk/sluzby/

<link
  rel="alternate"
  hreflang="en-GB"
  href="https://www.example.com/en-gb/services/"
>

<link
  rel="alternate"
  hreflang="sk-SK"
  href="https://www.example.com/sk-sk/sluzby/"
>

• url.
• @id.
• image.
• logo.
• mainEntityOfPage.
• Product and offer URLs.
• Breadcrumb item URLs.

• Every submitted URL is accessible.
• Indexable pages return HTTP 200.
• Canonical annotations agree with sitemap URLs.
• Redirected URLs are excluded.
• Staging and development URLs are absent.
• URLs use the correct protocol and hostname.

• Important pages and directories are not disallowed.
• CSS and JavaScript resources needed for rendering are accessible.
• Temporary noindex directives have been removed.
• The production sitemap is referenced correctly.
• The public website is not still configured as a staging environment.

1. Back up the original database and files.
2. Export and verify the existing URL inventory.
3. Prepare the old-to-new URL mapping.
4. Transfer and validate files and databases.
5. Test the new website in staging.
6. Verify forms, checkout, accounts and important business processes.
7. Configure permanent and temporary redirects.
8. Check canonical URLs, hreflang and structured data.
9. Generate the new XML sitemap.
10. Verify SSL certificates and DNS settings.

1. Confirm that the new server is ready.
2. Test the application and external integrations.
3. Update DNS records to point to the new infrastructure.
4. Monitor traffic reaching the new and old hosting environments.
5. Keep the old infrastructure available until users and search engine crawlers are receiving the correct content from the new server.

1. Deploy the new website.
2. Activate the redirect mapping.
3. Verify that old URLs reach their intended destinations.
4. Check that new URLs return the expected responses.
5. Update DNS and domain configuration where required.
6. Submit the new sitemap in Search Console.
7. Use the Change of Address tool when the move is between eligible domains or subdomains.

• HTTP-to-HTTPS migrations.
• Switching between www and non-www on the same domain.
• Moving URLs between paths on the same domain.

curl -I https://example.com/old-page/

HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page/

curl -IL https://example.com/old-page/

• Old URL response code.
• Redirect destination.
• Number of redirect hops.
• Final response code.
• Redirect loops.
• Broken destination URLs.
• Query parameter handling.
• Trailing slash variations.

• Opening nested routes directly.
• Refreshing nested routes.
• Browser back and forward navigation.
• Valid application routes.
• Invalid application routes.
• JavaScript and CSS resources.
• API endpoints.
• Server fallback behaviour.
• Redirect responses for migrated URLs.
• Actual HTTP status codes on not-found pages.

• Page indexing.
• Crawl statistics.
• Sitemap processing.
• URL Inspection results.
• Redirected pages.
• Server errors.
• Not found pages.
• Indexed URLs.

• Organic clicks.
• Search impressions.
• Average search position.
• Organic landing-page sessions.
• Conversion rate.
• Indexed page count.

• Old URLs.
• New URLs.
• Redirect destinations.
• Images and documents.
• JavaScript and CSS resources.
• Invalid application routes.
• API endpoints.

• Site Moves and Migrations
• Changing Your Web Hosting and SEO
• Redirects and Google Search
• How to Specify a Canonical URL
• JavaScript SEO Basics
• Troubleshoot Crawling Errors
• Change of Address Tool

• WordPress: Migrating a Website
• WP-CLI: Database Export
• WP-CLI: Database Import
• WP-CLI: Search and Replace
• Rank Math: Setting Up Redirections
• WooCommerce: High-Performance Order Storage

• Apache HTTP Server: mod_rewrite
• Apache: Per-directory Rewrites
• Apache: RewriteRule Flags
• Apache: AllowOverride
• Nginx: Rewrite Module
• Nginx: Core Module

• Vue Router: Different History Modes
• Next.js: Redirects Configuration
• Vercel: Rewrites
• Netlify: Redirects and Rewrites
• Netlify: Rewrites and Proxies
• Cloudflare: Redirects