How to Import Products to Shopify (CSV and No-Code Methods)

TL;DR

There are two practical ways to import products to Shopify: the native CSV import (free, but it mangles variants and drops metafields at scale) and a no-code import via an app like Apimio (which maps any supplier format, preserves variants/images/metafields, and keeps the catalog in sync afterwards). This guide covers both, step by step, and when to use each.

The two ways to import products to Shopify

Whether you’re launching a store, onboarding a supplier, or migrating a catalog, importing products to Shopify comes down to two practical methods. The first is Shopify’s built-in CSV import — free, available to every store, and fine for a small, simple catalog. The second is a no-code import through an app or catalog tool like Apimio, which matters once your catalog has real variants, metafields, or supplier feeds that don’t arrive in Shopify’s exact format. This guide walks through both, shows where the native method breaks, and helps you pick the right one.

The reason the choice matters: importing isn’t a one-time event. Products get re-imported when suppliers update prices, when you add a range, or when you launch a second store. A method that’s painful to repeat — or that loses data each time — turns a routine task into a recurring problem.

It also helps to be honest about scale up front, because the right method depends entirely on it. If you sell 30 hand-made products and rarely change them, native CSV is genuinely all you need, and reaching for anything heavier is over-engineering. But if you carry hundreds or thousands of SKUs, onboard suppliers regularly, run complex variants, or operate more than one store, the import method becomes a structural decision — it determines how much of your team’s week is spent moving data around versus selling. The mistake most growing brands make is sticking with native CSV well past the point where it fits, because it worked fine at 30 products and the pain crept up gradually. The two methods below aren’t competitors so much as the right tool at two different stages, and knowing which stage you’re in saves a lot of wasted effort.

Method 1: Shopify’s native CSV import

Shopify accepts a CSV file with a fixed column structure. Each row is a product (or a variant of one), and columns map to fields like Title, Body (HTML), Vendor, Variant Price, Variant SKU, and image src. The steps:

1. In Shopify admin, go to Products → Import.
2. Download Shopify’s sample CSV to see the exact column headers and order it expects.
3. Format your product data to match — one row per variant, with the handle column tying a product’s variants together.
4. Upload the file (there’s a file-size limit, so very large catalogs must be split).
5. Review the preview, then import — Shopify processes the rows and reports errors per row.

For a few dozen simple products, this works. The friction starts the moment your data doesn’t already look exactly like Shopify’s template — which, for most real catalogs and every supplier feed, it doesn’t.

Where native CSV import breaks at scale

CSV import is deceptively limited once products get complex:

• Variants are fiddly — a furniture product with finish × size × material can have dozens of rows tied by a handle; one wrong handle and the variants split into separate products.
• Metafields don’t come through — specs, materials, ingredients, and SEO data either need a separate import or are dropped entirely.
• Images detach — image-to-variant mapping (the colour-to-photo link a fashion catalog needs) is easy to break.
• Supplier files never match — every supplier sends a different column layout, so you reformat each one to Shopify’s template by hand.
• No sync — a CSV import is a one-time dump; when the supplier updates prices next month, you do the whole thing again.
• Error-prone at volume — a 10,000-row file with a few malformed cells fails partway, and finding the bad rows is painful.

This is why teams that start with CSV usually outgrow it: the file format that makes import “simple” is the same thing that makes it fragile.

Method 2: No-code import with Apimio

The no-code route removes the “reformat to Shopify’s template” step entirely. Instead of forcing your data into a fixed CSV, you bring your data as-is and map it once:

1. Install Apimio from the Shopify App Store — OAuth connects in about 30 seconds.
2. Upload your product file in whatever format it arrives (supplier spreadsheet, export, etc.).
3. Let Apimio’s AI column mapping match your columns to the right fields — title, price, variant options, metafields — and save the mapping as a reusable template per supplier.
4. Review and clean the data in Catalog Hub (fix gaps, standardise attributes) before it touches your store.
5. Publish to Shopify — products, variants, images, and metafields are created cleanly, and stay in sync going forward.

Because the mapping is saved per supplier, the second import — and every one after — is a near-instant repeat instead of a fresh reformatting job.

CSV vs API vs no-code: which to use

Rule of thumb: a handful of simple products, native CSV is fine; recurring supplier imports or complex catalogs, a no-code tool pays for itself fast; a bespoke integration only makes sense with engineering capacity and high volume.

Importing from suppliers (the real-world case)

Most import pain isn’t launching a store — it’s onboarding suppliers, because every supplier sends data differently. A furniture retailer might receive one supplier’s catalog as a 40-column spreadsheet with dimensions in centimetres and another’s as a flat export with no variant structure at all. A fashion brand gets size-and-colour matrices that don’t line up with Shopify’s variant model. A beauty retailer receives ingredient and compliance data in free-text columns. Native CSV makes each of these a manual reformatting project; Apimio’s Supplier Bridge maps each supplier once and reuses the template, turning a two-day reformatting ritual into a ten-minute task.

Related reading: the Shopify CSV file format reference, and how to import a supplier CSV fast.

Preparing your product data before import

Most failed imports fail in preparation, not upload. Whichever method you use, a few data fundamentals decide whether the import is clean:

• Handles — the handle is the unique key that groups a product’s variants. Every variant row of one product must share the same handle, or Shopify splits them into separate products. This is the single most common cause of “my variants imported as separate products.”
• Variant options — Shopify allows up to three option dimensions (e.g. size, colour, material). A furniture product with finish × size × material is right at that limit, and a fourth dimension simply won’t map — you have to model it differently.
• Images — image rows reference a URL and an optional variant. Getting the colour-to-image link right matters for fashion and décor; a missing variant reference dumps every image onto the product instead of the right variant.
• Inventory and pricing — inventory quantity, price, and compare-at price are per-variant; mixing units or leaving them blank produces silent errors.
• Required vs optional columns — Title and handle are essential; many others are optional but, once omitted, are easy to forget to backfill later (metafields especially).

The reason a no-code importer helps here is that it validates this structure for you — flagging a furniture catalog’s missing dimensions or a fashion file’s broken size matrix before anything reaches the live store, rather than after a customer sees a half-imported product.

Common Shopify CSV import errors (and how to fix them)

When native CSV import goes wrong, it tends to fail in recognisable ways:

• “Variants imported as separate products” — almost always inconsistent handles. Fix: ensure every variant row of a product shares one handle.
• “Images missing or on the wrong variant” — the image-variant reference is blank or mismatched. Fix: set the variant image column correctly per row.
• “Some rows skipped” — malformed cells (bad characters, wrong number format, missing required fields). Fix: read the per-row error report and correct those rows.
• “File too large” — the catalog exceeds Shopify’s import file-size limit. Fix: split into multiple files, which then have to be tracked separately.
• “Metafields didn’t import” — basic CSV doesn’t carry custom data. Fix: a separate metafield import, or a tool that handles them natively.
• “Prices look wrong after a re-import” — a fresh CSV overwrote edits made in Shopify. Fix: treat one system as the source of truth instead of importing over live data.

Each of these is survivable once or twice. The problem is that with native CSV you re-encounter them on every import, because nothing remembers how your data should be shaped. A tool that saves the mapping turns these one-time fixes into permanent ones.

What happens after import: keeping products current

Importing is the start, not the end. A catalog is a living thing — suppliers change prices, you add ranges, descriptions get corrected, stock moves. The weakness of a one-time CSV import is that it captures a single moment; the next change means another manual import, with all the same risks. This is where the difference between “importing products” and “managing a catalog” shows up.

With a source of truth, the import is the on-ramp to ongoing sync. Once products live in Catalog Hub, supplier updates flow in through saved mappings, edits are made once, and changes publish to your store (or stores) automatically. A furniture retailer onboarding ten suppliers doesn’t do ten imports and then ten more next quarter — it maps each supplier once and the catalog stays current. A beauty brand correcting an ingredient list does it in one place, not in a re-uploaded file. The import stops being a recurring chore and becomes a pipeline that maintains itself.

That shift — from repeated manual dumps to a maintained pipeline — is the real reason to think beyond native CSV the moment your catalog or supplier count grows. The import method you choose isn’t just about today’s upload; it’s about whether next month’s update is a click or a project.

Migrating an existing catalog to Shopify

Importing also covers the bigger case: moving a whole catalog onto Shopify from another platform or a legacy system. Migration raises the stakes, because you’re not adding a few products — you’re bringing across years of accumulated data, often messy, with variants, images, categories, and custom fields that don’t map one-to-one to Shopify’s model. A native CSV migration of a large catalog is where the cracks become chasms: handle collisions, lost metafields, broken image links, and split variants, multiplied across thousands of products.

The cleaner path is to stage the catalog in a source of truth first, fix the structure there, and then publish to Shopify. That lets you reconcile inconsistent data (three spellings of “oak,” missing dimensions, free-text ingredient lists) before it lands on the live store, and it gives you a clean base to run the store from afterwards. A furniture brand migrating from a legacy ERP-driven store, or a fashion label consolidating two catalogs into one, gets a complete, correct Shopify catalog instead of a half-broken import they spend the next quarter repairing — and they come out the other side with the catalog already centralised for ongoing management.

How AI column mapping changes supplier imports

The slowest part of any supplier import is matching their columns to your fields — deciding that their “Item Description (Long)” is your body content, their “UPC” is your barcode, their “Colour/Color/Colour Name” is one variant option. Done by hand, this is the two-day reformatting job every supplier triggers. AI column mapping does this matching automatically: it reads the incoming columns, proposes the right field for each, and learns the mapping so the next file from that supplier maps itself. For a retailer onboarding many suppliers — a home-décor store with dozens of artisan vendors, say — this is the difference between supplier onboarding being a bottleneck and being a background task. It’s also what makes recurring imports sustainable: the supplier’s monthly price file flows in through the saved mapping with no manual touch, so your catalog stays current without anyone re-doing the work.

Best practices for importing products to Shopify

• Match Shopify’s exact column headers if you use native CSV — start from its sample file.
• Keep one row per variant and a consistent handle so variants stay grouped.
• Import metafields deliberately — don’t assume they carry over with a basic CSV.
• Clean and standardise data before import, not after it’s live.
• Save per-supplier mappings so re-imports are fast and consistent.
• For recurring imports, choose a method that stays in sync rather than a one-time dump.

Frequently asked questions

How do I import products to Shopify?

Two ways: Shopify’s native CSV import (Products → Import, with a file matching Shopify’s template) for small simple catalogs, or a no-code app like Apimio that maps any format and preserves variants, images, and metafields for complex or supplier-driven imports.

How do I import products to Shopify in bulk?

For bulk, native CSV works up to the file-size limit but is fragile with variants and metafields. Apimio imports bulk catalogs from any source format, preserves the full product structure, and keeps them in sync.

What is the best way to import a product CSV to Shopify?

Start from Shopify’s sample CSV and match its columns exactly, one row per variant. If your data doesn’t already match that template — or you import from suppliers regularly — a no-code tool that maps your format is faster and safer.

CSV import or API — which should I use?

CSV for small, occasional imports; a custom API integration only if you have engineering capacity and high volume; a no-code tool like Apimio for recurring supplier imports and complex catalogs without writing code.

Will my variants and metafields survive the import?

With native CSV, often not cleanly. With Apimio, variants, images, and metafields are preserved because your data is mapped to the right fields rather than flattened into a template.