A Magento to Shopify migration runs in six stages. Audit what the Magento store actually does. Map its data model to Shopify’s. Build the theme. Rehearse the data import on a staging store. Rewire payments and integrations. Then cut over with a complete redirect map, and watch search for weeks after. At #10, we ran a premium California olive oil and wine brand on Magento for six years, moved it to Shopify Plus in 2020 without closing the store, and still run it today. This is the process from that work.
The Magento store keeps selling the whole time. Nothing about a well-run migration process requires downtime. The new Shopify store is built and tested in parallel, and the switch itself is a domain change scheduled for a quiet hour.
This guide is the end-to-end process. If you are leaving WooCommerce, read WooCommerce to Shopify: migrating without losing rankings. For a checklist of what tends to go missing in any move, see Shopify migration: what gets lost, and how to prevent it.
Why Magento stores move, and what that means for the plan
Adobe ended support for Magento 1 in June 2020. That pushed many brands into moving from Magento to Shopify the same year. It was the deadline for the brand above too. A Magento 2 to Shopify move is usually about cost instead. Magento 2 (now Magento Open Source and Adobe Commerce) is still supported, but it carries the same cost structure: hosting, security patches, version upgrades and a developer for most changes.
The reason you are moving shapes the plan. A store leaving because of upkeep cost should come out the other side with less custom code, not a line-for-line copy of the old one. Magento stores collect extensions and custom modules over the years. Each one needs a decision in the move, and “keep everything” is usually the wrong default.
Stage 1: audit what the Magento store actually does
Start with an inventory of your current Magento store, not a theme. This is the migration strategy in practice. We list:
- Every installed extension, enabled or not, and what it does for the business today.
- Custom modules and template overrides, including checkout changes, which are where Magento stores hide the most logic.
- Every rule the checkout runs: shipping tables, discounts, gating, gift options, tax.
- Every system connected to the store: ERP, warehouse or 3PL, email platform, tax service, reviews, search.
- Data volumes: products, variants, customers, orders, reviews, CMS pages and blog posts.
Then each item gets one of four outcomes: Shopify does it natively, an app does it, the theme does it, or it stops. For the olive oil and wine brand, the list ran from wine-shipping compliance and a membership club with stored cards to custom fulfillment routing and a long tail of promotion rules. Some became Shopify apps. Some became theme code. A few were dropped because nobody used them anymore.
This is also where an SEO baseline gets captured. Export the pages that earn search traffic, the backlink targets and the current titles and descriptions. You need the before picture to judge the after.
Stage 2: map the Magento data model to Shopify
Magento and Shopify describe the same online store in different shapes. Each Magento concept has a Shopify equivalent, but not always a one-to-one one. The mapping decides what the import looks like, so it happens before any data moves.
| Magento | Shopify | What to decide |
|---|---|---|
| Configurable product with simple children | One product with variants | Shopify allows three options per product. |
| Attribute sets, custom attributes | Metafields and metaobjects | Which attributes customers see, filter on or never use. |
| Nested categories | Collections, plus menus for hierarchy | How the old category tree becomes navigation. |
| Customer groups, tier prices | Customer tags, or B2B companies and price lists on Plus | Who gets which price, and how it’s enforced. |
| Cart price rules | Shopify discounts, Functions or an app | Which rules still earn their keep. |
| CMS pages and static blocks | Pages and theme sections | What staff need to edit without a developer. |
| Store views (languages, regions) | Shopify Markets | How the international URLs and hreflang work. |
| URL rewrites | URL redirects | Every rewrite with search value. |
The variant limit used to be a hard constraint. Shopify now allows up to 2,048 variants per product, up from 100, but the three-option limit still applies. A Magento configurable product with four configurable attributes needs a decision: split it, fold one attribute into the product name, or handle it with an options app.
Custom attributes are the other place data quietly disappears. A wine’s vintage, an oil’s harvest date, a product’s pairing notes: if the theme shows it on Magento, it needs a metafield on Shopify and a place in the template.
Stage 3: build the theme
The theme can be built while the data work runs. There are two common approaches. You can match the existing Magento design closely, so returning customers see the same store on a new platform. Or you can redesign as part of the move.
For the olive oil and wine brand, we customized a Shopify theme to match the existing Magento design, and used a page builder for content pages so the team could edit them without code. That kept the launch focused. A redesign at the same time adds decisions and makes it harder to tell, after launch, whether a change in results came from the platform or the design.
Whichever way you go, build the templates against real migrated data, not sample products. Long product names, missing images and odd attribute values show up immediately on real data and never on a demo.
Stage 4: rehearse the data migration on a staging store
The Magento data moves at least twice. First a test batch into a staging store, which the team reviews. Then the full import, close to launch, followed by a final delta of orders and customers created since.
Each data type has its own route:
- Products from Magento are exported, transformed to Shopify’s import format and loaded with a migration tool. On our project that was Excelify (now Matrixify), a bulk import app from the Shopify App Store. Check them against the source, down to images and metafields.
- Customer data comes across with names, addresses, tags and marketing consent. Their passwords can’t come across, because Magento stores them as one-way hashes.
- Order history imports so customers see past orders and your reporting stays whole.
- Reviews need mapping from Magento product IDs to Shopify products. On our project we matched them through a lookup table built from both exports before importing.
- Blog posts and CMS content move with their URLs recorded, so they can be redirected. That brand’s blog had run on WordPress inside Magento, and it moved into Shopify’s blog.
Checking is the part that gets skipped under deadline pressure, and it is where data loss hides. We compare record counts, then spot-check samples by hand: a product with many variants, a customer with a long order history, a review on a discontinued product. A spreadsheet that imported without errors has not been checked yet.
Stage 5: move payments and rewire integrations
Saved payment methods don’t live in Magento. They live with the payment processor. Moving them means a processor-to-processor transfer, arranged between the two processors and mapped back to the right customers. On our project, saved cards moved from Authorize.net to Stripe this way, with a mapping file that linked each old card record to its customer on the new platform. That matters most for anything that charges a stored card: subscriptions, membership clubs and repeat orders.
Integrations get rewired one at a time:
- Email. Flows tied to Magento events need Shopify triggers. Coupon code variables in templates change too. We updated those for Klaviyo after launch on our project, and it’s easy to miss because the flows keep sending.
- ERP, warehouse or 3PL. Order and inventory feeds need new connections and a test order through each. Our Shopify ERP integration work covers this side.
- The rest. Each tax, reviews, search or analytics service needs its Shopify version installed and checked against real orders.
Promotions get rebuilt, not migrated. Cart price rules don’t export to Shopify discounts. We recreated the brand’s active promotions on Shopify before launch, starting with the ones customers would hit in the first week.
Stage 6: redirect every URL and cut over
Magento URLs look nothing like Shopify’s. Product URLs usually end in .html, sometimes with the category in the path. Magento 1 also exposes raw system paths like /catalog/product/view/id/123. Shopify uses fixed prefixes with no suffix.
| Magento URL | Shopify URL |
|---|---|
/extra-virgin-olive-oil.html |
/products/extra-virgin-olive-oil |
/oils/extra-virgin-olive-oil.html |
/products/extra-virgin-olive-oil |
/oils/infused.html |
/collections/infused-oils |
/about-us |
/pages/about-us |
/blog/harvest-notes/ |
/blogs/news/harvest-notes |
The full list of old Magento URLs comes from the URL rewrite table, the sitemap, Search Console and backlink data. We merge them and remove duplicates. Existing Magento redirects get flattened, so every old URL reaches its Shopify page in one hop. Shopify imports redirects from a CSV file in the Shopify admin, and a redirect only fires when the old path doesn’t load a live page.
Clean up the redirects you inherited while you’re at it. When we first audited that brand’s Magento store, years before the move, it had more than a hundred temporary 302 redirects that should have been permanent 301s. A migration is the moment to fix that kind of debt, not to copy it.
Before cutover, titles, meta descriptions and structured data are checked on the staging store. On launch day the domain switches, checkout gets a final live test and the sitemap goes to Search Console. We also sent activation emails to existing customers and club members, so they knew to set up their new account before they needed it.
<figure class=“ar-fig”><svg viewBox=“0 0 640 320” role=“img” aria-labelledby=“m2s-time-t m2s-time-d”><title id=“m2s-time-t”>Magento to Shopify migration timeline</title><desc id=“m2s-time-d”>Four work tracks run across five phases: discover, build, rehearse, launch, settle. The Magento store sells through launch day. Theme and data work run in parallel during build and rehearse. Payments and integrations move during rehearse and launch. Redirects and search start in discover and continue after launch.</desc><g style=“font-size:13px;fill:var(–muted)”><text x=“150” y=“28” text-anchor=“middle”>Discover</text><text x=“250” y=“28” text-anchor=“middle”>Build</text><text x=“350” y=“28” text-anchor=“middle”>Rehearse</text><text x=“450” y=“28” text-anchor=“middle”>Launch</text><text x=“560” y=“28” text-anchor=“middle”>Settle</text></g><path d=“M100 40 V300 M200 40 V300 M300 40 V300 M400 40 V300 M500 40 V300” stroke=“var(–line)” stroke-width=“1”/><g style=“font-size:14px”><text x=“0” y=“76”>Magento</text><text x=“0” y=“132”>Theme</text><text x=“0” y=“188”>Data</text><text x=“0” y=“244”>Systems</text><text x=“0” y=“292”>Search</text></g><rect x=“100” y=“60” width=“350” height=“24” rx=“6” fill=“var(–ar-c0)”/><text x=“110” y=“77” style=“font-size:13px;fill:#fff”>keeps selling</text><rect x=“200” y=“116” width=“200” height=“24” rx=“6” fill=“var(–ar-c1)”/><text x=“210” y=“133” style=“font-size:13px;fill:#fff”>build on real data</text><rect x=“120” y=“172” width=“80” height=“24” rx=“6” fill=“var(–ar-c1)” opacity=“0.55”/><rect x=“200” y=“172” width=“250” height=“24” rx=“6” fill=“var(–ar-c1)”/><text x=“210” y=“189” style=“font-size:13px;fill:#fff”>map, test batch, full import</text><rect x=“300” y=“228” width=“160” height=“24” rx=“6” fill=“var(–ar-c2)”/><text x=“310” y=“245” style=“font-size:13px;fill:#fff”>payments, feeds</text><rect x=“120” y=“276” width=“500” height=“24” rx=“6” fill=“var(–ar-c3)”/><text x=“130” y=“293” style=“font-size:13px;fill:#fff”>baseline, redirect map, then watch</text><path d=“M450 46 V306” stroke=“var(–ink)” stroke-width=“2” stroke-dasharray=“5 4”/><text x=“456” y=“52” style=“font-size:12px;fill:var(–ink)”>cutover</text></svg><figcaption>The tracks overlap on purpose. Search work starts before any data moves and ends weeks after launch. Durations depend on catalog size and how much custom logic the Magento store carries.</figcaption></figure>
After launch: the first eight weeks
The work doesn’t stop at cutover. In the weeks after, we crawl the old URL list to confirm every redirect, watch the 404 and indexing reports in Search Console, and compare traffic on key pages to the weeks before launch. Some movement is normal while search engines recrawl. Drops that don’t recover usually point to a specific mapping error or missing content, and they can be found and fixed.
Expect a queue of small fixes too: an email template still pointing at an old coupon variable, a collection image missing on mobile, a low-stock notification nobody rebuilt. On our project these were launch-week tasks, handled while the store was live. Then the work turned into running the store, which for that brand now covers subscriptions, the club, wholesale, the ranch shops’ registers and the inventory system.
A Magento to Shopify migration checklist
Use this to check a plan, ours or anyone’s. Each line should have a name next to it before work starts.
| Check | Stage | Done when |
|---|---|---|
| Every extension and custom module has an outcome | 1 | Native, app, theme or retired, in writing |
| SEO baseline exported | 1 | Top pages, their titles and descriptions, backlink targets saved |
| Attributes mapped to metafields | 2 | Each customer-facing field has a home in the Shopify theme |
| Test batch reviewed on staging | 4 | Counts match and the team has signed off on samples |
| Saved cards and subscriptions planned | 5 | Processor transfer scheduled with the subscription app |
| Every integration tested | 5 | A real order has gone through each feed |
| Redirect map complete | 6 | Every old URL answers with one 301 to a live page |
| Customer launch email ready | 6 | Explains the new sign-in before anyone needs it |
The same list works for a Magento 2 to Shopify Plus move and a Magento 1 store that has waited too long. The volume changes. The checks don’t.
Questions brands ask before a Magento to Shopify migration
How long does a Magento to Shopify migration take?
Our replatforming projects typically run 8 to 14 weeks for a straightforward store, longer with more custom logic. The olive oil and wine brand, with a membership club, stored cards, compliance rules and several integrations, launched in under eight months. The replatforming check gives a ballpark for a store your size.
Magento to Shopify or Shopify Plus?
It depends on what the store needs, not its size alone. Plus adds built-in B2B (company accounts, price lists, payment terms), more control over checkout, and expansion stores for other regions or brands. A Magento store with wholesale customers, complex checkout rules or several regions usually makes a Magento to Shopify Plus move. A simpler store often doesn’t need it.
Will we lose SEO moving from Magento to Shopify?
Some movement is normal after any move. Lasting losses come from missed redirects, dropped titles and descriptions, or thinner pages. A complete redirect map, content carried across unchanged and weeks of Search Console monitoring prevent most of it. No one can promise rankings. We can promise a map with no missing pages.
What happens to our Magento extensions?
Each one gets a decision. Many become Shopify apps or native features. Some become theme code. Some stop, because Shopify already does the job or nobody uses it. The extension list is one of the first things we review.
Do customers have to reset their passwords?
Passwords can’t move from Magento to any platform, because they’re stored as one-way hashes. Shopify’s newer customer accounts sign in with a one-time email code instead of a password. Either way, send customers a clear note at launch.
Should we use a Magento to Shopify migration service or a migration app?
A migration app moves records. They don’t audit extensions, decide what happens to a custom checkout rule, move stored cards between processors or build a redirect map from your search data. For a small, simple catalog, an app and a careful checklist can work. For a store with years of customization, the planning is most of the job.
Bring us your extension list
If you are planning to migrate from Magento to Shopify, the most useful first step is the list from Stage 1: every extension and integration, and every checkout rule your store runs. Run your store through the replatforming check, read how our replatforming service runs, or talk to #10. We’ll tell you what we’d move first and what we’d leave behind.
