Wix to Shopify Migration: What Breaks Most Often (and How to Avoid It)

Most Wix to Shopify migration guides describe what should happen. This one documents what actually happens — the database mismatches, CSV rejections, tracking failures, and SEO collapses we encounter in production migrations — and the precise technical steps to fix each one.

If your Wix store drives real revenue through organic search or paid campaigns, this is the migration manual you need before touching a single export file.

A Wix to Shopify migration looks deceivingly simple: export products, import products, rebuild the theme, copy the pages. Merchants who treat it that way are usually the ones who call us two weeks post-launch asking why traffic has dropped 60 percent or why their Meta Pixel is reporting zero purchase events against a Shopify dashboard showing confirmed orders.

The failure isn't a lack of effort. It's a misunderstanding of what actually has to transfer.

Your Wix store is not just a collection of web pages. It's a functioning commerce system — with a URL equity footprint, a product data architecture, an analytics instrumentation layer, and customer acquisition flows built on top of it. Shopify doesn't automatically inherit any of those. You have to rebuild each layer deliberately.

The businesses that migrate without disruption are the ones that treat this as an engineering handoff, not a website redesign.

Wix operates on a page-first, flexible relational architecture. Products live inside pages. Design is largely freeform. The platform allows merchants to define up to six custom option categories per product without enforcing naming standards or structural consistency.

Shopify is built around a commerce-first data model with hard API constraints. Each product handle supports a maximum of three distinct option identifiers (for example: Size, Color, Material) and a hard cap of 100 variants per product. These are not soft limits. They are enforced at the API layer.

What this means in practice: any Wix product with more than three option types or more than 100 variant combinations will fail at import or get silently truncated. We've seen this wipe out entire SKU structures for apparel and custom product catalogs during migrations where the merchant assumed the CSV export was import-ready.

It is never import-ready. It requires structural intervention first.

When migrating large catalogs from Wix, the most technically complex problem we encounter consistently is schema collapse. Wix's flexible product architecture creates data structures that Shopify's API will simply reject.

Here is what happens at a database level: Wix stores product options in a loosely typed relational format that doesn't enforce option count limits. When you export to CSV and push that file toward Shopify's importer, the parser hits the three-option ceiling and either fails the entire row or drops extra options without logging an error. Merchants discover this only when customers report that certain variants are missing from product pages.

The resolution requires pre-import structural intervention at the spreadsheet level. For products with four or more option categories, you have two engineering paths:

Path One — Metafield Mapping. Move non-purchasing options (things like care instructions, material composition, or secondary specifications) into Shopify's Metafield infrastructure. These values don't drive variant selection, so they don't need to occupy one of the three option slots. They can instead be structured as product metafields and surfaced on the product page through theme metafield blocks. This preserves the product information without consuming variant capacity.

Path Two — Handle Splitting. For products where all option types genuinely affect purchasing decisions, the product must be programmatically divided into multiple product handles before import. For example, a product with Size, Color, Material, and Finish options becomes two separate product handles — one for Size/Color/Material, one for a size-agnostic Finish variant group — connected in the storefront through a metaobject relationship or a bundle app.

For catalogs pushing the 100-variant ceiling, the math works the same way. A product with 5 sizes, 5 colors, and 5 materials generates 125 variants. Shopify will reject it. The fix is splitting at the option level: 5 sizes × 5 colors = 25 variants on one handle (under the limit), with material handled through a metafield or a companion product.

This is pre-import work. Doing it after launch means re-importing, rebuilding collection assignments, and re-mapping any existing metafield data — a significantly more expensive problem to fix.

The migration shortcut most guides recommend — export your Wix CSV and upload it directly to Shopify — causes systematic import failures in production environments. We see this on nearly every initial migration attempt from a Wix store, regardless of catalog size.

The underlying problem is that Shopify's CSV parser requires exact column headers that don't exist in a raw Wix export. Wix uses generic output tags that don't map to Shopify's expected schema. The result is that Shopify either rejects the file entirely or misassigns field data in ways that silently corrupt product records.

The specific headers that cause the most failures:

Wix exports inventory data under generic column labels. Shopify requires the column to be labeled precisely as Variant Inventory Qty for quantity values and Variant Tracking Method for inventory tracking status. Any deviation causes those columns to be skipped entirely, meaning every imported product launches with zero inventory tracking.

Beyond header renaming, the raw data inside the cells requires sanitization before import. The most common cell-level problem we encounter is variant attribute inconsistency. A single product catalog might list the same size as "L", "Large", "Lg", and "large" across different rows — four distinct values that Shopify's merchandising and filtering treats as four separate options. This breaks collection filtering, makes inventory reconciliation unreliable, and creates a browsing experience where the same size appears multiple times in product selectors.

In our production workflow, we run a deduplication pass across all option value columns before staging the import. Every attribute value is normalized to a single canonical form across the full catalog. This step alone has prevented import failures and post-launch inventory errors on every migration we've executed.

Additional sanitization requirements include auditing SKU uniqueness (Shopify requires globally unique SKUs; Wix does not enforce this), standardizing vendor field values to prevent duplicate vendor records in the Shopify admin, and verifying that image URLs in the export are publicly accessible (Wix sometimes generates temporary or authenticated media URLs that expire before Shopify can pull them).

File size constraints to know before importing: Shopify's native CSV importer handles product sheets up to 15MB. Customer import files (for historical customer records) have a hard cap of 1MB. Catalogs exceeding the product sheet limit require chunked imports — splitting the file into batches and importing sequentially.

One of the most consistently underestimated post-launch surprises in a Wix to Shopify migration is what happens to the customer database.

Both Wix and Shopify use proprietary cryptographic hashing algorithms to secure account credentials. This is a non-negotiable security standard on both platforms. As a direct consequence, customer passwords cannot be exported from Wix under any circumstances. This is not a limitation of the export tool or a feature restriction that can be worked around — it is the intended behavior of any compliant authentication system.

When you import a historical customer CSV into Shopify, the profile attributes transfer correctly: names, email addresses, shipping addresses, order history counts, and tags. But every imported account lands in an Inactive state. The customer cannot log in until they establish new credentials through Shopify's account system.

If you launch without a reactivation strategy, your existing customer base discovers they can no longer access their accounts. This affects loyalty retention, order history visibility, and the perceived continuity of the brand transition.

The correct protocol is to build an Account Activation email campaign triggered at or immediately after launch. Using Shopify Email or Klaviyo, this campaign sends a personalized, secure account activation link to every imported customer. The link prompts them to set a new password and confirms their account is active on the new platform.

The campaign should be staged carefully. Sending all activation emails simultaneously to a large customer list can trigger spam filters. A batched send schedule — segmented by customer lifetime value or recency — protects deliverability and gives your support team manageable activation request volume if customers have questions.

Store the activation campaign as a draft in your email platform before launch, ready to deploy the moment the Shopify store goes live. Waiting until after launch to build this campaign means your customers hit dead accounts with no context while you're still building the communication.

This is the section where most migrations fail silently for weeks before merchants understand what happened.

Wix gives store owners structural freedom to build URL paths anywhere in the root domain. Product pages, blog posts, collection pages, and landing pages can exist at custom paths with no enforced folder structure. Shopify uses a rigid, enforced directory system: every product page must reside under /products/, every collection under /collections/, every blog post under /blogs/[blog-name]/. There is no configuration option to change this.

The result: virtually no Wix URL will match its Shopify equivalent automatically. Every indexed link your domain has built with search engines — from product pages, blog posts, backlinks from third-party sites, internal links — resolves to a 404 error the moment you switch domains unless you build an explicit redirect map.

The critical mistake we see most often is deploying a catch-all redirect rule that points all legacy traffic to the new Shopify homepage. This feels efficient. It is catastrophically damaging. Search engines identify mass homepage redirects as "Soft 404" behavior — a signal that the destination page is not a genuine match for the redirected URL. Google's systems interpret this as low-quality migration behavior and systematically strip the affected URLs of their accumulated authority. Rankings that took years to build can collapse within a single crawl cycle after this type of redirect implementation.

The most expensive post-migration failure we encounter is a tracking breakdown that isn't discovered until ad spend has been misallocated for several weeks.

Here's the mechanism: Shopify processes its checkout through a separate structural pipeline than Wix. Event triggers, conversion signals, and session data are passed through a different set of hooks. If you carry over your existing Google Tag Manager setup, Meta Pixel configuration, or GA4 event schema without reconfiguring them for Shopify's checkout architecture, those tags will appear to be installed but will fail to fire correctly for purchase events.

The ad networks continue receiving session and page view data. They continue reporting audience activity. But the purchase conversion signals — the events that feed the optimization algorithms — stop being recorded accurately. Without accurate conversion data, Meta and Google's automated bidding systems optimize toward the wrong behavior. ROAS calculations become unreliable. Budget allocation decisions are made on corrupted data. This problem compounds quietly until someone runs a reconciliation between ad platform reported conversions and Shopify revenue and discovers the gap.

Understanding what breaks is only valuable if it informs how you run the migration. The following process is structured around risk reduction, not speed.

The pre-migration audit comes first. Before exporting a single file, build a complete inventory of what the business depends on: top-revenue pages, indexed URL set, installed scripts and marketing tags, Wix apps with backend dependencies, operational workflows your team runs through the Wix admin, and email or automation flows connected to Wix forms. Without this inventory, the migration scope is guesswork.

Clean the catalog before import, not after. Export the Wix product CSV and run the sanitization process described in Section 2 before the Shopify store is set up. Doing cleanup after import means re-importing and reconciling the delta, which creates duplicate SKU and collection assignment problems.

Plan the Shopify architecture before building. Define the collection structure, product template design, metafield schema, and filtering logic before any development begins. Shopify's commerce-first architecture rewards stores that are structured intentionally and punishes stores that are assembled reactively. Retrofitting collection architecture after the store is built costs more than building it correctly the first time.

Rebuild key pages, don't migrate them. High-ranking blog posts, brand story pages, shipping and returns policies, FAQ pages, and top-converting landing pages should be rebuilt in Shopify with deliberate attention to content depth, internal linking, and metadata. These pages carry trust signals and SEO equity that don't survive a copy-paste approach.

Build and upload the redirect map before going live. The redirect map should be complete and uploaded to Shopify's URL Redirects panel before the domain is pointed. Redirects implemented after launch — even by hours — can allow Googlebot to crawl 404s during the window, which accelerates ranking impact.

Validate tracking in staging before launch. Use Shopify's test payment gateway to run complete purchase transactions in the staging environment. Confirm that all conversion events fire correctly, that no duplicate transactions are recorded, and that ad platform dashboards reflect the test purchases.

Stabilize before optimizing. The first two weeks after launch are a stabilization period, not a growth phase. Googlebot will crawl the new store more aggressively than usual. Real customers will discover edge cases in checkout, filtering, and discount logic. Tracking accuracy needs to be monitored daily. Having engineering support available during this period — not just for deployment — is what separates clean migrations from ongoing incident response.

SEO continuity in a platform migration is not achieved through redirects alone. It's achieved through continuity of intent.

A Wix collection page that ranked because it was a strong commercial category landing page needs to become a Shopify collection page that functions equally well as a commercial category landing page. A Wix blog post that ranked because it was a comprehensive buying guide needs a Shopify equivalent that preserves the content depth, internal linking structure, and topical coverage that earned that position.

The redirect transfers the URL equity. The page's content quality and structural relevance is what preserves the ranking signal after the redirect resolves.

Post-migration, submit the new sitemap to Google Search Console immediately after launch. Monitor the Index Coverage report daily for the first two weeks to catch 404 errors or redirect chains. Watch for drops in crawl rate, which can indicate that Googlebot is encountering errors that weren't caught in pre-launch testing.

Core Web Vitals performance on Shopify often differs meaningfully from Wix. Run Lighthouse audits on key page templates — homepage, product page, collection page — and address any significant LCP, FID, or CLS regressions before they affect ranking signals.