WooCommerce to Shopify Migration Checklist: The URLs Shopify Won't Redirect

A WooCommerce to Shopify migration moves products, then customers, then historical orders, rebuilds payments, tax and shipping, and imports redirects before the domain switches. Settle one question first, where your product URLs live: on the Flatsome theme's public WooCommerce demo store, 67 of 67 product URLs in the sitemap Keplaris's URL-mapping script read on November 9, 2026 start with /shop/, and Shopify's URL redirect help page says "You can't redirect URLs that begin with" /shop. That /shop/ comes from the demo's product permalink setting, not from WooCommerce itself: WooCommerce's permalinks documentation makes /product/ the default base on any non-plain permalink structure and lists "Shop base with category", which gives /shop/{category}/{slug}, as an option a store chooses.
The answer changes the size of the job. On the control store, Astra's Brandstore 02 demo, which keeps the default /product/ base, 31 of 31 product URLs mapped to /products/ with a prefix swap. On the Flatsome demo, 113 of 505 unique sitemap URLs went into the redirect CSV, and the run table further down shows why the other 392 were held back. This post is the checklist phase by phase, with that URL map run in the middle and the script at the end.
Keplaris is a Shopify development studio that builds stores, checkout customizations and integrations, so we have a stake in you moving. We have no client migration data in this post. The facts come from Shopify's, Google's and WooCommerce's documentation, read on November 9, 2026. The URL map comes from one day of runs of our script on two public theme demo stores, not real shops, so the counts show which URL patterns break, not how common /shop/ product URLs are or how much traffic a store would lose.
WooCommerce to Shopify migration: the checklist in short
A WooCommerce to Shopify migration runs in nine phases, from a URL and plugin audit to 30 days of 404 checks after DNS moves. Most WooCommerce URLs change on Shopify, because Shopify serves products under /products/, collections under /collections/, pages under /pages/ and posts under /blogs/, and a product's category path disappears. That makes the URL map the step to start early, not the one to leave for launch week. The cutover itself runs in this order: freeze content, run the final URL map, import redirects, run a final delta sync, then switch DNS. Here are the nine phases, one line each:
- Audit. List your URLs from the sitemap, Search Console and server logs, every active plugin, and the data each plugin holds. Check whether your product URLs start with
/shop/. - Export and import. Products first, then customers, then historical orders, the order Shopify's WooCommerce migration guide gives. Shopify's free Store Migration app handles products and customers; order history needs a third-party app.
- URL map and redirects. Map each old URL to its Shopify path and resolve collisions. Shopify won't redirect sources that begin with
/shopor/cart, so decide what happens to those URLs. - SEO carry-over. Titles, descriptions, canonicals, internal links and the new sitemap.
- Customers. Plan for passwords not moving, and tell customers how they'll sign in.
- Payments, tax and shipping. Rebuild them in Shopify and prove them with test orders.
- Apps and subscriptions. Match each plugin to a native feature, an app, or a decision to drop it.
- Cutover. Content freeze, final URL map, redirects imported, final delta sync, then DNS.
- Monitoring. Thirty days of 404 checks, and redirects kept for at least a year.
What the work costs depends on catalog size, data and redirects; our Shopify developer cost guide has the rates.
Should you move? When staying on WooCommerce is the right call
If your WordPress content is the business and the store is a side section, much of what makes the site work has no Shopify equivalent to move it into. We build Shopify stores, so read this table knowing that. Each row is a condition, not a verdict on either platform:
| If... | Then |
|---|---|
| Content is the business (posts, custom post types, LMS or membership plugins) and the store is a side section | Stay, or move only the store. The script's unmappable count won't tell you which: on the Flatsome demo store, 259 of its 279 were image attachment pages. Count your posts and custom post types instead |
Your product URLs live under /shop/ and earn most of your search traffic | Weigh it hard: Shopify's redirect tool won't take those sources. On the Flatsome demo store, 67 of 67 product URLs started with /shop/ |
| A plugin does a job you haven't matched to a Shopify app or native feature (bookings, configurators) | Find the replacement first; don't assume one exists |
| You can't commit to keeping redirects a year and watching 404s for a month | Wait until you can |
| The reason to move is a slow or messy WooCommerce build | A rebuild on WordPress may fix that without a platform move |
| It's November and you sell into Black Friday | Wait for January |
| Hosting, plugin updates and security patches take more time than the store can spare, and you want checkout and payments maintained for you | These are common reasons to move |
Pre-migration audit: URLs, plugins and data types
Before you migrate WooCommerce to Shopify, build the URL list. A sitemap is the starting list, not the full one: add the URLs Search Console and your server logs say people and bots actually request. Our script reads sitemaps because they're public, which is also its main gap. On a real store, export the Search Console Pages report and the Performance report by page, pull the most-requested paths from your access logs, and add anything that has backlinks.
Then inventory three more things:
- Plugins. Write down each active plugin and what it stores: reviews, wishlists, bookings, subscriptions, product add-ons, custom fields, SEO meta.
- Variation attributes per product. Shopify allows three options per product (more on that below). Our script reads the public Store API and prints the most variation attributes on any product. Both demos topped out at 2.
- Customer data. Shopify's guide says "WooCommerce doesn't include a customer CSV export with full address details, so you need to install a plugin to export your customer data," and the example it names, Import Export Suite for WooCommerce, "is a paid plugin." The Customers report in WooCommerce Analytics exports as CSV, but Shopify notes "it doesn't include street addresses."
What moves, in what order, and which route moves it
Shopify's WooCommerce guide says orders and coupons can't be imported by CSV, and that reviews, blog posts and pages aren't in WooCommerce's exports. Products with four or more variation attributes import without their variants. The guide lists five routes: copy and paste, the Store Migration app, CSV import, third-party migration apps and a Shopify Partner. The order it gives is products, then customers, then historical orders: "Import your products and customers before you import your orders."
| Data | Store Migration app | CSV | Third-party apps Shopify's guide names | Notes from Shopify's guide |
|---|---|---|---|---|
| Products | Yes, as drafts | Yes, after reformatting to Shopify's product CSV | Not needed | Keep WooCommerce online: images are downloaded from their URLs during import |
| Variants | Up to 3 options; 4 or more variation attributes import without variants | One row per variant, same handle | Not needed | "You can add the variants after the import, or use third-party apps or metafields" |
| Categories | Not stated | No matching column | Not needed | Shopify's guide: add category names to Tags and build collections on them. Our note: collections are flat, so nesting is lost |
| Customers | Yes | Yes, from a plugin export | Not needed | "There is no data mapping support for customer CSV imports" |
| Passwords | No | No | No | "Customer passwords can't be migrated" |
| Historical orders | No | No | LitExtension Store Migration, Matrixify, Ablestar WooCommerce Importer | "Orders can't be imported to Shopify by using a CSV file" |
| Coupons | No | No | Matrixify | Or recreate them as Shopify discounts |
| Reviews | No | Not in the product export | Judge.me, Ablestar WooCommerce Importer | |
| Blog posts and pages | No | Not in WooCommerce exports | Matrixify | Or add them by hand |
| SEO titles and descriptions | Not stated | Shopify's product CSV has SEO title and SEO description columns | Not named | Plugin meta is in the WooCommerce export when you select "Yes, export all custom meta" |
| Custom fields and non-variation attributes (ACF, plugin product meta) | Not stated | Yes, as metafield columns once the metafield is defined | Not named | Shopify's product CSV page: "Product metafields are supported in product bulk import/export using CSV files." Headers take the form product.metafields.namespace.key |
Vendors claim more: Matrixify's tutorial says it migrates "Products, Collections, Customers, Orders, Discounts, Blog Posts, Pages and Redirects." We didn't test any third-party app, and we don't rank them.
WooCommerce attributes that aren't used for variations have no option column on Shopify. Our approach is to define a product metafield for each one, or use tags if shoppers filter on it, and map the values in the CSV.
Two details in the guide catch people: "Sale dates aren't imported," so check each live sale before you map prices, and weights convert to grams ("multiply kilograms by 1,000, pounds by 453.6, or ounces by 28.35").
Shopify's Store Migration app: what it imports
The Store Migration app is by Shopify, free, and was launched July 17, 2024. Its listing says it moves "product and customer data" from Square, WooCommerce, Etsy, Wix, Amazon, eBay, Clover and Lightspeed R/X (Vend), by CSV upload or, "on supported platforms," by connecting your account. On November 9, 2026 it was rated 3.2 from 78 reviews. Shopify's guide adds that "Imported products are added to your store as drafts."
Variant and option limits after the 2,048 change
Shopify allows 2,048 variants per product, but still three options, and some themes and apps stop at 100. The add variants page says "You can create up to 2,048 variants for a product. Each product can have up to three options." (The old 2048-variant-limit help URL now redirects there.) Shopify's changelog dated the change October 15, 2025, "a significant increase from our long-standing limit of 100 variants per product." So guides that still say 100 are out of date.
The same page keeps the caveats: some third-party themes, theme app extensions, public apps and sales channels "might not support more than 100 variants," and the Stocky and legacy Order Printer apps don't.
On our demos the most variations on one product were 20 (Flatsome) and 5 (Brandstore), so nothing crossed the 100 or 2,048 lines. Three of Flatsome's 11 variable products listed 0 variations in the Store API. We opened two of them: both product pages say "This product is currently out of stock and unavailable." and carry an empty variation list, so the zero is what the store publishes, not a gap in the API. Count variations from the WooCommerce admin export, not the public API.
WooCommerce to Shopify URL mapping: /product/ to /products/ and the rest
Most WooCommerce URLs can't stay the same on Shopify: /product/{slug}/ becomes /products/{slug}, categories become flat /collections/ handles, pages move under /pages/ and posts under /blogs/. Because collections are flat, /product-category/women/sweaters/ becomes /collections/sweaters, and two categories with the same leaf name would fight over one handle. The table shows each WooCommerce pattern our script met, the Shopify path it maps to and the rule that bites. Examples are real paths from the two demos.
| WooCommerce pattern | Example from the run | Shopify target | Risk |
|---|---|---|---|
/product/{slug}/ (default base) | /product/dnk-red-shoes/ | /products/dnk-red-shoes | Low: a prefix swap |
/shop/{category path}/{slug}/ | /shop/women/sweaters/on1-jersey-unif-2/ | /products/on1-jersey-unif-2 | Source begins with /shop, so it can't be a redirect row |
Shop page at /shop/ | Flatsome /shop/ | /collections/all | Same /shop problem |
| Shop page elsewhere | Brandstore /store/ | /collections/all | Low |
/product-category/{parent}/{child}/ | /product-category/women/sweaters/ | /collections/sweaters | Hierarchy flattened; repeated leaf names collide (none did on these demos) |
/product-tag/{tag}/ | 28 tags on Flatsome | No row in our run | Decide per tag: a collection, a filter, or let it 404 |
/YYYY/MM/DD/{slug}/ | /2015/10/13/a-simple-blog-post/ | /blogs/news/a-simple-blog-post | Low |
| Posts page | /blog/ | /blogs/news | Low |
/category/{x}/, /tag/{x}/ | /category/style/ | /blogs/news/tagged/style | Articles must carry the tag |
| Nested pages | /elements/pages/ | /pages/pages | Leaf handles collide with other pages |
/my-account/ | /my-account/ | /account | Low |
/cart/, /checkout/ | /cart/ | Shopify has its own cart; checkout gets no row | /cart is a prefix Shopify won't redirect |
| Attachments | /?attachment_id=16 | No row | No Shopify equivalent; 74 of Flatsome's 259 are query-string URLs |
?add-to-cart= links | Not in either sitemap | Drop | Flatsome's robots.txt disallows them |
Handles follow Shopify's product CSV rule: "A valid URL handle can contain letters, dashes, and numbers, but it can't contain any spaces." Our script also lowercases, turns any other character into a dash and collapses repeats. That normalisation is ours, not Shopify's, and on these demos it changed no slug.
Add-to-cart links deserve a word. Google's Gary Illyes said in a February 3, 2026 video on crawling challenges that action parameters such as add-to-cart GET links "immediately doubled your URL space," and that WooCommerce fixed its version after Google filed an issue. Don't redirect them; let them go.
We mapped two WooCommerce demo stores: what Shopify won't redirect
On the Flatsome demo, 67 of 67 product URLs began with /shop/, and Shopify's URL redirect help page says you can't redirect URLs that begin with /shop. Our script read each store's robots.txt first, then its sitemaps and the public WooCommerce Store API, at one request a second: 17 requests to Flatsome and 11 to Brandstore per run. We ran it twice on November 9, 2026 with byte-for-byte identical output.
| Measure | Flatsome demo (primary) | Brandstore 02 demo (control) |
|---|---|---|
| Unique sitemap URLs | 505 | 99 |
| Products (Store API) | 67: 55 simple, 11 variable, 1 external | 31: 19 simple, 12 variable |
| Product URL pattern | /shop/{category path}/{slug}/ | /product/{slug}/ |
| Products under a prefix Shopify won't redirect | 67 of 67 | 0 of 31 |
| All sources under such a prefix | 69 (67 products, /shop/, /cart/) | 2 (/shop/, /cart/) |
Rows in redirects.csv | 113 | 38 |
| URLs held back | 392 | 61 |
| Unmappable (attachments, theme and plugin post types, author) | 279 | 56 |
| Query-string URLs | 74 (all attachments) | 31 (all attachments) |
| Product tags skipped | 28 | 0 |
| Already at their Shopify path | 11 | 2 |
| Collisions | 2 (4 URLs) | 0 |
Handles that would collide if the -N suffix were stripped | 11 | 1 |
Brandstore lives in a subdirectory (/brandstore-02/), so the script strips that base path and maps as if the store sat at the domain root. Its /shop/ is an ordinary WordPress page, so it's held back for the same prefix reason. It also has a /shop-2/ page, which begins with the letters /shop but not the /shop segment. Shopify's wording, "begin with", doesn't settle whether that counts, and we couldn't test it, so the script holds it back and labels it untested.
Flatsome's two collisions are page pairs: /pages/ and /elements/pages/ both need the handle pages, and /pages/portfolio/ and /elements/portfolio/ both need portfolio. All four stay out of the CSV until you rename one page in each pair.
The 11 URLs already at their Shopify path are Flatsome's home page, /cart/ and nine WordPress pages that sit under a parent page called "pages", such as /pages/contact/. On Shopify a page with the handle contact lives at /pages/contact, so those need no redirect if you keep the handle. Shopify's URL redirect help page doesn't mention trailing slashes, and we didn't test whether /pages/contact/ resolves, so check it on your store.
Traced example: one product URL, end to end
Take /shop/women/sweaters/on1-jersey-unif-2/ on Flatsome:
- Class. It comes from
product-sitemap.xmland matches a product in the Store API, with the category pathwomen/sweatersin its URL. - Handle. The leaf slug is
on1-jersey-unif-2, and the normalisation leaves it unchanged. It ends in a WordPress-style-2. - The trap. The usual advice is to strip WordPress's
-2. Here that would collide:/shop/women/sweaters/on1-jersey-unif/is a different product in the same sitemap. Keep the suffix or rename on purpose. Nine other Flatsome products and one post tag were in the same position. - Target and verdict. The target is
/products/on1-jersey-unif-2. The source begins with/shop, so the row stays out ofredirects.csvand is listed in the report with the flagsCATEGORY_PATH_DROPPED WP_SUFFIX NO_REDIRECT_PREFIX WP_SUFFIX_STRIP_COLLIDES.
What to do with each held-back class
- Products and the shop page under
/shop/. Shopify's redirect tool won't take them. We searched help.shopify.com and the Shopify Community on November 9, 2026 and found no Shopify-documented way to redirect these sources; a Community question from February 2024 asking exactly this had no reply. Redirect apps and an edge layer in front of Shopify are the routes people discuss; we haven't tested either, so we don't recommend one. What you control: let those URLs 404, submit the new sitemap, update your internal links, and ask the sites that link to your top products to update their links. If most of your search traffic lands on/shop/product URLs, treat this as a reason to weigh the move harder. - Attachments, theme post types and the author archive. Let them go. Google's site-move guide says "Don't redirect many old URLs to one irrelevant single URL destination, such as the home page of the new site," because that "might be treated as a soft 404 error."
- Query-string URLs. Shopify says they "might not work as expected with URL redirects." On these demos they were all attachment URLs, so the decision above covers them.
- Product tags. Our run used
TAG_POLICY = "skip". If a tag page earns traffic, make it a collection and set the policy to"collection". Shopify's URL redirect help page says tag-filter collection URLs can't be redirected, so build real collections rather than pointing at a filtered URL. - Collisions. Rename one page in each pair, then rerun.
- Same-path pages. Create the Shopify page with the same handle and check the trailing slash.
- The
/shop-2/edge case. Test one row on a development store before you rely on it either way.
WooCommerce to Shopify redirects: the CSV and Shopify's rules
WooCommerce to Shopify redirects are a two-column CSV, Redirect from,Redirect to, imported under Content, Menus, URL redirects before you transfer the domain. Shopify allows 100,000 rows, or 20,000,000 on Plus. A redirect fires only when the old path is broken on Shopify, and sources beginning with prefixes such as /shop, /cart or /orders are refused.
Shopify's URL redirect help page says "You can redirect only from broken URLs" and "If the URL still loads a valid webpage, then the URL redirect won't work." Here are the rules, all quoted from that page on November 9, 2026. Our script checks the prefixes, the fixed and reserved paths, the cap and query strings:
- Prefixes. "You can't redirect URLs that begin with the following prefixes: /apps, /application, /cart, /carts, /orders, /services, or /shop."
- Fixed paths. "You can't redirect URLs that use fixed Shopify paths: /products, /collections, /collections/all."
- Reserved paths. "Certain URL paths are reserved by Shopify and cannot be used for redirects":
/collections/vendors,/collections/types,/collections/all,/apps/,/a/,/community/,/tools/, and "MyShopify domain paths ending in /shop or /services." - Caps. "You can create a maximum of 100,000 URL redirects unless your store is on the Plus plan, which has a maximum of 20,000,000 URL redirects." Our Flatsome file has 113 rows.
- Tag filters. "You cannot create redirects for URLs that use collection tag filtering."
.html. "URLs ending in .html cannot be redirected to the same URL without .html."- Query strings. URLs containing them "might not work as expected with URL redirects."
- Visibility. If you redirect a hidden collection or product and later make it visible again, "the URL redirect is automatically deleted because redirects only work for URLs that return 404 errors."
- Caching. "301 redirects are cached by browsers and search engines," so a redirect you remove can keep working in a visitor's browser until the cache expires.
On market subfolders the page says two things. Its limitations list says redirects "don't automatically apply to all market subfolders," while its subfolders section says "Creating a URL redirect applies to all language or market subfolders" and gives an /en-ca/ example. If you sell through subfolders, test one redirect on a subfolder before launch.
The file itself follows Shopify's sample redirect template, a 73-byte file whose header is Redirect from,Redirect to and whose example row is /example_product.php,/products/example-product. Our script writes that header byte for byte, one path per row, without the domain. You import it under Content, Menus, URL redirects, Import. And timing matters: Shopify's WooCommerce guide says that "before you transfer your domain, you can set up URL redirects in advance," so they work from the first request.
Migrating without losing SEO: titles, canonicals and sitemaps
SEO carries over through four things you control: a redirect for each old URL that earns traffic, where Shopify allows one, self-referencing canonicals on the new URLs, internal links pointed at the final URLs, and the new sitemap submitted in Search Console. Titles and descriptions move through the product CSV. No move guarantees rankings: Google's site-move guide says to "Expect temporary fluctuation in site ranking during the move."
Start with the limits: Shopify's product CSV takes an SEO title up to 70 characters and an SEO description up to 320, so measure your plugin's titles before you import them. The product CSV page says the SEO title "can be alphanumeric and include up to 70 characters" and the description "up to 320 characters." Leave either blank and Shopify uses the product title or description.
Yoast and Rank Math keep their titles and descriptions as plugin data on each post, outside WooCommerce's standard product columns. Shopify's guide names the export option that includes them: "select Yes, export all custom meta." Our script read the Yoast field from each demo's public REST API instead. On Flatsome the longest Yoast title tag, site name included, was 49 characters and on Brandstore 44, so none crossed 70, and neither store had a meta description set on any product.
Then three checks on the new store:
- Canonicals. Google's site-move guide says each new URL should carry a self-referencing
rel="canonical"tag, and once the redirects are live, to "ensure that the rel='canonical' link annotations on the new site are using the new URLs." - Internal links. Point menus, product descriptions and blog posts straight at the final Shopify URLs, so nothing relies on a redirect.
- Sitemap. Shopify's guide says "All Shopify stores automatically generate a sitemap.xml file," at the root of your domain. Submit it in Search Console.
We don't publish a traffic-loss or recovery figure. The figures we saw in the top 10 results our search tool returned on 2026-11-09 (we opened 9 of them) don't link to a study, so we don't repeat them.
Customer accounts and passwords
Customer passwords don't move to Shopify, and on a new store they don't need to: customer accounts sign in with an email and a one-time code. Shopify's WooCommerce guide says "Customer passwords can't be migrated. With customer accounts, imported customers sign in with their email address and a one-time verification code, so they don't need a password." Its advice to invite customers to create new passwords applies only to stores on legacy customer accounts.
New stores can't choose legacy accounts. Shopify's developer changelog, dated February 26, 2026, says "Legacy customer accounts are no longer available to new stores and existing stores not using it," and "A final sunset date for legacy customer accounts will be announced later in 2026." As of November 9, 2026 we found no date published. Our checkout guide covers the legacy customer accounts deprecation from the checkout side.
What to do: import customers, then send one email before launch explaining that sign-in now uses a code sent to their email address. Many password-reset guides were written for legacy accounts.
Payments, tax and shipping: rebuild them, then place test orders
Shopify's guide treats tax, shipping zones and payment providers as setup steps, not imports: you rebuild each one and prove it with test orders before the domain moves. The guide describes no import route for WooCommerce tax rates or shipping zones. Its setup steps 13 to 16 are shipping zones and rates, tax setup, a payment provider, then test orders. It suggests test orders for "a successful and a failed transaction," "refunding and canceling an order," "fulfilling or partially fulfilling an order" and "archiving a successful order."
On tax, the guide says Shopify calculates shipping-destination taxes automatically, and that if you need to adjust taxes "based on a region with unique tax restrictions or based on a specific collection of products, then you can do so with a tax override." Our advice: rebuild each WooCommerce tax class that existed for a reason as an override, and place a test order into that region.
Your gateway choice also changes your fees. Shopify's guide notes that with Shopify Payments "you can avoid paying additional third-party transaction fees." Which plan you land on is a separate decision, covered in our Shopify Plus vs Advanced guide.
Apps, plugins and subscriptions
Treat each WooCommerce plugin as a decision (native feature, app or drop), because each app you add can load its own scripts on your storefront. Our Shopify speed guide puts it plainly: "Every app you install can inject scripts and stylesheets sitewide, even on pages where the app does nothing."
- Coupons become Shopify discounts, rebuilt by hand or with an app such as Matrixify, per Shopify's guide. If a coupon plugin ran custom logic, check whether a public app covers it before you plan a custom build; our Shopify Functions guide covers which plans can run which Functions.
- Bookings. Six Flatsome demo products sit in a
bookingcategory. A booking plugin's job needs a Shopify booking app, chosen before you move the products. - External (affiliate) products. Flatsome has one,
/shop/bags/adelia-bag-nypd/. Decide how its buy button will work on Shopify before you import it. - Subscriptions. We make no claim here about moving stored payment methods. Ask your payment gateway in writing whether stored payment methods can be exported to the subscription app you'll use on Shopify, and plan renewals around the answer.
Cutover runbook: content freeze, redirects, delta sync, then DNS
Don't move platforms in the weeks before Black Friday. Schedule the cutover for January, in this order: freeze content, run the final URL map, import redirects, run a final delta sync, then switch DNS. Black Friday is November 27 and Cyber Monday November 30, 2026. Our Black Friday checklist starts its feature freeze on Monday, November 9 ("no new apps, sections or integrations") and quotes Shopify's engineering team: "We don't use BFCM as a release deadline." A replatform is a bigger change than any of those, so keep selling on WooCommerce through the peak.
In a Search Off the Record episode from February 23, 2023, Google's Gary Illyes advised separating a site move from a redesign, because fewer simultaneous changes mean fewer errors. If you can, launch with a theme close to your current layout and redesign later.
An example January calendar (an example, not a rule):
| Date | Step |
|---|---|
| Mon 2027-01-04 | Content freeze on WooCommerce: no new products, no slug changes. Final URL map run |
| Week of Jan 4 | Redirect CSV imported and a sample spot-checked on the store's myshopify.com address; test orders |
| Mon 2027-01-11 | Final delta sync: orders, customers and products changed since the main import, with products re-imported under "Overwrite products with matching handles" |
| Tue 2027-01-12 | DNS switch in your lowest-traffic hour; check the top 50 old URLs by hand |
| Jan 12 to Feb 12 | Daily 404 checks in Search Console and your logs |
The delta sync needs one setting. Shopify's product CSV page says "If the overwrite option isn't selected, then the products that match an existing handle are ignored during CSV import," so a re-import of changed products without "Overwrite products with matching handles" leaves those products as they were.
For the DNS step, Shopify's manual connection page lists the A record 23.227.38.65, the AAAA record 2620:0127:f00f:5:: and the www CNAME shops.myshopify.com., and says "It might take up to 48 hours for your domain to be fully live." Keep a copy of the WooCommerce site on a non-public address, blocked from indexing, for the first month, so you can still pull data from it.
After launch: 30 days of checks and a year of redirects
For the first 30 days, watch 404s and Performance by page in Search Console and spot-check redirects. Keep the redirects for at least a year, as Google advises. The checks:
- Watch 404s. Check the Search Console Pages report and your server logs for old URLs that now 404, and add redirect rows for the ones that matter (where Shopify allows them).
- Watch Performance by page. Compare the old URLs' clicks with the new URLs' as Google swaps them. Google says "for medium-sized websites, it can take a few weeks or more for Google to gradually start showing the new URLs instead of the old ones."
- Spot-check redirects. Shopify's guide says to confirm each one by "entering the original URL in a web browser."
- Keep the redirects. Google says "Keep the redirects for as long as possible, generally at least 1 year."
A move that keeps the same domain doesn't use Search Console's Change of Address tool. Google's site-move guide says "You only need this tool when moving from one domain or subdomain to another," and "You don't need it for... moving paths within the same domain." Redirects, sitemaps and canonicals do the work.
Run the URL-mapping script yourself
Save the script as url-map.mjs and run node url-map.mjs <store URL>. It needs Node 18 or later and nothing else: no npm install. It reads the host's robots.txt first and skips any URL it disallows, then fetches the store's sitemaps, the public WooCommerce Store API and the public WordPress REST API, at one request a second (a larger Crawl-delay wins). It writes redirects.csv in Shopify's template format and url-map-report.csv with every URL, its class, its Shopify target and its flags, plus every response body for checking. Each Shopify rule it checks sits at the top with the sentence it came from.
Run metadata: node url-map.mjs https://demos.flatsome.com/ https://websitedemos.net/brandstore-02/, Node v24.20.0, Apple M1 Max (10 cores, 64 GB RAM), macOS 27.0.1. Run 1 from 09:53:35 to 09:54:06 UTC and run 2 from 09:54:06 to 09:54:39 UTC on 2026-11-09, 28 requests each (17 to Flatsome, 11 to Brandstore), with byte-for-byte identical output and CSVs. A trial run and two earlier runs that morning, before we reworded some output lines, wrote the same CSVs.
// url-map.mjs: map a WooCommerce store's sitemap URLs to Shopify paths and write Shopify's redirect CSV.
// Node 18+, no dependencies. Run: node url-map.mjs <store URL> [<store URL> ...]
// Reads robots.txt first, then sitemaps and the public WooCommerce Store API, one request a second.
// Every Shopify rule below was read on help.shopify.com on 2026-11-09. Change them when Shopify does.
import { mkdirSync, writeFileSync } from "node:fs";
import { join } from "node:path";
const CHECKED = "2026-11-09";
const PACE_MS = 1000; // one request a second (a larger robots.txt Crawl-delay wins)
const MAX_REQUESTS = 150; // per store
const USER_AGENT = "keplaris-research (+https://keplaris.com)";
const TAG_POLICY = "skip"; // "skip": product tags get no redirect row; "collection": map each to /collections/{tag}
const FETCH_META = true; // read SEO titles and descriptions (Yoast REST field) to compare with Shopify's caps
const SAVE_RAW = true; // keep every response body next to the CSVs
// https://help.shopify.com/en/manual/online-store/menus-and-links/url-redirect
// "You can't redirect URLs that begin with the following prefixes: /apps, /application, /cart, /carts,
// /orders, /services, or /shop."
const NO_REDIRECT_PREFIXES = ["/apps", "/application", "/cart", "/carts", "/orders", "/services", "/shop"];
// "You can't redirect URLs that use fixed Shopify paths: /products, /collections, /collections/all."
const FIXED_PATHS = ["/products", "/collections", "/collections/all"];
// "Certain URL paths are reserved by Shopify and cannot be used for redirects: /collections/vendors,
// /collections/types, /collections/all /apps/, /a/, /community/, /tools/"
const RESERVED_PATHS = ["/collections/vendors", "/collections/types", "/collections/all", "/apps/", "/a/", "/community/", "/tools/"];
// "You can create a maximum of 100,000 URL redirects unless your store is on the Plus plan,
// which has a maximum of 20,000,000 URL redirects."
const REDIRECT_LIMIT = 100000;
const REDIRECT_LIMIT_PLUS = 20000000;
// Header of Shopify's sample file, byte for byte:
// https://help.shopify.com/cdn/shopifycloud/product-knowledge/production/csv/sample-redirect-template.csv
const CSV_HEADER = "Redirect from,Redirect to";
// https://help.shopify.com/en/manual/products/variants/add-variants
// "You can create up to 2,048 variants for a product. Each product can have up to three options."
// "Some third-party themes might not support more than 100 variants."
const MAX_OPTIONS = 3;
const MAX_VARIANTS = 2048;
const VARIANT_THEME_CAVEAT = 100;
// https://help.shopify.com/en/manual/products/import-export/using-csv
// SEO title "up to 70 characters", SEO description "up to 320 characters".
// "A valid URL handle can contain letters, dashes, and numbers, but it can't contain any spaces."
// Lowercasing and turning every other character into a dash is OUR normalisation, not a Shopify rule.
const SEO_TITLE_MAX = 70;
const SEO_DESC_MAX = 320;
// WooCommerce pages with a fixed job. null = no Shopify path to send them to.
const SYSTEM_PAGES = { cart: "/cart", checkout: null, "my-account": "/account", wishlist: null, "track-order": null };
// Product categories that tell you a plugin did the work (edit for your store).
const NOTE_CATEGORIES = { booking: "bookable products: pick a Shopify booking app before you move them" };
// Rows with any of these flags stay out of redirects.csv and are listed in the report.
const HOLD = ["QUERY_STRING", "UNMAPPABLE", "NO_TARGET", "SAME_PATH", "NO_REDIRECT_PREFIX", "PREFIX_AMBIGUOUS",
"FIXED_PATH_SOURCE", "RESERVED_PATH_SOURCE", "TAG_SKIPPED", "COLLISION"];
// ---------------------------------------------------------------- fetching
let requests = 0, last = 0, delay = PACE_MS, rules = [], rawDir = null;
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
function allowed(path) {
let best = { len: -1, allow: true };
for (const r of rules) {
if (!r.pattern) continue;
const re = new RegExp("^" + r.pattern.replace(/[.+?^{}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\\\$$|\$$/, "$"));
if (re.test(path) && (r.pattern.length > best.len || (r.pattern.length === best.len && r.allow)))
best = { len: r.pattern.length, allow: r.allow };
}
return best.allow;
}
async function get(url, { check = true } = {}) {
const u = new URL(url);
if (check && !allowed(u.pathname + u.search)) return { status: "robots", body: "" };
if (requests >= MAX_REQUESTS) throw new Error(`stopped at MAX_REQUESTS (${MAX_REQUESTS})`);
const wait = last + delay - Date.now();
if (wait > 0) await sleep(wait);
last = Date.now();
requests++;
const res = await fetch(url, { headers: { "user-agent": USER_AGENT }, redirect: "follow" });
const body = await res.text();
if (SAVE_RAW && rawDir) writeFileSync(join(rawDir, String(requests).padStart(3, "0") + "-" + (u.pathname + u.search).replace(/[^a-z0-9]+/gi, "_").slice(0, 80) + ".txt"), body);
if (res.status === 429) throw new Error(`429 from ${url}: stopping`);
return { status: res.status, body, headers: res.headers };
}
function parseRobots(txt) {
const groups = [];
let cur = null, lastWasAgent = false;
const sitemaps = [];
for (const raw of txt.split(/\r?\n/)) {
const line = raw.replace(/#.*/, "").trim();
const m = line.match(/^([a-z-]+)\s*:\s*(.*)$/i);
if (!m) continue;
const key = m[1].toLowerCase(), val = m[2].trim();
if (key === "sitemap") { sitemaps.push(val); continue; }
if (key === "user-agent") {
if (!lastWasAgent) { cur = { agents: [], rules: [], crawlDelay: null }; groups.push(cur); }
cur.agents.push(val.toLowerCase()); lastWasAgent = true; continue;
}
lastWasAgent = false;
if (!cur) continue;
if (key === "allow" || key === "disallow") cur.rules.push({ allow: key === "allow", pattern: val });
if (key === "crawl-delay") cur.crawlDelay = Number(val);
}
const token = USER_AGENT.split(" ")[0].toLowerCase();
let mine = groups.filter((g) => g.agents.includes(token));
if (!mine.length) mine = groups.filter((g) => g.agents.includes("*"));
return { sitemaps, groups: mine, rules: mine.flatMap((g) => g.rules), crawlDelay: Math.max(0, ...mine.map((g) => g.crawlDelay || 0)) };
}
const locs = (xml, tag) => [...xml.matchAll(new RegExp(`<${tag}>[\\s\\S]*?<loc>([^<]*)</loc>`, "g"))]
.map((m) => m[1].trim().replace(/&/g, "&"));
// ---------------------------------------------------------------- mapping rules
function handle(slug) {
let s = slug;
try { s = decodeURIComponent(slug); } catch {}
return s.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
}
const noSlash = (p) => (p.length > 1 ? p.replace(/\/+$/, "") : p);
function prefixCheck(path) {
const first = "/" + (path.split("/")[1] || "");
for (const p of NO_REDIRECT_PREFIXES) {
if (first === p) return { flag: "NO_REDIRECT_PREFIX", prefix: p };
if (path.startsWith(p)) return { flag: "PREFIX_AMBIGUOUS", prefix: p };
}
return null;
}
function typeOf(sitemapUrl) {
const f = sitemapUrl.split("/").pop();
let m = f.match(/^wp-sitemap-(?:posts|taxonomies)-([a-z0-9_-]+?)-\d+\.xml$/);
if (m) return m[1];
if (/^wp-sitemap-users-\d+\.xml$/.test(f)) return "author";
m = f.match(/^([a-z0-9_-]+?)-sitemap\d*\.xml$/);
return m ? m[1] : "unknown";
}
// ---------------------------------------------------------------- one store
async function mapStore(input) {
requests = 0; last = 0; delay = PACE_MS; rules = [];
const start = new URL(input);
const origin = start.origin;
const base = start.pathname.replace(/\/+$/, ""); // "" for a store at the domain root
const label = (start.host + base).replace(/[^a-z0-9]+/gi, "-");
const outDir = join("url-map-out", label);
rawDir = join(outDir, "raw");
mkdirSync(rawDir, { recursive: true });
const out = [];
const say = (s = "") => out.push(s);
say(`######## ${input}`);
// 1. robots.txt lives at the host root, even for a store installed in a subdirectory
const rob = await get(origin + "/robots.txt", { check: false });
const robots = rob.status === 200 ? parseRobots(rob.body) : { sitemaps: [], groups: [], rules: [], crawlDelay: 0 };
rules = robots.rules;
delay = Math.max(PACE_MS, robots.crawlDelay * 1000);
say(`robots.txt: ${rob.status}, groups that apply to us: ${robots.groups.length} (agent ${robots.groups.map((g) => g.agents.join("+")).join(", ") || "none"}), crawl-delay: ${robots.crawlDelay || "none"}`);
for (const r of robots.rules) say(` ${r.allow ? "allow " : "disallow"} ${r.pattern || "(empty)"}`);
say(`base path: ${base || "none (store at the domain root)"}${base ? " (stripped before mapping, as if the store sat at the domain root)" : ""}`);
// 2. sitemaps: robots.txt Sitemap lines under this store, else the usual WordPress names
let indexes = robots.sitemaps.filter((s) => s.startsWith(origin + base + "/"));
if (!indexes.length) indexes = ["/sitemap_index.xml", "/wp-sitemap.xml", "/sitemap.xml"].map((p) => origin + base + p);
const children = [];
for (const idx of indexes) {
const r = await get(idx);
if (r.status !== 200) continue;
if (/<sitemapindex/.test(r.body)) children.push(...locs(r.body, "sitemap"));
else children.push(idx);
if (children.length) break;
}
say(`sitemap index: ${indexes[0].replace(origin, "")}, child sitemaps: ${children.length}`);
const PRIORITY = ["product", "product_cat", "product_tag", "post", "page", "category", "post_tag", "author", "attachment"];
children.sort((a, b) => ((PRIORITY.indexOf(typeOf(a)) + 99) % 99) - ((PRIORITY.indexOf(typeOf(b)) + 99) % 99) || a.localeCompare(b));
const seen = new Map(); // key = path + query
let fragments = 0, dupes = 0;
for (const c of children) {
const r = await get(c);
const urls = r.status === 200 ? locs(r.body, "url") : [];
say(` ${c.replace(origin, "").padEnd(base.length + 32)} ${String(r.status).padStart(3)} ${String(urls.length).padStart(4)} URLs`);
for (const u of urls) {
const x = new URL(u);
if (x.hash) fragments++;
let path = x.pathname;
if (base && path.startsWith(base + "/")) path = path.slice(base.length);
const key = path + x.search;
if (seen.has(key)) { dupes++; seen.get(key).also.push(typeOf(c)); continue; }
seen.set(key, { url: u.replace(/#.*$/, ""), path, query: x.search, sitemap: c.split("/").pop(), type: typeOf(c), also: [] });
}
}
say(`unique URLs: ${seen.size} (fragments stripped: ${fragments}, they never reach the server; listed in two sitemaps: ${dupes})`);
// 3. public Store API: product types, variation attributes, variations, categories
const api = new Map();
let apiNote = "";
for (let page = 1; page <= 10; page++) {
const r = await get(`${origin}${base}/wp-json/wc/store/v1/products?per_page=100&page=${page}`);
if (r.status !== 200) { apiNote = `store api: ${r.status}`; break; }
const list = JSON.parse(r.body);
for (const p of list) {
let path = new URL(p.permalink).pathname;
if (base && path.startsWith(base + "/")) path = path.slice(base.length);
api.set(path, p);
}
if (list.length < 100) break;
}
const prods = [...api.values()];
const types = {};
for (const p of prods) types[p.type] = (types[p.type] || 0) + 1;
const varAttrs = (p) => (p.attributes || []).filter((a) => a.has_variations);
const variable = prods.filter((p) => p.type === "variable");
say(apiNote || `store api: ${prods.length} products (${Object.entries(types).map(([k, v]) => `${k} ${v}`).join(", ")})`);
if (prods.length) {
say(` most variation attributes on one product: ${Math.max(0, ...prods.map((p) => varAttrs(p).length))} (Shopify allows ${MAX_OPTIONS} options)`);
say(` most variations on one product: ${Math.max(0, ...prods.map((p) => (p.variations || []).length))} (Shopify allows ${MAX_VARIANTS}; some themes and apps stop at ${VARIANT_THEME_CAVEAT})`);
say(` variable products listing 0 variations in the Store API: ${variable.filter((p) => !(p.variations || []).length).length} of ${variable.length} (check these on the product page)`);
}
// 4. posts list (tells the blog index apart from posts) and SEO meta from the Yoast REST field
const postPaths = new Set();
const r4 = await get(`${origin}${base}/wp-json/wp/v2/posts?per_page=100&_fields=link`);
if (r4.status === 200) for (const p of JSON.parse(r4.body)) postPaths.add(new URL(p.link).pathname.slice(base.length));
let metaLine = "meta: not fetched";
if (FETCH_META) {
const r = await get(`${origin}${base}/wp-json/wp/v2/product?per_page=100&_fields=link,yoast_head_json`);
const list = r.status === 200 ? JSON.parse(r.body) : [];
const withMeta = list.filter((p) => p.yoast_head_json && p.yoast_head_json.title);
if (withMeta.length) {
const t = withMeta.map((p) => p.yoast_head_json.title.length);
const d = withMeta.map((p) => (p.yoast_head_json.description || "").length).filter((n) => n > 0);
metaLine = `meta (Yoast REST field, ${withMeta.length} products): SEO titles over ${SEO_TITLE_MAX} chars: ${t.filter((n) => n > SEO_TITLE_MAX).length} (longest ${Math.max(...t)}); ` +
`meta descriptions set: ${d.length}, over ${SEO_DESC_MAX} chars: ${d.filter((n) => n > SEO_DESC_MAX).length}`;
} else metaLine = `meta: not fetched (wp/v2/product returned ${r.status}${r.status === 200 ? " without yoast_head_json" : ""})`;
}
say(metaLine);
// 5. classify and map
const rows = [];
for (const s of seen.values()) {
const segs = s.path.split("/").filter(Boolean);
const leaf = segs[segs.length - 1] || "";
const h = handle(leaf);
const row = { ...s, cls: "unknown", target: null, ns: null, handle: h, flags: new Set(), note: "" };
const t = s.type;
if (s.query) row.flags.add("QUERY_STRING");
if (t === "product") {
if (api.size && !api.has(s.path)) { row.cls = "shop_root"; row.target = "/collections/all"; }
else {
row.cls = "product"; row.ns = "products"; row.target = "/products/" + h;
if (segs.length > 2) row.flags.add("CATEGORY_PATH_DROPPED");
const p = api.get(s.path);
if (p) {
if (p.type === "external") row.flags.add("EXTERNAL_PRODUCT");
if (p.type === "grouped") row.flags.add("GROUPED_PRODUCT");
if (varAttrs(p).length > MAX_OPTIONS) row.flags.add("OVER_3_OPTIONS");
const n = (p.variations || []).length;
if (n > MAX_VARIANTS) row.flags.add("OVER_2048_VARIANTS");
else if (n > VARIANT_THEME_CAVEAT) row.flags.add("OVER_100_VARIANTS");
for (const c of p.categories || []) if (NOTE_CATEGORIES[c.slug]) { row.flags.add("NOTE_" + c.slug.toUpperCase()); row.note = NOTE_CATEGORIES[c.slug]; }
}
}
} else if (t === "product_cat") {
row.cls = "product_cat"; row.ns = "collections"; row.target = "/collections/" + h;
if (segs.length > 2) row.flags.add("HIERARCHY_FLATTENED");
} else if (t === "product_tag") {
row.cls = "product_tag";
if (TAG_POLICY === "collection") { row.ns = "collections"; row.target = "/collections/" + h; }
else row.flags.add("TAG_SKIPPED");
} else if (t === "post") {
if (postPaths.size ? !postPaths.has(s.path) : false) { row.cls = "blog_index"; row.target = "/blogs/news"; }
else { row.cls = /^\/\d{4}\/\d{2}\/(\d{2}\/)?[^/]+\/?$/.test(s.path) ? "post_dated" : "post"; row.ns = "articles"; row.target = "/blogs/news/" + h; }
} else if (t === "category" || t === "post_tag") {
row.cls = t === "category" ? "post_category" : "post_tag"; row.ns = "blog_tags"; row.target = "/blogs/news/tagged/" + h;
} else if (t === "page") {
if (!segs.length) { row.cls = "home"; row.target = "/"; }
else if (leaf in SYSTEM_PAGES) { row.cls = "system"; row.target = SYSTEM_PAGES[leaf]; if (!row.target) row.flags.add("NO_TARGET"); }
else { row.cls = "page"; row.ns = "pages"; row.target = "/pages/" + h; if (segs.length > 1) row.flags.add("HIERARCHY_FLATTENED"); }
} else if (t === "attachment") { row.cls = "attachment"; row.flags.add("UNMAPPABLE"); }
else if (t === "author") { row.cls = "author"; row.flags.add("UNMAPPABLE"); }
else { row.cls = "custom_type:" + t; row.flags.add("UNMAPPABLE"); }
if (row.target && leaf && h !== leaf) row.flags.add("HANDLE_CHANGED");
if (row.ns && /-\d+$/.test(h)) row.flags.add("WP_SUFFIX");
if (row.target && noSlash(s.path) === row.target && !s.query) row.flags.add("SAME_PATH");
const pre = prefixCheck(s.path);
if (pre) { row.flags.add(pre.flag); row.prefix = pre.prefix; }
if (FIXED_PATHS.includes(noSlash(s.path))) row.flags.add("FIXED_PATH_SOURCE");
if (RESERVED_PATHS.some((r) => (r.endsWith("/") ? s.path.startsWith(r) : noSlash(s.path) === r))) row.flags.add("RESERVED_PATH_SOURCE");
rows.push(row);
}
// collisions: two sources that need the same handle in the same Shopify namespace
const byKey = new Map();
for (const r of rows) if (r.ns) { const k = r.ns + ":" + r.handle; byKey.set(k, [...(byKey.get(k) || []), r]); }
const collisions = [...byKey.entries()].filter(([, v]) => v.length > 1);
for (const [, v] of collisions) for (const r of v) r.flags.add("COLLISION");
// WordPress -N suffixes: stripping one would hit another source's handle
const stripHits = [];
for (const r of rows) if (r.flags.has("WP_SUFFIX")) {
const bare = r.handle.replace(/-\d+$/, "");
const other = byKey.get(r.ns + ":" + bare);
if (other) { r.flags.add("WP_SUFFIX_STRIP_COLLIDES"); stripHits.push([r, other[0]]); }
}
// 6. write files
const written = rows.filter((r) => r.target && !HOLD.some((f) => r.flags.has(f)));
const q = (v) => (/[",\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v);
writeFileSync(join(outDir, "redirects.csv"), [CSV_HEADER, ...written.map((r) => q(r.path) + "," + q(r.target))].join("\n") + "\n");
writeFileSync(join(outDir, "url-map-report.csv"), ["source_url,source_path,sitemap,class,shopify_target,in_redirects_csv,flags",
...rows.map((r) => [r.url, r.path + r.query, r.sitemap, r.cls, r.target || "", written.includes(r) ? "yes" : "no", [...r.flags].join(" ")].map(q).join(","))].join("\n") + "\n");
// 7. summary
say("");
say("== URLs by class");
const classes = {};
for (const r of rows) {
const shape = r.cls === "system" ? "/cart, /account or none" : !r.target ? "-" : r.ns && r.target.endsWith("/" + r.handle) ? r.target.slice(0, -r.handle.length) + "{handle}" : r.target;
const c = (classes[r.cls] ||= { n: 0, w: 0, target: shape });
c.n++; if (written.includes(r)) c.w++;
}
say("class".padEnd(36) + "URLs".padStart(5) + " in csv".padStart(8) + " Shopify target");
for (const [k, v] of Object.entries(classes).sort((a, b) => b[1].n - a[1].n || a[0].localeCompare(b[0])))
say(k.padEnd(36) + String(v.n).padStart(5) + String(v.w).padStart(8) + " " + v.target);
say("total".padEnd(36) + String(rows.length).padStart(5) + String(written.length).padStart(8));
say("");
say(`== redirects.csv: ${written.length} rows written, ${rows.length - written.length} URLs held back (limit ${REDIRECT_LIMIT.toLocaleString("en-US")}, ${REDIRECT_LIMIT_PLUS.toLocaleString("en-US")} on Plus: ${written.length <= REDIRECT_LIMIT ? "under" : "OVER"})`);
say("flag counts (a URL can carry several; * = held out of redirects.csv)");
const counts = {};
for (const r of rows) for (const f of r.flags) counts[f] = (counts[f] || 0) + 1;
for (const [f, n] of Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])))
say(` ${HOLD.includes(f) ? "*" : " "} ${f.padEnd(26)}${String(n).padStart(4)}`);
const blocked = rows.filter((r) => r.flags.has("NO_REDIRECT_PREFIX"));
say("");
say(`== sources Shopify won't redirect (first segment is a listed prefix): ${blocked.length}`);
const byCls = {};
for (const r of blocked) byCls[r.cls] = (byCls[r.cls] || 0) + 1;
say(" by class: " + Object.entries(byCls).map(([k, v]) => `${k} ${v}`).join(", "));
const pc = rows.filter((r) => r.cls === "product");
say(` products under a blocked prefix: ${pc.filter((r) => r.flags.has("NO_REDIRECT_PREFIX")).length} of ${pc.length}`);
for (const r of blocked.slice(0, 4)) say(` ${r.path} (would map to ${r.target || "-"})`);
const amb = rows.filter((r) => r.flags.has("PREFIX_AMBIGUOUS"));
say(`== starts with a prefix's letters but not its segment (untested, Shopify's wording doesn't settle it): ${amb.length}`);
for (const r of amb) say(` ${r.path} (starts with ${r.prefix}; would map to ${r.target || "-"})`);
say("");
say(`== collisions (two sources, one Shopify handle): ${collisions.length}`);
for (const [, v] of collisions) say(` ${v[0].target} is needed by ${v.map((r) => r.path).join(" and ")}`);
const suf = rows.filter((r) => r.flags.has("WP_SUFFIX"));
say(`== handles ending in -N (a WordPress duplicate suffix or part of the name): ${suf.length} (${Object.entries(suf.reduce((a, r) => ((a[r.cls] = (a[r.cls] || 0) + 1), a), {})).map(([k, v]) => `${k} ${v}`).join(", ")})`);
say(` stripping the suffix would collide: ${stripHits.length}`);
for (const [a, b] of stripHits) say(` ${a.handle} without its suffix is ${a.handle.replace(/-\d+$/, "")}, already the handle of ${b.path}`);
const same = rows.filter((r) => r.flags.has("SAME_PATH"));
say(`== same path on Shopify (no redirect if the Shopify page exists at that handle): ${same.length}`);
say(" " + same.map((r) => r.path).join(" "));
const notes = rows.filter((r) => r.note);
if (notes.length) say(`== notes: ${notes.length} ${notes[0].note}`);
const ext = rows.filter((r) => r.flags.has("EXTERNAL_PRODUCT"));
if (ext.length) say(`== external (affiliate) products: ${ext.length}: ${ext.map((r) => r.path).join(" ")}`);
say("== unmappable URLs are not sent to the home page. Google: \"Don't redirect many old URLs to one irrelevant");
say(" single URL destination, such as the home page of the new site.\"");
say(`files: ${join(outDir, "redirects.csv")}, ${join(outDir, "url-map-report.csv")}`);
say(`requests to this store: ${requests}`);
return { out, requests, rows: rows.length, written: written.length };
}
// ---------------------------------------------------------------- main
const stores = process.argv.slice(2);
if (!stores.length) { console.error("usage: node url-map.mjs <store URL> [<store URL> ...]"); process.exit(1); }
console.log("url-map.mjs: WooCommerce sitemap URLs mapped to Shopify paths (public demo stores, no client data)");
console.log(`rules checked: ${CHECKED} | node: ${process.version} | pace: 1 request per ${PACE_MS} ms | user agent: ${USER_AGENT}`);
console.log(`tag policy: ${TAG_POLICY} | meta pass: ${FETCH_META} | CSV header: ${CSV_HEADER}`);
let total = 0;
for (const s of stores) {
console.log("");
try {
const r = await mapStore(s);
console.log(r.out.join("\n"));
total += r.requests;
} catch (e) {
console.log(`######## ${s}\nstopped: ${e.message}`);
total += requests;
}
}
console.log("");
console.log(`requests, all stores: ${total}`);
The unedited output of that command from 2026-11-09 (identical across both runs):
url-map.mjs: WooCommerce sitemap URLs mapped to Shopify paths (public demo stores, no client data)
rules checked: 2026-11-09 | node: v24.20.0 | pace: 1 request per 1000 ms | user agent: keplaris-research (+https://keplaris.com)
tag policy: skip | meta pass: true | CSV header: Redirect from,Redirect to
######## https://demos.flatsome.com/
robots.txt: 200, groups that apply to us: 2 (agent *, *), crawl-delay: none
disallow /wp-content/uploads/wc-logs/
disallow /wp-content/uploads/woocommerce_transient_files/
disallow /wp-content/uploads/woocommerce_uploads/
disallow /*?add-to-cart=
disallow /*?*add-to-cart=
disallow /wp-admin/
allow /wp-admin/admin-ajax.php
disallow (empty)
base path: none (store at the domain root)
sitemap index: /sitemap_index.xml, child sitemaps: 12
/product-sitemap.xml 200 68 URLs
/product_cat-sitemap.xml 200 15 URLs
/product_tag-sitemap.xml 200 28 URLs
/post-sitemap.xml 200 9 URLs
/page-sitemap.xml 200 101 URLs
/category-sitemap.xml 200 2 URLs
/post_tag-sitemap.xml 200 4 URLs
/author-sitemap.xml 200 1 URLs
/attachment-sitemap.xml 200 259 URLs
/blocks-sitemap.xml 200 8 URLs
/featured_item_category-sitemap.xml 200 2 URLs
/featured_item-sitemap.xml 200 9 URLs
unique URLs: 505 (fragments stripped: 259, they never reach the server; listed in two sitemaps: 1)
store api: 67 products (simple 55, variable 11, external 1)
most variation attributes on one product: 2 (Shopify allows 3 options)
most variations on one product: 20 (Shopify allows 2048; some themes and apps stop at 100)
variable products listing 0 variations in the Store API: 3 of 11 (check these on the product page)
meta (Yoast REST field, 67 products): SEO titles over 70 chars: 0 (longest 49); meta descriptions set: 0, over 320 chars: 0
== URLs by class
class URLs in csv Shopify target
attachment 259 0 -
page 94 82 /pages/{handle}
product 67 0 /products/{handle}
product_tag 28 0 -
product_cat 15 15 /collections/{handle}
custom_type:featured_item 9 0 -
custom_type:blocks 8 0 -
post_dated 8 8 /blogs/news/{handle}
system 5 1 /cart, /account or none
post_tag 4 4 /blogs/news/tagged/{handle}
custom_type:featured_item_category 2 0 -
post_category 2 2 /blogs/news/tagged/{handle}
author 1 0 -
blog_index 1 1 /blogs/news
home 1 0 /
shop_root 1 0 /collections/all
total 505 113
== redirects.csv: 113 rows written, 392 URLs held back (limit 100,000, 20,000,000 on Plus: under)
flag counts (a URL can carry several; * = held out of redirects.csv)
* UNMAPPABLE 279
HIERARCHY_FLATTENED 95
* QUERY_STRING 74
* NO_REDIRECT_PREFIX 69
CATEGORY_PATH_DROPPED 67
* TAG_SKIPPED 28
WP_SUFFIX 24
* SAME_PATH 11
WP_SUFFIX_STRIP_COLLIDES 11
NOTE_BOOKING 6
* COLLISION 4
* NO_TARGET 3
EXTERNAL_PRODUCT 1
== sources Shopify won't redirect (first segment is a listed prefix): 69
by class: shop_root 1, product 67, system 1
products under a blocked prefix: 67 of 67
/shop/ (would map to /collections/all)
/shop/women/sweaters/on1-jersey-unif-2/ (would map to /products/on1-jersey-unif-2)
/shop/men/t-shirts/osaka-entry-tee-superdry/ (would map to /products/osaka-entry-tee-superdry)
/shop/shoes/all-star-canvas-hi-converse/ (would map to /products/all-star-canvas-hi-converse)
== starts with a prefix's letters but not its segment (untested, Shopify's wording doesn't settle it): 0
== collisions (two sources, one Shopify handle): 2
/pages/portfolio is needed by /pages/portfolio/ and /elements/portfolio/
/pages/pages is needed by /pages/ and /elements/pages/
== handles ending in -N (a WordPress duplicate suffix or part of the name): 24 (product 17, post_dated 1, page 4, post_tag 2)
stripping the suffix would collide: 11
on1-jersey-unif-2 without its suffix is on1-jersey-unif, already the handle of /shop/women/sweaters/on1-jersey-unif/
woo-ninja-3 without its suffix is woo-ninja, already the handle of /shop/clothing/woo-ninja/
woo-logo-3 without its suffix is woo-logo, already the handle of /shop/clothing/woo-logo/
ship-your-idea-3 without its suffix is ship-your-idea, already the handle of /shop/clothing/ship-your-idea/
happy-ninja-2 without its suffix is happy-ninja, already the handle of /shop/clothing/happy-ninja/
ninja-silhouette-2 without its suffix is ninja-silhouette, already the handle of /shop/clothing/ninja-silhouette/
woo-logo-2 without its suffix is woo-logo, already the handle of /shop/clothing/woo-logo/
woo-ninja-2 without its suffix is woo-ninja, already the handle of /shop/clothing/woo-ninja/
ship-your-idea-2 without its suffix is ship-your-idea, already the handle of /shop/clothing/ship-your-idea/
premium-quality-2 without its suffix is premium-quality, already the handle of /shop/women/tops/premium-quality/
style-2 without its suffix is style, already the handle of /category/style/
== same path on Shopify (no redirect if the Shopify page exists at that handle): 11
/ /pages/our-stores/ /pages/portfolio/ /pages/contact/ /pages/size-chart/ /pages/left-sidebar/ /pages/about/ /pages/maintenance/ /pages/faq/ /cart/ /pages/layouts/
== notes: 6 bookable products: pick a Shopify booking app before you move them
== external (affiliate) products: 1: /shop/bags/adelia-bag-nypd/
== unmappable URLs are not sent to the home page. Google: "Don't redirect many old URLs to one irrelevant
single URL destination, such as the home page of the new site."
files: url-map-out/demos-flatsome-com/redirects.csv, url-map-out/demos-flatsome-com/url-map-report.csv
requests to this store: 17
######## https://websitedemos.net/brandstore-02/
robots.txt: 200, groups that apply to us: 1 (agent *), crawl-delay: none
disallow (empty)
base path: /brandstore-02 (stripped before mapping, as if the store sat at the domain root)
sitemap index: /brandstore-02/sitemap_index.xml, child sitemaps: 6
/brandstore-02/product-sitemap.xml 200 32 URLs
/brandstore-02/product_cat-sitemap.xml 200 3 URLs
/brandstore-02/page-sitemap.xml 200 9 URLs
/brandstore-02/attachment-sitemap.xml 200 51 URLs
/brandstore-02/cartflows_step-sitemap.xml 200 4 URLs
/brandstore-02/elementor-hf-sitemap.xml 200 1 URLs
unique URLs: 99 (fragments stripped: 0, they never reach the server; listed in two sitemaps: 1)
store api: 31 products (variable 12, simple 19)
most variation attributes on one product: 2 (Shopify allows 3 options)
most variations on one product: 5 (Shopify allows 2048; some themes and apps stop at 100)
variable products listing 0 variations in the Store API: 0 of 12 (check these on the product page)
meta (Yoast REST field, 31 products): SEO titles over 70 chars: 0 (longest 44); meta descriptions set: 0, over 320 chars: 0
== URLs by class
class URLs in csv Shopify target
attachment 51 0 -
product 31 31 /products/{handle}
custom_type:cartflows_step 4 0 -
page 4 2 /pages/{handle}
product_cat 3 3 /collections/{handle}
system 3 1 /cart, /account or none
custom_type:elementor-hf 1 0 -
home 1 0 /
shop_root 1 1 /collections/all
total 99 38
== redirects.csv: 38 rows written, 61 URLs held back (limit 100,000, 20,000,000 on Plus: under)
flag counts (a URL can carry several; * = held out of redirects.csv)
* UNMAPPABLE 56
* QUERY_STRING 31
* NO_REDIRECT_PREFIX 2
* SAME_PATH 2
* NO_TARGET 1
* PREFIX_AMBIGUOUS 1
WP_SUFFIX 1
WP_SUFFIX_STRIP_COLLIDES 1
== sources Shopify won't redirect (first segment is a listed prefix): 2
by class: system 1, page 1
products under a blocked prefix: 0 of 31
/cart/ (would map to /cart)
/shop/ (would map to /pages/shop)
== starts with a prefix's letters but not its segment (untested, Shopify's wording doesn't settle it): 1
/shop-2/ (starts with /shop; would map to /pages/shop-2)
== collisions (two sources, one Shopify handle): 0
== handles ending in -N (a WordPress duplicate suffix or part of the name): 1 (page 1)
stripping the suffix would collide: 1
shop-2 without its suffix is shop, already the handle of /shop/
== same path on Shopify (no redirect if the Shopify page exists at that handle): 2
/ /cart/
== unmappable URLs are not sent to the home page. Google: "Don't redirect many old URLs to one irrelevant
single URL destination, such as the home page of the new site."
files: url-map-out/websitedemos-net-brandstore-02/redirects.csv, url-map-out/websitedemos-net-brandstore-02/url-map-report.csv
requests to this store: 11
requests, all stores: 28
The first 10 rows of Flatsome's redirects.csv, with Shopify's header:
Redirect from,Redirect to
/product-category/clothing/,/collections/clothing
/product-category/women/,/collections/women
/product-category/booking/,/collections/booking
/product-category/clothing/hoodies/,/collections/hoodies
/product-category/men/,/collections/men
/product-category/bags/,/collections/bags
/product-category/music/,/collections/music
/product-category/men/t-shirts/,/collections/t-shirts
/product-category/posters/,/collections/posters
/product-category/shoes/,/collections/shoes
The first 10 rows of Brandstore's redirects.csv:
Redirect from,Redirect to
/store/,/collections/all
/product/dnk-red-shoes/,/products/dnk-red-shoes
/product/slim-fit-blue-jeans/,/products/slim-fit-blue-jeans
/product/white-underground-tshirt/,/products/white-underground-tshirt
/product/faint-washed-denim-blue-jeans/,/products/faint-washed-denim-blue-jeans
/product/purple-tshirt/,/products/purple-tshirt
/product/dark-gray-jeans/,/products/dark-gray-jeans
/product/lemons-tshirt/,/products/lemons-tshirt
/product/dnk-green-shoes/,/products/dnk-green-shoes
/product/flamingo-tshirt/,/products/flamingo-tshirt
The traced product and the product its suffix would collide with, from Flatsome's url-map-report.csv:
https://demos.flatsome.com/shop/women/sweaters/on1-jersey-unif-2/,/shop/women/sweaters/on1-jersey-unif-2/,product-sitemap.xml,product,/products/on1-jersey-unif-2,no,CATEGORY_PATH_DROPPED WP_SUFFIX NO_REDIRECT_PREFIX WP_SUFFIX_STRIP_COLLIDES
https://demos.flatsome.com/shop/women/sweaters/on1-jersey-unif/,/shop/women/sweaters/on1-jersey-unif/,product-sitemap.xml,product,/products/on1-jersey-unif,no,CATEGORY_PATH_DROPPED NO_REDIRECT_PREFIX
What this checklist can't tell you
The two stores are theme demos, not real shops: they show which URL patterns break, not how much traffic a real store would lose. Their URL lists come from sitemaps alone, while a real store's list also needs Search Console and server logs. The mapping rules past Shopify's quoted ones are ours (lowercasing, leaf-slug handles, /blogs/news as the blog). We didn't import the CSV into a Shopify store, so Shopify-side behaviour, from the /shop-2/ case to trailing slashes and market subfolders, is quoted from Shopify's documentation, not tested by us. And this post gives no cost, timeline or traffic outcome for your migration; for rates, see our Shopify developer cost guide.
If you're moving to Shopify and want the store on the other side built properly, theme, checkout and integrations included, our Shopify e-commerce team can scope it.
Frequently asked questions
How do I migrate from WooCommerce to Shopify?
Audit your URLs, plugins and data, then import products, customers and historical orders, the order Shopify's WooCommerce guide gives. Build the URL map, carry over SEO titles and descriptions, rebuild payments, tax and shipping, and place test orders. At cutover, freeze content, run the final URL map, import the redirect CSV, run a final delta sync and switch DNS. Then watch Search Console for 404s for a month.
Can I migrate WooCommerce to Shopify for free?
Partly. Shopify's Store Migration app is free and imports WooCommerce products, as drafts, and customers; products with 4 or more variation attributes arrive without variants. Orders and coupons can't be imported by CSV, and reviews, blog posts and pages aren't in the WooCommerce exports. For order history Shopify's guide names LitExtension Store Migration, Matrixify and Ablestar WooCommerce Importer. A customer export with full addresses needs a plugin; the one Shopify names is paid.
Will I lose SEO rankings moving from WooCommerce to Shopify?
Rankings can fluctuate for a while. Google's site-move guide says to expect temporary fluctuation during a move, and that medium-sized sites can take 'a few weeks or more' to show the new URLs. We found no study-backed traffic-loss figure, so we don't quote one. The Shopify-specific risk is that its redirect tool refuses sources beginning with /shop, and on the Flatsome demo store we mapped, 67 of 67 product URLs did.
How do I redirect WooCommerce URLs to Shopify?
Map each old URL to its Shopify path, then import a CSV with the header 'Redirect from,Redirect to' under Content, Menus, URL redirects, before you transfer the domain. A redirect only fires when the old path is broken on Shopify. You can't redirect sources that begin with /apps, /application, /cart, /carts, /orders, /services or /shop, and Shopify says URLs with query strings might not work as expected.
Can customer passwords be migrated from WooCommerce to Shopify?
No. Shopify's WooCommerce guide says customer passwords can't be migrated. With customer accounts, which is what new stores get, imported customers sign in with their email address and a one-time verification code, so they don't need a password. Shopify deprecated legacy customer accounts on February 26, 2026 and they are no longer available to new stores; Shopify says a final sunset date will be announced later in 2026.
How long does a WooCommerce to Shopify migration take?
It depends on catalog size, data and the URL map, so we don't give one figure. The cutover in our example January calendar runs eight days from content freeze to DNS switch, then a month of daily 404 checks. Google says medium-sized sites can take 'a few weeks or more' to show the new URLs, and to keep redirects for at least a year.
Should I migrate from WooCommerce to Shopify before Black Friday?
No. Black Friday is November 27 and Cyber Monday November 30, 2026, and a platform move is the largest change a store can make. Keep selling on WooCommerce through the peak and plan the cutover for January: freeze content, run the final URL map, import redirects, run a final delta sync of orders, customers and changed products, then switch DNS in a low-traffic hour.
Get in touch.
Whether you have questions or just want to explore what's possible, we're here to help.
