# Shopify CSV Import Checker & Catalog Diff (`overbifrost/shopify-csv-import-checker-catalog-diff`) Actor

Compare current and proposed Shopify product CSVs before import. SKUFuse flags significant price changes, stock going to zero, unmatched or ambiguous SKUs, and rows requiring manual review. Comparison only — it never writes to your store.

- **URL**: https://apify.com/overbifrost/shopify-csv-import-checker-catalog-diff.md
- **Developed by:** [Lasse](https://apify.com/overbifrost) (community)
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.007 / comparison completed

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Compare the Shopify product CSV you have now with the file you are about to import. **SKUFuse** surfaces risky price, inventory, SKU, variant, option, and overwrite changes before anything is written to your store.

This is a **Shopify CSV import preflight and catalog comparison tool**, not an importer. It never connects to Shopify, edits products, or writes inventory.

### Shopify CSV import checker: what it catches

Depending on the selected profile, SKUFuse can flag:

- Price drops or increases beyond configured thresholds
- Tracked inventory changing from a positive value to zero
- Duplicate, unmatched, ambiguous, or uncheckable SKUs
- Variant identity changes
- Variant option columns missing from an overwrite import
- Populated values that would be cleared by present-but-blank cells
- Invalid compare-at-price relationships
- Inventory tracker or quantity problems
- Incomplete coverage instead of silently guessing

A generic CSV validator asks whether a file is structurally valid. A generic diff asks which cells changed. SKUFuse asks **what the proposed Shopify import changes and which of those changes need human review**.

### Best for

- Shopify merchants reviewing product CSV imports before upload
- Agencies managing catalog and variant changes for multiple stores
- Teams that need repeatable checks for price, inventory, SKU, and variant changes
- Automated catalog workflows that need deterministic review output before the write step

### Quick start: check a Shopify product CSV before import

1. Keep **Run synthetic demo** enabled and press **Start** for a safe first run.
2. Review the built-in 3-row example with a ~90% price drop and inventory going to zero.
3. For real data, turn the demo off and choose the appropriate comparison profile.
4. Upload the current Shopify product CSV and the proposed import CSV.
5. Confirm the required declarations, run the comparison, and open **Review report (HTML)**.

You can also use inline CSV, public HTTPS URLs, Apify datasets, or a saved SKUFuse baseline.

### Shopify product and variant comparison profiles

| Profile | Best for |
|---|---|
| `shopify_product_price_stock_single_location_v1` | Price, SKU, tracker, and single-location inventory review |
| `shopify_product_variants_v2` | Variant identity, option structure, blank-overwrite, compare-at-price, price, and optional inventory review |

The variants profile requires `confirmOverwriteMatchingHandles: true` because its import-sensitive checks model Shopify's **Overwrite existing products that have matching handles** behavior.

`Inventory quantity` is single-location data. Multi-location merchants can still use the variants profile for product and variant review while handling per-location quantities through Shopify's separate Inventory CSV workflow.

### Outputs for human review and automation

Every completed comparison produces:

- **`REVIEW.html`** — readable review report
- **`OUTPUT`** — canonical JSON comparison report
- **`FINDINGS.csv`** — spreadsheet-ready findings
- **Default dataset item** — the canonical report for downstream Apify workflows
- **`RUN_METADATA`** — operational and billing metadata

The report distinguishes review findings from unmatched, uncheckable, or ignored image/metadata-only rows and uses bounded output for large catalogs.

### Saved baselines, schedules, and webhooks

SKUFuse can store named catalog baselines for later comparisons. For recurring checks, save the input as an Apify Task and attach an Apify Schedule. An optional `reviewWebhook` can send a small summary only for selected statuses such as `review_required` or `incomplete`.

SKUFuse itself does not schedule imports or write to Shopify.

### Pricing

Pay per event, with platform usage included. **All prices below are USD per event**, not per 1,000 events.

| Event | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| `comparison-completed` | $0.01 | $0.009 | $0.008 | $0.007 |
| `row-evaluated` | $0.00001 | $0.00001 | $0.00001 | $0.00001 |
| `apify-actor-start` | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

- **Comparison:** the primary, infrequent event; charged at most once when a completed report evaluates at least one proposed row.
- **Rows:** one event per evaluated row, including unchanged rows. Multiple findings on one row still count as one row event.
- **Start:** charged by Apify, including failed runs. One event at up to 1 GB; higher memory adds start events.

| Example, at up to 1 GB | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Built-in example: 3 evaluated rows | $0.01008 | $0.00908 | $0.00808 | $0.00708 |
| Comparison: 1,000 evaluated rows | $0.02005 | $0.01905 | $0.01805 | $0.01705 |

**Maximum cost per run is a spending cap, not a minimum bill.** The minimum allowed cap is $0.011. That covers the built-in example at up to 1 GB; for 1,000 evaluated rows on Free, use $0.021 or more.

Unmatched rows, uncheckable rows, ignored image/metadata-only rows, header-only files, and insufficient-budget runs are not billed as evaluated-row events. Custom events are charged after report delivery and a complete-cost budget check. The [Pricing tab](https://apify.com/overbifrost/shopify-csv-import-checker-catalog-diff/pricing) is authoritative.

### Important boundaries

- **Comparison only:** no import, store connection, live-state verification, repair, or automatic approval.
- A report with no findings is **not a guarantee that a later import is safe**.
- Matching is deterministic; ambiguous identities are not guessed.
- Shopify product CSV input is comma-separated; other CSV dialects are outside this Actor's Shopify product CSV contract.
- Catalog comparisons support up to **100,000 comparison-relevant data records per file** under the documented limits.
- Remote CSV sources are HTTPS-only and subject to strict size and network limits.

### API

Use the Actor technical name:

```text
overbifrost/shopify-csv-import-checker-catalog-diff
```

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('overbifrost/shopify-csv-import-checker-catalog-diff').call(input);
```

### Related SKUFuse Actors

- [WooCommerce CSV Import Checker & Catalog Diff](https://apify.com/overbifrost/woocommerce-csv-import-checker-catalog-diff) — review WooCommerce product and variation CSV changes before import.
- [Inventory CSV Diff & Stock Change Checker](https://apify.com/overbifrost/inventory-csv-diff-stock-change-checker) — review inventory snapshot and stock-sync changes by SKU or SKU + location.

### FAQ

#### Does SKUFuse import or modify Shopify products?

No. It only compares the current and proposed data and produces review outputs. The write/import step stays outside SKUFuse.

#### Is this only a Shopify CSV validator?

No. A validator checks whether one file is structurally acceptable. SKUFuse compares **current vs. proposed** product data and highlights material import changes, variant identity risks, ambiguity, and incomplete coverage.

#### What about Shopify stores with multiple inventory locations?

The product CSV's `Inventory quantity` semantics are single-location. In the variants profile, multi-location merchants can omit that quantity column and still review price, SKU, option, and variant changes; use Shopify's Inventory CSV workflow for per-location quantities.

#### Can I try it without preparing files?

Yes. Leave **Run synthetic demo** on and start the Actor. The default Store run uses fixed synthetic data and produces a normal review report and dataset item.

#### Can I run recurring checks?

Yes. Saved baselines can be combined with Apify Tasks, Schedules, and the optional conditional review webhook for recurring catalog review.

# Changelog

This Actor's version history is a separate document: https://apify.com/overbifrost/shopify-csv-import-checker-catalog-diff/changelog.md

# Actor input Schema

## `demoMode` (type: `boolean`):

Recommended first run. Uses a fixed 3-row Shopify example with a large price drop and inventory going to zero. Turn this off before comparing your own files. The demo is billed like a normal 3-row comparison.

## `schemaVersion` (type: `string`):

Use Price + inventory for the standard single-location product CSV workflow. Use Product variants for variant identity, options, blank-overwrite, compare-at-price, and optional inventory checks.

## `currentCsvFile` (type: `string`):

Upload the Shopify product CSV that represents the current state (up to 10 MB). Use exactly one current source.

## `proposedCsvFile` (type: `string`):

Upload the Shopify product CSV you plan to import (up to 10 MB). Use exactly one proposed source.

## `currency` (type: `string`):

Required for real comparisons. Enter the three-letter ISO 4217 code used by both files, for example USD. SKUFuse labels the report with this currency; it does not convert prices.

## `confirmComparablePrices` (type: `boolean`):

Required for real comparisons. Confirm both files use the same currency and price basis, such as both net or both gross.

## `confirmSingleLocationInventory` (type: `boolean`):

Required whenever the proposed file includes Inventory quantity. Confirm that quantity represents one inventory location.

## `confirmOverwriteMatchingHandles` (type: `boolean`):

Required only for Product variants. Confirm the planned Shopify import overwrites existing products with matching handles.

## `rules` (type: `object`):

Control which price and inventory changes are highlighted for review.

## `maxFindings` (type: `integer`):

Limit the retained finding list to 1–1000 entries. SKUFuse still counts all findings when the list is capped.

## `currentCsv` (type: `string`):

Alternative to file upload: paste the current Shopify product CSV as text (max 512 KB). Use exactly one current source.

## `proposedCsv` (type: `string`):

Alternative to file upload: paste the proposed Shopify product CSV as text (max 512 KB). Use exactly one proposed source.

## `currentCsvUrl` (type: `string`):

Public HTTPS URL returning the current CSV (max 10 MB). HTTPS port 443 only; redirects and URL credentials are rejected.

## `proposedCsvUrl` (type: `string`):

Public HTTPS URL returning the proposed CSV (max 10 MB). HTTPS port 443 only; redirects and URL credentials are rejected.

## `currentDataset` (type: `string`):

Alternative current source: select an Apify dataset containing Shopify product records. SKUFuse requests READ-only access.

## `proposedDataset` (type: `string`):

Alternative proposed source: select an Apify dataset containing the planned update. SKUFuse requests READ-only access.

## `currentDatasetMapping` (type: `object`):

Optional visual mapping when current dataset field names differ from Shopify columns.

## `proposedDatasetMapping` (type: `object`):

Optional visual mapping when proposed dataset field names differ from Shopify columns.

## `baseline` (type: `object`):

Optional recurring workflow. Save, replace, inspect, delete, or compare against a named catalog baseline without writing JSON.

## `reviewWebhook` (type: `object`):

Optional encrypted webhook configuration for API or Task input. Hidden from the Form view so customers are never asked to enter JSON.

## `payload` (type: `object`):

Platform-provided integration envelope for chained Apify runs.

## Actor input object example

```json
{
  "demoMode": true,
  "schemaVersion": "shopify_product_price_stock_single_location_v1",
  "currency": "USD",
  "maxFindings": 1000,
  "currentCsvUrl": "https://example.com/exports/current-products.csv",
  "proposedCsvUrl": "https://example.com/exports/proposed-products.csv"
}
```

# Actor output Schema

## `reviewHtml` (type: `string`):

No description

## `findingsCsv` (type: `string`):

No description

## `report` (type: `string`):

No description

## `datasetItem` (type: `string`):

No description

## `runMetadata` (type: `string`):

No description

## `errorRecord` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "demoMode": true,
    "schemaVersion": "shopify_product_price_stock_single_location_v1"
};

// Run the Actor and wait for it to finish
const run = await client.actor("overbifrost/shopify-csv-import-checker-catalog-diff").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "demoMode": True,
    "schemaVersion": "shopify_product_price_stock_single_location_v1",
}

# Run the Actor and wait for it to finish
run = client.actor("overbifrost/shopify-csv-import-checker-catalog-diff").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "demoMode": true,
  "schemaVersion": "shopify_product_price_stock_single_location_v1"
}' |
apify call overbifrost/shopify-csv-import-checker-catalog-diff --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,overbifrost/shopify-csv-import-checker-catalog-diff"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PCM4S0uQblfqClqRI/builds/2oS1BKNabWx8QXKVw/openapi.json