Quick Answer
Product CSV import failures on Shopify and WooCommerce fall into five categories: encoding errors (non-UTF-8 encoding, BOM artifacts, smart/curly quotes), format structure errors (missing or mismatched Handle values, variant row displacement, case-sensitive header mismatches), scale failures (Shopify's 15MB file limit and 1,000-new-variants-per-24-hours limit), data validation errors (price rules, invalid field types, required field gaps), and platform-specific quirks (image URL row position, column name trailing spaces). The fix path is always the same: check encoding and structure before upload, validate against the platform's rules, and split if the file exceeds the platform's size or variant limits. All of this runs in your browser with no upload required.
TL;DR: A product CSV that imports successfully can still break your catalog — 432 products "imported" with no variants, missing images, and wrong prices because the success banner masks row-level failures. The fix path is: check encoding and delimiters first, validate required fields and price rules against your platform's spec, split large catalogs before upload. SplitForge Data Validator validates your product CSV against Shopify's requirements before any file reaches the platform — using the built-in E-commerce preset as a starting point.
The Import That Looked Fine
The import banner said "File imported successfully." It showed 432 products. What it didn't show was that 187 of those products had no variants — because the variant rows had been severed from their parent Handle when the catalog was sorted by price in Excel before export. Another 43 products had broken image URLs: also from sorting, which displaced image-URL rows past the position where Shopify expects them relative to the product row. The store launched with half a catalog working.
This is the survivability problem with product CSV imports: the platform tells you an import succeeded when it didn't, because "succeeded" means "the file parsed without a syntax error." The data integrity layer — are the variants where they belong, are the images reachable, are the prices correct, is the SKU unique — is yours to validate before the file gets uploaded.
At catalog scale, this gets harder. Excel silently strips leading zeros from SKU barcodes when it converts text columns to numbers. It injects curly/smart quotes during cell editing that trigger illegal-quoting errors. The platform docs tell you what to do — re-encode to UTF-8, remove duplicate handles, fix the variant rows, split the file if it's over 15MB — but they hand you no tool to do it. Paid apps will, but they upload your catalog to their servers. SplitForge does all of it in your browser, at any catalog size, without transmitting the file.
Here's the complete map of why product CSVs break — and how to get yours import-ready before it hits the platform.
What Product CSV Errors Actually Mean
| Error or Symptom | Root Cause | Fix | Deep-dive |
|---|---|---|---|
| "There was an error importing your file" | Illegal quoting — smart/curly quotes or a stray unescaped quote from spreadsheet editing | Replace curly quotes with straight ASCII quotes before import | E1 |
| CSV opens in one column / fields not separated | Wrong delimiter — semicolon or tab instead of comma (common in European locale exports) | Detect and convert delimiter to comma | E1 |
| Garbled characters after import — accented names, em dashes replaced with ? | Non-UTF-8 encoding (Windows-1252 / ANSI) — file saved from Excel on Windows without specifying UTF-8 | Re-encode file to UTF-8 before import | E1 |
| "Daily variant creation limit reached" | More than 1,000 new product variants submitted in a 24-hour period | Split the catalog into day-spaced batches of ≤1,000 new variants each | H2 |
| Upload fails, times out, or "file too large" | File exceeds Shopify's 15MB CSV import limit | Split into smaller files and re-import part by part | H2 |
| Duplicate products or "handle already exists" | Duplicate Handle values in the import file or matching an existing store product | Deduplicate and fix Handle values before import | E1 |
| "Variant 'Default Title' already exists" | Duplicate option combination — two variant rows with identical option values under the same Handle | Fix parent/child variant row structure | E1 |
| Products imported with no images | Image URL rows severed from their parent Handle row — typically from Excel sorting the CSV by price or alphabetically | Recover row structure: image URL rows must follow the product row | R1 |
| Leading zeros stripped from SKU or barcode (012345 → 12345) | Excel auto-converted the column from text to number on open | Restore column formatting to text before export; recover from backup if lost | H1 / R1 |
| Compare-At price ≤ regular price / "invalid price" error | Validation rule violation — Shopify requires Compare-At Price to exceed Price if both are set | Validate price columns before upload | V1 |
| WooCommerce export fails to import into Shopify | Column schema mismatch — different variant models (SKU-per-row vs. Handle-per-product), different required fields | Remap columns and restructure variant rows | C1 (coming) |
| WooCommerce import fails with "could not import SKU" or product type not supported | SKU format errors or unsupported product type value | Fix SKU format and confirm product type field values | E3 |
| Import "succeeded" but products have wrong variants or missing attributes | Silent structural corruption — columns reordered, variant rows displaced, required fields blank | Validate structure row-by-row before upload | V1 |
| Amazon Seller Central flat file rejected / "invalid SKU format" | SKU format violations or missing required flat file fields | Fix SKU format and confirm all required flat file columns are present | E2 |
Table of Contents
- Why Product CSV Imports Fail: The Five Failure Categories
- Platform CSV Formats: Shopify vs. WooCommerce vs. Amazon
- The Scale Problem: 15MB and the 1,000-Variant Limit
- Preparing a Product CSV Before Import: The Sanitation Workflow
- Converting and Migrating Between Platforms
- Recovering a Corrupted or Broken Product CSV
- Why In-Browser Processing Matters for Product Data
- FAQ
This guide covers Shopify, WooCommerce, and Amazon Seller Central product CSV formats — for e-commerce operations managers, migration specialists, and store owners preparing bulk catalog imports or platform migrations.
Why Product CSV Imports Fail: The Five Failure Categories
Product CSV imports fail in five distinct categories — and the platform's error message usually identifies the symptom, not the root cause. "Error importing your file" maps to encoding or quoting. "Handle already exists" maps to structure. "File too large" or a timeout maps to scale. "Invalid price" maps to data validation. A silent successful import with broken variants or missing images maps to a platform-specific structural quirk. Knowing which category applies determines what to fix.
Category 1 — Encoding errors
Non-UTF-8 encoding is the most common encoding failure. Files exported from Excel on Windows default to Windows-1252 (ANSI / CP1252 encoding). On Shopify, this produces garbled characters on import for any product title, description, or tag containing accented letters, em dashes, or non-ASCII characters. The fix: re-save from Excel as CSV UTF-8 (Comma delimited), or use Format Checker to detect encoding and convert before upload — in your browser, without transmitting the file.
Byte Order Mark (BOM) is a related artifact. Some tools export UTF-8 files with a BOM prefix (the three bytes EF BB BF). Most Shopify import flows handle BOM, but a malformed BOM can cause the first column header to fail recognition, breaking the entire import mapping. Format Checker detects and optionally removes the BOM.
Smart quotes — curly/typographic quote characters (" " ' ') instead of straight ASCII quotes (" ') — are injected by Excel and word processors when you edit cells containing quoted text. A CSV parser treats a curly quote in a field as an unescaped quote character, producing an illegal-quoting parse error on the first affected row. Fix: use Find & Replace to replace curly quotes with straight ASCII equivalents before import.
Category 2 — Format structure errors
Shopify's product CSV uses a parent-row / variant-row structure. The first row for each product carries the Handle, Title, and all product-level fields. Subsequent rows for the same product carry the same Handle and only variant-level fields — option values, Variant SKU, Variant Price, Variant Inventory Qty. The parent row must precede all variant rows for the same Handle.
If this structure breaks — Handle values changed mid-file, parent/variant rows reordered, header column names modified, or required columns missing — the import either rejects the file outright or silently creates products with wrong variant structures and no error. See Fix the Five Most Common Shopify CSV Import Errors for the full structural diagnosis.
Category 3 — Scale failures
Shopify enforces two scale limits: a 15MB file size ceiling on CSV imports, and a 1,000-new-variant-creations-per-24-hours rate limit. Large catalogs — 5,000+ products with multiple variants — routinely hit one or both. Neither produces a clear pre-upload warning. "File too large" is the signal for the size limit; "daily variant creation limit reached" is the signal for the rate limit, and by the time you see it, some of your products have already imported with no variants. Route → H2.
Category 4 — Data validation errors
Field type and business-rule violations produce row-level rejections. Shopify validates: price format (numeric, no currency symbol), Compare-At Price (must exceed Price if both are set), image URL format (must be a reachable public URL), and required fields depending on product type. WooCommerce validates: SKU uniqueness, product type values (simple, variable, external, grouped), and stock quantity format. These failures are catchable before upload with Data Validator — use the built-in E-commerce Orders preset as a starting configuration. Route → V1.
Category 5 — Platform-specific quirks
Shopify column headers are case-sensitive and whitespace-sensitive: Handle not handle; Variant SKU not variant sku; a trailing space in "Variant SKU " causes the column to fail mapping silently. Image URL rows must appear immediately after the product row they belong to — not at the top of an alphabetical sort. These quirks are where well-prepared files still fail. See E1 for Shopify specifics and E3 for WooCommerce specifics.
Platform CSV Formats: Shopify vs. WooCommerce vs. Amazon
Shopify, WooCommerce, and Amazon Seller Central use different CSV schemas — different column names, different variant models, different required fields, and in Amazon's case, a different delimiter entirely. A file exported from one platform will not import cleanly into another without structural changes. These differences are why migration is a column-remap problem, not just an encoding problem.
| Attribute | Shopify Product CSV | WooCommerce Product CSV | Amazon Seller Central Flat File |
|---|---|---|---|
| Product identifier | Handle (unique per product, repeated on all variant rows) | SKU (unique per row — parent + each variation) | seller-sku |
| Variant model | Parent row + variant rows under same Handle | Parent row + variation rows linked by parent_id | ASIN + variation theme field |
| Header format | Case-sensitive exact match required (Variant SKU ≠ variant sku) | Case-insensitive in most configurations | Category-specific flat file template |
| Image handling | Image Src column — image row must follow product row | Images column — pipe-separated URLs on one row | main-image-url + other-image-url1 through 5 |
| Price column | Variant Price (numeric, no currency symbol) | regular_price | item-price |
| Compare-At price | Variant Compare At Price — must exceed Variant Price | sale_price | Not directly equivalent |
| Encoding | UTF-8 required | UTF-8 required | UTF-8 required |
| Delimiter | Comma | Comma | Tab (.txt flat file) |
| File size limit | 15MB per import | Server-configurable | Varies by marketplace |
Shopify Handle vs. WooCommerce SKU — the structural mismatch
In Shopify, the Handle is a product-level identifier: all variants of a product share one Handle, and each variant occupies its own row. In WooCommerce, the SKU is a row-level identifier: every row — the parent product and each variation — has a distinct SKU, and variations are linked to their parent by the parent_id field.
These are not equivalent fields and cannot be mapped 1:1. A WooCommerce→Shopify migration requires restructuring variation rows (each with its own SKU) into variant rows under a single parent Handle. This is a structural transformation, not just column renaming. The full remap workflow is in C1 (coming).
Amazon Seller Central flat file
Amazon uses tab-delimited flat files (.txt extension, RFC 4180 applies to CSV structure but not to the tab delimiter). The flat file format is category-specific — the Clothing inventory template has different required columns than the Electronics or Home & Garden templates. The category-specific template is required for upload; using the wrong template produces "column not found" and "required field missing" errors before any SKU validation begins. For Amazon-specific SKU format and flat file errors, see E2.
Paid migration apps vs. in-browser processing
Matrixify and LitExtension handle WooCommerce→Shopify column remap and variant restructure automatically, with a migration workflow UI. They upload your product catalog to their servers to perform the transformation. Format Converter handles CSV-to-CSV structural transformation in your browser without upload, for the column-mapping layer. The full WooCommerce→Shopify conversion workflow is in C1 (coming).
The Scale Problem: 15MB and the 1,000-Variant Limit
Shopify's own help documentation says that if your import file is too large, you should "split the CSV file into smaller files." It offers no splitter. Every third-party migration guide says the same thing. The only tools that automate this are paid apps — Matrixify, for example — that upload your catalog to their servers to process the split. CSV Splitter handles any catalog size, runs entirely in your browser, and requires no upload.
The 15MB file size limit
Shopify imposes a 15MB ceiling on CSV import files. At 15MB, a product CSV represents roughly 30,000–50,000 rows depending on field density — description text and multiple image URL rows per product inflate file size quickly. A catalog of 5,000 products with 8 variants each (40,000+ rows, once image rows are included) often exceeds this limit. The fix: split the file into parts under 15MB each and re-import part by part.
The 1,000-variant-per-24-hours limit
Shopify limits new variant creations to 1,000 per 24-hour period. This limit applies to new variants only — updating existing variants does not count. A bulk import of 500 products with 5 variants each (2,500 new variants) will import the first 200 products cleanly, then stop creating variants for the remaining 300. Those 300 products appear in your store with no purchasable options. The fix: split into batches of ≤200 products (≤1,000 new variants at 5 variants/product) and import on separate days.
The variant orphaning risk
When you split a product CSV by row count, a split boundary can fall mid-product — the parent row (with the Handle and Title) lands in the first file, and some variant rows for the same Handle fall into the second file. On re-import, the orphaned variant rows fail because the parent Handle hasn't been created yet (if the second file imports first) or because the variant rows arrive after the product was already committed without them.
To avoid this: before splitting, understand the maximum variant count across all products in your catalog. If the largest product has 8 variants, it occupies 9 rows (1 parent + 8 variant rows). A safe split threshold is a multiple of your maximum group size — for a catalog where no product has more than 8 variants, split at every 900 rows (100 products × 9 rows each) to stay within the 1,000-variant daily limit with margin. CSV Splitter's SPLIT_BY_ROWS and SPLIT_BY_PARTS modes handle the mechanical split; the boundary calculation is a manual pre-split step.
Deep-dive → How to Split a Large Shopify Product CSV
Preparing a Product CSV Before Import: The Sanitation Workflow
The sanitation workflow is a one-shot pre-import operation, not continuous infrastructure. Run it once before each import: confirm encoding, check delimiters, match headers to the platform template, deduplicate handles and SKUs, validate price rules and required fields, split if necessary. A file that completes this workflow imports correctly. A file that skips it produces errors, silent data corruption, or a success banner with broken catalog data.
For per-catalog cleaning of a single export file, see How to Clean a Product Catalog CSV for Shopify and WooCommerce. This section covers the pre-import validation sequence specifically.
Step 1 — Check encoding and delimiters first
Run Format Checker before any other step. Format Checker detects encoding (UTF-8 vs. Windows-1252), delimiter (comma vs. semicolon — critical for European-locale exports), line endings (CRLF/LF), BOM, and intra-file column-count consistency. A Windows-1252 file must be re-encoded before import. A semicolon-delimited file must be converted to comma-delimited. Do this first: encoding errors corrupt delimiter detection, so any validation run on an incorrectly-encoded or mis-delimited file produces false results.
Step 2 — Match headers to the platform template
Download the Shopify product CSV template from your store's admin. Compare your column names character-for-character against the template. Shopify headers are case-sensitive: Handle ≠ handle. A trailing space in a header cell ("Variant SKU ") causes that column to fail mapping with no error message — the column simply isn't imported. Use Data Cleaner trimWhitespace to remove leading/trailing spaces from all cells, including header cells, before import.
Step 3 — Deduplicate handles and SKUs
Each product should appear once in the file (one parent row per Handle, followed by its variant rows). Duplicate Handle values across products produce "handle already exists" errors or silently merge product data. Use Remove Duplicates to identify duplicate Handles. Remove Duplicates supports fuzzy matching — it detects near-duplicate Handles like shirt-red vs shirt_red or blue-tshirt vs blue-t-shirt that exact-match deduplication misses.
Step 4 — Validate price rules and required fields
Load the file in Data Validator. Start with the built-in E-commerce Orders preset, then extend it for your catalog:
requiredonHandle,Title,Variant PricedataType: decimalandrange: min 0onVariant PriceandVariant Compare At Price- A custom rule comparing Compare-At Price > Price (if Compare-At is present)
regexonVariant SKUfor your SKU format patternenumonOption1 Nameif your product option names are fixed (Size,Color,Material)
For the full pre-import validation checklist, see V1.
Step 5 — Split if necessary
If the file exceeds 15MB, split with CSV Splitter. Use SPLIT_BY_SIZE to target files under 15MB each, or SPLIT_BY_PARTS to produce a fixed number of equal-size files. Before splitting, calculate a safe row threshold that does not break within a Handle group. See the Scale Problem section above for the boundary-calculation logic.
Converting and Migrating Between Platforms
WooCommerce and Shopify use fundamentally different CSV schemas. A WooCommerce product export cannot be directly imported into Shopify — the column names differ, the variant model differs (WooCommerce uses parent_id linking; Shopify uses Handle repetition), and the required fields differ. Migration requires a column remap and a variant-row restructure, not just a file format change.
The Handle/SKU structural mismatch
WooCommerce uses per-row SKUs: every row — the parent product and each variation — has its own distinct SKU, and variations are linked to their parent by the parent_id field. Shopify uses per-product Handles: all variants of a product share one Handle, with each variant on its own row under that Handle.
A WooCommerce export has one row per SKU. A Shopify import expects one parent row per Handle followed by variant rows. Converting the format requires: (1) mapping WooCommerce parent product rows to Shopify parent rows; (2) mapping each WooCommerce variation row to a Shopify variant row under the correct parent Handle; (3) renaming columns to Shopify's case-sensitive column names. This is a structural transformation — Format Converter handles the column-mapping layer in your browser. The full column-remap and variant-restructure workflow is in C1 (coming).
WooCommerce image URL structure
WooCommerce stores multiple product image URLs pipe-separated in a single Images column: https://example.com/img1.jpg|https://example.com/img2.jpg. Shopify expects a separate Image Src row for each product image, positioned after the product's parent row. Converting from WooCommerce image format to Shopify image rows requires splitting the pipe-separated URL field into individual rows — a structural change the column-rename alone doesn't handle.
Amazon Seller Central flat file format
Amazon's inventory upload uses tab-delimited flat files with a .txt extension — not standard comma-delimited CSVs. The flat file schema is category-specific: the Clothing category template has different required columns than Electronics or Home & Garden. Using the wrong template, or submitting a comma-delimited file where Amazon expects tab-delimited, produces immediate rejection. For the full Amazon flat file error taxonomy, see E2.
Paid apps vs. in-browser tools
Matrixify, LitExtension, and Cart2Cart provide migration workflow UIs that handle the column remap and variant restructure with guided steps — they upload your catalog to their servers for processing. SplitForge's Format Converter performs CSV-to-CSV transformation in your browser. The tradeoff: paid apps provide more automation; in-browser processing means your product data never leaves your machine. Full conversion guide → C1 (coming).
Recovering a Corrupted or Broken Product CSV
Shopify's documentation states plainly: "Shopify can't recover corrupted files for you." Most product-CSV damage is not file-level corruption — it is structural damage from spreadsheet editing: Excel sorts that sever image URL rows from their products, leading zeros stripped from SKU barcodes, smart quotes injected during cell editing, encoding converted from UTF-8 to Windows-1252 on open-and-save. These are recoverable with free tools. Genuine .xlsx file corruption — where the file itself cannot be opened — escalates to Excel Repair (Pro).
Encoding corruption (garbled characters after Excel open/save)
Excel on Windows silently converts UTF-8 CSV files to Windows-1252 when you open and re-save them without specifying UTF-8 output. The accented characters and special symbols are replaced at the byte level. Fix: use Format Checker to detect the current encoding and re-encode to UTF-8. If the original UTF-8 bytes are still present but misinterpreted (encoding label mismatch), re-encoding recovers them. If the bytes were overwritten on save, the original characters are unrecoverable and must be corrected manually.
Image URL rows severed by Excel sorting
Shopify expects image URL rows to follow their product's Handle row. Excel's column sort operates on individual rows, not on Handle groups — sorting by price alphabetizes all rows independently, severing image-URL rows from their parent Handle. To recover: export the CSV again from the source if available. If no source backup exists, sort the file by the Handle column in a plain text editor or CSV viewer (not Excel), then manually confirm that image URL rows follow their parent product row. Data Cleaner can re-sort by column value without the row-severing risk Excel introduces. Deep-dive → R1.
Leading zeros stripped from SKU or barcode
Excel auto-converts text columns that look like numbers to numeric values on open, stripping leading zeros (012345 → 12345). Once stripped, the original values are lost from the CSV. Prevention: open CSVs with the Text Import Wizard (Data → From Text/CSV in Excel), setting numeric-looking columns to Text format before loading. Recovery: if you have a backup or a source system with the original SKU values, use Find & Replace with a regex pattern to restore the leading zero padding. If no backup exists, the correct values must be manually re-entered.
Genuine .xlsx file corruption
If your source file is an .xlsx that Excel cannot open — "file is corrupted and cannot be opened" — this escalates beyond CSV-level recovery. Excel Repair (Pro) extracts readable data from corrupted .xlsx files using three repair modes: standard (formula-preserving), data-only (extract values, discard formatting), and partial (recover what's salvageable). Free tool recovery handles the common product-CSV damage scenarios above. Excel Repair handles true file corruption.
Bound against E1: E1 covers pre-import error fixing on a file that is structurally intact — encoding check, duplicate handle removal, header normalization. This section covers files that were already damaged through spreadsheet operations, failed saves, or corrupt imports.
Why In-Browser Processing Matters for Product Data
Product CSVs contain your full catalog — SKUs, pricing, supplier codes, images, inventory levels. A customer export includes names, email addresses, and order history. Running these files through a tool that uploads them to a third-party server for processing creates a data transmission risk and, for EU merchants, a GDPR Article 28 processor relationship requiring a Data Processing Agreement with the tool provider. SplitForge processes product and customer data entirely in your browser — no file leaves your machine.
Scale without server-side limits
Paid migration and processing apps impose plan-based upload limits — often capped at 1,000–5,000 products on free tiers. These limits exist because the app processes files on their infrastructure; larger files cost more server resources. SplitForge processes in the browser's Web Worker thread, which scales with your local machine. A 200,000-row product catalog processes in the browser at constant cost, without a per-product pricing model, and without the upload timeout that slow connections introduce.
Excel's hard ceiling is 1,048,576 rows. A catalog that exceeds this limit cannot be opened in Excel at all — it truncates on load without warning. SplitForge tools process any file size without a row ceiling.
No transmission, no retention
When you upload a product CSV to an online processing tool, the file transits the network, lands on the tool's server, and may be retained in logs, temporary storage, or processing queues. The tool's privacy policy and subprocessor disclosures govern what happens. SplitForge's Format Checker, Data Cleaner, Find & Replace, CSV Splitter, Data Validator, and Format Converter run entirely in your browser via Web Worker threads. Verify with DevTools Network tab: zero POST requests appear during file loading or processing. For the privacy analysis of online tool upload risk, see Never Upload a Payroll CSV to an Online Tool and Privacy-First Data Processing Guide.
Commercially sensitive catalog data
B2B product catalogs, wholesale price lists, and catalog exports with supplier pricing or negotiated margins are commercially sensitive independent of GDPR. Uploading a wholesale price list to an online processing tool creates competitive exposure. In-browser processing eliminates this exposure — the data never reaches a third-party server.
Additional Resources
Tested: product CSV import errors reproduced against Shopify's product importer documentation and WooCommerce CSV importer documentation, May 2026. Error strings are representative — exact wording may vary by account type, store plan, and platform version.
Platform documentation:
- Shopify: Import a CSV file — Shopify's official product CSV import guide; includes the file size limit and template download
- Shopify: Open and edit a CSV file — Includes the "Shopify can't recover corrupted files for you" statement
- WooCommerce: Product CSV importer and exporter — WooCommerce's official CSV importer documentation
- Amazon Seller Central: Create your inventory file template — Amazon category-specific flat file documentation
Standards:
- RFC 4180: Common Format and MIME Type for CSV Files — The CSV format standard; relevant to quoting rules, delimiter handling, and column count consistency
Encoding and browser processing:
- MDN Web Docs: TextDecoder — How browsers handle encoding detection and conversion in client-side file processing
- Unicode FAQ: UTF-8, UTF-16, UTF-32 & BOM — Encoding reference; explains BOM, byte-order marks, and the UTF-8 vs. Windows-1252 difference
- SheetJS Community Edition — Open-source library for parsing Excel and CSV files; reference for how spreadsheet applications handle CSV column typing and encoding on open