How to Import Products Into a Shopify Store: 9 Methods We Use on Real Migrations

A Croatian shelving retailer landed on our desk with a catalogue that lived in downloadable PDF spec sheets and a phone number. Every sale started with a customer calling to ask whether a given shelf could hold 120 kilos and fit a two-metre wall. Before we could rebuild any of that as a proper storefront, we had to solve the boring problem underneath it: how to import products into a Shopify store when the products are defined by numbers, dimensions, load capacity, total system weight, and none of it is written down in a way a computer can read. That client was Metalne Police, and getting their catalogue into Shopify cleanly is the reason the rest of the project worked at all.

We have done this dozens of times now across Shopify, WooCommerce, Shopware and nopCommerce builds, and the product import is where most migrations quietly go wrong. Not with a crash, but with 4,000 products that look almost right and are subtly broken: wrong variant grouping, images that never attached, prices with the wrong VAT flag. This article is the ranked list of methods we actually reach for, when each one is the right call, and where each one bites you.

TL;DR

• START WITH THE CSV, NOT THE APP: For most stores under a few thousand SKUs, a well-structured Shopify product CSV is faster, cheaper and more predictable than a migration app, and it forces you to look at your own data. We reach for apps only when the source system or volume makes CSV genuinely impractical.
• THE HARD PART IS NEVER THE UPLOAD: Importing products into a Shopify store is a data-modelling problem wearing an upload button. Variants, metafields, images and tax flags are where projects run over, and no tool fixes a catalogue you have not decided how to structure first.
• SPECS ARE THE INTERFACE: For spec-driven catalogues (industrial, B2B, PPE), the way you import product data determines the entire shopping experience. Get the metafields right on import and the product page sells itself. Get them wrong and you are back to phone calls.

Quick Comparison

#	Method	Primary Value	Setup Effort	Expected Impact
1	Native Shopify CSV import	Predictable, free, full control	Medium	High for <2k SKUs
2	Structured metafields on import	Turns specs into a buying interface	Medium-High	Very high for spec catalogues
3	Migration apps (Matrixify)	Handles scale and complex data	Low-Medium	High for large/messy catalogues
4	Store-to-store copy apps	Fast Shopify-to-Shopify moves	Low	Medium
5	Admin API / custom import	Automation and edge cases	High	High for 10k+ or recurring
6	ERP / XML feed integration	Keeps catalogue in sync, not just imported	High	Very high for B2B
7	Image and media handling	Prevents the most common silent failure	Medium	High (avoids rework)
8	Staged import with a sandbox	De-risks large migrations	Medium	High for launch safety
9	Post-import QA and reconciliation	Catches what every method misses	Medium	Essential, not optional

We ordered this list by the impact we have seen in client work, strongest first, with one adjustment: the CSV sits at number one not because it is the most powerful method but because it is the one most people should use and most people skip straight past toward an app that does more than they need.

1. Native Shopify CSV Import

When Metalne Police came to us, the catalogue was not enormous, a few hundred shelving systems and their variants, but it was messy in the way industrial catalogues always are: the same shelf sold in six heights, load capacity stated per shelf and per system, and half the dimensions living only in PDFs. The first thing we check when a store like this comes in is whether the whole catalogue can be reduced to a clean spreadsheet a human can read top to bottom. For them it could, so we used the native Shopify CSV import rather than reaching for an app.

We hold a firm position here that a thoughtful competitor could disagree with: for most stores under roughly two thousand SKUs, the CSV is the right tool, and jumping straight to a migration app is a mistake because it lets you avoid the one task that actually matters, deciding how your data is structured. The spreadsheet forces that decision. An app lets you push your existing mess into a new box and discover the mess later, in production.

Key Steps:

• Map your columns first: Match every source field to Shopify’s Handle, Title, Option1 Name, Variant Price and so on before touching the importer.
• Fix variants in the sheet: Each variant is its own row sharing a Handle; get this wrong and Shopify creates duplicate products, which we have watched happen live.
• Set the Published flag deliberately: Import as unpublished so nothing goes live until QA passes.
• Handle images with full URLs: Every image needs a reachable public URL in the Image Src column, one row per additional image.
• Import in a test batch of ten: Never run the full file first; validate the shape on a handful of products.

Advantages:

• Free and built in, no third-party billing or data access to approve.
• Fully transparent: you can read every value before it lands.
• Forces catalogue decisions early, when they are cheap to change.
• Repeatable: re-importing to correct a field is trivial.

Limitations:

• Metafields are painful in the native importer; complex spec data often needs a supporting method.
• No rollback: a bad import means manual cleanup or a full product deletion.
• Falls apart past a few thousand rows or with deeply nested variant logic, which is exactly where we hit its ceiling on larger jobs.

Complexity: Medium. Best For: catalogues under 2k SKUs with clean-ish source data. Result: for Metalne Police, the clean CSV import was the foundation of a rebuild that increased conversions by 18% compared to their previous setup. We wrote up the mechanics of moving a mid-sized catalogue this way in our guide on importing 500 products via CSV.

2. Structured Metafields: Turning Specs Into a Buying Interface

This is where the Metalne Police project actually earned its outcome, and it is the method most import guides ignore entirely. Their customers do not buy “a shelf,” they buy load capacity and fit. So importing the products was only half the job; the other half was importing the specifications as structured metafields, height in millimetres, load per shelf in kilograms, total system weight, so we could build browse-by-space and filter-by-capacity directly into the storefront. Treat specifications as the interface, and answer the fit-and-capacity question on the product page itself, and the phone stops ringing.

A client on that project asked us directly: “why can’t we just put the spec sheet PDF back on the page like before?” The honest answer is that a PDF is a dead end for both the customer and Google. A visitor with a PDF still has to do the mental math of whether it fits their garage. A metafield-driven page does that math in the interface, and it is filterable and indexable. That single decision, specs as data not attachments, is the through-line across three of our industrial builds.

Key Features:

• Define your metafield schema first: Decide the exact fields and units before import; changing units later means re-importing everything.
• Use a metafield-aware importer: The native CSV supports metafield columns with a specific header syntax, but complex sets are far easier via Matrixify or the API.
• Attach metafields to a taxonomy: Group products by use case (garage, warehouse, workshop) so the catalogue browses the way buyers think.
• Expose metafields in theme and filters: Import is wasted if the theme never surfaces the data on the page and in collection filters.

Advantages:

• Turns raw specs into a self-serve buying experience, no contact required.
• Filterable and SEO-friendly in a way PDFs never are.
• Reusable across collection pages, comparison views and search.

Limitations:

• Schema mistakes are expensive: we once mixed centimetres and millimetres across a source file and had to re-import the affected products.
• Native CSV metafield handling is fiddly; large sets push you toward a paid tool.

Complexity: Medium-High. Best For: any catalogue bought on numbers, industrial, B2B, technical goods. Result: this approach is what let a first-time Metalne Police visitor go from “I need shelves for my garage” to a completed order with no phone call.

3. Migration Apps for Scale and Messy Data

We do not always start with a CSV. When a client came to us wanting to move a large, tag-heavy catalogue off BigCommerce with orders and customer records attached, the native CSV was the wrong tool and we said so. The trade-off is real: apps like Matrixify and Cart2Cart cost money and want broad access to your store data, but they handle the things the native importer chokes on, thousands of products, metafields at scale, and the collateral data (orders, redirects) that a real migration carries.

Our rule of thumb from scoping: below about two thousand clean SKUs, CSV; above that, or with orders and customers in scope, an app. We laid out exactly how we weigh this on the BigCommerce path in our breakdown of CSV versus app migration, and the logic holds for most source platforms.

Key Steps:

• Confirm what the app can and cannot map: Not every field survives; get the gaps in writing before you buy.
• Run a partial export first: Migrate a subset, inspect it, then commit to the full run.
• Preserve URLs with redirects: A migration app that skips 301 redirects will quietly tank your organic traffic.
• Reconcile counts after each run: Products in should equal products out; investigate every discrepancy.

Advantages:

• Handles volume and complex data types the native importer cannot.
• Migrates orders, customers and metafields in one pass.
• Excel-based re-import (Matrixify) makes bulk edits genuinely fast.

Limitations:

• Ongoing or per-migration cost, and broad data access to approve.
• Still needs a human to define structure; the app will faithfully migrate a bad decision.

Complexity: Low-Medium. Best For: 2k+ SKUs, or any migration carrying orders and customers. Estimate: in our scoping, an app-based migration of a mid-sized store with orders usually lands at two to four weeks of work once source data is clean, most of it in mapping and QA, not the upload itself.

4. Copying Products From Another Shopify Store

“Can I import products from another Shopify store?” is one of the most common questions clients ask, usually because they are spinning up a second regional store or splitting a brand. Yes, and there are two clean ways to do it. You can export the source store to CSV and re-import (free, and it strips you back to core fields), or use a store-copy app that preserves metafields and media in one step.

We generally recommend the CSV round-trip when the target store is a fresh, deliberately different catalogue, and the copy app when you genuinely want a mirror. The trap we have seen: teams copy store to store expecting a perfect clone, then discover that app-installed data, subscription contracts, and store-specific metaobjects do not travel. Products travel; the ecosystem around them often does not.

Key Steps:

• Export from the source as CSV: Use the built-in product export as your baseline transfer file.
• Decide mirror versus fork: A mirror wants a copy app; a fork wants a trimmed CSV.
• Re-check pricing and currency: Regional stores almost always need price and tax adjustments the copy will not make for you.
• Rebuild collections and navigation: Smart collection rules do not always survive a store-to-store move.

Advantages:

• Fast for launching regional or sister stores.
• CSV route is free and gives you a clean data baseline.
• Copy apps preserve media and metafields the native export drops.

Limitations:

• App data, subscriptions and metaobjects do not reliably transfer.
• A “clone” still needs manual pricing, tax and navigation work per market.

Complexity: Low. Best For: launching a second or regional Shopify store from an existing one. Estimate: we typically budget two to five days for a store-to-store product copy including the pricing and tax adjustments the copy itself will not handle.

5. Admin API and Custom Import Scripts

Sometimes neither CSV nor an app fits, and we write code. This is the method we reach for when a catalogue is very large, when the source data needs transformation the tools cannot express, or when the import needs to run repeatedly on a schedule rather than once. The Shopify Admin API with its product and bulk-operation endpoints lets us build exactly the import the client’s data actually requires.

We built Ardon Adria’s storefront, a Croatian workwear and PPE supplier whose catalogue is defined by protection ratings, sizing and certification classes, as a custom ecommerce store with ERP and XML feed integrations precisely because their product data was never going to sit still in a spreadsheet. Certifications get reissued, sizing runs vary, stock moves. A one-time CSV would have been stale within a week. Same principle as Metalne Police, specs are the interface, but the delivery mechanism had to be programmatic.

Key Steps:

• Map source to Shopify’s data model in code: Handle transformation, unit conversion and variant grouping in the script, not by hand.
• Respect rate limits: The API throttles; batch and back off or your import stalls halfway.
• Make it idempotent: Re-running the script should update, not duplicate; key everything on a stable SKU or external ID.
• Log every write: When something breaks at product 4,102, you want the log to tell you which one and why.

Advantages:

• Handles arbitrary volume and any transformation logic you can code.
• Repeatable and schedulable for feeds that change over time.
• Full control over variants, metafields and media placement.

Limitations:

• Requires developer time and ongoing maintenance as APIs version.
• Overkill for a one-time import of a small, clean catalogue.

Complexity: High. Best For: 10k+ SKUs, complex transformations, or recurring imports. Result: for Ardon Adria this approach delivered a custom Shopify store with ERP and XML feed integrations that a static import could never have kept current. Our note on systematic debugging is basically the discipline we apply when one of these scripts fails at scale.

Our clients are usually old school and they need a very straightforward and easy way of online shopping. Presta delivered exactly that!

Get Your Catalogue Into Shopify Without the Quiet Disasters

If you are staring at a source catalogue and are not sure whether it is a CSV job or an ERP integration, that judgement is most of the value we bring. Presta builds and migrates stores on Shopify, WooCommerce and Shopware, and we handle the ugly middle layer, ERP and feed integrations, variant restructuring, metafield schemas, that decides whether an import lands clean or leaves you cleaning up for months. This is worth it if your catalogue is large, spec-driven, or connected to an ERP; it is honestly not worth it if you have 200 tidy products and an afternoon, in which case the native CSV and this article are all you need. If you are in the first camp, talk to our ecommerce team.

6. ERP and XML Feed Integration

For B2B and industrial clients, “importing products” is the wrong mental model. The product data is not a file you load once; it is a feed that has to stay in sync with the system that owns the truth, usually an ERP. This is the highest-effort method on the list and, for the right client, the highest-impact.

The clearest case in our portfolio is Ludendorff, a German building-supplies house in Darmstadt founded in 1924, carrying roughly 1.2 million articles from over 400 manufacturers across sanitation, heating, solar and tools. They publish product data in DATANORM so tradespeople can pull it straight into their own estimating software. We built their store on Shopware, and the honest framing is that catalogue scale is the whole problem: a storefront at that size is a data-interchange project wearing an ecommerce hat. You do not import 1.2 million articles; you plumb a pipeline and let it flow.

Key Features:

• Establish the system of record: The ERP owns price, stock and spec; the store reflects it, never the reverse.
• Choose the feed format deliberately: DATANORM, XML or a direct ERP connector each carry different fields and cadences.
• Sync on a schedule with deltas: Push only what changed; full re-syncs at that scale are impractical.
• Reconcile continuously: A feed that silently drops a category is worse than one that fails loudly.

Advantages:

• Catalogue stays accurate without manual re-imports.
• Scales to hundreds of thousands or millions of articles.
• Serves both storefront browsing and B2B data-export needs from one source.

Limitations:

• Highest build and maintenance cost of any method here.
• Feed and format edge cases (encoding, missing fields) surface constantly and need monitoring.

Complexity: High. Best For: B2B catalogues tied to an ERP, especially in DACH. Result: Ludendorff’s Shopware store with ERP integration increased their revenue by 80%. This is also the multi-platform commerce work that sits behind how we think about running catalogues across systems.

7. Image and Media Handling: The Silent Failure

Ask us where a product import breaks most often and the answer is not variants or tax, it is images. Every method above will happily import a product with a broken image link and report success. The customer then lands on a page with a grey placeholder, and nobody notices until conversions dip. On the Metalne Police catalogue we specifically staged image handling as its own step because industrial product photos came from mixed sources at wildly different resolutions.

The rule we enforce: images need reachable public URLs at import time, and you validate that they actually loaded, not that the import “succeeded.” A 200 status on the import row is not proof the image attached.

Key Steps:

• Stage images at a public URL first: Host them somewhere reachable before the import runs, not on a laptop.
• Order images with position values: The first image is the thumbnail everywhere; set it deliberately.
• Match alt text to the spec: For spec-driven products, alt text carries dimensions and load, useful for both accessibility and search.
• Spot-check rendered pages, not import logs: Open twenty live product pages and look.

Advantages:

• Prevents the single most common post-import complaint.
• Alt text tied to specs supports both SEO and accessibility.
• Correct image order fixes thumbnails across the whole store at once.

Limitations:

• Requires a hosting or staging step the tools do not do for you.
• Large image sets slow imports and can hit CDN processing lags.

Complexity: Medium. Best For: every import, no exceptions. Estimate: from past projects, we budget roughly a day of media QA per few hundred products with mixed-source imagery.

8. Staged Import With a Development Store

We do not run large product imports against a live store, ever, after learning the hard way. On an early migration we imported into production to “save time” and spent the next week untangling duplicate products in front of real traffic. Now every non-trivial import runs first against a Shopify development store or a fresh sandbox, and only the validated output touches production.

This is also where we tell clients the uncomfortable truth about timelines. We once scoped a migration at three weeks and it took five, entirely because the source data was dirtier than the sample export suggested. The sandbox is where you discover that, cheaply, instead of in production.

Key Steps:

• Import to a dev store first: Validate structure, variants and media away from customers.
• Diff against the source: Compare counts and spot-check fields between source and sandbox.
• Freeze the source catalogue during cutover: Stop edits on the old system so nothing drifts mid-migration.
• Promote only validated data: Move the checked output to production; do not re-run the raw import.

Advantages:

• Catches structural and data errors before customers see them.
• Lets you rehearse the full import end to end.
• Makes timeline surprises visible early, when they are still cheap.

Limitations:

• Adds a step and some setup time to the schedule.
• A dev store does not perfectly mirror production apps and theme behaviour.

Complexity: Medium. Best For: any import above a few hundred products or carrying orders. If you are running an old store in parallel during this, our guide on keeping a WooCommerce store live during migration covers the cutover mechanics in detail.

9. Post-Import QA and Reconciliation

No method on this list is complete at the moment of upload. The last step, and the one clients most want to skip, is reconciliation: proving that what is in Shopify matches what was supposed to be there. This is not optional polish; it is the difference between a migration that is done and one that merely appears done.

For Beberusha, a baby and childcare retailer whose Shopify store we tuned rather than rebuilt, the wins came almost entirely from getting existing product data and merchandising right, not from adding features. Tweaking that store, correct pricing, clean variants, proper collections, increased their revenue by 30% in the first month. That is the payoff of treating product data as something you verify, not something you dump.

Key Steps:

• Reconcile counts by type: Products, variants and images in Shopify should match the source, category by category.
• Audit pricing and tax flags: The ERP export we once received had the wrong VAT flag on a whole category; catch this before customers do.
• Test the full buy path: Add to cart and checkout on a sample of imported products.
• Check collection membership: Confirm products land in the right collections and filters return them.
• Verify redirects: Every old product URL should 301 to its new home.

Advantages:

• Catches the errors every import method leaves behind.
• Protects pricing, tax and SEO in one pass.
• Turns a raw import into a store that actually sells.

Limitations:

• Time-consuming and unglamorous; the step teams most often cut.
• Needs someone who knows the catalogue to spot “that price is wrong.”

Complexity: Medium. Best For: every import. Result: Beberusha’s 30% first-month revenue lift came from exactly this kind of data-first tuning rather than new features.

The Specs-First Import Framework

Across every one of these engagements we run the same four-step framework, and it is deliberately not an acronym because we did not invent it, we just do it every time.

Decide the data model before you touch a tool: Define your variant structure, metafield schema and units first. This is the step that determines whether the import is easy or a nightmare.

Choose the method by scale and change frequency: A one-time small catalogue is CSV; a large one is an app; a spec catalogue that changes is an API or ERP feed. Match the mechanism to the data’s behaviour, not to what looks impressive.

Import to a sandbox and reconcile: Run it where customers cannot see it, diff against source, fix, repeat until counts and spot-checks pass.

Promote and verify live: Move validated data to production, then re-test the buy path and redirects on real pages, not import logs.

Measuring Success: 30 / 60 / 90 Day KPIs

A product import is a means, not an end, so we measure it by what happens to the store afterward. Here is how we frame outcomes for clients, anchored to what we actually saw.

Window	What We Measure	What Good Looks Like
30 days	Data integrity: broken pages, missing images, wrong prices; and early conversion signal	Zero broken product pages; conversion holding or rising. Beberusha hit +30% revenue in month one from clean data alone.
60 days	Self-serve completion: sessions reaching checkout without support contact; filter and search usage	Fewer spec-question support tickets; filters getting used. For Metalne Police this is the “garage shelves to order, no phone call” path working.
90 days	Conversion and revenue against the old baseline	Metalne Police: +18% conversions vs the previous setup. Ludendorff: +80% revenue with the ERP-fed catalogue live and stable.

The 30-day window is deliberately about not-breaking, because a beautiful new store with wrong prices loses money faster than the old one did. Only once integrity is proven do we start reading the conversion signal as real.

Where to Start

We closed the loop on Metalne Police the way we hoped to: a shelving retailer whose customers used to phone in to ask about load capacity now sends first-time visitors from “I need shelves for my garage” to a completed EUR checkout with nobody in the loop, and conversions rose 18% against the old setup. The lesson we carry out of that project into every import since is that the upload is trivial and the data model is everything. Heavy products did not need a heavy platform; they needed their specifications treated as the interface.

If you are just getting started with a fresh catalogue, prioritise the data model and a clean CSV before you evaluate a single app; you will make better tool decisions once your own data is legible. If you are auditing something that already exists, start at method nine, reconciliation, and work backward: pull a count of products, variants and images, spot-check pricing and tax, and open twenty live pages. The gaps you find will tell you what your next import actually needs to fix.

Next Steps:

• Export your current catalogue and reduce it to one clean spreadsheet you can read end to end.
• Decide your variant structure and metafield schema on paper before touching an importer.
• Run any import above a few hundred products against a development store first, and reconcile counts before going live.

Frequently Asked Questions

How do I import products into Shopify?

For most stores the answer is the native CSV importer. Export or build a spreadsheet that matches Shopify’s product template, with one row per variant sharing a Handle, prices, and full public image URLs. Import as unpublished, validate a batch of ten first, then run the rest and check the results on live pages rather than trusting the import log.

The step people skip, and the one that actually matters, is deciding your data structure before you open the importer. Variant grouping, units and metafields need to be settled in the sheet. If your catalogue is spec-driven, plan the metafields at the same time so the specs become filters and page content, not attachments.

What’s the best way to bulk import products to Shopify?

It depends on scale and how often the data changes, and here is the choice we make in the common cases. Under roughly two thousand clean SKUs with no orders in scope, the native CSV is the best route: free, transparent and repeatable. Above that, or when you are also moving orders and customers, a migration app like Matrixify is worth its cost because it handles metafields and collateral data the native importer cannot.

If the catalogue is very large or changes constantly, neither is right and you want the Admin API or an ERP feed, so the store stays in sync rather than importing once and going stale. The mistake is defaulting to the most powerful tool; match the method to how your data behaves.

Can I import products from another Shopify store?

Yes. Export the source store’s products to CSV and re-import into the target, which gives you a clean baseline of core fields, or use a store-copy app if you want media and metafields carried across in one step. Choose the CSV route when the new store is a deliberate fork with different pricing, and the copy app when you genuinely want a mirror.

Be aware that products travel but the ecosystem around them often does not. App-installed data, subscription contracts and store-specific metaobjects will not reliably come along, and regional stores always need pricing, tax and navigation adjustments the copy does not make for you.

How long does a product import or migration actually take?

The upload is fast; the surrounding work is not. In our scoping, a mid-sized app-based migration carrying orders usually lands at two to four weeks once the source data is clean, and most of that is mapping and QA. A store-to-store product copy we typically budget at two to five days including pricing and tax fixes.

The honest caveat: we once scoped a migration at three weeks and it took five because the source export was far dirtier than the sample suggested. Dirty source data is the single biggest timeline risk, which is why we validate against a real export early rather than trusting a clean-looking sample.

Why do my images or variants break after import?

Variants break when rows do not share a common Handle, which makes Shopify create duplicate products instead of one product with options. Images break when the Image Src URL is not publicly reachable at import time; the import can report success while the image never attaches. Both fail silently, which is why we insist on checking rendered pages, not logs.

Fixing them means correcting the source data and re-importing, so it pays to catch these in a sandbox. Reconcile variant counts and open a sample of live pages before you go anywhere near production.

When is it worth bringing in an agency like Presta for this?

Not every store needs us, and we will say so. If you have a few hundred tidy products and no ERP, the native CSV plus the framework in this article is genuinely all you need, and hiring anyone would be overkill.

It becomes worth bringing in a team when the catalogue is large, spec-driven, or tied to an ERP or feed, because at that point the import is really a data-interchange project. That is where mistakes get expensive and hard to reverse: a wrong VAT flag across a category, a botched variant model, a feed that silently drops products. We build and migrate on Shopify, WooCommerce and Shopware and handle the ERP and XML integration layer, so if your project looks more like Ludendorff or Ardon Adria than a 200-product boutique, that is the threshold. Our piece on why hiring an experienced agency pays off walks through how we think about that trade-off.

Do I need metafields, or are standard product fields enough?

If customers buy on numbers, dimensions, load capacity, protection class, sizing, you need metafields, because standard fields cannot carry structured specs in a filterable, page-usable way. This is the difference between a product page that answers the buyer’s question and one that makes them phone you.

If your products are simple and bought on brand or look rather than specs, standard fields are fine and metafields would be unnecessary complexity. The test is whether a customer needs to compare a number against their own requirement before buying; if they do, model that number as a metafield on import.

Should I import products before or after I build the theme?

Import to a development store early, even in rough form, so the theme is built against real data rather than placeholders. Themes that look perfect on demo products routinely fall apart on real ones: long titles wrap badly, missing specs leave gaps, variant-heavy products break layouts. Building against your actual catalogue surfaces those problems while they are cheap to fix.

That said, keep production clean until the theme and data are both validated. The sequence we run is import to sandbox, build and test against real products, reconcile, then promote validated data to production for launch.

Sources

• Shopify Help Center: Importing products with CSV
• Shopify Admin API documentation
• Matrixify (bulk import/export app)
• DATANORM data-interchange standard