Migration Site Magento vers Shopify: Le Guide Technique Complet pour Développeurs

Migrating a Magento store to Shopify is not a copy-paste operation. The core problem is an architectural mismatch: Magento stores product data in an Entity-Attribute-Value (EAV) relational schema spread across dozens of tables, while Shopify uses a flat object model built around Products, Variants, Metafields, and Metaobjects. Every hour of planning you do before touching a single row of data will save you three hours of post-launch firefighting.

Key takeaways

• Magento's EAV model is the single hardest part of the migration; map every attribute to a Shopify metafield or metaobject before the data transfer runs.
• Adobe Commerce 2.4.4 support ended in April 2026 and 2.4.5 in August 2026, leaving self-hosted stores exposed to real PCI compliance risk.
• Shopify's fixed /products/ and /collections/ URL structure will almost never match Magento's URL patterns, so a bulk 301 redirect map is non-negotiable.
• Magento Passwords do not migrate: different hashing algorithms mean customers must reset on first login.
• Shopify Scripts hit full end-of-life on 30 June 2026; any checkout logic must be rebuilt in Shopify Functions before you cut over.
• The Shopify Admin API v2023-07 sunset at the end of Q2 2026; new integrations should target the current stable version (2026-07 as of this writing).

Why developers are doing more of these migrations in 2026

The business case has crystallised quickly. Adobe Commerce 2.4.4 regular support ended in April 2026, and 2.4.5 in August 2026, leaving self-hosted merchants with live PCI compliance exposure. At the same time, Adobe's April 2026 push to consolidate Magento Open Source users into Adobe Commerce Cloud licensing is quietly making mid-market merchants check the exit door. There are still around 97,000 live Magento/Adobe Commerce stores globally according to BuiltWith data, down from roughly 250,000 five years ago, and the migration volume is accelerating: Shopping Cart Migration's March 2026 momentum report recorded a single Magento-to-Shopify transfer of 267,626 data entities in one month, with 46% of all migrations that month originating from stores eight or more years old.

On the destination side, Shopify Plus's Winter 2026 Edition shipped 150+ updates, including native B2B improvements that closed long-standing gaps that once kept complex merchants on Magento. Shopify's developer pool is now roughly five to ten times larger than Magento's by conservative estimates, with lower average day rates and faster hiring cycles.

The architectural gap you have to close: EAV to Shopify's object model

This is where 60% of migration time gets spent, and it is the part most merchants underestimate.

Magento's EAV schema scatters product data across tables like catalog_product_entity_varchar, _text, _decimal, and _datetime. Querying a single product with all its attributes requires joining multiple tables, which creates significant query overhead in legacy Magento 2 setups compared to Shopify's flat data architecture.

Shopify's object model has no EAV equivalent. Everything maps onto:

• Product and Variant core fields (title, vendor, price, SKU, weight)
• Metafield for simple custom attributes (a single value keyed by namespace + key)
• Metaobject for relational data (store locators, warranty structures, anything that needs its own entity with multiple fields)

The transformation rule is straightforward in principle:

1. Core attributes (title, price, vendor, SKU) go directly onto the product or variant object.
2. Variant-level differences (colour, size) become Shopify ProductOption entries and Variant records.
3. Custom flat attributes (material, care instructions, country of origin) become metafields in a custom namespace.
4. Relational attributes (multi-tier warranties, linked content blocks) become metaobjects.

Simple attributes like colour map cleanly to standard product metafields. However, complex relational data should be mapped to Shopify metaobjects to preserve relational integrity without cluttering the core product database. A word of caution from the field: if your catalog contains bundles with more than ten variants, attempting to use storefront cart-transform Shopify Functions can cause execution timeouts. In those cases, split the SKUs downstream in your ERP rather than trying to handle it all at the Shopify layer.

Here is the minimum GraphQL mutation to create a metafield definition before the data import runs:

mutation CreateMetafieldDefinition {
  metafieldDefinitionCreate(definition: {
    name: "Material"
    namespace: "product_specs"
    key: "material"
    type: "single_line_text_field"
    ownerType: PRODUCT
    visibleToStorefrontApi: true
  }) {
    createdDefinition {
      id
      name
    }
    userErrors {
      field
      message
    }
  }
}

Create all definitions first, then populate values in bulk. The GraphQL Bulk Operations API is the right tool for large catalogs: CSV imports cap at 15 MB per file, so stores with 10,000+ SKUs (the kind I work with regularly) need to go through bulkOperationRunMutation to stay within rate limits and keep the import traceable.

Concept mapping reference

Use this table before scoping the project. It tells you where the real complexity lives.

SEO: the part that kills revenue if you skip it

Shopify enforces a fixed URL structure. Products always live at /products/[handle] and collections at /collections/[handle]. Magento URLs typically follow a category-path pattern like /catalog/category/product-name.html or use custom URL rewrites configured per store. The two structures will almost never overlap.

The redirect rule: any URL with more than ten organic clicks in the trailing 90 days is a ranked asset that needs a 301 on day one of launch. Build your redirect map in a spreadsheet with three columns: old Magento URL, new Shopify URL, HTTP status (301 for permanent, 410 for pages you are intentionally retiring). Shopify's bulk redirect CSV import handles up to 10,000 redirects per file.

A few other SEO-specific items that consistently get missed:

• Hreflang on international stores. Shopify Markets (Markets Pro, released in 2024) supports subfolder localization natively, so you no longer need a third-party proxy for /de/ or /fr/. But map hreflang annotations carefully: any mismatch between canonical and hreflang targets will suppress international rankings.
• Layered navigation URLs. Magento's layered navigation creates filterable URLs like /category.html?color=49&size=91. Shopify uses collection filter parameters differently. Map each Magento attribute set to a corresponding Shopify metafield definition before the data migration runs, then configure the Search & Discovery app to surface them.
• Structured data. Migrate gtin, sku, brand, and aggregateRating from Magento product attributes to Shopify metafields, then reference those metafields in your theme's JSON-LD block. Google's rich results for products require at minimum price, priceCurrency, and availability.

For more on how Shopify handles duplicate URLs after a migration, see my reference on Shopify duplicate content.

Data that does and does not transfer cleanly

What migrates without major transformation:

• Product titles, descriptions, images, prices, SKUs, and weights
• Customer records (name, email, address, tags)
• Order history (importable via the GraphQL Admin API; important for loyalty program continuity)
• Blog posts and CMS pages (as Shopify pages and articles, though formatting will need cleanup)

What requires extra work:

• Passwords. Magento password hashes use a different algorithm than Shopify's. Customers will be prompted to reset on first login. Send a transactional email a week before launch explaining this; it prevents a support ticket spike on day one.
• Downloadable products. Shopify's free Digital Downloads app replaces Magento's downloadable product type, but the file links do not migrate. You re-upload each file after import.
• Page Builder content. Magento 2.4+ Page Builder stores content as pagebuilder_* XML tags inside cms_block and cms_page tables. There is no import path into Shopify. Budget for a rebuild.
• Magento customer groups become Shopify tags. Tag-driven pricing requires an app (Wholesale Club, Bold B2B) or Shopify Plus B2B Catalogs.

Checkout logic: Scripts are gone, Functions are the replacement

If you are migrating a Shopify Plus store that already used Shopify Scripts, note that Scripts hit full end-of-life on 30 June 2026 (frozen from editing on 15 April 2026). Any checkout customisation that lived in a Script must be rebuilt as a Shopify Function before you migrate.

Functions are deployed as part of a Shopify app (private or public) written in Rust or JavaScript. The migration path by use case:

• Discount Scripts become Discount Functions (order discounts, product discounts, shipping discounts).
• Shipping Scripts become Delivery Customization Functions.
• Payment Scripts become Payment Customization Functions.
• Cart Transform is a new capability with no Scripts equivalent: it lets you merge cart lines, expand bundles into component products, or transform cart line item properties before checkout begins.

For any Script that made external API calls to determine discount eligibility, you need to rearchitect: sync the external data to Shopify metafields first, then have the Function read from metafields rather than making async calls (Functions are synchronous and have strict execution time limits).

See also my broader breakdown of how Shopify Functions and the checkout extensibility model work.

Integration layer: ERP, 3PL, and ESP

Magento modules run as PHP inside the application itself. Shopify's extension model has no equivalent surface for that. Every custom module gets rebuilt as a Shopify app, swapped for an equivalent app from the App Store, or retired. This is where the project scope diverges most sharply by store: a catalog-only DTC brand might retire or swap 90% of modules, while an ERP-integrated B2B merchant could spend the majority of their budget here.

The current Shopify API stack to build against:

• GraphQL Admin API (2026-07) for products, orders, customers, inventory, and B2B objects. Admin API v2023 reached sunset at the end of Q2 2026; target 2026-07 for any new integration.
• GraphQL Bulk Operations for large catalog writes (products, metafields at scale).
• Webhooks with RSA signature validation (the RSA rollout landed in Q3 2026; update your signature verification logic if you are inheriting a legacy integration).
• Shopify Functions for checkout, discount, and cart transform logic that needs to execute at request time.

For middleware between Shopify and your ERP or 3PL, evaluate whether a direct integration exists in the App Store before building custom. Tools like Celigo or a lightweight custom middleware layer are common when a native connector does not exist.

Timeline and the verification checklist

A realistic timeline for a mid-market migration (fashion, lifestyle, beauty; single-region; moderate EAV complexity; one ERP integration):

• Weeks 1-3: Discovery and audit. Document every EAV attribute, every custom module, every integration endpoint. Build the metafield definition map and redirect spreadsheet before touching data.
• Weeks 4-7: Theme build or Liquid theme selection. Data migration dry run in a development store.
• Weeks 8-11: Integration rebuild (ERP connector, ESP, loyalty). Function rewrites for any checkout logic.
• Weeks 12-14: Full QA, redirect verification, performance testing, staging launch review.
• Week 15: Cutover. Domain pointed to Shopify, old Magento kept read-only for 30 days minimum. Sitemap submitted in Google Search Console on launch day. Post-launch crawl within 24 hours to verify redirect implementation on production.

Verification steps you should not skip:

• Crawl the Shopify store with Screaming Frog or Ahrefs and cross-reference against your redirect map. Any 404 that was previously a ranked page is lost revenue.
• Spot-check 50 random product records: compare EAV attribute values in the Magento database against the corresponding metafield values in Shopify via the Admin API. Automation errors tend to cluster in edge cases (null values, special characters, multi-select attributes).
• Trigger a test order end-to-end in staging before cutover. Confirm taxes, shipping rates, and payment methods resolve correctly for every market you serve.
• Verify that customer password reset emails send correctly and link to the Shopify account page, not the old Magento domain.

The migration is not done at launch. Keep a monitoring dashboard on organic traffic, 404 rate, and checkout conversion rate for at least 90 days post-launch. Ranking fluctuations are normal for four to six weeks; a sustained drop after that signals a redirect or structured data issue worth investigating.